1 //===- llvm/Type.h - Classes for handling data types ------------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 // This file contains the declaration of the Type class. For more "Type"
10 // stuff, look in DerivedTypes.h.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_IR_TYPE_H
15 #define LLVM_IR_TYPE_H
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"
31 template<class GraphType
> struct GraphTraits
;
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
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.
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
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
80 /// This refers to the LLVMContext in which this type was uniqued.
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.
89 friend class LLVMContextImpl
;
91 explicit Type(LLVMContext
&C
, TypeID tid
)
92 : Context(C
), ID(tid
), SubclassData(0) {}
95 unsigned getSubclassData() const { return SubclassData
; }
97 void setSubclassData(unsigned val
) {
99 // Ensure we don't have any accidental truncation.
100 assert(getSubclassData() == val
&& "Subclass data too large for field");
103 /// Keeps track of how many Type*'s there are in the ContainedTys list.
104 unsigned NumContainedTys
= 0;
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,
111 Type
* const *ContainedTys
= nullptr;
113 static bool isSequentialType(TypeID TyID
) {
114 return TyID
== ArrayTyID
|| TyID
== VectorTyID
;
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;
129 /// Return the LLVMContext in which this type was uniqued.
130 LLVMContext
&getContext() const { return Context
; }
132 //===--------------------------------------------------------------------===//
133 // Accessors for working with types.
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
; }
140 /// Return true if this is 'void'.
141 bool isVoidTy() const { return getTypeID() == VoidTyID
; }
143 /// Return true if this is 'half', a 16-bit IEEE fp type.
144 bool isHalfTy() const { return getTypeID() == HalfTyID
; }
146 /// Return true if this is 'float', a 32-bit IEEE fp type.
147 bool isFloatTy() const { return getTypeID() == FloatTyID
; }
149 /// Return true if this is 'double', a 64-bit IEEE fp type.
150 bool isDoubleTy() const { return getTypeID() == DoubleTyID
; }
152 /// Return true if this is x86 long double.
153 bool isX86_FP80Ty() const { return getTypeID() == X86_FP80TyID
; }
155 /// Return true if this is 'fp128'.
156 bool isFP128Ty() const { return getTypeID() == FP128TyID
; }
158 /// Return true if this is powerpc long double.
159 bool isPPC_FP128Ty() const { return getTypeID() == PPC_FP128TyID
; }
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
;
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");
181 /// Return true if this is X86 MMX.
182 bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID
; }
184 /// Return true if this is a FP type or a vector of FP.
185 bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); }
187 /// Return true if this is 'label'.
188 bool isLabelTy() const { return getTypeID() == LabelTyID
; }
190 /// Return true if this is 'metadata'.
191 bool isMetadataTy() const { return getTypeID() == MetadataTyID
; }
193 /// Return true if this is 'token'.
194 bool isTokenTy() const { return getTypeID() == TokenTyID
; }
196 /// True if this is an instance of IntegerType.
197 bool isIntegerTy() const { return getTypeID() == IntegerTyID
; }
199 /// Return true if this is an IntegerType of the given width.
200 bool isIntegerTy(unsigned Bitwidth
) const;
202 /// Return true if this is an integer type or a vector of integer types.
203 bool isIntOrIntVectorTy() const { return getScalarType()->isIntegerTy(); }
205 /// Return true if this is an integer type or a vector of integer types of
207 bool isIntOrIntVectorTy(unsigned BitWidth
) const {
208 return getScalarType()->isIntegerTy(BitWidth
);
211 /// Return true if this is an integer type or a pointer type.
212 bool isIntOrPtrTy() const { return isIntegerTy() || isPointerTy(); }
214 /// True if this is an instance of FunctionType.
215 bool isFunctionTy() const { return getTypeID() == FunctionTyID
; }
217 /// True if this is an instance of StructType.
218 bool isStructTy() const { return getTypeID() == StructTyID
; }
220 /// True if this is an instance of ArrayType.
221 bool isArrayTy() const { return getTypeID() == ArrayTyID
; }
223 /// True if this is an instance of PointerType.
224 bool isPointerTy() const { return getTypeID() == PointerTyID
; }
226 /// Return true if this is a pointer type or a vector of pointer types.
227 bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); }
229 /// True if this is an instance of VectorType.
230 bool isVectorTy() const { return getTypeID() == VectorTyID
; }
232 /// Return true if this type could be converted with a lossless BitCast to
233 /// type 'Ty'. For example, i8* to i32*. BitCasts are valid for types of the
234 /// same size only where no re-interpretation of the bits is done.
235 /// Determine if this type could be losslessly bitcast to Ty
236 bool canLosslesslyBitCastTo(Type
*Ty
) const;
238 /// Return true if this type is empty, that is, it has no elements or all of
239 /// its elements are empty.
240 bool isEmptyTy() const;
242 /// Return true if the type is "first class", meaning it is a valid type for a
244 bool isFirstClassType() const {
245 return getTypeID() != FunctionTyID
&& getTypeID() != VoidTyID
;
248 /// Return true if the type is a valid type for a register in codegen. This
249 /// includes all first-class types except struct and array types.
250 bool isSingleValueType() const {
251 return isFloatingPointTy() || isX86_MMXTy() || isIntegerTy() ||
252 isPointerTy() || isVectorTy();
255 /// Return true if the type is an aggregate type. This means it is valid as
256 /// the first operand of an insertvalue or extractvalue instruction. This
257 /// includes struct and array types, but does not include vector types.
258 bool isAggregateType() const {
259 return getTypeID() == StructTyID
|| getTypeID() == ArrayTyID
;
262 /// Return true if it makes sense to take the size of this type. To get the
263 /// actual size for a particular target, it is reasonable to use the
264 /// DataLayout subsystem to do this.
265 bool isSized(SmallPtrSetImpl
<Type
*> *Visited
= nullptr) const {
266 // If it's a primitive, it is always sized.
267 if (getTypeID() == IntegerTyID
|| isFloatingPointTy() ||
268 getTypeID() == PointerTyID
||
269 getTypeID() == X86_MMXTyID
)
271 // If it is not something that can have a size (e.g. a function or label),
272 // it doesn't have a size.
273 if (getTypeID() != StructTyID
&& getTypeID() != ArrayTyID
&&
274 getTypeID() != VectorTyID
)
276 // Otherwise we have to try harder to decide.
277 return isSizedDerivedType(Visited
);
280 /// Return the basic size of this type if it is a primitive type. These are
281 /// fixed by LLVM and are not target-dependent.
282 /// This will return zero if the type does not have a size or is not a
285 /// If this is a scalable vector type, the scalable property will be set and
286 /// the runtime size will be a positive integer multiple of the base size.
288 /// Note that this may not reflect the size of memory allocated for an
289 /// instance of the type or the number of bytes that are written when an
290 /// instance of the type is stored to memory. The DataLayout class provides
291 /// additional query functions to provide this information.
293 TypeSize
getPrimitiveSizeInBits() const LLVM_READONLY
;
295 /// If this is a vector type, return the getPrimitiveSizeInBits value for the
296 /// element type. Otherwise return the getPrimitiveSizeInBits value for this
298 unsigned getScalarSizeInBits() const LLVM_READONLY
;
300 /// Return the width of the mantissa of this type. This is only valid on
301 /// floating-point types. If the FP type does not have a stable mantissa (e.g.
302 /// ppc long double), this method returns -1.
303 int getFPMantissaWidth() const;
305 /// If this is a vector type, return the element type, otherwise return
307 Type
*getScalarType() const {
309 return getVectorElementType();
310 return const_cast<Type
*>(this);
313 //===--------------------------------------------------------------------===//
314 // Type Iteration support.
316 using subtype_iterator
= Type
* const *;
318 subtype_iterator
subtype_begin() const { return ContainedTys
; }
319 subtype_iterator
subtype_end() const { return &ContainedTys
[NumContainedTys
];}
320 ArrayRef
<Type
*> subtypes() const {
321 return makeArrayRef(subtype_begin(), subtype_end());
324 using subtype_reverse_iterator
= std::reverse_iterator
<subtype_iterator
>;
326 subtype_reverse_iterator
subtype_rbegin() const {
327 return subtype_reverse_iterator(subtype_end());
329 subtype_reverse_iterator
subtype_rend() const {
330 return subtype_reverse_iterator(subtype_begin());
333 /// This method is used to implement the type iterator (defined at the end of
334 /// the file). For derived types, this returns the types 'contained' in the
336 Type
*getContainedType(unsigned i
) const {
337 assert(i
< NumContainedTys
&& "Index out of range!");
338 return ContainedTys
[i
];
341 /// Return the number of types in the derived type.
342 unsigned getNumContainedTypes() const { return NumContainedTys
; }
344 //===--------------------------------------------------------------------===//
345 // Helper methods corresponding to subclass methods. This forces a cast to
346 // the specified subclass and calls its accessor. "getVectorNumElements" (for
347 // example) is shorthand for cast<VectorType>(Ty)->getNumElements(). This is
348 // only intended to cover the core methods that are frequently used, helper
349 // methods should not be added here.
351 inline unsigned getIntegerBitWidth() const;
353 inline Type
*getFunctionParamType(unsigned i
) const;
354 inline unsigned getFunctionNumParams() const;
355 inline bool isFunctionVarArg() const;
357 inline StringRef
getStructName() const;
358 inline unsigned getStructNumElements() const;
359 inline Type
*getStructElementType(unsigned N
) const;
361 inline Type
*getSequentialElementType() const {
362 assert(isSequentialType(getTypeID()) && "Not a sequential type!");
363 return ContainedTys
[0];
366 inline uint64_t getArrayNumElements() const;
368 Type
*getArrayElementType() const {
369 assert(getTypeID() == ArrayTyID
);
370 return ContainedTys
[0];
373 inline bool getVectorIsScalable() const;
374 inline unsigned getVectorNumElements() const;
375 inline ElementCount
getVectorElementCount() const;
376 Type
*getVectorElementType() const {
377 assert(getTypeID() == VectorTyID
);
378 return ContainedTys
[0];
381 Type
*getPointerElementType() const {
382 assert(getTypeID() == PointerTyID
);
383 return ContainedTys
[0];
386 /// Given an integer or vector type, change the lane bitwidth to NewBitwidth,
387 /// whilst keeping the old number of lanes.
388 inline Type
*getWithNewBitWidth(unsigned NewBitWidth
) const;
390 /// Given scalar/vector integer type, returns a type with elements twice as
391 /// wide as in the original type. For vectors, preserves element count.
392 inline Type
*getExtendedType() const;
394 /// Get the address space of this pointer or pointer vector type.
395 inline unsigned getPointerAddressSpace() const;
397 //===--------------------------------------------------------------------===//
398 // Static members exported by the Type class itself. Useful for getting
399 // instances of Type.
402 /// Return a type based on an identifier.
403 static Type
*getPrimitiveType(LLVMContext
&C
, TypeID IDNumber
);
405 //===--------------------------------------------------------------------===//
406 // These are the builtin types that are always available.
408 static Type
*getVoidTy(LLVMContext
&C
);
409 static Type
*getLabelTy(LLVMContext
&C
);
410 static Type
*getHalfTy(LLVMContext
&C
);
411 static Type
*getFloatTy(LLVMContext
&C
);
412 static Type
*getDoubleTy(LLVMContext
&C
);
413 static Type
*getMetadataTy(LLVMContext
&C
);
414 static Type
*getX86_FP80Ty(LLVMContext
&C
);
415 static Type
*getFP128Ty(LLVMContext
&C
);
416 static Type
*getPPC_FP128Ty(LLVMContext
&C
);
417 static Type
*getX86_MMXTy(LLVMContext
&C
);
418 static Type
*getTokenTy(LLVMContext
&C
);
419 static IntegerType
*getIntNTy(LLVMContext
&C
, unsigned N
);
420 static IntegerType
*getInt1Ty(LLVMContext
&C
);
421 static IntegerType
*getInt8Ty(LLVMContext
&C
);
422 static IntegerType
*getInt16Ty(LLVMContext
&C
);
423 static IntegerType
*getInt32Ty(LLVMContext
&C
);
424 static IntegerType
*getInt64Ty(LLVMContext
&C
);
425 static IntegerType
*getInt128Ty(LLVMContext
&C
);
426 template <typename ScalarTy
> static Type
*getScalarTy(LLVMContext
&C
) {
427 int noOfBits
= sizeof(ScalarTy
) * CHAR_BIT
;
428 if (std::is_integral
<ScalarTy
>::value
) {
429 return (Type
*) Type::getIntNTy(C
, noOfBits
);
430 } else if (std::is_floating_point
<ScalarTy
>::value
) {
433 return Type::getFloatTy(C
);
435 return Type::getDoubleTy(C
);
438 llvm_unreachable("Unsupported type in Type::getScalarTy");
441 //===--------------------------------------------------------------------===//
442 // Convenience methods for getting pointer types with one of the above builtin
445 static PointerType
*getHalfPtrTy(LLVMContext
&C
, unsigned AS
= 0);
446 static PointerType
*getFloatPtrTy(LLVMContext
&C
, unsigned AS
= 0);
447 static PointerType
*getDoublePtrTy(LLVMContext
&C
, unsigned AS
= 0);
448 static PointerType
*getX86_FP80PtrTy(LLVMContext
&C
, unsigned AS
= 0);
449 static PointerType
*getFP128PtrTy(LLVMContext
&C
, unsigned AS
= 0);
450 static PointerType
*getPPC_FP128PtrTy(LLVMContext
&C
, unsigned AS
= 0);
451 static PointerType
*getX86_MMXPtrTy(LLVMContext
&C
, unsigned AS
= 0);
452 static PointerType
*getIntNPtrTy(LLVMContext
&C
, unsigned N
, unsigned AS
= 0);
453 static PointerType
*getInt1PtrTy(LLVMContext
&C
, unsigned AS
= 0);
454 static PointerType
*getInt8PtrTy(LLVMContext
&C
, unsigned AS
= 0);
455 static PointerType
*getInt16PtrTy(LLVMContext
&C
, unsigned AS
= 0);
456 static PointerType
*getInt32PtrTy(LLVMContext
&C
, unsigned AS
= 0);
457 static PointerType
*getInt64PtrTy(LLVMContext
&C
, unsigned AS
= 0);
459 /// Return a pointer to the current type. This is equivalent to
460 /// PointerType::get(Foo, AddrSpace).
461 PointerType
*getPointerTo(unsigned AddrSpace
= 0) const;
464 /// Derived types like structures and arrays are sized iff all of the members
465 /// of the type are sized as well. Since asking for their size is relatively
466 /// uncommon, move this operation out-of-line.
467 bool isSizedDerivedType(SmallPtrSetImpl
<Type
*> *Visited
= nullptr) const;
470 // Printing of types.
471 inline raw_ostream
&operator<<(raw_ostream
&OS
, const Type
&T
) {
476 // allow isa<PointerType>(x) to work without DerivedTypes.h included.
477 template <> struct isa_impl
<PointerType
, Type
> {
478 static inline bool doit(const Type
&Ty
) {
479 return Ty
.getTypeID() == Type::PointerTyID
;
483 // Create wrappers for C Binding types (see CBindingWrapping.h).
484 DEFINE_ISA_CONVERSION_FUNCTIONS(Type
, LLVMTypeRef
)
486 /* Specialized opaque type conversions.
488 inline Type
**unwrap(LLVMTypeRef
* Tys
) {
489 return reinterpret_cast<Type
**>(Tys
);
492 inline LLVMTypeRef
*wrap(Type
**Tys
) {
493 return reinterpret_cast<LLVMTypeRef
*>(const_cast<Type
**>(Tys
));
496 } // end namespace llvm
498 #endif // LLVM_IR_TYPE_H