diff options
Diffstat (limited to 'include/llvm/Type.h')
-rw-r--r-- | include/llvm/Type.h | 458 |
1 files changed, 0 insertions, 458 deletions
diff --git a/include/llvm/Type.h b/include/llvm/Type.h deleted file mode 100644 index def4575..0000000 --- a/include/llvm/Type.h +++ /dev/null @@ -1,458 +0,0 @@ -//===-- llvm/Type.h - Classes for handling data types -----------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file contains the declaration of the Type class. For more "Type" -// stuff, look in DerivedTypes.h. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_TYPE_H -#define LLVM_TYPE_H - -#include "llvm/Support/Casting.h" -#include "llvm/Support/DataTypes.h" - -namespace llvm { - -class PointerType; -class IntegerType; -class raw_ostream; -class Module; -class LLVMContext; -class LLVMContextImpl; -class StringRef; -template<class GraphType> struct GraphTraits; - -/// The instances of the Type class are immutable: once they are created, -/// they are never changed. Also note that only one instance of a particular -/// type is ever created. Thus seeing if two types are equal is a matter of -/// doing a trivial pointer comparison. To enforce that no two equal instances -/// are created, Type instances can only be created via static factory methods -/// in class Type and in derived classes. Once allocated, Types are never -/// free'd. -/// -class Type { -public: - //===--------------------------------------------------------------------===// - /// Definitions of all of the base types for the Type system. Based on this - /// value, you can cast to a class defined in DerivedTypes.h. - /// Note: If you add an element to this, you need to add an element to the - /// Type::getPrimitiveType function, or else things will break! - /// Also update LLVMTypeKind and LLVMGetTypeKind () in the C binding. - /// - enum TypeID { - // PrimitiveTypes - make sure LastPrimitiveTyID stays up to date. - VoidTyID = 0, ///< 0: type with no size - HalfTyID, ///< 1: 16-bit floating point type - FloatTyID, ///< 2: 32-bit floating point type - DoubleTyID, ///< 3: 64-bit floating point type - X86_FP80TyID, ///< 4: 80-bit floating point type (X87) - FP128TyID, ///< 5: 128-bit floating point type (112-bit mantissa) - PPC_FP128TyID, ///< 6: 128-bit floating point type (two 64-bits, PowerPC) - LabelTyID, ///< 7: Labels - MetadataTyID, ///< 8: Metadata - X86_MMXTyID, ///< 9: MMX vectors (64 bits, X86 specific) - - // Derived types... see DerivedTypes.h file. - // Make sure FirstDerivedTyID stays up to date! - IntegerTyID, ///< 10: Arbitrary bit width integers - FunctionTyID, ///< 11: Functions - StructTyID, ///< 12: Structures - ArrayTyID, ///< 13: Arrays - PointerTyID, ///< 14: Pointers - VectorTyID, ///< 15: SIMD 'packed' format, or other vector type - - NumTypeIDs, // Must remain as last defined ID - LastPrimitiveTyID = X86_MMXTyID, - FirstDerivedTyID = IntegerTyID - }; - -private: - /// Context - This refers to the LLVMContext in which this type was uniqued. - LLVMContext &Context; - - // Due to Ubuntu GCC bug 910363: - // https://bugs.launchpad.net/ubuntu/+source/gcc-4.5/+bug/910363 - // Bitpack ID and SubclassData manually. - // Note: TypeID : low 8 bit; SubclassData : high 24 bit. - uint32_t IDAndSubclassData; - -protected: - friend class LLVMContextImpl; - explicit Type(LLVMContext &C, TypeID tid) - : Context(C), IDAndSubclassData(0), - NumContainedTys(0), ContainedTys(0) { - setTypeID(tid); - } - ~Type() {} - - void setTypeID(TypeID ID) { - IDAndSubclassData = (ID & 0xFF) | (IDAndSubclassData & 0xFFFFFF00); - assert(getTypeID() == ID && "TypeID data too large for field"); - } - - unsigned getSubclassData() const { return IDAndSubclassData >> 8; } - - void setSubclassData(unsigned val) { - IDAndSubclassData = (IDAndSubclassData & 0xFF) | (val << 8); - // Ensure we don't have any accidental truncation. - assert(getSubclassData() == val && "Subclass data too large for field"); - } - - /// NumContainedTys - Keeps track of how many Type*'s there are in the - /// ContainedTys list. - unsigned NumContainedTys; - - /// ContainedTys - A pointer to the array of Types contained by this Type. - /// For example, this includes the arguments of a function type, the elements - /// of a structure, the pointee of a pointer, the element type of an array, - /// etc. This pointer may be 0 for types that don't contain other types - /// (Integer, Double, Float). - Type * const *ContainedTys; - -public: - void print(raw_ostream &O) const; - void dump() const; - - /// getContext - Return the LLVMContext in which this type was uniqued. - LLVMContext &getContext() const { return Context; } - - //===--------------------------------------------------------------------===// - // Accessors for working with types. - // - - /// getTypeID - Return the type id for the type. This will return one - /// of the TypeID enum elements defined above. - /// - TypeID getTypeID() const { return (TypeID)(IDAndSubclassData & 0xFF); } - - /// isVoidTy - Return true if this is 'void'. - bool isVoidTy() const { return getTypeID() == VoidTyID; } - - /// isHalfTy - Return true if this is 'half', a 16-bit IEEE fp type. - bool isHalfTy() const { return getTypeID() == HalfTyID; } - - /// isFloatTy - Return true if this is 'float', a 32-bit IEEE fp type. - bool isFloatTy() const { return getTypeID() == FloatTyID; } - - /// isDoubleTy - Return true if this is 'double', a 64-bit IEEE fp type. - bool isDoubleTy() const { return getTypeID() == DoubleTyID; } - - /// isX86_FP80Ty - Return true if this is x86 long double. - bool isX86_FP80Ty() const { return getTypeID() == X86_FP80TyID; } - - /// isFP128Ty - Return true if this is 'fp128'. - bool isFP128Ty() const { return getTypeID() == FP128TyID; } - - /// isPPC_FP128Ty - Return true if this is powerpc long double. - bool isPPC_FP128Ty() const { return getTypeID() == PPC_FP128TyID; } - - /// isFloatingPointTy - Return true if this is one of the six floating point - /// types - bool isFloatingPointTy() const { - return getTypeID() == HalfTyID || getTypeID() == FloatTyID || - getTypeID() == DoubleTyID || - getTypeID() == X86_FP80TyID || getTypeID() == FP128TyID || - getTypeID() == PPC_FP128TyID; - } - - /// isX86_MMXTy - Return true if this is X86 MMX. - bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID; } - - /// isFPOrFPVectorTy - Return true if this is a FP type or a vector of FP. - /// - bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); } - - /// isLabelTy - Return true if this is 'label'. - bool isLabelTy() const { return getTypeID() == LabelTyID; } - - /// isMetadataTy - Return true if this is 'metadata'. - bool isMetadataTy() const { return getTypeID() == MetadataTyID; } - - /// isIntegerTy - True if this is an instance of IntegerType. - /// - bool isIntegerTy() const { return getTypeID() == IntegerTyID; } - - /// isIntegerTy - Return true if this is an IntegerType of the given width. - bool isIntegerTy(unsigned Bitwidth) const; - - /// isIntOrIntVectorTy - Return true if this is an integer type or a vector of - /// integer types. - /// - bool isIntOrIntVectorTy() const { return getScalarType()->isIntegerTy(); } - - /// isFunctionTy - True if this is an instance of FunctionType. - /// - bool isFunctionTy() const { return getTypeID() == FunctionTyID; } - - /// isStructTy - True if this is an instance of StructType. - /// - bool isStructTy() const { return getTypeID() == StructTyID; } - - /// isArrayTy - True if this is an instance of ArrayType. - /// - bool isArrayTy() const { return getTypeID() == ArrayTyID; } - - /// isPointerTy - True if this is an instance of PointerType. - /// - bool isPointerTy() const { return getTypeID() == PointerTyID; } - - /// isPtrOrPtrVectorTy - Return true if this is a pointer type or a vector of - /// pointer types. - /// - bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); } - - /// isVectorTy - True if this is an instance of VectorType. - /// - bool isVectorTy() const { return getTypeID() == VectorTyID; } - - /// canLosslesslyBitCastTo - Return true if this type could be converted - /// with a lossless BitCast to type 'Ty'. For example, i8* to i32*. BitCasts - /// are valid for types of the same size only where no re-interpretation of - /// the bits is done. - /// @brief Determine if this type could be losslessly bitcast to Ty - bool canLosslesslyBitCastTo(Type *Ty) const; - - /// isEmptyTy - Return true if this type is empty, that is, it has no - /// elements or all its elements are empty. - bool isEmptyTy() const; - - /// Here are some useful little methods to query what type derived types are - /// Note that all other types can just compare to see if this == Type::xxxTy; - /// - bool isPrimitiveType() const { return getTypeID() <= LastPrimitiveTyID; } - bool isDerivedType() const { return getTypeID() >= FirstDerivedTyID; } - - /// isFirstClassType - Return true if the type is "first class", meaning it - /// is a valid type for a Value. - /// - bool isFirstClassType() const { - return getTypeID() != FunctionTyID && getTypeID() != VoidTyID; - } - - /// isSingleValueType - Return true if the type is a valid type for a - /// register in codegen. This includes all first-class types except struct - /// and array types. - /// - bool isSingleValueType() const { - return (getTypeID() != VoidTyID && isPrimitiveType()) || - getTypeID() == IntegerTyID || getTypeID() == PointerTyID || - getTypeID() == VectorTyID; - } - - /// isAggregateType - Return true if the type is an aggregate type. This - /// means it is valid as the first operand of an insertvalue or - /// extractvalue instruction. This includes struct and array types, but - /// does not include vector types. - /// - bool isAggregateType() const { - return getTypeID() == StructTyID || getTypeID() == ArrayTyID; - } - - /// isSized - Return true if it makes sense to take the size of this type. To - /// get the actual size for a particular target, it is reasonable to use the - /// DataLayout subsystem to do this. - /// - bool isSized() const { - // If it's a primitive, it is always sized. - if (getTypeID() == IntegerTyID || isFloatingPointTy() || - getTypeID() == PointerTyID || - getTypeID() == X86_MMXTyID) - return true; - // If it is not something that can have a size (e.g. a function or label), - // it doesn't have a size. - if (getTypeID() != StructTyID && getTypeID() != ArrayTyID && - getTypeID() != VectorTyID) - return false; - // Otherwise we have to try harder to decide. - return isSizedDerivedType(); - } - - /// getPrimitiveSizeInBits - Return the basic size of this type if it is a - /// primitive type. These are fixed by LLVM and are not target dependent. - /// This will return zero if the type does not have a size or is not a - /// primitive type. - /// - /// Note that this may not reflect the size of memory allocated for an - /// instance of the type or the number of bytes that are written when an - /// instance of the type is stored to memory. The DataLayout class provides - /// additional query functions to provide this information. - /// - unsigned getPrimitiveSizeInBits() const; - - /// getScalarSizeInBits - If this is a vector type, return the - /// getPrimitiveSizeInBits value for the element type. Otherwise return the - /// getPrimitiveSizeInBits value for this type. - unsigned getScalarSizeInBits(); - - /// getFPMantissaWidth - Return the width of the mantissa of this type. This - /// is only valid on floating point types. If the FP type does not - /// have a stable mantissa (e.g. ppc long double), this method returns -1. - int getFPMantissaWidth() const; - - /// getScalarType - If this is a vector type, return the element type, - /// otherwise return 'this'. - const Type *getScalarType() const; - Type *getScalarType(); - - //===--------------------------------------------------------------------===// - // Type Iteration support. - // - typedef Type * const *subtype_iterator; - subtype_iterator subtype_begin() const { return ContainedTys; } - subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];} - - /// getContainedType - This method is used to implement the type iterator - /// (defined a the end of the file). For derived types, this returns the - /// types 'contained' in the derived type. - /// - Type *getContainedType(unsigned i) const { - assert(i < NumContainedTys && "Index out of range!"); - return ContainedTys[i]; - } - - /// getNumContainedTypes - Return the number of types in the derived type. - /// - unsigned getNumContainedTypes() const { return NumContainedTys; } - - //===--------------------------------------------------------------------===// - // Helper methods corresponding to subclass methods. This forces a cast to - // the specified subclass and calls its accessor. "getVectorNumElements" (for - // example) is shorthand for cast<VectorType>(Ty)->getNumElements(). This is - // only intended to cover the core methods that are frequently used, helper - // methods should not be added here. - - unsigned getIntegerBitWidth() const; - - Type *getFunctionParamType(unsigned i) const; - unsigned getFunctionNumParams() const; - bool isFunctionVarArg() const; - - StringRef getStructName() const; - unsigned getStructNumElements() const; - Type *getStructElementType(unsigned N) const; - - Type *getSequentialElementType() const; - - uint64_t getArrayNumElements() const; - Type *getArrayElementType() const { return getSequentialElementType(); } - - unsigned getVectorNumElements() const; - Type *getVectorElementType() const { return getSequentialElementType(); } - - Type *getPointerElementType() const { return getSequentialElementType(); } - - /// \brief Get the address space of this pointer or pointer vector type. - unsigned getPointerAddressSpace() const; - - //===--------------------------------------------------------------------===// - // Static members exported by the Type class itself. Useful for getting - // instances of Type. - // - - /// getPrimitiveType - Return a type based on an identifier. - static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber); - - //===--------------------------------------------------------------------===// - // These are the builtin types that are always available. - // - static Type *getVoidTy(LLVMContext &C); - static Type *getLabelTy(LLVMContext &C); - static Type *getHalfTy(LLVMContext &C); - static Type *getFloatTy(LLVMContext &C); - static Type *getDoubleTy(LLVMContext &C); - static Type *getMetadataTy(LLVMContext &C); - static Type *getX86_FP80Ty(LLVMContext &C); - static Type *getFP128Ty(LLVMContext &C); - static Type *getPPC_FP128Ty(LLVMContext &C); - static Type *getX86_MMXTy(LLVMContext &C); - static IntegerType *getIntNTy(LLVMContext &C, unsigned N); - static IntegerType *getInt1Ty(LLVMContext &C); - static IntegerType *getInt8Ty(LLVMContext &C); - static IntegerType *getInt16Ty(LLVMContext &C); - static IntegerType *getInt32Ty(LLVMContext &C); - static IntegerType *getInt64Ty(LLVMContext &C); - - //===--------------------------------------------------------------------===// - // Convenience methods for getting pointer types with one of the above builtin - // types as pointee. - // - static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0); - static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0); - static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0); - static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0); - static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0); - static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0); - static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0); - static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0); - static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0); - static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0); - static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0); - static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0); - static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0); - - /// getPointerTo - Return a pointer to the current type. This is equivalent - /// to PointerType::get(Foo, AddrSpace). - PointerType *getPointerTo(unsigned AddrSpace = 0); - -private: - /// isSizedDerivedType - Derived types like structures and arrays are sized - /// iff all of the members of the type are sized as well. Since asking for - /// their size is relatively uncommon, move this operation out of line. - bool isSizedDerivedType() const; -}; - -// Printing of types. -static inline raw_ostream &operator<<(raw_ostream &OS, Type &T) { - T.print(OS); - return OS; -} - -// allow isa<PointerType>(x) to work without DerivedTypes.h included. -template <> struct isa_impl<PointerType, Type> { - static inline bool doit(const Type &Ty) { - return Ty.getTypeID() == Type::PointerTyID; - } -}; - - -//===----------------------------------------------------------------------===// -// Provide specializations of GraphTraits to be able to treat a type as a -// graph of sub types. - - -template <> struct GraphTraits<Type*> { - typedef Type NodeType; - typedef Type::subtype_iterator ChildIteratorType; - - static inline NodeType *getEntryNode(Type *T) { return T; } - static inline ChildIteratorType child_begin(NodeType *N) { - return N->subtype_begin(); - } - static inline ChildIteratorType child_end(NodeType *N) { - return N->subtype_end(); - } -}; - -template <> struct GraphTraits<const Type*> { - typedef const Type NodeType; - typedef Type::subtype_iterator ChildIteratorType; - - static inline NodeType *getEntryNode(NodeType *T) { return T; } - static inline ChildIteratorType child_begin(NodeType *N) { - return N->subtype_begin(); - } - static inline ChildIteratorType child_end(NodeType *N) { - return N->subtype_end(); - } -}; - -} // End llvm namespace - -#endif |