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
29namespace llvm {
30
31template<class GraphType> struct GraphTraits;
32class IntegerType;
33class LLVMContext;
34class PointerType;
35class raw_ostream;
36class 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///
46class Type {
47public:
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
79private:
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
88protected:
89 friend class LLVMContextImpl;
90
91 explicit Type(LLVMContext &C, TypeID tid)
92 : Context(C), ID(tid), SubclassData(0) {}
93 ~Type() = default;
94
95 unsigned getSubclassData() const { return SubclassData; }
96
97 void setSubclassData(unsigned val) {
98 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
117public:
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 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 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 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() == FloatTyID ||
164 getTypeID() == DoubleTyID ||
165 getTypeID() == X86_FP80TyID || getTypeID() == FP128TyID ||
166 getTypeID() == PPC_FP128TyID;
167 }
168
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");
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 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 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 return getScalarType()->isIntegerTy(BitWidth);
209 }
210
211 /// Return true if this is an integer type or a pointer type.
212 bool isIntOrPtrTy() const { return isIntegerTy() || isPointerTy(); }
213
214 /// True if this is an instance of FunctionType.
215 bool isFunctionTy() const { return getTypeID() == FunctionTyID; }
216
217 /// True if this is an instance of StructType.
218 bool isStructTy() const { return getTypeID() == StructTyID; }
219
220 /// True if this is an instance of ArrayType.
221 bool isArrayTy() const { return getTypeID() == ArrayTyID; }
222
223 /// True if this is an instance of PointerType.
224 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 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 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 bool isSingleValueType() const {
251 return isFloatingPointTy() || isX86_MMXTy() || isIntegerTy() ||
252 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 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 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)
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 if (getTypeID() != StructTyID && getTypeID() != ArrayTyID &&
274 getTypeID() != VectorTyID)
275 return false;
276 // Otherwise we have to try harder to decide.
277 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 if (isVectorTy())
306 return getVectorElementType();
307 return const_cast<Type*>(this);
308 }
309
310 //===--------------------------------------------------------------------===//
311 // Type Iteration support.
312 //
313 using subtype_iterator = Type * const *;
314
315 subtype_iterator subtype_begin() const { return ContainedTys; }
316 subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
317 ArrayRef<Type*> subtypes() const {
318 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 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 Type *getContainedType(unsigned i) const {
334 assert(i < NumContainedTys && "Index out of range!");
335 return ContainedTys[i];
336 }
337
338 /// Return the number of types in the derived type.
339 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 inline Type *getSequentialElementType() const {
359 assert(isSequentialType(getTypeID()) && "Not a sequential type!");
360 return ContainedTys[0];
361 }
362
363 inline uint64_t getArrayNumElements() const;
364
365 Type *getArrayElementType() const {
366 assert(getTypeID() == ArrayTyID);
367 return ContainedTys[0];
368 }
369
370 inline unsigned getVectorNumElements() const;
371 Type *getVectorElementType() const {
372 assert(getTypeID() == VectorTyID);
373 return ContainedTys[0];
374 }
375
376 Type *getPointerElementType() const {
377 assert(getTypeID() == PointerTyID);
378 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 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
450private:
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.
458inline raw_ostream &operator<<(raw_ostream &OS, const Type &T) {
459 T.print(OS);
460 return OS;
461}
462
463// allow isa<PointerType>(x) to work without DerivedTypes.h included.
464template <> struct isa_impl<PointerType, Type> {
465 static inline bool doit(const Type &Ty) {
466 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
474template <> struct GraphTraits<Type *> {
475 using NodeRef = Type *;
476 using ChildIteratorType = Type::subtype_iterator;
477
478 static NodeRef getEntryNode(Type *T) { return T; }
479 static ChildIteratorType child_begin(NodeRef N) { return N->subtype_begin(); }
480 static ChildIteratorType child_end(NodeRef N) { return N->subtype_end(); }
481};
482
483template <> 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).
493DEFINE_ISA_CONVERSION_FUNCTIONS(Type, LLVMTypeRef)
494
495/* Specialized opaque type conversions.
496 */
497inline Type **unwrap(LLVMTypeRef* Tys) {
498 return reinterpret_cast<Type**>(Tys);
499}
500
501inline 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
508