LLVM  8.0.0svn
Type.h
Go to the documentation of this file.
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"
22 #include "llvm/Support/Casting.h"
23 #include "llvm/Support/Compiler.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  : 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 
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  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 ||
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();
175  case FP128TyID: return APFloat::IEEEquad();
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 
316  subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
319  }
320 
321  using subtype_reverse_iterator = std::reverse_iterator<subtype_iterator>;
322 
325  }
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 
366  assert(getTypeID() == ArrayTyID);
367  return ContainedTys[0];
368  }
369 
370  inline unsigned getVectorNumElements() const;
373  return ContainedTys[0];
374  }
375 
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 
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  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  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 *;
477 
478  static NodeRef getEntryNode(Type *T) { return T; }
481 };
482 
483 template <> struct GraphTraits<const Type*> {
484  using NodeRef = const Type *;
486 
487  static NodeRef getEntryNode(NodeRef T) { return T; }
490 };
491 
492 // Create wrappers for C Binding types (see CBindingWrapping.h).
494 
495 /* Specialized opaque type conversions.
496  */
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
Type * getVectorElementType() const
Definition: Type.h:371
uint64_t CallInst * C
static const fltSemantics & IEEEquad() LLVM_READNONE
Definition: APFloat.cpp:126
7: Labels
Definition: Type.h:64
ArrayRef< Type * > subtypes() const
Definition: Type.h:317
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:165
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:173
LLVMContext & Context
bool isMetadataTy() const
Return true if this is &#39;metadata&#39;.
Definition: Type.h:191
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
subtype_iterator subtype_begin() const
Definition: Type.h:315
unsigned getFunctionNumParams() const
Definition: DerivedTypes.h:157
bool isSized(SmallPtrSetImpl< Type *> *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:265
2: 32-bit floating point type
Definition: Type.h:59
bool isFP128Ty() const
Return true if this is &#39;fp128&#39;.
Definition: Type.h:156
static PointerType * getInt32PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:228
bool isIntOrIntVectorTy(unsigned BitWidth) const
Return true if this is an integer type or a vector of integer types of the given width.
Definition: Type.h:207
13: Structures
Definition: Type.h:73
4: 80-bit floating point type (X87)
Definition: Type.h:61
Type * getStructElementType(unsigned N) const
Definition: DerivedTypes.h:333
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:503
1: 16-bit floating point type
Definition: Type.h:58
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:177
static Type * getMetadataTy(LLVMContext &C)
Definition: Type.cpp:166
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:230
15: Pointers
Definition: Type.h:75
static IntegerType * getInt16Ty(LLVMContext &C)
Definition: Type.cpp:175
static Type * getX86_MMXTy(LLVMContext &C)
Definition: Type.cpp:171
static PointerType * getX86_MMXPtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:208
12: Functions
Definition: Type.h:72
bool isPPC_FP128Ty() const
Return true if this is powerpc long double.
Definition: Type.h:159
static PointerType * getInt64PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:232
static Type * getX86_FP80Ty(LLVMContext &C)
Definition: Type.cpp:168
Type *const * ContainedTys
A pointer to the array of Types contained by this Type.
Definition: Type.h:111
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:130
static bool isSequentialType(TypeID TyID)
Definition: Type.h:113
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:344
static Type * getTokenTy(LLVMContext &C)
Definition: Type.cpp:167
Type * getPointerElementType() const
Definition: Type.h:376
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:195
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:164
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:138
bool isFloatingPointTy() const
Return true if this is one of the six floating-point types.
Definition: Type.h:162
uint64_t getArrayNumElements() const
Definition: DerivedTypes.h:388
PointerType * getPointerTo(unsigned AddrSpace=0) const
Return a pointer to the current type.
Definition: Type.cpp:639
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:197
TypeID
Definitions of all of the base types for the Type system.
Definition: Type.h:55
static PointerType * getInt16PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:224
Type * getFunctionParamType(unsigned i) const
Definition: DerivedTypes.h:153
static Type * getPPC_FP128Ty(LLVMContext &C)
Definition: Type.cpp:170
#define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)
struct LLVMOpaqueType * LLVMTypeRef
Each value in the LLVM IR has a type, an LLVMTypeRef.
Definition: Types.h:69
static Type * getLabelTy(LLVMContext &C)
Definition: Type.cpp:162
bool isFirstClassType() const
Return true if the type is "first class", meaning it is a valid type for a Value. ...
Definition: Type.h:244
#define T
static bool doit(const Type &Ty)
Definition: Type.h:465
~Type()=default
static PointerType * getDoublePtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:192
bool isIntOrPtrTy() const
Return true if this is an integer type or a pointer type.
Definition: Type.h:212
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:203
int getFPMantissaWidth() const
Return the width of the mantissa of this type.
Definition: Type.cpp:134
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:123
subtype_iterator subtype_end() const
Definition: Type.h:316
Type(LLVMContext &C, TypeID tid)
Definition: Type.h:91
Type *const * subtype_iterator
Definition: Type.h:313
Class to represent pointers.
Definition: DerivedTypes.h:467
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return &#39;this&#39;.
Definition: Type.h:304
11: Arbitrary bit width integers
Definition: Type.h:71
bool isVoidTy() const
Return true if this is &#39;void&#39;.
Definition: Type.h:141
bool isFloatTy() const
Return true if this is &#39;float&#39;, a 32-bit IEEE fp type.
Definition: Type.h:147
static ChildIteratorType child_end(NodeRef N)
Definition: Type.h:489
static ChildIteratorType child_begin(NodeRef N)
Definition: Type.h:488
0: type with no size
Definition: Type.h:57
static IntegerType * getInt128Ty(LLVMContext &C)
Definition: Type.cpp:178
bool isLabelTy() const
Return true if this is &#39;label&#39;.
Definition: Type.h:188
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
static NodeRef getEntryNode(Type *T)
Definition: Type.h:478
unsigned getNumContainedTypes() const
Return the number of types in the derived type.
Definition: Type.h:339
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:224
10: Tokens
Definition: Type.h:67
amdgpu inline
std::reverse_iterator< subtype_iterator > subtype_reverse_iterator
Definition: Type.h:321
This file declares a class to represent arbitrary precision floating point values and provide a varie...
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:161
bool isHalfTy() const
Return true if this is &#39;half&#39;, a 16-bit IEEE fp type.
Definition: Type.h:144
6: 128-bit floating point type (two 64-bits, PowerPC)
Definition: Type.h:63
unsigned getStructNumElements() const
Definition: DerivedTypes.h:329
bool isX86_MMXTy() const
Return true if this is X86 MMX.
Definition: Type.h:182
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
Definition: APFloat.cpp:129
Class to represent integer types.
Definition: DerivedTypes.h:40
static PointerType * getPPC_FP128PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:204
bool isFunctionVarArg() const
Definition: DerivedTypes.h:149
static PointerType * getFloatPtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:188
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:220
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
static Type * getFP128Ty(LLVMContext &C)
Definition: Type.cpp:169
static PointerType * getX86_FP80PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:196
void dump() const
Definition: AsmWriter.cpp:4274
subtype_reverse_iterator subtype_rbegin() const
Definition: Type.h:323
14: Arrays
Definition: Type.h:74
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:163
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
Definition: Type.h:227
Type * getSequentialElementType() const
Definition: Type.h:358
static const fltSemantics & IEEEsingle() LLVM_READNONE
Definition: APFloat.cpp:120
static PointerType * getInt1PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:216
static const fltSemantics & IEEEhalf() LLVM_READNONE
Definition: APFloat.cpp:117
static ChildIteratorType child_end(NodeRef N)
Definition: Type.h:480
16: SIMD &#39;packed&#39; format, or other vector type
Definition: Type.h:76
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type...
Definition: Type.cpp:130
bool isAggregateType() const
Return true if the type is an aggregate type.
Definition: Type.h:258
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
Definition: Type.cpp:180
static PointerType * getHalfPtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:184
static Type * getPrimitiveType(LLVMContext &C, TypeID IDNumber)
Return a type based on an identifier.
Definition: Type.cpp:39
static PointerType * getFP128PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:200
8: Metadata
Definition: Type.h:65
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:462
Type::subtype_iterator ChildIteratorType
Definition: Type.h:485
bool isX86_FP80Ty() const
Return true if this is x86 long double.
Definition: Type.h:153
static const fltSemantics & PPCDoubleDouble() LLVM_READNONE
Definition: APFloat.cpp:135
unsigned getSubclassData() const
Definition: Type.h:95
bool isFunctionTy() const
True if this is an instance of FunctionType.
Definition: Type.h:215
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:190
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:176
unsigned getIntegerBitWidth() const
Definition: DerivedTypes.h:97
void print(raw_ostream &O, bool IsForDebug=false, bool NoDetails=false) const
Print the current type.
Definition: AsmWriter.cpp:4094
bool isTokenTy() const
Return true if this is &#39;token&#39;.
Definition: Type.h:194
subtype_reverse_iterator subtype_rend() const
Definition: Type.h:326
bool canLosslesslyBitCastTo(Type *Ty) const
Return true if this type could be converted with a lossless BitCast to type &#39;Ty&#39;. ...
Definition: Type.cpp:61
static ChildIteratorType child_begin(NodeRef N)
Definition: Type.h:479
#define N
#define LLVM_READONLY
Definition: Compiler.h:184
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2033
static PointerType * getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS=0)
Definition: Type.cpp:212
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
Definition: Type.h:185
3: 64-bit floating point type
Definition: Type.h:60
void setSubclassData(unsigned val)
Definition: Type.h:97
Type::subtype_iterator ChildIteratorType
Definition: Type.h:476
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static Type * getScalarTy(LLVMContext &C)
Definition: Type.h:413
aarch64 promote const
bool isSingleValueType() const
Return true if the type is a valid type for a register in codegen.
Definition: Type.h:250
static NodeRef getEntryNode(NodeRef T)
Definition: Type.h:487
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:115
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Type * getArrayElementType() const
Definition: Type.h:365
bool isEmptyTy() const
Return true if this type is empty, that is, it has no elements or all of its elements are empty...
Definition: Type.cpp:98
9: MMX vectors (64 bits, X86 specific)
Definition: Type.h:66
bool isDoubleTy() const
Return true if this is &#39;double&#39;, a 64-bit IEEE fp type.
Definition: Type.h:150
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:174
unsigned NumContainedTys
Keeps track of how many Type*&#39;s there are in the ContainedTys list.
Definition: Type.h:104
bool isStructTy() const
True if this is an instance of StructType.
Definition: Type.h:218
bool isArrayTy() const
True if this is an instance of ArrayType.
Definition: Type.h:221
Type * getContainedType(unsigned i) const
This method is used to implement the type iterator (defined at the end of the file).
Definition: Type.h:333
const fltSemantics & getFltSemantics() const
Definition: Type.h:169
5: 128-bit floating point type (112-bit mantissa)
Definition: Type.h:62
StringRef getStructName() const
Definition: DerivedTypes.h:325