include/llvm/Type.h

   1 //===-- llvm/Type.h - Classes for handling data types -----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains the declaration of the Type class.  For more "Type"
  11 // stuff, look in DerivedTypes.h.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_TYPE_H
  16 #define LLVM_TYPE_H
  17
  18 #include "llvm/Support/Casting.h"
  19
  20 namespace llvm {
  21
  22 class DerivedType;
  23 class PointerType;
  24 class IntegerType;
  25 class raw_ostream;
  26 class Module;
  27 class LLVMContext;
  28 class LLVMContextImpl;
  29 template<class GraphType> struct GraphTraits;
  30
  31 /// The instances of the Type class are immutable: once they are created,
  32 /// they are never changed.  Also note that only one instance of a particular
  33 /// type is ever created.  Thus seeing if two types are equal is a matter of
  34 /// doing a trivial pointer comparison. To enforce that no two equal instances
  35 /// are created, Type instances can only be created via static factory methods
  36 /// in class Type and in derived classes.  Once allocated, Types are never
  37 /// free'd.
  38 ///
  39 class Type {
  40 public:
  41   //===--------------------------------------------------------------------===//
  42   /// Definitions of all of the base types for the Type system.  Based on this
  43   /// value, you can cast to a "DerivedType" subclass (see DerivedTypes.h)
  44   /// Note: If you add an element to this, you need to add an element to the
  45   /// Type::getPrimitiveType function, or else things will break!
  46   /// Also update LLVMTypeKind and LLVMGetTypeKind () in the C binding.
  47   ///
  48   enum TypeID {
  49     // PrimitiveTypes - make sure LastPrimitiveTyID stays up to date.
  50     VoidTyID = 0,    ///<  0: type with no size
  51     FloatTyID,       ///<  1: 32-bit floating point type
  52     DoubleTyID,      ///<  2: 64-bit floating point type
  53     X86_FP80TyID,    ///<  3: 80-bit floating point type (X87)
  54     FP128TyID,       ///<  4: 128-bit floating point type (112-bit mantissa)
  55     PPC_FP128TyID,   ///<  5: 128-bit floating point type (two 64-bits, PowerPC)
  56     LabelTyID,       ///<  6: Labels
  57     MetadataTyID,    ///<  7: Metadata
  58     X86_MMXTyID,     ///<  8: MMX vectors (64 bits, X86 specific)
  59
  60     // Derived types... see DerivedTypes.h file.
  61     // Make sure FirstDerivedTyID stays up to date!
  62     IntegerTyID,     ///<  9: Arbitrary bit width integers
  63     FunctionTyID,    ///< 10: Functions
  64     StructTyID,      ///< 11: Structures
  65     ArrayTyID,       ///< 12: Arrays
  66     PointerTyID,     ///< 13: Pointers
  67     VectorTyID,      ///< 14: SIMD 'packed' format, or other vector type
  68
  69     NumTypeIDs,                         // Must remain as last defined ID
  70     LastPrimitiveTyID = X86_MMXTyID,
  71     FirstDerivedTyID = IntegerTyID
  72   };
  73
  74 private:
  75   /// Context - This refers to the LLVMContext in which this type was uniqued.
  76   LLVMContext &Context;
  77
  78   TypeID   ID : 8;            // The current base type of this type.
  79   unsigned SubclassData : 24; // Space for subclasses to store data
  80
  81 protected:
  82   friend class LLVMContextImpl;
  83   explicit Type(LLVMContext &C, TypeID tid)
  84     : Context(C), ID(tid), SubclassData(0),
  85       NumContainedTys(0), ContainedTys(0) {}
  86   ~Type() {}
  87
  88   unsigned getSubclassData() const { return SubclassData; }
  89   void setSubclassData(unsigned val) {
  90     SubclassData = val;
  91     // Ensure we don't have any accidental truncation.
  92     assert(SubclassData == val && "Subclass data too large for field");
  93   }
  94
  95   /// NumContainedTys - Keeps track of how many Type*'s there are in the
  96   /// ContainedTys list.
  97   unsigned NumContainedTys;
  98
  99   /// ContainedTys - A pointer to the array of Types contained by this Type.
 100   /// For example, this includes the arguments of a function type, the elements
 101   /// of a structure, the pointee of a pointer, the element type of an array,
 102   /// etc.  This pointer may be 0 for types that don't contain other types
 103   /// (Integer, Double, Float).
 104   Type * const *ContainedTys;
 105
 106 public:
 107   void print(raw_ostream &O) const;
 108   void dump() const;
 109
 110   /// getContext - Return the LLVMContext in which this type was uniqued.
 111   LLVMContext &getContext() const { return Context; }
 112
 113   //===--------------------------------------------------------------------===//
 114   // Accessors for working with types.
 115   //
 116
 117   /// getTypeID - Return the type id for the type.  This will return one
 118   /// of the TypeID enum elements defined above.
 119   ///
 120   TypeID getTypeID() const { return ID; }
 121
 122   /// isVoidTy - Return true if this is 'void'.
 123   bool isVoidTy() const { return ID == VoidTyID; }
 124
 125   /// isFloatTy - Return true if this is 'float', a 32-bit IEEE fp type.
 126   bool isFloatTy() const { return ID == FloatTyID; }
 127
 128   /// isDoubleTy - Return true if this is 'double', a 64-bit IEEE fp type.
 129   bool isDoubleTy() const { return ID == DoubleTyID; }
 130
 131   /// isX86_FP80Ty - Return true if this is x86 long double.
 132   bool isX86_FP80Ty() const { return ID == X86_FP80TyID; }
 133
 134   /// isFP128Ty - Return true if this is 'fp128'.
 135   bool isFP128Ty() const { return ID == FP128TyID; }
 136
 137   /// isPPC_FP128Ty - Return true if this is powerpc long double.
 138   bool isPPC_FP128Ty() const { return ID == PPC_FP128TyID; }
 139
 140   /// isFloatingPointTy - Return true if this is one of the five floating point
 141   /// types
 142   bool isFloatingPointTy() const {
 143     return ID == FloatTyID || ID == DoubleTyID ||
 144       ID == X86_FP80TyID || ID == FP128TyID || ID == PPC_FP128TyID;
 145   }
 146
 147   /// isX86_MMXTy - Return true if this is X86 MMX.
 148   bool isX86_MMXTy() const { return ID == X86_MMXTyID; }
 149
 150   /// isFPOrFPVectorTy - Return true if this is a FP type or a vector of FP.
 151   ///
 152   bool isFPOrFPVectorTy() const;
 153
 154   /// isLabelTy - Return true if this is 'label'.
 155   bool isLabelTy() const { return ID == LabelTyID; }
 156
 157   /// isMetadataTy - Return true if this is 'metadata'.
 158   bool isMetadataTy() const { return ID == MetadataTyID; }
 159
 160   /// isIntegerTy - True if this is an instance of IntegerType.
 161   ///
 162   bool isIntegerTy() const { return ID == IntegerTyID; }
 163
 164   /// isIntegerTy - Return true if this is an IntegerType of the given width.
 165   bool isIntegerTy(unsigned Bitwidth) const;
 166
 167   /// isIntOrIntVectorTy - Return true if this is an integer type or a vector of
 168   /// integer types.
 169   ///
 170   bool isIntOrIntVectorTy() const;
 171
 172   /// isFunctionTy - True if this is an instance of FunctionType.
 173   ///
 174   bool isFunctionTy() const { return ID == FunctionTyID; }
 175
 176   /// isStructTy - True if this is an instance of StructType.
 177   ///
 178   bool isStructTy() const { return ID == StructTyID; }
 179
 180   /// isArrayTy - True if this is an instance of ArrayType.
 181   ///
 182   bool isArrayTy() const { return ID == ArrayTyID; }
 183
 184   /// isPointerTy - True if this is an instance of PointerType.
 185   ///
 186   bool isPointerTy() const { return ID == PointerTyID; }
 187
 188   /// isVectorTy - True if this is an instance of VectorType.
 189   ///
 190   bool isVectorTy() const { return ID == VectorTyID; }
 191
 192   /// canLosslesslyBitCastTo - Return true if this type could be converted
 193   /// with a lossless BitCast to type 'Ty'. For example, i8* to i32*. BitCasts
 194   /// are valid for types of the same size only where no re-interpretation of
 195   /// the bits is done.
 196   /// @brief Determine if this type could be losslessly bitcast to Ty
 197   bool canLosslesslyBitCastTo(const Type *Ty) const;
 198
 199   /// isEmptyTy - Return true if this type is empty, that is, it has no
 200   /// elements or all its elements are empty.
 201   bool isEmptyTy() const;
 202
 203   /// Here are some useful little methods to query what type derived types are
 204   /// Note that all other types can just compare to see if this == Type::xxxTy;
 205   ///
 206   bool isPrimitiveType() const { return ID <= LastPrimitiveTyID; }
 207   bool isDerivedType()   const { return ID >= FirstDerivedTyID; }
 208
 209   /// isFirstClassType - Return true if the type is "first class", meaning it
 210   /// is a valid type for a Value.
 211   ///
 212   bool isFirstClassType() const {
 213     return ID != FunctionTyID && ID != VoidTyID;
 214   }
 215
 216   /// isSingleValueType - Return true if the type is a valid type for a
 217   /// register in codegen.  This includes all first-class types except struct
 218   /// and array types.
 219   ///
 220   bool isSingleValueType() const {
 221     return (ID != VoidTyID && isPrimitiveType()) ||
 222             ID == IntegerTyID || ID == PointerTyID || ID == VectorTyID;
 223   }
 224
 225   /// isAggregateType - Return true if the type is an aggregate type. This
 226   /// means it is valid as the first operand of an insertvalue or
 227   /// extractvalue instruction. This includes struct and array types, but
 228   /// does not include vector types.
 229   ///
 230   bool isAggregateType() const {
 231     return ID == StructTyID || ID == ArrayTyID;
 232   }
 233
 234   /// isSized - Return true if it makes sense to take the size of this type.  To
 235   /// get the actual size for a particular target, it is reasonable to use the
 236   /// TargetData subsystem to do this.
 237   ///
 238   bool isSized() const {
 239     // If it's a primitive, it is always sized.
 240     if (ID == IntegerTyID || isFloatingPointTy() || ID == PointerTyID ||
 241         ID == X86_MMXTyID)
 242       return true;
 243     // If it is not something that can have a size (e.g. a function or label),
 244     // it doesn't have a size.
 245     if (ID != StructTyID && ID != ArrayTyID && ID != VectorTyID)
 246       return false;
 247     // Otherwise we have to try harder to decide.
 248     return isSizedDerivedType();
 249   }
 250
 251   /// getPrimitiveSizeInBits - Return the basic size of this type if it is a
 252   /// primitive type.  These are fixed by LLVM and are not target dependent.
 253   /// This will return zero if the type does not have a size or is not a
 254   /// primitive type.
 255   ///
 256   /// Note that this may not reflect the size of memory allocated for an
 257   /// instance of the type or the number of bytes that are written when an
 258   /// instance of the type is stored to memory. The TargetData class provides
 259   /// additional query functions to provide this information.
 260   ///
 261   unsigned getPrimitiveSizeInBits() const;
 262
 263   /// getScalarSizeInBits - If this is a vector type, return the
 264   /// getPrimitiveSizeInBits value for the element type. Otherwise return the
 265   /// getPrimitiveSizeInBits value for this type.
 266   unsigned getScalarSizeInBits() const;
 267
 268   /// getFPMantissaWidth - Return the width of the mantissa of this type.  This
 269   /// is only valid on floating point types.  If the FP type does not
 270   /// have a stable mantissa (e.g. ppc long double), this method returns -1.
 271   int getFPMantissaWidth() const;
 272
 273   /// getScalarType - If this is a vector type, return the element type,
 274   /// otherwise return 'this'.
 275   const Type *getScalarType() const;
 276
 277   //===--------------------------------------------------------------------===//
 278   // Type Iteration support.
 279   //
 280   typedef Type * const *subtype_iterator;
 281   subtype_iterator subtype_begin() const { return ContainedTys; }
 282   subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
 283
 284   /// getContainedType - This method is used to implement the type iterator
 285   /// (defined a the end of the file).  For derived types, this returns the
 286   /// types 'contained' in the derived type.
 287   ///
 288   Type *getContainedType(unsigned i) const {
 289     assert(i < NumContainedTys && "Index out of range!");
 290     return ContainedTys[i];
 291   }
 292
 293   /// getNumContainedTypes - Return the number of types in the derived type.
 294   ///
 295   unsigned getNumContainedTypes() const { return NumContainedTys; }
 296
 297   //===--------------------------------------------------------------------===//
 298   // Static members exported by the Type class itself.  Useful for getting
 299   // instances of Type.
 300   //
 301
 302   /// getPrimitiveType - Return a type based on an identifier.
 303   static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber);
 304
 305   //===--------------------------------------------------------------------===//
 306   // These are the builtin types that are always available.
 307   //
 308   static Type *getVoidTy(LLVMContext &C);
 309   static Type *getLabelTy(LLVMContext &C);
 310   static Type *getFloatTy(LLVMContext &C);
 311   static Type *getDoubleTy(LLVMContext &C);
 312   static Type *getMetadataTy(LLVMContext &C);
 313   static Type *getX86_FP80Ty(LLVMContext &C);
 314   static Type *getFP128Ty(LLVMContext &C);
 315   static Type *getPPC_FP128Ty(LLVMContext &C);
 316   static Type *getX86_MMXTy(LLVMContext &C);
 317   static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
 318   static IntegerType *getInt1Ty(LLVMContext &C);
 319   static IntegerType *getInt8Ty(LLVMContext &C);
 320   static IntegerType *getInt16Ty(LLVMContext &C);
 321   static IntegerType *getInt32Ty(LLVMContext &C);
 322   static IntegerType *getInt64Ty(LLVMContext &C);
 323
 324   //===--------------------------------------------------------------------===//
 325   // Convenience methods for getting pointer types with one of the above builtin
 326   // types as pointee.
 327   //
 328   static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
 329   static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
 330   static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);
 331   static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0);
 332   static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0);
 333   static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);
 334   static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0);
 335   static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0);
 336   static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0);
 337   static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0);
 338   static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0);
 339   static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0);
 340
 341   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 342   static inline bool classof(const Type *) { return true; }
 343
 344   /// getPointerTo - Return a pointer to the current type.  This is equivalent
 345   /// to PointerType::get(Foo, AddrSpace).
 346   PointerType *getPointerTo(unsigned AddrSpace = 0) const;
 347
 348 private:
 349   /// isSizedDerivedType - Derived types like structures and arrays are sized
 350   /// iff all of the members of the type are sized as well.  Since asking for
 351   /// their size is relatively uncommon, move this operation out of line.
 352   bool isSizedDerivedType() const;
 353 };
 354
 355 // Printing of types.
 356 static inline raw_ostream &operator<<(raw_ostream &OS, const Type &T) {
 357   T.print(OS);
 358   return OS;
 359 }
 360
 361 // allow isa<PointerType>(x) to work without DerivedTypes.h included.
 362 template <> struct isa_impl<PointerType, Type> {
 363   static inline bool doit(const Type &Ty) {
 364     return Ty.getTypeID() == Type::PointerTyID;
 365   }
 366 };
 367
 368
 369 //===----------------------------------------------------------------------===//
 370 // Provide specializations of GraphTraits to be able to treat a type as a
 371 // graph of sub types.
 372
 373
 374 template <> struct GraphTraits<Type*> {
 375   typedef Type NodeType;
 376   typedef Type::subtype_iterator ChildIteratorType;
 377
 378   static inline NodeType *getEntryNode(Type *T) { return T; }
 379   static inline ChildIteratorType child_begin(NodeType *N) {
 380     return N->subtype_begin();
 381   }
 382   static inline ChildIteratorType child_end(NodeType *N) {
 383     return N->subtype_end();
 384   }
 385 };
 386
 387 template <> struct GraphTraits<const Type*> {
 388   typedef const Type NodeType;
 389   typedef Type::subtype_iterator ChildIteratorType;
 390
 391   static inline NodeType *getEntryNode(const Type *T) { return T; }
 392   static inline ChildIteratorType child_begin(NodeType *N) {
 393     return N->subtype_begin();
 394   }
 395   static inline ChildIteratorType child_end(NodeType *N) {
 396     return N->subtype_end();
 397   }
 398 };
 399
 400 } // End llvm namespace
 401
 402 #endif