LLVM  10.0.0svn
Type.h
Go to the documentation of this file.
1 //===- llvm/Type.h - Classes for handling data types ------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains the declaration of the Type class. For more "Type"
10 // stuff, look in DerivedTypes.h.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_IR_TYPE_H
15 #define LLVM_IR_TYPE_H
16 
17 #include "llvm/ADT/APFloat.h"
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/SmallPtrSet.h"
21 #include "llvm/Support/Casting.h"
22 #include "llvm/Support/Compiler.h"
24 #include "llvm/Support/TypeSize.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  /// If this is a scalable vector type, the scalable property will be set and
286  /// the runtime size will be a positive integer multiple of the base size.
287  ///
288  /// Note that this may not reflect the size of memory allocated for an
289  /// instance of the type or the number of bytes that are written when an
290  /// instance of the type is stored to memory. The DataLayout class provides
291  /// additional query functions to provide this information.
292  ///
294 
295  /// If this is a vector type, return the getPrimitiveSizeInBits value for the
296  /// element type. Otherwise return the getPrimitiveSizeInBits value for this
297  /// type.
298  unsigned getScalarSizeInBits() const LLVM_READONLY;
299 
300  /// Return the width of the mantissa of this type. This is only valid on
301  /// floating-point types. If the FP type does not have a stable mantissa (e.g.
302  /// ppc long double), this method returns -1.
303  int getFPMantissaWidth() const;
304 
305  /// If this is a vector type, return the element type, otherwise return
306  /// 'this'.
307  Type *getScalarType() const {
308  if (isVectorTy())
309  return getVectorElementType();
310  return const_cast<Type*>(this);
311  }
312 
313  //===--------------------------------------------------------------------===//
314  // Type Iteration support.
315  //
316  using subtype_iterator = Type * const *;
317 
319  subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
322  }
323 
324  using subtype_reverse_iterator = std::reverse_iterator<subtype_iterator>;
325 
328  }
331  }
332 
333  /// This method is used to implement the type iterator (defined at the end of
334  /// the file). For derived types, this returns the types 'contained' in the
335  /// derived type.
336  Type *getContainedType(unsigned i) const {
337  assert(i < NumContainedTys && "Index out of range!");
338  return ContainedTys[i];
339  }
340 
341  /// Return the number of types in the derived type.
342  unsigned getNumContainedTypes() const { return NumContainedTys; }
343 
344  //===--------------------------------------------------------------------===//
345  // Helper methods corresponding to subclass methods. This forces a cast to
346  // the specified subclass and calls its accessor. "getVectorNumElements" (for
347  // example) is shorthand for cast<VectorType>(Ty)->getNumElements(). This is
348  // only intended to cover the core methods that are frequently used, helper
349  // methods should not be added here.
350 
351  inline unsigned getIntegerBitWidth() const;
352 
353  inline Type *getFunctionParamType(unsigned i) const;
354  inline unsigned getFunctionNumParams() const;
355  inline bool isFunctionVarArg() const;
356 
357  inline StringRef getStructName() const;
358  inline unsigned getStructNumElements() const;
359  inline Type *getStructElementType(unsigned N) const;
360 
361  inline Type *getSequentialElementType() const {
362  assert(isSequentialType(getTypeID()) && "Not a sequential type!");
363  return ContainedTys[0];
364  }
365 
366  inline uint64_t getArrayNumElements() const;
367 
369  assert(getTypeID() == ArrayTyID);
370  return ContainedTys[0];
371  }
372 
373  inline bool getVectorIsScalable() const;
374  inline unsigned getVectorNumElements() const;
375  inline ElementCount getVectorElementCount() const;
378  return ContainedTys[0];
379  }
380 
383  return ContainedTys[0];
384  }
385 
386  /// Given an integer or vector type, change the lane bitwidth to NewBitwidth,
387  /// whilst keeping the old number of lanes.
388  inline Type *getWithNewBitWidth(unsigned NewBitWidth) const;
389 
390  /// Given scalar/vector integer type, returns a type with elements twice as
391  /// wide as in the original type. For vectors, preserves element count.
392  inline Type *getExtendedType() const;
393 
394  /// Get the address space of this pointer or pointer vector type.
395  inline unsigned getPointerAddressSpace() const;
396 
397  //===--------------------------------------------------------------------===//
398  // Static members exported by the Type class itself. Useful for getting
399  // instances of Type.
400  //
401 
402  /// Return a type based on an identifier.
403  static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber);
404 
405  //===--------------------------------------------------------------------===//
406  // These are the builtin types that are always available.
407  //
408  static Type *getVoidTy(LLVMContext &C);
409  static Type *getLabelTy(LLVMContext &C);
410  static Type *getHalfTy(LLVMContext &C);
411  static Type *getFloatTy(LLVMContext &C);
412  static Type *getDoubleTy(LLVMContext &C);
413  static Type *getMetadataTy(LLVMContext &C);
414  static Type *getX86_FP80Ty(LLVMContext &C);
415  static Type *getFP128Ty(LLVMContext &C);
416  static Type *getPPC_FP128Ty(LLVMContext &C);
417  static Type *getX86_MMXTy(LLVMContext &C);
418  static Type *getTokenTy(LLVMContext &C);
419  static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
420  static IntegerType *getInt1Ty(LLVMContext &C);
421  static IntegerType *getInt8Ty(LLVMContext &C);
422  static IntegerType *getInt16Ty(LLVMContext &C);
423  static IntegerType *getInt32Ty(LLVMContext &C);
424  static IntegerType *getInt64Ty(LLVMContext &C);
425  static IntegerType *getInt128Ty(LLVMContext &C);
426  template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
427  int noOfBits = sizeof(ScalarTy) * CHAR_BIT;
428  if (std::is_integral<ScalarTy>::value) {
429  return (Type*) Type::getIntNTy(C, noOfBits);
430  } else if (std::is_floating_point<ScalarTy>::value) {
431  switch (noOfBits) {
432  case 32:
433  return Type::getFloatTy(C);
434  case 64:
435  return Type::getDoubleTy(C);
436  }
437  }
438  llvm_unreachable("Unsupported type in Type::getScalarTy");
439  }
440 
441  //===--------------------------------------------------------------------===//
442  // Convenience methods for getting pointer types with one of the above builtin
443  // types as pointee.
444  //
445  static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
446  static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
447  static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
448  static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);
449  static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0);
450  static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0);
451  static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);
452  static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0);
453  static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0);
454  static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0);
455  static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0);
456  static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0);
457  static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0);
458 
459  /// Return a pointer to the current type. This is equivalent to
460  /// PointerType::get(Foo, AddrSpace).
461  PointerType *getPointerTo(unsigned AddrSpace = 0) const;
462 
463 private:
464  /// Derived types like structures and arrays are sized iff all of the members
465  /// of the type are sized as well. Since asking for their size is relatively
466  /// uncommon, move this operation out-of-line.
467  bool isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited = nullptr) const;
468 };
469 
470 // Printing of types.
471 inline raw_ostream &operator<<(raw_ostream &OS, const Type &T) {
472  T.print(OS);
473  return OS;
474 }
475 
476 // allow isa<PointerType>(x) to work without DerivedTypes.h included.
477 template <> struct isa_impl<PointerType, Type> {
478  static inline bool doit(const Type &Ty) {
479  return Ty.getTypeID() == Type::PointerTyID;
480  }
481 };
482 
483 // Create wrappers for C Binding types (see CBindingWrapping.h).
485 
486 /* Specialized opaque type conversions.
487  */
489  return reinterpret_cast<Type**>(Tys);
490 }
491 
492 inline LLVMTypeRef *wrap(Type **Tys) {
493  return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
494 }
495 
496 } // end namespace llvm
497 
498 #endif // LLVM_IR_TYPE_H
Type * getVectorElementType() const
Definition: Type.h:376
uint64_t CallInst * C
static const fltSemantics & IEEEquad() LLVM_READNONE
Definition: APFloat.cpp:161
7: Labels
Definition: Type.h:64
ArrayRef< Type * > subtypes() const
Definition: Type.h:320
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:169
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:177
LLVMContext & Context
bool isMetadataTy() const
Return true if this is &#39;metadata&#39;.
Definition: Type.h:191
This class represents lattice values for constants.
Definition: AllocatorList.h:23
subtype_iterator subtype_begin() const
Definition: Type.h:318
unsigned getFunctionNumParams() const
Definition: DerivedTypes.h:162
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:232
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:370
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:635
1: 16-bit floating point type
Definition: Type.h:58
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:181
static Type * getMetadataTy(LLVMContext &C)
Definition: Type.cpp:170
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:179
static Type * getX86_MMXTy(LLVMContext &C)
Definition: Type.cpp:175
static PointerType * getX86_MMXPtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:212
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:236
static Type * getX86_FP80Ty(LLVMContext &C)
Definition: Type.cpp:172
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:343
static Type * getTokenTy(LLVMContext &C)
Definition: Type.cpp:171
Type * getPointerElementType() const
Definition: Type.h:381
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:204
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:168
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:450
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:427
PointerType * getPointerTo(unsigned AddrSpace=0) const
Return a pointer to the current type.
Definition: Type.cpp:659
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:228
Type * getFunctionParamType(unsigned i) const
Definition: DerivedTypes.h:158
static Type * getPPC_FP128Ty(LLVMContext &C)
Definition: Type.cpp:174
#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:166
bool isFirstClassType() const
Return true if the type is "first class", meaning it is a valid type for a Value. ...
Definition: Type.h:244
static bool doit(const Type &Ty)
Definition: Type.h:478
~Type()=default
static PointerType * getDoublePtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:196
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:32
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:138
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:158
subtype_iterator subtype_end() const
Definition: Type.h:319
Type(LLVMContext &C, TypeID tid)
Definition: Type.h:91
Type * getExtendedType() const
Given scalar/vector integer type, returns a type with elements twice as wide as in the original type...
Definition: DerivedTypes.h:615
Type *const * subtype_iterator
Definition: Type.h:316
Class to represent pointers.
Definition: DerivedTypes.h:579
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return &#39;this&#39;.
Definition: Type.h:307
11: Arbitrary bit width integers
Definition: Type.h:71
ElementCount getVectorElementCount() const
Definition: DerivedTypes.h:574
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
0: type with no size
Definition: Type.h:57
static IntegerType * getInt128Ty(LLVMContext &C)
Definition: Type.cpp:182
bool isLabelTy() const
Return true if this is &#39;label&#39;.
Definition: Type.h:188
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:115
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:64
unsigned getNumContainedTypes() const
Return the number of types in the derived type.
Definition: Type.h:342
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:324
This file declares a class to represent arbitrary precision floating point values and provide a varie...
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:165
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:366
bool isX86_MMXTy() const
Return true if this is X86 MMX.
Definition: Type.h:182
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
Definition: APFloat.cpp:164
Class to represent integer types.
Definition: DerivedTypes.h:40
static PointerType * getPPC_FP128PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:208
bool isFunctionVarArg() const
Definition: DerivedTypes.h:154
static PointerType * getFloatPtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:192
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:224
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
static Type * getFP128Ty(LLVMContext &C)
Definition: Type.cpp:173
static PointerType * getX86_FP80PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:200
void dump() const
Definition: AsmWriter.cpp:4433
subtype_reverse_iterator subtype_rbegin() const
Definition: Type.h:326
Type * getWithNewBitWidth(unsigned NewBitWidth) const
Given an integer or vector type, change the lane bitwidth to NewBitwidth, whilst keeping the old numb...
Definition: DerivedTypes.h:625
14: Arrays
Definition: Type.h:74
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:167
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:361
static const fltSemantics & IEEEsingle() LLVM_READNONE
Definition: APFloat.cpp:155
static PointerType * getInt1PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:220
static const fltSemantics & IEEEhalf() LLVM_READNONE
Definition: APFloat.cpp:152
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:134
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:184
static PointerType * getHalfPtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:188
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:204
8: Metadata
Definition: Type.h:65
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:566
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:170
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:199
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:180
unsigned getIntegerBitWidth() const
Definition: DerivedTypes.h:102
void print(raw_ostream &O, bool IsForDebug=false, bool NoDetails=false) const
Print the current type.
Definition: AsmWriter.cpp:4253
bool isTokenTy() const
Return true if this is &#39;token&#39;.
Definition: Type.h:194
subtype_reverse_iterator subtype_rend() const
Definition: Type.h:329
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
#define N
#define LLVM_READONLY
Definition: Compiler.h:204
bool getVectorIsScalable() const
Definition: DerivedTypes.h:570
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2047
static PointerType * getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS=0)
Definition: Type.cpp:216
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
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static Type * getScalarTy(LLVMContext &C)
Definition: Type.h:426
bool isSingleValueType() const
Return true if the type is a valid type for a register in codegen.
Definition: Type.h:250
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
Type * getArrayElementType() const
Definition: Type.h:368
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:178
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:336
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:362