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/ArrayRef.h" 18 #include "llvm/Support/CBindingWrapping.h" 19 #include "llvm/Support/Casting.h" 20 #include "llvm/Support/Compiler.h" 21 #include "llvm/Support/ErrorHandling.h" 22 #include "llvm/Support/TypeSize.h" 23 #include <cassert> 24 #include <cstdint> 25 #include <iterator> 26 27 namespace llvm { 28 29 class IntegerType; 30 struct fltSemantics; 31 class LLVMContext; 32 class PointerType; 33 class raw_ostream; 34 class StringRef; 35 template <typename PtrType> class SmallPtrSetImpl; 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 56 HalfTyID = 0, ///< 16-bit floating point type 57 BFloatTyID, ///< 16-bit floating point type (7-bit significand) 58 FloatTyID, ///< 32-bit floating point type 59 DoubleTyID, ///< 64-bit floating point type 60 X86_FP80TyID, ///< 80-bit floating point type (X87) 61 FP128TyID, ///< 128-bit floating point type (112-bit significand) 62 PPC_FP128TyID, ///< 128-bit floating point type (two 64-bits, PowerPC) 63 VoidTyID, ///< type with no size 64 LabelTyID, ///< Labels 65 MetadataTyID, ///< Metadata 66 X86_MMXTyID, ///< MMX vectors (64 bits, X86 specific) 67 X86_AMXTyID, ///< AMX vectors (8192 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 92 explicit Type(LLVMContext &C, TypeID tid) 93 : Context(C), ID(tid), SubclassData(0) {} 94 ~Type() = default; 95 96 unsigned getSubclassData() const { return SubclassData; } 97 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. 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. 135 TypeID getTypeID() const { return ID; } 136 137 /// Return true if this is 'void'. 138 bool isVoidTy() const { return getTypeID() == VoidTyID; } 139 140 /// Return true if this is 'half', a 16-bit IEEE fp type. 141 bool isHalfTy() const { return getTypeID() == HalfTyID; } 142 143 /// Return true if this is 'bfloat', a 16-bit bfloat type. 144 bool isBFloatTy() const { return getTypeID() == BFloatTyID; } 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() == BFloatTyID || 164 getTypeID() == FloatTyID || getTypeID() == DoubleTyID || 165 getTypeID() == X86_FP80TyID || getTypeID() == FP128TyID || 166 getTypeID() == PPC_FP128TyID; 167 } 168 169 const fltSemantics &getFltSemantics() const; 170 171 /// Return true if this is X86 MMX. 172 bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID; } 173 174 /// Return true if this is X86 AMX. 175 bool isX86_AMXTy() const { return getTypeID() == X86_AMXTyID; } 176 177 /// Return true if this is a FP type or a vector of FP. 178 bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); } 179 180 /// Return true if this is 'label'. 181 bool isLabelTy() const { return getTypeID() == LabelTyID; } 182 183 /// Return true if this is 'metadata'. 184 bool isMetadataTy() const { return getTypeID() == MetadataTyID; } 185 186 /// Return true if this is 'token'. 187 bool isTokenTy() const { return getTypeID() == TokenTyID; } 188 189 /// True if this is an instance of IntegerType. 190 bool isIntegerTy() const { return getTypeID() == IntegerTyID; } 191 192 /// Return true if this is an IntegerType of the given width. 193 bool isIntegerTy(unsigned Bitwidth) const; 194 195 /// Return true if this is an integer type or a vector of integer types. 196 bool isIntOrIntVectorTy() const { return getScalarType()->isIntegerTy(); } 197 198 /// Return true if this is an integer type or a vector of integer types of 199 /// the given width. 200 bool isIntOrIntVectorTy(unsigned BitWidth) const { 201 return getScalarType()->isIntegerTy(BitWidth); 202 } 203 204 /// Return true if this is an integer type or a pointer type. 205 bool isIntOrPtrTy() const { return isIntegerTy() || isPointerTy(); } 206 207 /// True if this is an instance of FunctionType. 208 bool isFunctionTy() const { return getTypeID() == FunctionTyID; } 209 210 /// True if this is an instance of StructType. 211 bool isStructTy() const { return getTypeID() == StructTyID; } 212 213 /// True if this is an instance of ArrayType. 214 bool isArrayTy() const { return getTypeID() == ArrayTyID; } 215 216 /// True if this is an instance of PointerType. 217 bool isPointerTy() const { return getTypeID() == PointerTyID; } 218 219 /// True if this is an instance of an opaque PointerType. 220 bool isOpaquePointerTy() const; 221 222 /// Return true if this is a pointer type or a vector of pointer types. 223 bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); } 224 225 /// True if this is an instance of VectorType. 226 inline bool isVectorTy() const { 227 return getTypeID() == ScalableVectorTyID || getTypeID() == FixedVectorTyID; 228 } 229 230 /// Return true if this type could be converted with a lossless BitCast to 231 /// type 'Ty'. For example, i8* to i32*. BitCasts are valid for types of the 232 /// same size only where no re-interpretation of the bits is done. 233 /// Determine if this type could be losslessly bitcast to Ty 234 bool canLosslesslyBitCastTo(Type *Ty) const; 235 236 /// Return true if this type is empty, that is, it has no elements or all of 237 /// its elements are empty. 238 bool isEmptyTy() const; 239 240 /// Return true if the type is "first class", meaning it is a valid type for a 241 /// Value. 242 bool isFirstClassType() const { 243 return getTypeID() != FunctionTyID && getTypeID() != VoidTyID; 244 } 245 246 /// Return true if the type is a valid type for a register in codegen. This 247 /// includes all first-class types except struct and array types. 248 bool isSingleValueType() const { 249 return isFloatingPointTy() || isX86_MMXTy() || isIntegerTy() || 250 isPointerTy() || isVectorTy() || isX86_AMXTy(); 251 } 252 253 /// Return true if the type is an aggregate type. This means it is valid as 254 /// the first operand of an insertvalue or extractvalue instruction. This 255 /// includes struct and array types, but does not include vector types. 256 bool isAggregateType() const { 257 return getTypeID() == StructTyID || getTypeID() == ArrayTyID; 258 } 259 260 /// Return true if it makes sense to take the size of this type. To get the 261 /// actual size for a particular target, it is reasonable to use the 262 /// DataLayout subsystem to do this. 263 bool isSized(SmallPtrSetImpl<Type*> *Visited = nullptr) const { 264 // If it's a primitive, it is always sized. 265 if (getTypeID() == IntegerTyID || isFloatingPointTy() || 266 getTypeID() == PointerTyID || getTypeID() == X86_MMXTyID || 267 getTypeID() == X86_AMXTyID) 268 return true; 269 // If it is not something that can have a size (e.g. a function or label), 270 // it doesn't have a size. 271 if (getTypeID() != StructTyID && getTypeID() != ArrayTyID && !isVectorTy()) 272 return false; 273 // Otherwise we have to try harder to decide. 274 return isSizedDerivedType(Visited); 275 } 276 277 /// Return the basic size of this type if it is a primitive type. These are 278 /// fixed by LLVM and are not target-dependent. 279 /// This will return zero if the type does not have a size or is not a 280 /// primitive type. 281 /// 282 /// If this is a scalable vector type, the scalable property will be set and 283 /// the runtime size will be a positive integer multiple of the base size. 284 /// 285 /// Note that this may not reflect the size of memory allocated for an 286 /// instance of the type or the number of bytes that are written when an 287 /// instance of the type is stored to memory. The DataLayout class provides 288 /// additional query functions to provide this information. 289 /// 290 TypeSize getPrimitiveSizeInBits() const LLVM_READONLY; 291 292 /// If this is a vector type, return the getPrimitiveSizeInBits value for the 293 /// element type. Otherwise return the getPrimitiveSizeInBits value for this 294 /// type. 295 unsigned getScalarSizeInBits() const LLVM_READONLY; 296 297 /// Return the width of the mantissa of this type. This is only valid on 298 /// floating-point types. If the FP type does not have a stable mantissa (e.g. 299 /// ppc long double), this method returns -1. 300 int getFPMantissaWidth() const; 301 302 /// Return whether the type is IEEE compatible, as defined by the eponymous 303 /// method in APFloat. 304 bool isIEEE() const; 305 306 /// If this is a vector type, return the element type, otherwise return 307 /// 'this'. 308 inline Type *getScalarType() const { 309 if (isVectorTy()) 310 return getContainedType(0); 311 return const_cast<Type *>(this); 312 } 313 314 //===--------------------------------------------------------------------===// 315 // Type Iteration support. 316 // 317 using subtype_iterator = Type * const *; 318 319 subtype_iterator subtype_begin() const { return ContainedTys; } 320 subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];} 321 ArrayRef<Type*> subtypes() const { 322 return makeArrayRef(subtype_begin(), subtype_end()); 323 } 324 325 using subtype_reverse_iterator = std::reverse_iterator<subtype_iterator>; 326 327 subtype_reverse_iterator subtype_rbegin() const { 328 return subtype_reverse_iterator(subtype_end()); 329 } 330 subtype_reverse_iterator subtype_rend() const { 331 return subtype_reverse_iterator(subtype_begin()); 332 } 333 334 /// This method is used to implement the type iterator (defined at the end of 335 /// the file). For derived types, this returns the types 'contained' in the 336 /// derived type. 337 Type *getContainedType(unsigned i) const { 338 assert(i < NumContainedTys && "Index out of range!"); 339 return ContainedTys[i]; 340 } 341 342 /// Return the number of types in the derived type. 343 unsigned getNumContainedTypes() const { return NumContainedTys; } 344 345 //===--------------------------------------------------------------------===// 346 // Helper methods corresponding to subclass methods. This forces a cast to 347 // the specified subclass and calls its accessor. "getArrayNumElements" (for 348 // example) is shorthand for cast<ArrayType>(Ty)->getNumElements(). This is 349 // only intended to cover the core methods that are frequently used, helper 350 // methods should not be added here. 351 352 inline unsigned getIntegerBitWidth() const; 353 354 inline Type *getFunctionParamType(unsigned i) const; 355 inline unsigned getFunctionNumParams() const; 356 inline bool isFunctionVarArg() const; 357 358 inline StringRef getStructName() const; 359 inline unsigned getStructNumElements() const; 360 inline Type *getStructElementType(unsigned N) const; 361 362 inline uint64_t getArrayNumElements() const; 363 364 Type *getArrayElementType() const { 365 assert(getTypeID() == ArrayTyID); 366 return ContainedTys[0]; 367 } 368 369 /// This method is deprecated without replacement. Pointer element types are 370 /// not available with opaque pointers. 371 Type *getPointerElementType() const { 372 return getNonOpaquePointerElementType(); 373 } 374 375 /// Only use this method in code that is not reachable with opaque pointers, 376 /// or part of deprecated methods that will be removed as part of the opaque 377 /// pointers transition. 378 Type *getNonOpaquePointerElementType() const { 379 assert(getTypeID() == PointerTyID); 380 assert(NumContainedTys && 381 "Attempting to get element type of opaque pointer"); 382 return ContainedTys[0]; 383 } 384 385 /// Given vector type, change the element type, 386 /// whilst keeping the old number of elements. 387 /// For non-vectors simply returns \p EltTy. 388 inline Type *getWithNewType(Type *EltTy) const; 389 390 /// Given an integer or vector type, change the lane bitwidth to NewBitwidth, 391 /// whilst keeping the old number of lanes. 392 inline Type *getWithNewBitWidth(unsigned NewBitWidth) const; 393 394 /// Given scalar/vector integer type, returns a type with elements twice as 395 /// wide as in the original type. For vectors, preserves element count. 396 inline Type *getExtendedType() const; 397 398 /// Get the address space of this pointer or pointer vector type. 399 inline unsigned getPointerAddressSpace() const; 400 401 //===--------------------------------------------------------------------===// 402 // Static members exported by the Type class itself. Useful for getting 403 // instances of Type. 404 // 405 406 /// Return a type based on an identifier. 407 static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber); 408 409 //===--------------------------------------------------------------------===// 410 // These are the builtin types that are always available. 411 // 412 static Type *getVoidTy(LLVMContext &C); 413 static Type *getLabelTy(LLVMContext &C); 414 static Type *getHalfTy(LLVMContext &C); 415 static Type *getBFloatTy(LLVMContext &C); 416 static Type *getFloatTy(LLVMContext &C); 417 static Type *getDoubleTy(LLVMContext &C); 418 static Type *getMetadataTy(LLVMContext &C); 419 static Type *getX86_FP80Ty(LLVMContext &C); 420 static Type *getFP128Ty(LLVMContext &C); 421 static Type *getPPC_FP128Ty(LLVMContext &C); 422 static Type *getX86_MMXTy(LLVMContext &C); 423 static Type *getX86_AMXTy(LLVMContext &C); 424 static Type *getTokenTy(LLVMContext &C); 425 static IntegerType *getIntNTy(LLVMContext &C, unsigned N); 426 static IntegerType *getInt1Ty(LLVMContext &C); 427 static IntegerType *getInt8Ty(LLVMContext &C); 428 static IntegerType *getInt16Ty(LLVMContext &C); 429 static IntegerType *getInt32Ty(LLVMContext &C); 430 static IntegerType *getInt64Ty(LLVMContext &C); 431 static IntegerType *getInt128Ty(LLVMContext &C); 432 template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) { 433 int noOfBits = sizeof(ScalarTy) * CHAR_BIT; 434 if (std::is_integral<ScalarTy>::value) { 435 return (Type*) Type::getIntNTy(C, noOfBits); 436 } else if (std::is_floating_point<ScalarTy>::value) { 437 switch (noOfBits) { 438 case 32: 439 return Type::getFloatTy(C); 440 case 64: 441 return Type::getDoubleTy(C); 442 } 443 } 444 llvm_unreachable("Unsupported type in Type::getScalarTy"); 445 } 446 static Type *getFloatingPointTy(LLVMContext &C, const fltSemantics &S); 447 448 //===--------------------------------------------------------------------===// 449 // Convenience methods for getting pointer types with one of the above builtin 450 // types as pointee. 451 // 452 static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0); 453 static PointerType *getBFloatPtrTy(LLVMContext &C, unsigned AS = 0); 454 static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0); 455 static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0); 456 static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0); 457 static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0); 458 static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0); 459 static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0); 460 static PointerType *getX86_AMXPtrTy(LLVMContext &C, unsigned AS = 0); 461 static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0); 462 static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0); 463 static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0); 464 static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0); 465 static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0); 466 static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0); 467 468 /// Return a pointer to the current type. This is equivalent to 469 /// PointerType::get(Foo, AddrSpace). 470 /// TODO: Remove this after opaque pointer transition is complete. 471 PointerType *getPointerTo(unsigned AddrSpace = 0) const; 472 473 private: 474 /// Derived types like structures and arrays are sized iff all of the members 475 /// of the type are sized as well. Since asking for their size is relatively 476 /// uncommon, move this operation out-of-line. 477 bool isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited = nullptr) const; 478 }; 479 480 // Printing of types. 481 inline raw_ostream &operator<<(raw_ostream &OS, const Type &T) { 482 T.print(OS); 483 return OS; 484 } 485 486 // allow isa<PointerType>(x) to work without DerivedTypes.h included. 487 template <> struct isa_impl<PointerType, Type> { 488 static inline bool doit(const Type &Ty) { 489 return Ty.getTypeID() == Type::PointerTyID; 490 } 491 }; 492 493 // Create wrappers for C Binding types (see CBindingWrapping.h). 494 DEFINE_ISA_CONVERSION_FUNCTIONS(Type, LLVMTypeRef) 495 496 /* Specialized opaque type conversions. 497 */ 498 inline Type **unwrap(LLVMTypeRef* Tys) { 499 return reinterpret_cast<Type**>(Tys); 500 } 501 502 inline LLVMTypeRef *wrap(Type **Tys) { 503 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys)); 504 } 505 506 } // end namespace llvm 507 508 #endif // LLVM_IR_TYPE_H 509