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