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