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