X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FDerivedTypes.h;h=22807f1a6b926cd9d94a6a8dcee9850699a40ab9;hb=edd5d9ece15f73ec1a31423a4ae39774aa6c521c;hp=b53ecd276d076b51f194ecc387e1d1d9fa448872;hpb=3e3bcbd222dace4b725b39e47d326ca767c8c5d8;p=oota-llvm.git diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h index b53ecd276d0..22807f1a6b9 100644 --- a/include/llvm/DerivedTypes.h +++ b/include/llvm/DerivedTypes.h @@ -1,13 +1,13 @@ //===-- llvm/DerivedTypes.h - Classes for handling data types ---*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // -// This file contains the declarations of classes that represent "derived +// This file contains the declarations of classes that represent "derived // types". These are things like "arrays of x" or "structure of x, y, z" or // "method returning x taking (y,z) as parameters", etc... // @@ -19,23 +19,27 @@ #define LLVM_DERIVED_TYPES_H #include "llvm/Type.h" +#include "llvm/Support/DataTypes.h" namespace llvm { +class Value; template class TypeMap; class FunctionValType; class ArrayValType; class StructValType; class PointerValType; +class PackedValType; class DerivedType : public Type, public AbstractTypeUser { // AbstractTypeUsers - Implement a list of the users that need to be notified // if I am a type, and I get resolved into a more concrete type. // mutable std::vector AbstractTypeUsers; + friend class Type; protected: - DerivedType(PrimitiveID id) : Type("", id) {} + DerivedType(TypeID id) : Type("", id) {} ~DerivedType() { assert(AbstractTypeUsers.empty()); } @@ -57,7 +61,7 @@ protected: delete this; } - + public: //===--------------------------------------------------------------------===// @@ -88,16 +92,13 @@ public: /// void refineAbstractTypeTo(const Type *NewType); - void dump() const { Value::dump(); } + void dump() const { Type::dump(); } // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const DerivedType *T) { return true; } static inline bool classof(const Type *T) { return T->isDerivedType(); } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } }; @@ -111,12 +112,12 @@ class FunctionType : public DerivedType { const FunctionType &operator=(const FunctionType &); // Do not implement protected: /// This should really be private, but it squelches a bogus warning - /// from GCC to make them protected: warning: `class FunctionType' only + /// from GCC to make them protected: warning: `class FunctionType' only /// defines private constructors and has no friends /// /// Private ctor - Only can be created by a static member... /// - FunctionType(const Type *Result, const std::vector &Params, + FunctionType(const Type *Result, const std::vector &Params, bool IsVarArgs); public: @@ -140,28 +141,25 @@ public: /// getNumParams - Return the number of fixed parameters this function type /// requires. This does not consider varargs. /// - unsigned getNumParams() const { return ContainedTys.size()-1; } + unsigned getNumParams() const { return unsigned(ContainedTys.size()-1); } // Implement the AbstractTypeUser interface. virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy); virtual void typeBecameConcrete(const DerivedType *AbsTy); - + // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const FunctionType *T) { return true; } static inline bool classof(const Type *T) { - return T->getPrimitiveID() == FunctionTyID; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return T->getTypeID() == FunctionTyID; } }; -/// CompositeType - Common super class of ArrayType, StructType, and PointerType -/// +/// CompositeType - Common super class of ArrayType, StructType, PointerType +/// and PackedType class CompositeType : public DerivedType { protected: - inline CompositeType(PrimitiveID id) : DerivedType(id) { } + inline CompositeType(TypeID id) : DerivedType(id) { } public: /// getTypeAtIndex - Given an index value into the type, return the type of @@ -173,12 +171,10 @@ public: // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const CompositeType *T) { return true; } static inline bool classof(const Type *T) { - return T->getPrimitiveID() == ArrayTyID || - T->getPrimitiveID() == StructTyID || - T->getPrimitiveID() == PointerTyID; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return T->getTypeID() == ArrayTyID || + T->getTypeID() == StructTyID || + T->getTypeID() == PointerTyID || + T->getTypeID() == PackedTyID; } }; @@ -192,7 +188,7 @@ class StructType : public CompositeType { protected: /// This should really be private, but it squelches a bogus warning - /// from GCC to make them protected: warning: `class StructType' only + /// from GCC to make them protected: warning: `class StructType' only /// defines private constructors and has no friends /// /// Private ctor - Only can be created by a static member... @@ -211,7 +207,7 @@ public: element_iterator element_end() const { return ContainedTys.end(); } // Random access to the elements - unsigned getNumElements() const { return ContainedTys.size(); } + unsigned getNumElements() const { return unsigned(ContainedTys.size()); } const Type *getElementType(unsigned N) const { assert(N < ContainedTys.size() && "Element number out of range!"); return ContainedTys[N]; @@ -230,25 +226,24 @@ public: // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const StructType *T) { return true; } static inline bool classof(const Type *T) { - return T->getPrimitiveID() == StructTyID; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return T->getTypeID() == StructTyID; } }; -/// SequentialType - This is the superclass of the array and pointer type -/// classes. Both of these represent "arrays" in memory. The array type +/// SequentialType - This is the superclass of the array, pointer and packed +/// type classes. All of these represent "arrays" in memory. The array type /// represents a specifically sized array, pointer types are unsized/unknown -/// size arrays. SequentialType holds the common features of both, which stem -/// from the fact that both lay their components out in memory identically. +/// size arrays, packed types represent specifically sized arrays that +/// allow for use of SIMD instructions. SequentialType holds the common +/// features of all, which stem from the fact that all three lay their +/// components out in memory identically. /// class SequentialType : public CompositeType { SequentialType(const SequentialType &); // Do not implement! const SequentialType &operator=(const SequentialType &); // Do not implement! protected: - SequentialType(PrimitiveID TID, const Type *ElType) : CompositeType(TID) { + SequentialType(TypeID TID, const Type *ElType) : CompositeType(TID) { ContainedTys.reserve(1); ContainedTys.push_back(PATypeHandle(ElType, this)); } @@ -256,24 +251,21 @@ protected: public: inline const Type *getElementType() const { return ContainedTys[0]; } + virtual bool indexValid(const Value *V) const; + /// getTypeAtIndex - Given an index value into the type, return the type of /// the element. For sequential types, there is only one subtype... /// virtual const Type *getTypeAtIndex(const Value *V) const { return ContainedTys[0]; } - virtual bool indexValid(const Value *V) const { - return V->getType()->isInteger(); - } // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const SequentialType *T) { return true; } static inline bool classof(const Type *T) { - return T->getPrimitiveID() == ArrayTyID || - T->getPrimitiveID() == PointerTyID; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return T->getTypeID() == ArrayTyID || + T->getTypeID() == PointerTyID || + T->getTypeID() == PackedTyID; } }; @@ -282,26 +274,26 @@ public: /// class ArrayType : public SequentialType { friend class TypeMap; - unsigned NumElements; + uint64_t NumElements; ArrayType(const ArrayType &); // Do not implement const ArrayType &operator=(const ArrayType &); // Do not implement protected: /// This should really be private, but it squelches a bogus warning - /// from GCC to make them protected: warning: `class ArrayType' only + /// from GCC to make them protected: warning: `class ArrayType' only /// defines private constructors and has no friends /// /// Private ctor - Only can be created by a static member... /// - ArrayType(const Type *ElType, unsigned NumEl); + ArrayType(const Type *ElType, uint64_t NumEl); public: /// ArrayType::get - This static method is the primary way to construct an /// ArrayType /// - static ArrayType *get(const Type *ElementType, unsigned NumElements); + static ArrayType *get(const Type *ElementType, uint64_t NumElements); - inline unsigned getNumElements() const { return NumElements; } + inline uint64_t getNumElements() const { return NumElements; } // Implement the AbstractTypeUser interface. virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy); @@ -310,10 +302,43 @@ public: // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ArrayType *T) { return true; } static inline bool classof(const Type *T) { - return T->getPrimitiveID() == ArrayTyID; + return T->getTypeID() == ArrayTyID; } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); +}; + +/// PackedType - Class to represent packed types +/// +class PackedType : public SequentialType { + friend class TypeMap; + unsigned NumElements; + + PackedType(const PackedType &); // Do not implement + const PackedType &operator=(const PackedType &); // Do not implement +protected: + /// This should really be private, but it squelches a bogus warning + /// from GCC to make them protected: warning: `class PackedType' only + /// defines private constructors and has no friends + /// + /// Private ctor - Only can be created by a static member... + /// + PackedType(const Type *ElType, unsigned NumEl); + +public: + /// PackedType::get - This static method is the primary way to construct an + /// PackedType + /// + static PackedType *get(const Type *ElementType, unsigned NumElements); + + inline unsigned getNumElements() const { return NumElements; } + + // Implement the AbstractTypeUser interface. + virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy); + virtual void typeBecameConcrete(const DerivedType *AbsTy); + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const PackedType *T) { return true; } + static inline bool classof(const Type *T) { + return T->getTypeID() == PackedTyID; } }; @@ -326,7 +351,7 @@ class PointerType : public SequentialType { const PointerType &operator=(const PointerType &); // Do not implement protected: // This should really be private, but it squelches a bogus warning - // from GCC to make them protected: warning: `class PointerType' only + // from GCC to make them protected: warning: `class PointerType' only // defines private constructors and has no friends // Private ctor - Only can be created by a static member... @@ -343,10 +368,7 @@ public: // Implement support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const PointerType *T) { return true; } static inline bool classof(const Type *T) { - return T->getPrimitiveID() == PointerTyID; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return T->getTypeID() == PointerTyID; } }; @@ -358,7 +380,7 @@ class OpaqueType : public DerivedType { const OpaqueType &operator=(const OpaqueType &); // DO NOT IMPLEMENT protected: /// This should really be private, but it squelches a bogus warning - /// from GCC to make them protected: warning: `class OpaqueType' only + /// from GCC to make them protected: warning: `class OpaqueType' only /// defines private constructors and has no friends /// /// Private ctor - Only can be created by a static member... @@ -382,10 +404,7 @@ public: // Implement support for type inquiry through isa, cast, and dyn_cast: static inline bool classof(const OpaqueType *T) { return true; } static inline bool classof(const Type *T) { - return T->getPrimitiveID() == OpaqueTyID; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + return T->getTypeID() == OpaqueTyID; } };