include/comma/ast/Type.h

Go to the documentation of this file.

//===-- ast/Type.h -------------------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license.  See LICENSE.txt for details.
//
// Copyright (C) 2008-2010, Stephen Wilson
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_AST_TYPE_HDR_GUARD
#define COMMA_AST_TYPE_HDR_GUARD

#include "comma/ast/AstBase.h"
#include "comma/ast/Range.h"
#include "comma/basic/ParameterModes.h"

#include "llvm/ADT/APInt.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/PointerIntPair.h"
#include "llvm/ADT/PointerUnion.h"
#include "llvm/Support/Casting.h"

namespace comma {

//===----------------------------------------------------------------------===//
// Type

class Type : public Ast {

public:
    virtual ~Type() { }

    enum Classification {
        CLASS_Scalar,
        CLASS_Discrete,
        CLASS_Enum,
        CLASS_Integer,
        CLASS_Composite,
        CLASS_Array,
        CLASS_String,
        CLASS_Access,
        CLASS_Record
    };

    bool memberOf(Classification ID) const;

    bool isScalarType() const;

    bool isDiscreteType() const;

    bool isIntegerType() const;

    bool isEnumType() const;

    bool isCompositeType() const;

    bool isArrayType() const;

    bool isRecordType() const;

    bool isStringType() const;

    bool isAccessType() const;

    bool isFatAccessType() const;

    bool isThinAccessType() const;

    bool isUniversalType() const;

    bool isUniversalIntegerType() const;

    bool isUniversalAccessType() const;

    bool isUniversalFixedType() const;

    bool isUniversalRealType() const;

    bool isUniversalTypeOf(const Type *type) const;

    ArrayType *getAsArrayType();
    IntegerType *getAsIntegerType();
    EnumerationType *getAsEnumType();

    bool involvesPercent() const;

    bool isIndefiniteType() const;

    bool isDefiniteType() const { return !isIndefiniteType(); }

    static bool classof(const Type *node) { return true; }
    static bool classof(const Ast *node) {
        return node->denotesType();
    }

protected:
    Type(AstKind kind) : Ast(kind) {
        // Types are never directly deletable -- they are always owned by a
        // containing node.
        deletable = false;
        assert(this->denotesType());
    }

private:
    Type(const Type &);         // Do not implement.
};

//===----------------------------------------------------------------------===//
// SubroutineType
class SubroutineType : public Type {

public:
    virtual ~SubroutineType() { delete[] argumentTypes; }

    unsigned getArity() const { return numArguments; }

    Type *getArgType(unsigned i) const { return argumentTypes[i]; }

    typedef Type **arg_type_iterator;
    arg_type_iterator begin() const { return argumentTypes; }
    arg_type_iterator end() const {
        return argumentTypes + numArguments; }

    // Support isa and dyn_cast.
    static bool classof(const SubroutineType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->denotesSubroutineType();
    }

protected:
    SubroutineType(AstKind kind, Type **argTypes, unsigned numArgs);

    Type **argumentTypes;
    unsigned numArguments;
};

//===----------------------------------------------------------------------===//
// FunctionType
class FunctionType : public SubroutineType, public llvm::FoldingSetNode {

public:
    Type *getReturnType() const { return returnType; }

    void Profile(llvm::FoldingSetNodeID &ID) {
        Profile(ID, argumentTypes, numArguments, returnType);
    }

    // Support isa and dyn_cast.
    static bool classof(const FunctionType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_FunctionType;
    }

private:
    Type *returnType;

    friend class AstResource;

    FunctionType(Type **argTypes, unsigned numArgs, Type *returnType)
        : SubroutineType(AST_FunctionType, argTypes, numArgs),
          returnType(returnType) { }

    static void Profile(llvm::FoldingSetNodeID &ID,
                        Type **argTypes, unsigned numArgs,
                        Type *returnType) {
        for (unsigned i = 0; i < numArgs; ++i)
            ID.AddPointer(argTypes[i]);
        ID.AddPointer(returnType);
    }
};

//===----------------------------------------------------------------------===//
// ProcedureType
class ProcedureType : public SubroutineType, public llvm::FoldingSetNode {

public:
    void Profile(llvm::FoldingSetNodeID &ID) {
        Profile(ID, argumentTypes, numArguments);
    }

    // Support isa and dyn_cast.
    static bool classof(const ProcedureType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ProcedureType;
    }

private:
    friend class AstResource;

    ProcedureType(Type **argTypes, unsigned numArgs)
        : SubroutineType(AST_ProcedureType, argTypes, numArgs) { }

    static void Profile(llvm::FoldingSetNodeID &ID,
                        Type **argTypes, unsigned numArgs) {
        if (numArgs)
            for (unsigned i = 0; i < numArgs; ++i)
                ID.AddPointer(argTypes[i]);
        else
            ID.AddPointer(0);
    }
};

//===----------------------------------------------------------------------===//
// UniversalType
//
class UniversalType : public Type {

public:


    static UniversalType *getUniversalInteger() {
        if (universal_integer)
            return universal_integer;
        universal_integer = new UniversalType();
        return universal_integer;
    }

    static UniversalType *getUniversalAccess() {
        if (universal_access)
            return universal_access;
        universal_access = new UniversalType();
        return universal_access;
    }

    static UniversalType *getUniversalFixed() {
        if (universal_fixed)
            return universal_fixed;
        universal_fixed = new UniversalType();
        return universal_fixed;
    }

    static UniversalType *getUniversalReal() {
        if (universal_real)
            return universal_real;
        universal_real = new UniversalType();
        return universal_real;
    }


    bool isUniversalIntegerType() const { return this == universal_integer; }
    bool isUniversalAccessType()  const { return this == universal_access;  }
    bool isUniversalFixedType()   const { return this == universal_fixed;   }
    bool isUniversalRealType()    const { return this == universal_real;    }

    Classification getClassification() const {
        // FIXME: Support all classifications.
        if (isUniversalIntegerType())
            return CLASS_Integer;
        assert(isUniversalAccessType() && "Unexpected universal type!");
        return CLASS_Access;
    }

    // Support isa/dyn_cast.
    static bool classof(const UniversalType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_UniversalType;
    }

private:
    UniversalType() : Type(AST_UniversalType) { }

    static UniversalType *universal_integer;
    static UniversalType *universal_access;
    static UniversalType *universal_fixed;
    static UniversalType *universal_real;
};

//===----------------------------------------------------------------------===//
// PrimaryType
//
class PrimaryType : public Type {

public:
    bool isSubtype() const { return typeChain.getInt(); }

    bool isRootType() const { return !isSubtype(); }



    const PrimaryType *getRootType() const {
        return const_cast<PrimaryType*>(this)->getRootType();
    }
    PrimaryType *getRootType() {
        PrimaryType *cursor = this;
        while (cursor->isSubtype())
            cursor = cursor->typeChain.getPointer();
        return cursor;
    }

    bool isDerivedType() const {
        const PrimaryType *root = getRootType();
        return root->typeChain.getPointer() != 0;
    }



    PrimaryType *getParentType() {
        PrimaryType *root = getRootType();
        return root->typeChain.getPointer();
    }
    const PrimaryType *getParentType() const {
        const PrimaryType *root = getRootType();
        return root->typeChain.getPointer();
    }



    const PrimaryType *getAncestorType() const {
        return typeChain.getPointer();
    }
    PrimaryType *getAncestorType() { return typeChain.getPointer(); }

    virtual bool isConstrained() const { return false; }

    bool isUnconstrained() const { return !isConstrained(); }

    bool isSubtypeOf(const PrimaryType *type) const {
        const PrimaryType *cursor = this;
        while (cursor->isSubtype()) {
            if (cursor == type)
                return true;
            cursor = cursor->typeChain.getPointer();
        }
        return cursor == type;
    }

    // Support isa/dyn_cast.
    static bool classof(const PrimaryType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->denotesPrimaryType();
    }

protected:
    PrimaryType(AstKind kind, PrimaryType *rootOrParent, bool subtype)
        : Type(kind) {
        assert(this->denotesPrimaryType());
        typeChain.setPointer(rootOrParent);
        typeChain.setInt(subtype);
    }

private:
    llvm::PointerIntPair<PrimaryType*, 1, bool> typeChain;
};

//===----------------------------------------------------------------------===//
// IncompleteType
//
class IncompleteType : public PrimaryType {

public:
    IdentifierInfo *getIdInfo() const;

    const char *getString() const { return getIdInfo()->getString(); }


    const IncompleteTypeDecl *getDefiningDecl() const {
        return const_cast<IncompleteType*>(this)->getDefiningDecl();
    }
    IncompleteTypeDecl *getDefiningDecl();

    bool hasCompletion() const;


    const PrimaryType *getCompleteType() const {
        return const_cast<IncompleteType*>(this)->getCompleteType();
    }
    PrimaryType *getCompleteType();


    IncompleteType *getRootType() {
        return llvm::cast<IncompleteType>(PrimaryType::getRootType());
    }
    const IncompleteType *getRootType() const {
        return llvm::cast<IncompleteType>(PrimaryType::getRootType());
    }

    // Support isa/dyn_cast.
    static bool classof(const IncompleteType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_IncompleteType;
    }

private:
    IncompleteType(IncompleteTypeDecl *decl)
        : PrimaryType(AST_IncompleteType, 0, false),
          definingDecl(decl) { }

    IncompleteType(IncompleteType *rootType, IdentifierInfo *name)
        : PrimaryType(AST_IncompleteType, rootType, true),
          definingDecl(name) { }

    friend class AstResource;

    llvm::PointerUnion<IncompleteTypeDecl *, IdentifierInfo *> definingDecl;
};


//===----------------------------------------------------------------------===//
// DomainType
class DomainType : public PrimaryType {

public:
    IdentifierInfo *getIdInfo() const;

    const char *getString() const { return getIdInfo()->getString(); }

    bool denotesPercent() const { return getPercentDecl() != 0; }

    bool isConcrete() const { return getInstanceDecl() != 0; }

    bool isAbstract() const { return getAbstractDecl() != 0; }

    //@
    const DomainTypeDecl *getDomainTypeDecl() const;
    DomainTypeDecl *getDomainTypeDecl();


    const PercentDecl *getPercentDecl() const;
    PercentDecl *getPercentDecl();

    //@
    const DomainInstanceDecl *getInstanceDecl() const;
    DomainInstanceDecl *getInstanceDecl();



    const AbstractDomainDecl *getAbstractDecl() const;
    AbstractDomainDecl *getAbstractDecl();



    const PrimaryType *getRepresentationType() const {
        return const_cast<DomainType*>(this)->getRepresentationType();
    }
    PrimaryType *getRepresentationType();


    DomainType *getRootType() {
        return llvm::cast<DomainType>(PrimaryType::getRootType());
    }
    const DomainType *getRootType() const {
        return llvm::cast<DomainType>(PrimaryType::getRootType());
    }

    static bool classof(const DomainType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_DomainType;
    }

private:
    DomainType(DomainTypeDecl *DTDecl);

    DomainType(DomainType *rootType, IdentifierInfo *name);

    friend class AstResource;

    llvm::PointerUnion<DomainTypeDecl*, IdentifierInfo*> definingDecl;
};

//===----------------------------------------------------------------------===//
// DiscreteType
//
class DiscreteType : public PrimaryType {

public:
    virtual IdentifierInfo *getIdInfo() const = 0;

    virtual void getUpperLimit(llvm::APInt &res) const = 0;

    virtual void getLowerLimit(llvm::APInt &res) const = 0;

    virtual uint64_t getSize() const = 0;

    uint64_t length() const;

    enum ContainmentResult {
        Is_Contained,
        Not_Contained,
        Maybe_Contained
    };

    ContainmentResult contains(const DiscreteType *target) const;

    ContainmentResult contains(const llvm::APInt &value) const;

    bool isSigned() const;


    const DiscreteType *getRootType() const {
        return llvm::cast<DiscreteType>(PrimaryType::getRootType());
    }
    DiscreteType *getRootType() {
        return llvm::cast<DiscreteType>(PrimaryType::getRootType());
    }



    virtual Range *getConstraint() = 0;
    virtual const Range *getConstraint() const = 0;

    bool isStaticallyConstrained() const {
        if (const Range *range = getConstraint())
            return range->isStatic();
        return false;
    }

    bool isDynamicallyConstrained() const {
        if (const Range *range = getConstraint())
            return !range->isStatic();
        return false;
    }

    virtual PosAD *getPosAttribute() = 0;

    virtual ValAD *getValAttribute() = 0;

    // Support isa/dyn_cast.
    static bool classof(const DiscreteType *node) { return true; }
    static bool classof(const Ast *node) {
        return denotesDiscreteType(node->getKind());
    }

protected:
    DiscreteType(AstKind kind, DiscreteType *rootOrParent, bool subtype)
        : PrimaryType(kind, rootOrParent, subtype) {
        assert(denotesDiscreteType(kind));
    }

    // Convinience utility for subclasses.  Returns the number of bits that
    // should be used for the size of the type, given the minimal number of bits
    // needed to represent the entity.
    static unsigned getPreferredSize(uint64_t bits);

private:
    static bool denotesDiscreteType(AstKind kind) {
        return (kind == AST_EnumerationType || kind == AST_IntegerType);
    }
};

//===----------------------------------------------------------------------===//
// EnumerationType
class EnumerationType : public DiscreteType {

public:
    virtual ~EnumerationType() { }

    void getLowerLimit(llvm::APInt &res) const;

    void getUpperLimit(llvm::APInt &res) const;

    uint64_t getSize() const;

    uint64_t getNumLiterals() const;

    bool isCharacterType() const;

    bool isConstrained() const { return getConstraint() != 0; }



    Range *getConstraint();
    const Range *getConstraint() const;


    EnumerationType *getRootType() {
        return llvm::cast<EnumerationType>(PrimaryType::getRootType());
    }
    const EnumerationType *getRootType() const {
        return llvm::cast<EnumerationType>(PrimaryType::getRootType());
    }


    EnumerationType *getBaseSubtype();
    const EnumerationType *getBaseSubtype() const;


    const EnumerationDecl *getDefiningDecl() const {
        return const_cast<EnumerationType*>(this)->getDefiningDecl();
    }
    EnumerationDecl *getDefiningDecl();

    PosAD *getPosAttribute();

    ValAD *getValAttribute();

    // Support isa and dyn_cast.
    static bool classof(const EnumerationType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_EnumerationType;
    }

private:

    static EnumerationType *create(AstResource &resource,
                                   EnumerationDecl *decl);

    static EnumerationType *createSubtype(EnumerationType *rootType,
                                          EnumerationDecl *decl = 0);

    static EnumerationType *createConstrainedSubtype(EnumerationType *rootType,
                                                     Expr *lower, Expr *upper,
                                                     EnumerationDecl *decl);
    friend class AstResource;

protected:
    // representing the root, constrained, and unconstrained cases.  The
    // following enumeration identifiers each of these classes and is encoded
    // into the AST::bits field.
    enum EnumKind {
        RootEnumType_KIND,
        UnconstrainedEnumType_KIND,
        ConstrainedEnumType_KIND
    };

    static bool isSubtypeKind(EnumKind kind) {
        return (kind == UnconstrainedEnumType_KIND ||
                kind == ConstrainedEnumType_KIND);
    }

    EnumerationType(EnumKind kind, EnumerationType *rootOrParent)
        : DiscreteType(AST_EnumerationType, rootOrParent, isSubtypeKind(kind)) {
        bits = kind;
    }

public:
    EnumKind getEnumKind() const { return EnumKind(bits); }
};

//===----------------------------------------------------------------------===//
// IntegerType
//
// These nodes represent ranged, signed, integer types.  They are allocated and
// owned by an AstResource instance.
class IntegerType : public DiscreteType {

public:
    virtual ~IntegerType() { }

    void getLowerLimit(llvm::APInt &res) const;

    void getUpperLimit(llvm::APInt &res) const;

    bool baseContains(const llvm::APInt &value) const;

    uint64_t getSize() const;





    const IntegerType *getBaseSubtype() const {
        return const_cast<IntegerType*>(this)->getBaseSubtype();
    }
    IntegerType *getBaseSubtype();

    bool isConstrained() const { return getConstraint() != 0; }



    Range *getConstraint();
    const Range *getConstraint() const;


    IntegerType *getRootType() {
        return llvm::cast<IntegerType>(PrimaryType::getRootType());
    }
    const IntegerType *getRootType() const {
        return llvm::cast<IntegerType>(PrimaryType::getRootType());
    }

    PosAD *getPosAttribute();

    ValAD *getValAttribute();

    static bool classof(const IntegerType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_IntegerType;
    }

private:


    static IntegerType *create(AstResource &resource, IntegerDecl *decl,
                               const llvm::APInt &lower,
                               const llvm::APInt &upper);

    static IntegerType *createSubtype(IntegerType *rootType,
                                      IntegerDecl *decl = 0);

    static IntegerType *createConstrainedSubtype(IntegerType *rootType,
                                                 Expr *lower, Expr *upper,
                                                 IntegerDecl *decl);

    friend class AstResource;


    const IntegerDecl *getDefiningDecl() const {
        return const_cast<IntegerType*>(this)->getDefiningDecl();
    }
    virtual IntegerDecl *getDefiningDecl() = 0;

protected:
    enum IntegerKind {
        RootIntegerType_KIND,
        UnconstrainedIntegerType_KIND,
        ConstrainedIntegerType_KIND
    };

    static bool isSubtypeKind(IntegerKind kind) {
        return (kind == UnconstrainedIntegerType_KIND ||
                kind == ConstrainedIntegerType_KIND);
    }

    IntegerType(IntegerKind kind, IntegerType *rootOrParent)
        : DiscreteType(AST_IntegerType, rootOrParent, isSubtypeKind(kind)) {
        bits = kind;
    }

public:
    IntegerKind getIntegerKind() const { return IntegerKind(bits); }
};

//===----------------------------------------------------------------------===//
// CompositeType
//
class CompositeType : public PrimaryType {

public:
    static bool classof(const CompositeType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->denotesCompositeType();
    }

protected:
    CompositeType(AstKind kind, CompositeType *rootOrParent, bool subtype)
        : PrimaryType(kind, rootOrParent, subtype) {
        assert(this->denotesCompositeType());
    }
};

//===----------------------------------------------------------------------===//
// ArrayType
//
// These nodes describe the index profile and component type of an array type.
// They are allocated and owned by an AstResource instance.
class ArrayType : public CompositeType {

    typedef llvm::SmallVector<DiscreteType*, 4> IndexVec;

public:
    IdentifierInfo *getIdInfo() const;

    unsigned getRank() const { return indices.size(); }

    bool isVector() const { return getRank() == 1; }

    uint64_t length() const;


    const DiscreteType *getIndexType(unsigned i) const { return indices[i]; }
    DiscreteType *getIndexType(unsigned i) { return indices[i]; }


    typedef IndexVec::iterator iterator;
    iterator begin() { return indices.begin(); }
    iterator end() { return indices.end(); }

    typedef IndexVec::const_iterator const_iterator;
    const_iterator begin() const { return indices.begin(); }
    const_iterator end() const { return indices.end(); }

    Type *getComponentType() const { return componentType; }

    bool isConstrained() const { return constraintBit(); }

    bool isStaticallyConstrained() const;


    ArrayType *getRootType() {
        return llvm::cast<ArrayType>(PrimaryType::getRootType());
    }
    const ArrayType *getRootType() const {
        return llvm::cast<ArrayType>(PrimaryType::getRootType());
    }


    const ArrayDecl *getDefiningDecl() const {
        return getRootType()->definingDecl.get<ArrayDecl*>();
    }
    ArrayDecl *getDefiningDecl() {
        return getRootType()->definingDecl.get<ArrayDecl*>();
    }

    // Support isa and dyn_cast.
    static bool classof(const ArrayType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ArrayType;
    }

private:
    ArrayType(ArrayDecl *decl, unsigned rank, DiscreteType **indices,
              Type *component, bool isConstrained);

    ArrayType(IdentifierInfo *name, ArrayType *rootType,
              DiscreteType **indices);

    ArrayType(IdentifierInfo *name, ArrayType *rootType);

    friend class AstResource;

    enum PropertyTags {
        Constrained_PROP = 1,
    };

    bool constraintBit() const { return bits & Constrained_PROP; }

    void setConstraintBit() { bits |= Constrained_PROP; }

    IndexVec indices;

    Type *componentType;

    llvm::PointerUnion<ArrayDecl*, IdentifierInfo*> definingDecl;
};

//===----------------------------------------------------------------------===//
// RecordType
class RecordType : public CompositeType {

public:
    IdentifierInfo *getIdInfo() const;


    RecordType *getRootType() {
        return llvm::cast<RecordType>(PrimaryType::getRootType());
    }
    const RecordType *getRootType() const {
        return llvm::cast<RecordType>(PrimaryType::getRootType());
    }


    const RecordDecl *getDefiningDecl() const {
        return const_cast<RecordType*>(this)->getDefiningDecl();
    }
    RecordDecl *getDefiningDecl();

    unsigned numComponents() const;


    const Type *getComponentType(unsigned i) const {
        return const_cast<RecordType*>(this)->getComponentType(i);
    }
    Type *getComponentType(unsigned i);

    bool isConstrained() const { return true; }

    // Support isa/dyn_cast.
    static bool classof(const RecordType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_RecordType;
    }

private:
    RecordType(RecordDecl *decl);
    RecordType(RecordType *rootType, IdentifierInfo *name);

    friend class AstResource;

    llvm::PointerUnion<RecordDecl*, IdentifierInfo*> definingDecl;
};

//===----------------------------------------------------------------------===//
// AccessType
class AccessType : public PrimaryType {

public:
    IdentifierInfo *getIdInfo() const;

    const char *getString() const { return getIdInfo()->getString(); }


    const AccessDecl *getDefiningDecl() const {
        return const_cast<AccessType*>(this)->getDefiningDecl();
    }
    AccessDecl *getDefiningDecl();

    //@(
    const Type *getTargetType() const { return targetType; }
    Type *getTargetType() { return targetType; }


    AccessType *getRootType() {
        return llvm::cast<AccessType>(PrimaryType::getRootType());
    }
    const AccessType *getRootType() const {
        return llvm::cast<AccessType>(PrimaryType::getRootType());
    }

    // Support isa/dyn_cast;
    static bool classof(const AccessType *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_AccessType;
    }

private:
    AccessType(AccessDecl *decl, Type *targetType);

    AccessType(AccessType *rootType, IdentifierInfo *name);

    friend class AstResource;

    Type *targetType;

    llvm::PointerUnion<AccessDecl*, IdentifierInfo*> definingDecl;
};

} // End comma namespace

#endif

---