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