LLVM  6.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  /// True if this is an instance of FunctionType.
212  bool isFunctionTy() const { return getTypeID() == FunctionTyID; }
213 
214  /// True if this is an instance of StructType.
215  bool isStructTy() const { return getTypeID() == StructTyID; }
216 
217  /// True if this is an instance of ArrayType.
218  bool isArrayTy() const { return getTypeID() == ArrayTyID; }
219 
220  /// True if this is an instance of PointerType.
221  bool isPointerTy() const { return getTypeID() == PointerTyID; }
222 
223  /// Return true if this is a pointer type or a vector of pointer types.
224  bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); }
225 
226  /// True if this is an instance of VectorType.
227  bool isVectorTy() const { return getTypeID() == VectorTyID; }
228 
229  /// Return true if this type could be converted with a lossless BitCast to
230  /// type 'Ty'. For example, i8* to i32*. BitCasts are valid for types of the
231  /// same size only where no re-interpretation of the bits is done.
232  /// @brief Determine if this type could be losslessly bitcast to Ty
233  bool canLosslesslyBitCastTo(Type *Ty) const;
234 
235  /// Return true if this type is empty, that is, it has no elements or all of
236  /// its elements are empty.
237  bool isEmptyTy() const;
238 
239  /// Return true if the type is "first class", meaning it is a valid type for a
240  /// Value.
241  bool isFirstClassType() const {
242  return getTypeID() != FunctionTyID && getTypeID() != VoidTyID;
243  }
244 
245  /// Return true if the type is a valid type for a register in codegen. This
246  /// includes all first-class types except struct and array types.
247  bool isSingleValueType() const {
248  return isFloatingPointTy() || isX86_MMXTy() || isIntegerTy() ||
249  isPointerTy() || isVectorTy();
250  }
251 
252  /// Return true if the type is an aggregate type. This means it is valid as
253  /// the first operand of an insertvalue or extractvalue instruction. This
254  /// includes struct and array types, but does not include vector types.
255  bool isAggregateType() const {
256  return getTypeID() == StructTyID || getTypeID() == ArrayTyID;
257  }
258 
259  /// Return true if it makes sense to take the size of this type. To get the
260  /// actual size for a particular target, it is reasonable to use the
261  /// DataLayout subsystem to do this.
262  bool isSized(SmallPtrSetImpl<Type*> *Visited = nullptr) const {
263  // If it's a primitive, it is always sized.
264  if (getTypeID() == IntegerTyID || isFloatingPointTy() ||
265  getTypeID() == PointerTyID ||
266  getTypeID() == X86_MMXTyID)
267  return true;
268  // If it is not something that can have a size (e.g. a function or label),
269  // it doesn't have a size.
270  if (getTypeID() != StructTyID && getTypeID() != ArrayTyID &&
271  getTypeID() != VectorTyID)
272  return false;
273  // Otherwise we have to try harder to decide.
274  return isSizedDerivedType(Visited);
275  }
276 
277  /// Return the basic size of this type if it is a primitive type. These are
278  /// fixed by LLVM and are not target-dependent.
279  /// This will return zero if the type does not have a size or is not a
280  /// primitive type.
281  ///
282  /// Note that this may not reflect the size of memory allocated for an
283  /// instance of the type or the number of bytes that are written when an
284  /// instance of the type is stored to memory. The DataLayout class provides
285  /// additional query functions to provide this information.
286  ///
287  unsigned getPrimitiveSizeInBits() const LLVM_READONLY;
288 
289  /// If this is a vector type, return the getPrimitiveSizeInBits value for the
290  /// element type. Otherwise return the getPrimitiveSizeInBits value for this
291  /// type.
292  unsigned getScalarSizeInBits() const LLVM_READONLY;
293 
294  /// Return the width of the mantissa of this type. This is only valid on
295  /// floating-point types. If the FP type does not have a stable mantissa (e.g.
296  /// ppc long double), this method returns -1.
297  int getFPMantissaWidth() const;
298 
299  /// If this is a vector type, return the element type, otherwise return
300  /// 'this'.
301  Type *getScalarType() const {
302  if (isVectorTy())
303  return getVectorElementType();
304  return const_cast<Type*>(this);
305  }
306 
307  //===--------------------------------------------------------------------===//
308  // Type Iteration support.
309  //
310  using subtype_iterator = Type * const *;
311 
313  subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
316  }
317 
318  using subtype_reverse_iterator = std::reverse_iterator<subtype_iterator>;
319 
322  }
325  }
326 
327  /// This method is used to implement the type iterator (defined at the end of
328  /// the file). For derived types, this returns the types 'contained' in the
329  /// derived type.
330  Type *getContainedType(unsigned i) const {
331  assert(i < NumContainedTys && "Index out of range!");
332  return ContainedTys[i];
333  }
334 
335  /// Return the number of types in the derived type.
336  unsigned getNumContainedTypes() const { return NumContainedTys; }
337 
338  //===--------------------------------------------------------------------===//
339  // Helper methods corresponding to subclass methods. This forces a cast to
340  // the specified subclass and calls its accessor. "getVectorNumElements" (for
341  // example) is shorthand for cast<VectorType>(Ty)->getNumElements(). This is
342  // only intended to cover the core methods that are frequently used, helper
343  // methods should not be added here.
344 
345  inline unsigned getIntegerBitWidth() const;
346 
347  inline Type *getFunctionParamType(unsigned i) const;
348  inline unsigned getFunctionNumParams() const;
349  inline bool isFunctionVarArg() const;
350 
351  inline StringRef getStructName() const;
352  inline unsigned getStructNumElements() const;
353  inline Type *getStructElementType(unsigned N) const;
354 
355  inline Type *getSequentialElementType() const {
356  assert(isSequentialType(getTypeID()) && "Not a sequential type!");
357  return ContainedTys[0];
358  }
359 
360  inline uint64_t getArrayNumElements() const;
361 
363  assert(getTypeID() == ArrayTyID);
364  return ContainedTys[0];
365  }
366 
367  inline unsigned getVectorNumElements() const;
370  return ContainedTys[0];
371  }
372 
375  return ContainedTys[0];
376  }
377 
378  /// Get the address space of this pointer or pointer vector type.
379  inline unsigned getPointerAddressSpace() const;
380 
381  //===--------------------------------------------------------------------===//
382  // Static members exported by the Type class itself. Useful for getting
383  // instances of Type.
384  //
385 
386  /// Return a type based on an identifier.
387  static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber);
388 
389  //===--------------------------------------------------------------------===//
390  // These are the builtin types that are always available.
391  //
392  static Type *getVoidTy(LLVMContext &C);
393  static Type *getLabelTy(LLVMContext &C);
394  static Type *getHalfTy(LLVMContext &C);
395  static Type *getFloatTy(LLVMContext &C);
396  static Type *getDoubleTy(LLVMContext &C);
397  static Type *getMetadataTy(LLVMContext &C);
398  static Type *getX86_FP80Ty(LLVMContext &C);
399  static Type *getFP128Ty(LLVMContext &C);
400  static Type *getPPC_FP128Ty(LLVMContext &C);
401  static Type *getX86_MMXTy(LLVMContext &C);
402  static Type *getTokenTy(LLVMContext &C);
403  static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
404  static IntegerType *getInt1Ty(LLVMContext &C);
405  static IntegerType *getInt8Ty(LLVMContext &C);
406  static IntegerType *getInt16Ty(LLVMContext &C);
407  static IntegerType *getInt32Ty(LLVMContext &C);
408  static IntegerType *getInt64Ty(LLVMContext &C);
409  static IntegerType *getInt128Ty(LLVMContext &C);
410 
411  //===--------------------------------------------------------------------===//
412  // Convenience methods for getting pointer types with one of the above builtin
413  // types as pointee.
414  //
415  static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
416  static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
417  static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
418  static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);
419  static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0);
420  static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0);
421  static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);
422  static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0);
423  static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0);
424  static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0);
425  static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0);
426  static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0);
427  static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0);
428 
429  /// Return a pointer to the current type. This is equivalent to
430  /// PointerType::get(Foo, AddrSpace).
431  PointerType *getPointerTo(unsigned AddrSpace = 0) const;
432 
433 private:
434  /// Derived types like structures and arrays are sized iff all of the members
435  /// of the type are sized as well. Since asking for their size is relatively
436  /// uncommon, move this operation out-of-line.
437  bool isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited = nullptr) const;
438 };
439 
440 // Printing of types.
441 static inline raw_ostream &operator<<(raw_ostream &OS, const Type &T) {
442  T.print(OS);
443  return OS;
444 }
445 
446 // allow isa<PointerType>(x) to work without DerivedTypes.h included.
447 template <> struct isa_impl<PointerType, Type> {
448  static inline bool doit(const Type &Ty) {
449  return Ty.getTypeID() == Type::PointerTyID;
450  }
451 };
452 
453 //===----------------------------------------------------------------------===//
454 // Provide specializations of GraphTraits to be able to treat a type as a
455 // graph of sub types.
456 
457 template <> struct GraphTraits<Type *> {
458  using NodeRef = Type *;
460 
461  static NodeRef getEntryNode(Type *T) { return T; }
464 };
465 
466 template <> struct GraphTraits<const Type*> {
467  using NodeRef = const Type *;
469 
470  static NodeRef getEntryNode(NodeRef T) { return T; }
473 };
474 
475 // Create wrappers for C Binding types (see CBindingWrapping.h).
477 
478 /* Specialized opaque type conversions.
479  */
481  return reinterpret_cast<Type**>(Tys);
482 }
483 
484 inline LLVMTypeRef *wrap(Type **Tys) {
485  return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
486 }
487 
488 } // end namespace llvm
489 
490 #endif // LLVM_IR_TYPE_H
Type * getVectorElementType() const
Definition: Type.h:368
uint64_t CallInst * C
static const fltSemantics & IEEEquad() LLVM_READNONE
Definition: APFloat.cpp:125
7: Labels
Definition: Type.h:64
ArrayRef< Type * > subtypes() const
Definition: Type.h:314
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:312
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:262
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:227
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:345
static Type * getTokenTy(LLVMContext &C)
Definition: Type.cpp:167
Type * getPointerElementType() const
Definition: Type.h:373
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:241
#define T
static bool doit(const Type &Ty)
Definition: Type.h:448
~Type()=default
static PointerType * getDoublePtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:192
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:122
subtype_iterator subtype_end() const
Definition: Type.h:313
Type(LLVMContext &C, TypeID tid)
Definition: Type.h:91
Type *const * subtype_iterator
Definition: Type.h:310
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:301
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:472
static ChildIteratorType child_begin(NodeRef N)
Definition: Type.h:471
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:68
static NodeRef getEntryNode(Type *T)
Definition: Type.h:461
unsigned getNumContainedTypes() const
Return the number of types in the derived type.
Definition: Type.h:336
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:221
10: Tokens
Definition: Type.h:67
std::reverse_iterator< subtype_iterator > subtype_reverse_iterator
Definition: Type.h:318
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:128
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
const AMDGPUAS & AS
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:3610
subtype_reverse_iterator subtype_rbegin() const
Definition: Type.h:320
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:224
Type * getSequentialElementType() const
Definition: Type.h:355
static const fltSemantics & IEEEsingle() LLVM_READNONE
Definition: APFloat.cpp:119
static PointerType * getInt1PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:216
static const fltSemantics & IEEEhalf() LLVM_READNONE
Definition: APFloat.cpp:116
static ChildIteratorType child_end(NodeRef N)
Definition: Type.h:463
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:255
always inline
const size_t N
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:468
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:134
unsigned getSubclassData() const
Definition: Type.h:95
bool isFunctionTy() const
True if this is an instance of FunctionType.
Definition: Type.h:212
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:3433
bool isTokenTy() const
Return true if this is &#39;token&#39;.
Definition: Type.h:194
subtype_reverse_iterator subtype_rend() const
Definition: Type.h:323
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:462
#define LLVM_READONLY
Definition: Compiler.h:168
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2018
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:459
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
aarch64 promote const
bool isSingleValueType() const
Return true if the type is a valid type for a register in codegen.
Definition: Type.h:247
static NodeRef getEntryNode(NodeRef T)
Definition: Type.h:470
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:44
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Type * getArrayElementType() const
Definition: Type.h:362
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:215
bool isArrayTy() const
True if this is an instance of ArrayType.
Definition: Type.h:218
Type * getContainedType(unsigned i) const
This method is used to implement the type iterator (defined at the end of the file).
Definition: Type.h:330
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