Line data Source code
1 : //===- llvm/Type.h - Classes for handling data types ------------*- C++ -*-===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 : //
10 : // This file contains the declaration of the Type class. For more "Type"
11 : // stuff, look in DerivedTypes.h.
12 : //
13 : //===----------------------------------------------------------------------===//
14 :
15 : #ifndef LLVM_IR_TYPE_H
16 : #define LLVM_IR_TYPE_H
17 :
18 : #include "llvm/ADT/APFloat.h"
19 : #include "llvm/ADT/ArrayRef.h"
20 : #include "llvm/ADT/SmallPtrSet.h"
21 : #include "llvm/Support/CBindingWrapping.h"
22 : #include "llvm/Support/Casting.h"
23 : #include "llvm/Support/Compiler.h"
24 : #include "llvm/Support/ErrorHandling.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 - 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
68 :
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
77 : };
78 :
79 : private:
80 : /// This refers to the LLVMContext in which this type was uniqued.
81 : LLVMContext &Context;
82 :
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.
87 :
88 : protected:
89 : friend class LLVMContextImpl;
90 :
91 : explicit Type(LLVMContext &C, TypeID tid)
92 1594263 : : Context(C), ID(tid), SubclassData(0) {}
93 : ~Type() = default;
94 :
95 1199544530 : unsigned getSubclassData() const { return SubclassData; }
96 :
97 : void setSubclassData(unsigned val) {
98 1327749 : SubclassData = val;
99 : // Ensure we don't have any accidental truncation.
100 : assert(getSubclassData() == val && "Subclass data too large for field");
101 : }
102 :
103 : /// Keeps track of how many Type*'s there are in the ContainedTys list.
104 : unsigned NumContainedTys = 0;
105 :
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,
110 : /// Float).
111 : Type * const *ContainedTys = nullptr;
112 :
113 : static bool isSequentialType(TypeID TyID) {
114 : return TyID == ArrayTyID || TyID == VectorTyID;
115 : }
116 :
117 : public:
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;
126 :
127 : void dump() const;
128 :
129 : /// Return the LLVMContext in which this type was uniqued.
130 0 : LLVMContext &getContext() const { return Context; }
131 :
132 : //===--------------------------------------------------------------------===//
133 : // Accessors for working with types.
134 : //
135 :
136 : /// Return the type id for the type. This will return one of the TypeID enum
137 : /// elements defined above.
138 3123163906 : TypeID getTypeID() const { return ID; }
139 :
140 : /// Return true if this is 'void'.
141 : bool isVoidTy() const { return getTypeID() == VoidTyID; }
142 :
143 : /// Return true if this is 'half', a 16-bit IEEE fp type.
144 : bool isHalfTy() const { return getTypeID() == HalfTyID; }
145 :
146 : /// Return true if this is 'float', a 32-bit IEEE fp type.
147 17 : bool isFloatTy() const { return getTypeID() == FloatTyID; }
148 :
149 : /// Return true if this is 'double', a 64-bit IEEE fp type.
150 5 : 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 182066597 : return getTypeID() == HalfTyID || getTypeID() == FloatTyID ||
164 179893263 : getTypeID() == DoubleTyID ||
165 361261165 : getTypeID() == X86_FP80TyID || getTypeID() == FP128TyID ||
166 : getTypeID() == PPC_FP128TyID;
167 : }
168 :
169 7679 : const fltSemantics &getFltSemantics() const {
170 7679 : switch (getTypeID()) {
171 31 : case HalfTyID: return APFloat::IEEEhalf();
172 3022 : case FloatTyID: return APFloat::IEEEsingle();
173 4237 : case DoubleTyID: return APFloat::IEEEdouble();
174 376 : case X86_FP80TyID: return APFloat::x87DoubleExtended();
175 11 : case FP128TyID: return APFloat::IEEEquad();
176 2 : case PPC_FP128TyID: return APFloat::PPCDoubleDouble();
177 0 : default: llvm_unreachable("Invalid floating type");
178 : }
179 : }
180 :
181 : /// Return true if this is X86 MMX.
182 : bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID; }
183 :
184 : /// Return true if this is a FP type or a vector of FP.
185 : bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); }
186 :
187 : /// Return true if this is 'label'.
188 : bool isLabelTy() const { return getTypeID() == LabelTyID; }
189 :
190 : /// Return true if this is 'metadata'.
191 4 : bool isMetadataTy() const { return getTypeID() == MetadataTyID; }
192 :
193 : /// Return true if this is 'token'.
194 : bool isTokenTy() const { return getTypeID() == TokenTyID; }
195 :
196 : /// True if this is an instance of IntegerType.
197 37529796 : bool isIntegerTy() const { return getTypeID() == IntegerTyID; }
198 :
199 : /// Return true if this is an IntegerType of the given width.
200 : bool isIntegerTy(unsigned Bitwidth) const;
201 :
202 : /// Return true if this is an integer type or a vector of integer types.
203 : bool isIntOrIntVectorTy() const { return getScalarType()->isIntegerTy(); }
204 :
205 : /// Return true if this is an integer type or a vector of integer types of
206 : /// the given width.
207 : bool isIntOrIntVectorTy(unsigned BitWidth) const {
208 26917708 : return getScalarType()->isIntegerTy(BitWidth);
209 : }
210 :
211 : /// Return true if this is an integer type or a pointer type.
212 4579078 : bool isIntOrPtrTy() const { return isIntegerTy() || isPointerTy(); }
213 :
214 : /// True if this is an instance of FunctionType.
215 3382 : bool isFunctionTy() const { return getTypeID() == FunctionTyID; }
216 :
217 : /// True if this is an instance of StructType.
218 6 : bool isStructTy() const { return getTypeID() == StructTyID; }
219 :
220 : /// True if this is an instance of ArrayType.
221 50006 : bool isArrayTy() const { return getTypeID() == ArrayTyID; }
222 :
223 : /// True if this is an instance of PointerType.
224 4623177 : bool isPointerTy() const { return getTypeID() == PointerTyID; }
225 :
226 : /// Return true if this is a pointer type or a vector of pointer types.
227 : bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); }
228 :
229 : /// True if this is an instance of VectorType.
230 1367748 : bool isVectorTy() const { return getTypeID() == VectorTyID; }
231 :
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;
237 :
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;
241 :
242 : /// Return true if the type is "first class", meaning it is a valid type for a
243 : /// Value.
244 : bool isFirstClassType() const {
245 20169810 : return getTypeID() != FunctionTyID && getTypeID() != VoidTyID;
246 : }
247 :
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 781783 : bool isSingleValueType() const {
251 771645 : return isFloatingPointTy() || isX86_MMXTy() || isIntegerTy() ||
252 34666 : isPointerTy() || isVectorTy();
253 : }
254 :
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 12774579 : return getTypeID() == StructTyID || getTypeID() == ArrayTyID;
260 : }
261 :
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 297325007 : bool isSized(SmallPtrSetImpl<Type*> *Visited = nullptr) const {
266 : // If it's a primitive, it is always sized.
267 150364166 : if (getTypeID() == IntegerTyID || isFloatingPointTy() ||
268 443436230 : getTypeID() == PointerTyID ||
269 : getTypeID() == X86_MMXTyID)
270 : return true;
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 146106223 : if (getTypeID() != StructTyID && getTypeID() != ArrayTyID &&
274 : getTypeID() != VectorTyID)
275 : return false;
276 : // Otherwise we have to try harder to decide.
277 145931542 : return isSizedDerivedType(Visited);
278 : }
279 :
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
283 : /// primitive type.
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 : unsigned 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 : /// If this is a vector type, return the element type, otherwise return
303 : /// 'this'.
304 : Type *getScalarType() const {
305 714832209 : if (isVectorTy())
306 9086690 : return getVectorElementType();
307 : return const_cast<Type*>(this);
308 : }
309 :
310 : //===--------------------------------------------------------------------===//
311 : // Type Iteration support.
312 : //
313 : using subtype_iterator = Type * const *;
314 :
315 0 : subtype_iterator subtype_begin() const { return ContainedTys; }
316 716740 : subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
317 : ArrayRef<Type*> subtypes() const {
318 57198 : return makeArrayRef(subtype_begin(), subtype_end());
319 : }
320 :
321 : using subtype_reverse_iterator = std::reverse_iterator<subtype_iterator>;
322 :
323 : subtype_reverse_iterator subtype_rbegin() const {
324 477938 : return subtype_reverse_iterator(subtype_end());
325 : }
326 : subtype_reverse_iterator subtype_rend() const {
327 : return subtype_reverse_iterator(subtype_begin());
328 : }
329 :
330 : /// This method is used to implement the type iterator (defined at the end of
331 : /// the file). For derived types, this returns the types 'contained' in the
332 : /// derived type.
333 0 : Type *getContainedType(unsigned i) const {
334 : assert(i < NumContainedTys && "Index out of range!");
335 2457336 : return ContainedTys[i];
336 : }
337 :
338 : /// Return the number of types in the derived type.
339 0 : unsigned getNumContainedTypes() const { return NumContainedTys; }
340 :
341 : //===--------------------------------------------------------------------===//
342 : // Helper methods corresponding to subclass methods. This forces a cast to
343 : // the specified subclass and calls its accessor. "getVectorNumElements" (for
344 : // example) is shorthand for cast<VectorType>(Ty)->getNumElements(). This is
345 : // only intended to cover the core methods that are frequently used, helper
346 : // methods should not be added here.
347 :
348 : inline unsigned getIntegerBitWidth() const;
349 :
350 : inline Type *getFunctionParamType(unsigned i) const;
351 : inline unsigned getFunctionNumParams() const;
352 : inline bool isFunctionVarArg() const;
353 :
354 : inline StringRef getStructName() const;
355 : inline unsigned getStructNumElements() const;
356 : inline Type *getStructElementType(unsigned N) const;
357 :
358 0 : inline Type *getSequentialElementType() const {
359 : assert(isSequentialType(getTypeID()) && "Not a sequential type!");
360 356595 : return ContainedTys[0];
361 : }
362 :
363 : inline uint64_t getArrayNumElements() const;
364 :
365 0 : Type *getArrayElementType() const {
366 : assert(getTypeID() == ArrayTyID);
367 792 : return ContainedTys[0];
368 : }
369 :
370 : inline unsigned getVectorNumElements() const;
371 0 : Type *getVectorElementType() const {
372 : assert(getTypeID() == VectorTyID);
373 9405893 : return ContainedTys[0];
374 : }
375 :
376 0 : Type *getPointerElementType() const {
377 : assert(getTypeID() == PointerTyID);
378 22999468 : return ContainedTys[0];
379 : }
380 :
381 : /// Get the address space of this pointer or pointer vector type.
382 : inline unsigned getPointerAddressSpace() const;
383 :
384 : //===--------------------------------------------------------------------===//
385 : // Static members exported by the Type class itself. Useful for getting
386 : // instances of Type.
387 : //
388 :
389 : /// Return a type based on an identifier.
390 : static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber);
391 :
392 : //===--------------------------------------------------------------------===//
393 : // These are the builtin types that are always available.
394 : //
395 : static Type *getVoidTy(LLVMContext &C);
396 : static Type *getLabelTy(LLVMContext &C);
397 : static Type *getHalfTy(LLVMContext &C);
398 : static Type *getFloatTy(LLVMContext &C);
399 : static Type *getDoubleTy(LLVMContext &C);
400 : static Type *getMetadataTy(LLVMContext &C);
401 : static Type *getX86_FP80Ty(LLVMContext &C);
402 : static Type *getFP128Ty(LLVMContext &C);
403 : static Type *getPPC_FP128Ty(LLVMContext &C);
404 : static Type *getX86_MMXTy(LLVMContext &C);
405 : static Type *getTokenTy(LLVMContext &C);
406 : static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
407 : static IntegerType *getInt1Ty(LLVMContext &C);
408 : static IntegerType *getInt8Ty(LLVMContext &C);
409 : static IntegerType *getInt16Ty(LLVMContext &C);
410 : static IntegerType *getInt32Ty(LLVMContext &C);
411 : static IntegerType *getInt64Ty(LLVMContext &C);
412 : static IntegerType *getInt128Ty(LLVMContext &C);
413 : template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
414 : int noOfBits = sizeof(ScalarTy) * CHAR_BIT;
415 : if (std::is_integral<ScalarTy>::value) {
416 782767 : return (Type*) Type::getIntNTy(C, noOfBits);
417 : } else if (std::is_floating_point<ScalarTy>::value) {
418 : switch (noOfBits) {
419 : case 32:
420 : return Type::getFloatTy(C);
421 : case 64:
422 : return Type::getDoubleTy(C);
423 : }
424 : }
425 : llvm_unreachable("Unsupported type in Type::getScalarTy");
426 : }
427 :
428 : //===--------------------------------------------------------------------===//
429 : // Convenience methods for getting pointer types with one of the above builtin
430 : // types as pointee.
431 : //
432 : static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
433 : static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
434 : static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
435 : static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);
436 : static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0);
437 : static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0);
438 : static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);
439 : static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0);
440 : static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0);
441 : static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0);
442 : static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0);
443 : static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0);
444 : static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0);
445 :
446 : /// Return a pointer to the current type. This is equivalent to
447 : /// PointerType::get(Foo, AddrSpace).
448 : PointerType *getPointerTo(unsigned AddrSpace = 0) const;
449 :
450 : private:
451 : /// Derived types like structures and arrays are sized iff all of the members
452 : /// of the type are sized as well. Since asking for their size is relatively
453 : /// uncommon, move this operation out-of-line.
454 : bool isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited = nullptr) const;
455 : };
456 :
457 : // Printing of types.
458 : inline raw_ostream &operator<<(raw_ostream &OS, const Type &T) {
459 31379 : T.print(OS);
460 : return OS;
461 : }
462 :
463 : // allow isa<PointerType>(x) to work without DerivedTypes.h included.
464 : template <> struct isa_impl<PointerType, Type> {
465 : static inline bool doit(const Type &Ty) {
466 0 : return Ty.getTypeID() == Type::PointerTyID;
467 : }
468 : };
469 :
470 : //===----------------------------------------------------------------------===//
471 : // Provide specializations of GraphTraits to be able to treat a type as a
472 : // graph of sub types.
473 :
474 : template <> struct GraphTraits<Type *> {
475 : using NodeRef = Type *;
476 : using ChildIteratorType = Type::subtype_iterator;
477 :
478 : static NodeRef getEntryNode(Type *T) { return T; }
479 106384 : static ChildIteratorType child_begin(NodeRef N) { return N->subtype_begin(); }
480 182110 : static ChildIteratorType child_end(NodeRef N) { return N->subtype_end(); }
481 : };
482 :
483 : template <> struct GraphTraits<const Type*> {
484 : using NodeRef = const Type *;
485 : using ChildIteratorType = Type::subtype_iterator;
486 :
487 : static NodeRef getEntryNode(NodeRef T) { return T; }
488 : static ChildIteratorType child_begin(NodeRef N) { return N->subtype_begin(); }
489 : static ChildIteratorType child_end(NodeRef N) { return N->subtype_end(); }
490 : };
491 :
492 : // Create wrappers for C Binding types (see CBindingWrapping.h).
493 : DEFINE_ISA_CONVERSION_FUNCTIONS(Type, LLVMTypeRef)
494 :
495 : /* Specialized opaque type conversions.
496 : */
497 : inline Type **unwrap(LLVMTypeRef* Tys) {
498 : return reinterpret_cast<Type**>(Tys);
499 : }
500 :
501 : inline LLVMTypeRef *wrap(Type **Tys) {
502 : return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
503 : }
504 :
505 : } // end namespace llvm
506 :
507 : #endif // LLVM_IR_TYPE_H
|
