include/llvm/IR/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_IR_TYPE_H
  16 #define LLVM_IR_TYPE_H
  17
  18 #include "llvm-c/Core.h"
  19 #include "llvm/ADT/APFloat.h"
  20 #include "llvm/ADT/SmallPtrSet.h"
  21 #include "llvm/Support/CBindingWrapping.h"
  22 #include "llvm/Support/Casting.h"
  23 #include "llvm/Support/DataTypes.h"
  24 #include "llvm/Support/ErrorHandling.h"
  25
  26 namespace llvm {
  27
  28 class PointerType;
  29 class IntegerType;
  30 class raw_ostream;
  31 class Module;
  32 class LLVMContext;
  33 class LLVMContextImpl;
  34 class StringRef;
  35 template<class GraphType> struct GraphTraits;
  36
  37 /// The instances of the Type class are immutable: once they are created,
  38 /// they are never changed.  Also note that only one instance of a particular
  39 /// type is ever created.  Thus seeing if two types are equal is a matter of
  40 /// doing a trivial pointer comparison. To enforce that no two equal instances
  41 /// are created, Type instances can only be created via static factory methods
  42 /// in class Type and in derived classes.  Once allocated, Types are never
  43 /// free'd.
  44 ///
  45 class Type {
  46 public:
  47   //===--------------------------------------------------------------------===//
  48   /// Definitions of all of the base types for the Type system.  Based on this
  49   /// value, you can cast to a class defined in DerivedTypes.h.
  50   /// Note: If you add an element to this, you need to add an element to the
  51   /// Type::getPrimitiveType function, or else things will break!
  52   /// Also update LLVMTypeKind and LLVMGetTypeKind () in the C binding.
  53   ///
  54   enum TypeID {
  55     // PrimitiveTypes - make sure LastPrimitiveTyID stays up to date.
  56     VoidTyID = 0,    ///<  0: type with no size
  57     HalfTyID,        ///<  1: 16-bit floating point type
  58     FloatTyID,       ///<  2: 32-bit floating point type
  59     DoubleTyID,      ///<  3: 64-bit floating point type
  60     X86_FP80TyID,    ///<  4: 80-bit floating point type (X87)
  61     FP128TyID,       ///<  5: 128-bit floating point type (112-bit mantissa)
  62     PPC_FP128TyID,   ///<  6: 128-bit floating point type (two 64-bits, PowerPC)
  63     LabelTyID,       ///<  7: Labels
  64     MetadataTyID,    ///<  8: Metadata
  65     X86_MMXTyID,     ///<  9: MMX vectors (64 bits, X86 specific)
  66
  67     // Derived types... see DerivedTypes.h file.
  68     // Make sure FirstDerivedTyID stays up to date!
  69     IntegerTyID,     ///< 10: Arbitrary bit width integers
  70     FunctionTyID,    ///< 11: Functions
  71     StructTyID,      ///< 12: Structures
  72     ArrayTyID,       ///< 13: Arrays
  73     PointerTyID,     ///< 14: Pointers
  74     VectorTyID       ///< 15: SIMD 'packed' format, or other vector type
  75   };
  76
  77 private:
  78   /// Context - This refers to the LLVMContext in which this type was uniqued.
  79   LLVMContext &Context;
  80
  81   // Due to Ubuntu GCC bug 910363:
  82   // https://bugs.launchpad.net/ubuntu/+source/gcc-4.5/+bug/910363
  83   // Bitpack ID and SubclassData manually.
  84   // Note: TypeID : low 8 bit; SubclassData : high 24 bit.
  85   uint32_t IDAndSubclassData;
  86
  87 protected:
  88   friend class LLVMContextImpl;
  89   explicit Type(LLVMContext &C, TypeID tid)
  90     : Context(C), IDAndSubclassData(0),
  91       NumContainedTys(0), ContainedTys(nullptr) {
  92     setTypeID(tid);
  93   }
  94   ~Type() = default;
  95
  96   void setTypeID(TypeID ID) {
  97     IDAndSubclassData = (ID & 0xFF) | (IDAndSubclassData & 0xFFFFFF00);
  98     assert(getTypeID() == ID && "TypeID data too large for field");
  99   }
 100
 101   unsigned getSubclassData() const { return IDAndSubclassData >> 8; }
 102
 103   void setSubclassData(unsigned val) {
 104     IDAndSubclassData = (IDAndSubclassData & 0xFF) | (val << 8);
 105     // Ensure we don't have any accidental truncation.
 106     assert(getSubclassData() == val && "Subclass data too large for field");
 107   }
 108
 109   /// NumContainedTys - Keeps track of how many Type*'s there are in the
 110   /// ContainedTys list.
 111   unsigned NumContainedTys;
 112
 113   /// ContainedTys - A pointer to the array of Types contained by this Type.
 114   /// For example, this includes the arguments of a function type, the elements
 115   /// of a structure, the pointee of a pointer, the element type of an array,
 116   /// etc.  This pointer may be 0 for types that don't contain other types
 117   /// (Integer, Double, Float).
 118   Type * const *ContainedTys;
 119
 120 public:
 121   void print(raw_ostream &O) const;
 122   void dump() const;
 123
 124   /// getContext - Return the LLVMContext in which this type was uniqued.
 125   LLVMContext &getContext() const { return Context; }
 126
 127   //===--------------------------------------------------------------------===//
 128   // Accessors for working with types.
 129   //
 130
 131   /// getTypeID - Return the type id for the type.  This will return one
 132   /// of the TypeID enum elements defined above.
 133   ///
 134   TypeID getTypeID() const { return (TypeID)(IDAndSubclassData & 0xFF); }
 135
 136   /// isVoidTy - Return true if this is 'void'.
 137   bool isVoidTy() const { return getTypeID() == VoidTyID; }
 138
 139   /// isHalfTy - Return true if this is 'half', a 16-bit IEEE fp type.
 140   bool isHalfTy() const { return getTypeID() == HalfTyID; }
 141
 142   /// isFloatTy - Return true if this is 'float', a 32-bit IEEE fp type.
 143   bool isFloatTy() const { return getTypeID() == FloatTyID; }
 144
 145   /// isDoubleTy - Return true if this is 'double', a 64-bit IEEE fp type.
 146   bool isDoubleTy() const { return getTypeID() == DoubleTyID; }
 147
 148   /// isX86_FP80Ty - Return true if this is x86 long double.
 149   bool isX86_FP80Ty() const { return getTypeID() == X86_FP80TyID; }
 150
 151   /// isFP128Ty - Return true if this is 'fp128'.
 152   bool isFP128Ty() const { return getTypeID() == FP128TyID; }
 153
 154   /// isPPC_FP128Ty - Return true if this is powerpc long double.
 155   bool isPPC_FP128Ty() const { return getTypeID() == PPC_FP128TyID; }
 156
 157   /// isFloatingPointTy - Return true if this is one of the six floating point
 158   /// types
 159   bool isFloatingPointTy() const {
 160     return getTypeID() == HalfTyID || getTypeID() == FloatTyID ||
 161            getTypeID() == DoubleTyID ||
 162            getTypeID() == X86_FP80TyID || getTypeID() == FP128TyID ||
 163            getTypeID() == PPC_FP128TyID;
 164   }
 165
 166   const fltSemantics &getFltSemantics() const {
 167     switch (getTypeID()) {
 168     case HalfTyID: return APFloat::IEEEhalf;
 169     case FloatTyID: return APFloat::IEEEsingle;
 170     case DoubleTyID: return APFloat::IEEEdouble;
 171     case X86_FP80TyID: return APFloat::x87DoubleExtended;
 172     case FP128TyID: return APFloat::IEEEquad;
 173     case PPC_FP128TyID: return APFloat::PPCDoubleDouble;
 174     default: llvm_unreachable("Invalid floating type");
 175     }
 176   }
 177
 178   /// isX86_MMXTy - Return true if this is X86 MMX.
 179   bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID; }
 180
 181   /// isFPOrFPVectorTy - Return true if this is a FP type or a vector of FP.
 182   ///
 183   bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); }
 184
 185   /// isLabelTy - Return true if this is 'label'.
 186   bool isLabelTy() const { return getTypeID() == LabelTyID; }
 187
 188   /// isMetadataTy - Return true if this is 'metadata'.
 189   bool isMetadataTy() const { return getTypeID() == MetadataTyID; }
 190
 191   /// isIntegerTy - True if this is an instance of IntegerType.
 192   ///
 193   bool isIntegerTy() const { return getTypeID() == IntegerTyID; }
 194
 195   /// isIntegerTy - Return true if this is an IntegerType of the given width.
 196   bool isIntegerTy(unsigned Bitwidth) const;
 197
 198   /// isIntOrIntVectorTy - Return true if this is an integer type or a vector of
 199   /// integer types.
 200   ///
 201   bool isIntOrIntVectorTy() const { return getScalarType()->isIntegerTy(); }
 202
 203   /// isFunctionTy - True if this is an instance of FunctionType.
 204   ///
 205   bool isFunctionTy() const { return getTypeID() == FunctionTyID; }
 206
 207   /// isStructTy - True if this is an instance of StructType.
 208   ///
 209   bool isStructTy() const { return getTypeID() == StructTyID; }
 210
 211   /// isArrayTy - True if this is an instance of ArrayType.
 212   ///
 213   bool isArrayTy() const { return getTypeID() == ArrayTyID; }
 214
 215   /// isPointerTy - True if this is an instance of PointerType.
 216   ///
 217   bool isPointerTy() const { return getTypeID() == PointerTyID; }
 218
 219   /// isPtrOrPtrVectorTy - Return true if this is a pointer type or a vector of
 220   /// pointer types.
 221   ///
 222   bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); }
 223
 224   /// isVectorTy - True if this is an instance of VectorType.
 225   ///
 226   bool isVectorTy() const { return getTypeID() == VectorTyID; }
 227
 228   /// canLosslesslyBitCastTo - Return true if this type could be converted
 229   /// with a lossless BitCast to type 'Ty'. For example, i8* to i32*. BitCasts
 230   /// are valid for types of the same size only where no re-interpretation of
 231   /// the bits is done.
 232   /// @brief Determine if this type could be losslessly bitcast to Ty
 233   bool canLosslesslyBitCastTo(Type *Ty) const;
 234
 235   /// isEmptyTy - Return true if this type is empty, that is, it has no
 236   /// elements or all its elements are empty.
 237   bool isEmptyTy() const;
 238
 239   /// isFirstClassType - Return true if the type is "first class", meaning it
 240   /// is a valid type for a Value.
 241   ///
 242   bool isFirstClassType() const {
 243     return getTypeID() != FunctionTyID && getTypeID() != VoidTyID;
 244   }
 245
 246   /// isSingleValueType - Return true if the type is a valid type for a
 247   /// register in codegen.  This includes all first-class types except struct
 248   /// and array types.
 249   ///
 250   bool isSingleValueType() const {
 251     return isFloatingPointTy() || isX86_MMXTy() || isIntegerTy() ||
 252            isPointerTy() || isVectorTy();
 253   }
 254
 255   /// isAggregateType - Return true if the type is an aggregate type. This
 256   /// means it is valid as the first operand of an insertvalue or
 257   /// extractvalue instruction. This includes struct and array types, but
 258   /// does not include vector types.
 259   ///
 260   bool isAggregateType() const {
 261     return getTypeID() == StructTyID || getTypeID() == ArrayTyID;
 262   }
 263
 264   /// isSized - Return true if it makes sense to take the size of this type.  To
 265   /// get the actual size for a particular target, it is reasonable to use the
 266   /// DataLayout subsystem to do this.
 267   ///
 268   bool isSized(SmallPtrSetImpl<Type*> *Visited = nullptr) const {
 269     // If it's a primitive, it is always sized.
 270     if (getTypeID() == IntegerTyID || isFloatingPointTy() ||
 271         getTypeID() == PointerTyID ||
 272         getTypeID() == X86_MMXTyID)
 273       return true;
 274     // If it is not something that can have a size (e.g. a function or label),
 275     // it doesn't have a size.
 276     if (getTypeID() != StructTyID && getTypeID() != ArrayTyID &&
 277         getTypeID() != VectorTyID)
 278       return false;
 279     // Otherwise we have to try harder to decide.
 280     return isSizedDerivedType(Visited);
 281   }
 282
 283   /// getPrimitiveSizeInBits - Return the basic size of this type if it is a
 284   /// primitive type.  These are fixed by LLVM and are not target dependent.
 285   /// This will return zero if the type does not have a size or is not a
 286   /// primitive type.
 287   ///
 288   /// Note that this may not reflect the size of memory allocated for an
 289   /// instance of the type or the number of bytes that are written when an
 290   /// instance of the type is stored to memory. The DataLayout class provides
 291   /// additional query functions to provide this information.
 292   ///
 293   unsigned getPrimitiveSizeInBits() const LLVM_READONLY;
 294
 295   /// getScalarSizeInBits - If this is a vector type, return the
 296   /// getPrimitiveSizeInBits value for the element type. Otherwise return the
 297   /// getPrimitiveSizeInBits value for this type.
 298   unsigned getScalarSizeInBits() const LLVM_READONLY;
 299
 300   /// getFPMantissaWidth - Return the width of the mantissa of this type.  This
 301   /// is only valid on floating point types.  If the FP type does not
 302   /// have a stable mantissa (e.g. ppc long double), this method returns -1.
 303   int getFPMantissaWidth() const;
 304
 305   /// getScalarType - If this is a vector type, return the element type,
 306   /// otherwise return 'this'.
 307   Type *getScalarType() const LLVM_READONLY;
 308
 309   //===--------------------------------------------------------------------===//
 310   // Type Iteration support.
 311   //
 312   typedef Type * const *subtype_iterator;
 313   subtype_iterator subtype_begin() const { return ContainedTys; }
 314   subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
 315   ArrayRef<Type*> subtypes() const {
 316     return makeArrayRef(subtype_begin(), subtype_end());
 317   }
 318
 319   typedef std::reverse_iterator<subtype_iterator> subtype_reverse_iterator;
 320   subtype_reverse_iterator subtype_rbegin() const {
 321     return subtype_reverse_iterator(subtype_end());
 322   }
 323   subtype_reverse_iterator subtype_rend() const {
 324     return subtype_reverse_iterator(subtype_begin());
 325   }
 326
 327   /// getContainedType - This method is used to implement the type iterator
 328   /// (defined at the end of the file).  For derived types, this returns the
 329   /// types 'contained' in the derived type.
 330   ///
 331   Type *getContainedType(unsigned i) const {
 332     assert(i < NumContainedTys && "Index out of range!");
 333     return ContainedTys[i];
 334   }
 335
 336   /// getNumContainedTypes - Return the number of types in the derived type.
 337   ///
 338   unsigned getNumContainedTypes() const { return NumContainedTys; }
 339
 340   //===--------------------------------------------------------------------===//
 341   // Helper methods corresponding to subclass methods.  This forces a cast to
 342   // the specified subclass and calls its accessor.  "getVectorNumElements" (for
 343   // example) is shorthand for cast<VectorType>(Ty)->getNumElements().  This is
 344   // only intended to cover the core methods that are frequently used, helper
 345   // methods should not be added here.
 346
 347   unsigned getIntegerBitWidth() const;
 348
 349   Type *getFunctionParamType(unsigned i) const;
 350   unsigned getFunctionNumParams() const;
 351   bool isFunctionVarArg() const;
 352
 353   StringRef getStructName() const;
 354   unsigned getStructNumElements() const;
 355   Type *getStructElementType(unsigned N) const;
 356
 357   Type *getSequentialElementType() const;
 358
 359   uint64_t getArrayNumElements() const;
 360   Type *getArrayElementType() const { return getSequentialElementType(); }
 361
 362   unsigned getVectorNumElements() const;
 363   Type *getVectorElementType() const { return getSequentialElementType(); }
 364
 365   Type *getPointerElementType() const { return getSequentialElementType(); }
 366
 367   /// \brief Get the address space of this pointer or pointer vector type.
 368   unsigned getPointerAddressSpace() const;
 369
 370   //===--------------------------------------------------------------------===//
 371   // Static members exported by the Type class itself.  Useful for getting
 372   // instances of Type.
 373   //
 374
 375   /// getPrimitiveType - Return a type based on an identifier.
 376   static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber);
 377
 378   //===--------------------------------------------------------------------===//
 379   // These are the builtin types that are always available.
 380   //
 381   static Type *getVoidTy(LLVMContext &C);
 382   static Type *getLabelTy(LLVMContext &C);
 383   static Type *getHalfTy(LLVMContext &C);
 384   static Type *getFloatTy(LLVMContext &C);
 385   static Type *getDoubleTy(LLVMContext &C);
 386   static Type *getMetadataTy(LLVMContext &C);
 387   static Type *getX86_FP80Ty(LLVMContext &C);
 388   static Type *getFP128Ty(LLVMContext &C);
 389   static Type *getPPC_FP128Ty(LLVMContext &C);
 390   static Type *getX86_MMXTy(LLVMContext &C);
 391   static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
 392   static IntegerType *getInt1Ty(LLVMContext &C);
 393   static IntegerType *getInt8Ty(LLVMContext &C);
 394   static IntegerType *getInt16Ty(LLVMContext &C);
 395   static IntegerType *getInt32Ty(LLVMContext &C);
 396   static IntegerType *getInt64Ty(LLVMContext &C);
 397   static IntegerType *getInt128Ty(LLVMContext &C);
 398
 399   //===--------------------------------------------------------------------===//
 400   // Convenience methods for getting pointer types with one of the above builtin
 401   // types as pointee.
 402   //
 403   static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
 404   static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
 405   static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
 406   static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);
 407   static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0);
 408   static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0);
 409   static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);
 410   static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0);
 411   static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0);
 412   static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0);
 413   static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0);
 414   static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0);
 415   static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0);
 416
 417   /// getPointerTo - Return a pointer to the current type.  This is equivalent
 418   /// to PointerType::get(Foo, AddrSpace).
 419   PointerType *getPointerTo(unsigned AddrSpace = 0);
 420
 421 private:
 422   /// isSizedDerivedType - Derived types like structures and arrays are sized
 423   /// iff all of the members of the type are sized as well.  Since asking for
 424   /// their size is relatively uncommon, move this operation out of line.
 425   bool isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited = nullptr) const;
 426 };
 427
 428 // Printing of types.
 429 static inline raw_ostream &operator<<(raw_ostream &OS, Type &T) {
 430   T.print(OS);
 431   return OS;
 432 }
 433
 434 // allow isa<PointerType>(x) to work without DerivedTypes.h included.
 435 template <> struct isa_impl<PointerType, Type> {
 436   static inline bool doit(const Type &Ty) {
 437     return Ty.getTypeID() == Type::PointerTyID;
 438   }
 439 };
 440
 441
 442 //===----------------------------------------------------------------------===//
 443 // Provide specializations of GraphTraits to be able to treat a type as a
 444 // graph of sub types.
 445
 446
 447 template <> struct GraphTraits<Type*> {
 448   typedef Type NodeType;
 449   typedef Type::subtype_iterator ChildIteratorType;
 450
 451   static inline NodeType *getEntryNode(Type *T) { return T; }
 452   static inline ChildIteratorType child_begin(NodeType *N) {
 453     return N->subtype_begin();
 454   }
 455   static inline ChildIteratorType child_end(NodeType *N) {
 456     return N->subtype_end();
 457   }
 458 };
 459
 460 template <> struct GraphTraits<const Type*> {
 461   typedef const Type NodeType;
 462   typedef Type::subtype_iterator ChildIteratorType;
 463
 464   static inline NodeType *getEntryNode(NodeType *T) { return T; }
 465   static inline ChildIteratorType child_begin(NodeType *N) {
 466     return N->subtype_begin();
 467   }
 468   static inline ChildIteratorType child_end(NodeType *N) {
 469     return N->subtype_end();
 470   }
 471 };
 472
 473 // Create wrappers for C Binding types (see CBindingWrapping.h).
 474 DEFINE_ISA_CONVERSION_FUNCTIONS(Type, LLVMTypeRef)
 475
 476 /* Specialized opaque type conversions.
 477  */
 478 inline Type **unwrap(LLVMTypeRef* Tys) {
 479   return reinterpret_cast<Type**>(Tys);
 480 }
 481
 482 inline LLVMTypeRef *wrap(Type **Tys) {
 483   return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
 484 }
 485
 486 } // End llvm namespace
 487
 488 #endif