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