LLVM  6.0.0svn
ValueTypes.h
Go to the documentation of this file.
1 //===- CodeGen/ValueTypes.h - Low-Level Target independ. 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 defines the set of low-level target independent types which various
11 // values in the code generator are. This allows the target specific behavior
12 // of instructions to be described to target independent passes.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_CODEGEN_VALUETYPES_H
17 #define LLVM_CODEGEN_VALUETYPES_H
18 
20 #include "llvm/Support/Compiler.h"
22 #include <cassert>
23 #include <cstdint>
24 #include <string>
25 
26 namespace llvm {
27 
28  class LLVMContext;
29  class Type;
30 
31  /// Extended Value Type. Capable of holding value types which are not native
32  /// for any processor (such as the i12345 type), as well as the types an MVT
33  /// can represent.
34  struct EVT {
35  private:
37  Type *LLVMTy = nullptr;
38 
39  public:
40  constexpr EVT() = default;
41  constexpr EVT(MVT::SimpleValueType SVT) : V(SVT) {}
42  constexpr EVT(MVT S) : V(S) {}
43 
44  bool operator==(EVT VT) const {
45  return !(*this != VT);
46  }
47  bool operator!=(EVT VT) const {
48  if (V.SimpleTy != VT.V.SimpleTy)
49  return true;
51  return LLVMTy != VT.LLVMTy;
52  return false;
53  }
54 
55  /// Returns the EVT that represents a floating-point type with the given
56  /// number of bits. There are two floating-point types with 128 bits - this
57  /// returns f128 rather than ppcf128.
58  static EVT getFloatingPointVT(unsigned BitWidth) {
59  return MVT::getFloatingPointVT(BitWidth);
60  }
61 
62  /// Returns the EVT that represents an integer with the given number of
63  /// bits.
64  static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth) {
65  MVT M = MVT::getIntegerVT(BitWidth);
67  return M;
68  return getExtendedIntegerVT(Context, BitWidth);
69  }
70 
71  /// Returns the EVT that represents a vector NumElements in length, where
72  /// each element is of type VT.
73  static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements,
74  bool IsScalable = false) {
75  MVT M = MVT::getVectorVT(VT.V, NumElements, IsScalable);
77  return M;
78 
79  assert(!IsScalable && "We don't support extended scalable types yet");
80  return getExtendedVectorVT(Context, VT, NumElements);
81  }
82 
83  /// Returns the EVT that represents a vector EC.Min elements in length,
84  /// where each element is of type VT.
86  MVT M = MVT::getVectorVT(VT.V, EC);
88  return M;
89  assert (!EC.Scalable && "We don't support extended scalable types yet");
90  return getExtendedVectorVT(Context, VT, EC.Min);
91  }
92 
93  /// Return a vector with the same number of elements as this vector, but
94  /// with the element type converted to an integer type with the same
95  /// bitwidth.
97  if (!isSimple()) {
99  "We don't support extended scalable types yet");
100  return changeExtendedVectorElementTypeToInteger();
101  }
103  unsigned BitWidth = EltTy.getSizeInBits();
104  MVT IntTy = MVT::getIntegerVT(BitWidth);
105  MVT VecTy = MVT::getVectorVT(IntTy, getVectorNumElements(),
106  isScalableVector());
108  "Simple vector VT not representable by simple integer vector VT!");
109  return VecTy;
110  }
111 
112  /// Return the type converted to an equivalently sized integer or vector
113  /// with integer element type. Similar to changeVectorElementTypeToInteger,
114  /// but also handles scalars.
116  if (isVector())
118 
119  if (isSimple())
121 
122  return changeExtendedTypeToInteger();
123  }
124 
125  /// Test if the given EVT is simple (as opposed to being extended).
126  bool isSimple() const {
128  }
129 
130  /// Test if the given EVT is extended (as opposed to being simple).
131  bool isExtended() const {
132  return !isSimple();
133  }
134 
135  /// Return true if this is a FP or a vector FP type.
136  bool isFloatingPoint() const {
137  return isSimple() ? V.isFloatingPoint() : isExtendedFloatingPoint();
138  }
139 
140  /// Return true if this is an integer or a vector integer type.
141  bool isInteger() const {
142  return isSimple() ? V.isInteger() : isExtendedInteger();
143  }
144 
145  /// Return true if this is an integer, but not a vector.
146  bool isScalarInteger() const {
147  return isSimple() ? V.isScalarInteger() : isExtendedScalarInteger();
148  }
149 
150  /// Return true if this is a vector value type.
151  bool isVector() const {
152  return isSimple() ? V.isVector() : isExtendedVector();
153  }
154 
155  /// Return true if this is a vector type where the runtime
156  /// length is machine dependent
157  bool isScalableVector() const {
158  // FIXME: We don't support extended scalable types yet, because the
159  // matching IR type doesn't exist. Once it has been added, this can
160  // be changed to call isExtendedScalableVector.
161  if (!isSimple())
162  return false;
163  return V.isScalableVector();
164  }
165 
166  /// Return true if this is a 16-bit vector type.
167  bool is16BitVector() const {
168  return isSimple() ? V.is16BitVector() : isExtended16BitVector();
169  }
170 
171  /// Return true if this is a 32-bit vector type.
172  bool is32BitVector() const {
173  return isSimple() ? V.is32BitVector() : isExtended32BitVector();
174  }
175 
176  /// Return true if this is a 64-bit vector type.
177  bool is64BitVector() const {
178  return isSimple() ? V.is64BitVector() : isExtended64BitVector();
179  }
180 
181  /// Return true if this is a 128-bit vector type.
182  bool is128BitVector() const {
183  return isSimple() ? V.is128BitVector() : isExtended128BitVector();
184  }
185 
186  /// Return true if this is a 256-bit vector type.
187  bool is256BitVector() const {
188  return isSimple() ? V.is256BitVector() : isExtended256BitVector();
189  }
190 
191  /// Return true if this is a 512-bit vector type.
192  bool is512BitVector() const {
193  return isSimple() ? V.is512BitVector() : isExtended512BitVector();
194  }
195 
196  /// Return true if this is a 1024-bit vector type.
197  bool is1024BitVector() const {
198  return isSimple() ? V.is1024BitVector() : isExtended1024BitVector();
199  }
200 
201  /// Return true if this is a 2048-bit vector type.
202  bool is2048BitVector() const {
203  return isSimple() ? V.is2048BitVector() : isExtended2048BitVector();
204  }
205 
206  /// Return true if this is an overloaded type for TableGen.
207  bool isOverloaded() const {
208  return (V==MVT::iAny || V==MVT::fAny || V==MVT::vAny || V==MVT::iPTRAny);
209  }
210 
211  /// Return true if the bit size is a multiple of 8.
212  bool isByteSized() const {
213  return (getSizeInBits() & 7) == 0;
214  }
215 
216  /// Return true if the size is a power-of-two number of bytes.
217  bool isRound() const {
218  unsigned BitSize = getSizeInBits();
219  return BitSize >= 8 && !(BitSize & (BitSize - 1));
220  }
221 
222  /// Return true if this has the same number of bits as VT.
223  bool bitsEq(EVT VT) const {
224  if (EVT::operator==(VT)) return true;
225  return getSizeInBits() == VT.getSizeInBits();
226  }
227 
228  /// Return true if this has more bits than VT.
229  bool bitsGT(EVT VT) const {
230  if (EVT::operator==(VT)) return false;
231  return getSizeInBits() > VT.getSizeInBits();
232  }
233 
234  /// Return true if this has no less bits than VT.
235  bool bitsGE(EVT VT) const {
236  if (EVT::operator==(VT)) return true;
237  return getSizeInBits() >= VT.getSizeInBits();
238  }
239 
240  /// Return true if this has less bits than VT.
241  bool bitsLT(EVT VT) const {
242  if (EVT::operator==(VT)) return false;
243  return getSizeInBits() < VT.getSizeInBits();
244  }
245 
246  /// Return true if this has no more bits than VT.
247  bool bitsLE(EVT VT) const {
248  if (EVT::operator==(VT)) return true;
249  return getSizeInBits() <= VT.getSizeInBits();
250  }
251 
252  /// Return the SimpleValueType held in the specified simple EVT.
253  MVT getSimpleVT() const {
254  assert(isSimple() && "Expected a SimpleValueType!");
255  return V;
256  }
257 
258  /// If this is a vector type, return the element type, otherwise return
259  /// this.
260  EVT getScalarType() const {
261  return isVector() ? getVectorElementType() : *this;
262  }
263 
264  /// Given a vector type, return the type of each element.
266  assert(isVector() && "Invalid vector type!");
267  if (isSimple())
268  return V.getVectorElementType();
269  return getExtendedVectorElementType();
270  }
271 
272  /// Given a vector type, return the number of elements it contains.
273  unsigned getVectorNumElements() const {
274  assert(isVector() && "Invalid vector type!");
275  if (isSimple())
276  return V.getVectorNumElements();
277  return getExtendedVectorNumElements();
278  }
279 
280  // Given a (possibly scalable) vector type, return the ElementCount
282  assert((isVector()) && "Invalid vector type!");
283  if (isSimple())
284  return V.getVectorElementCount();
285 
287  "We don't support extended scalable types yet");
288  return {getExtendedVectorNumElements(), false};
289  }
290 
291  /// Return the size of the specified value type in bits.
292  unsigned getSizeInBits() const {
293  if (isSimple())
294  return V.getSizeInBits();
295  return getExtendedSizeInBits();
296  }
297 
298  unsigned getScalarSizeInBits() const {
299  return getScalarType().getSizeInBits();
300  }
301 
302  /// Return the number of bytes overwritten by a store of the specified value
303  /// type.
304  unsigned getStoreSize() const {
305  return (getSizeInBits() + 7) / 8;
306  }
307 
308  /// Return the number of bits overwritten by a store of the specified value
309  /// type.
310  unsigned getStoreSizeInBits() const {
311  return getStoreSize() * 8;
312  }
313 
314  /// Rounds the bit-width of the given integer EVT up to the nearest power of
315  /// two (and at least to eight), and returns the integer EVT with that
316  /// number of bits.
318  assert(isInteger() && !isVector() && "Invalid integer type!");
319  unsigned BitWidth = getSizeInBits();
320  if (BitWidth <= 8)
321  return EVT(MVT::i8);
322  return getIntegerVT(Context, 1 << Log2_32_Ceil(BitWidth));
323  }
324 
325  /// Finds the smallest simple value type that is greater than or equal to
326  /// half the width of this EVT. If no simple value type can be found, an
327  /// extended integer value type of half the size (rounded up) is returned.
329  assert(isInteger() && !isVector() && "Invalid integer type!");
330  unsigned EVTSize = getSizeInBits();
331  for (unsigned IntVT = MVT::FIRST_INTEGER_VALUETYPE;
332  IntVT <= MVT::LAST_INTEGER_VALUETYPE; ++IntVT) {
333  EVT HalfVT = EVT((MVT::SimpleValueType)IntVT);
334  if (HalfVT.getSizeInBits() * 2 >= EVTSize)
335  return HalfVT;
336  }
337  return getIntegerVT(Context, (EVTSize + 1) / 2);
338  }
339 
340  /// Return a VT for an integer vector type with the size of the
341  /// elements doubled. The typed returned may be an extended type.
343  EVT EltVT = getVectorElementType();
344  EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits());
345  return EVT::getVectorVT(Context, EltVT, getVectorElementCount());
346  }
347 
348  // Return a VT for a vector type with the same element type but
349  // half the number of elements. The type returned may be an
350  // extended type.
352  EVT EltVT = getVectorElementType();
353  auto EltCnt = getVectorElementCount();
354  assert(!(EltCnt.Min & 1) && "Splitting vector, but not in half!");
355  return EVT::getVectorVT(Context, EltVT, EltCnt / 2);
356  }
357 
358  /// Returns true if the given vector is a power of 2.
359  bool isPow2VectorType() const {
360  unsigned NElts = getVectorNumElements();
361  return !(NElts & (NElts - 1));
362  }
363 
364  /// Widens the length of the given vector EVT up to the nearest power of 2
365  /// and returns that type.
367  if (!isPow2VectorType()) {
368  unsigned NElts = getVectorNumElements();
369  unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts);
370  return EVT::getVectorVT(Context, getVectorElementType(), Pow2NElts,
371  isScalableVector());
372  }
373  else {
374  return *this;
375  }
376  }
377 
378  /// This function returns value type as a string, e.g. "i32".
379  std::string getEVTString() const;
380 
381  /// This method returns an LLVM type corresponding to the specified EVT.
382  /// For integer types, this returns an unsigned type. Note that this will
383  /// abort for types that cannot be represented.
385 
386  /// Return the value type corresponding to the specified type.
387  /// This returns all pointers as iPTR. If HandleUnknown is true, unknown
388  /// types are returned as Other, otherwise they are invalid.
389  static EVT getEVT(Type *Ty, bool HandleUnknown = false);
390 
392  if (isSimple())
393  return V.SimpleTy;
394  else
395  return (intptr_t)(LLVMTy);
396  }
397 
398  /// A meaningless but well-behaved order, useful for constructing
399  /// containers.
400  struct compareRawBits {
401  bool operator()(EVT L, EVT R) const {
402  if (L.V.SimpleTy == R.V.SimpleTy)
403  return L.LLVMTy < R.LLVMTy;
404  else
405  return L.V.SimpleTy < R.V.SimpleTy;
406  }
407  };
408 
409  private:
410  // Methods for handling the Extended-type case in functions above.
411  // These are all out-of-line to prevent users of this header file
412  // from having a dependency on Type.h.
413  EVT changeExtendedTypeToInteger() const;
414  EVT changeExtendedVectorElementTypeToInteger() const;
415  static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth);
416  static EVT getExtendedVectorVT(LLVMContext &C, EVT VT,
417  unsigned NumElements);
418  bool isExtendedFloatingPoint() const LLVM_READONLY;
419  bool isExtendedInteger() const LLVM_READONLY;
420  bool isExtendedScalarInteger() const LLVM_READONLY;
421  bool isExtendedVector() const LLVM_READONLY;
422  bool isExtended16BitVector() const LLVM_READONLY;
423  bool isExtended32BitVector() const LLVM_READONLY;
424  bool isExtended64BitVector() const LLVM_READONLY;
425  bool isExtended128BitVector() const LLVM_READONLY;
426  bool isExtended256BitVector() const LLVM_READONLY;
427  bool isExtended512BitVector() const LLVM_READONLY;
428  bool isExtended1024BitVector() const LLVM_READONLY;
429  bool isExtended2048BitVector() const LLVM_READONLY;
430  EVT getExtendedVectorElementType() const;
431  unsigned getExtendedVectorNumElements() const LLVM_READONLY;
432  unsigned getExtendedSizeInBits() const LLVM_READONLY;
433  };
434 
435 } // end namespace llvm
436 
437 #endif // LLVM_CODEGEN_VALUETYPES_H
uint64_t CallInst * C
static MVT getIntegerVT(unsigned BitWidth)
unsigned Log2_32_Ceil(uint32_t Value)
Return the ceil log base 2 of the specified value, 32 if the value is zero.
Definition: MathExtras.h:544
bool isInteger() const
Return true if this is an integer or a vector integer type.
LLVMContext & Context
bool isPow2VectorType() const
Returns true if the given vector is a power of 2.
Definition: ValueTypes.h:359
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static MVT getVectorVT(MVT VT, unsigned NumElements)
EVT getScalarType() const
If this is a vector type, return the element type, otherwise return this.
Definition: ValueTypes.h:260
bool operator==(EVT VT) const
Definition: ValueTypes.h:44
bool isVector() const
Return true if this is a vector value type.
EVT getHalfNumVectorElementsVT(LLVMContext &Context) const
Definition: ValueTypes.h:351
bool is256BitVector() const
Return true if this is a 256-bit vector type.
bool isScalarInteger() const
Return true if this is an integer, but not a vector.
Definition: ValueTypes.h:146
MVT getSimpleVT() const
Return the SimpleValueType held in the specified simple EVT.
Definition: ValueTypes.h:253
static MVT getFloatingPointVT(unsigned BitWidth)
unsigned getVectorNumElements() const
bool isScalableVector() const
Return true if this is a vector type where the runtime length is machine dependent.
Definition: ValueTypes.h:157
bool isInteger() const
Return true if this is an integer or a vector integer type.
Definition: ValueTypes.h:141
bool isByteSized() const
Return true if the bit size is a multiple of 8.
Definition: ValueTypes.h:212
EVT getPow2VectorType(LLVMContext &Context) const
Widens the length of the given vector EVT up to the nearest power of 2 and returns that type...
Definition: ValueTypes.h:366
bool is16BitVector() const
Return true if this is a 16-bit vector type.
Definition: ValueTypes.h:167
bool isFloatingPoint() const
Return true if this is a FP or a vector FP type.
Definition: ValueTypes.h:136
constexpr EVT(MVT S)
Definition: ValueTypes.h:42
Type * getTypeForEVT(LLVMContext &Context) const
This method returns an LLVM type corresponding to the specified EVT.
Definition: ValueTypes.cpp:205
SimpleValueType SimpleTy
unsigned getStoreSize() const
Return the number of bytes overwritten by a store of the specified value type.
Definition: ValueTypes.h:304
MVT::ElementCount getVectorElementCount() const
Definition: ValueTypes.h:281
bool is64BitVector() const
Return true if this is a 64-bit vector type.
unsigned getSizeInBits() const
bool operator!=(EVT VT) const
Definition: ValueTypes.h:47
A meaningless but well-behaved order, useful for constructing containers.
Definition: ValueTypes.h:400
bool is1024BitVector() const
Return true if this is a 1024-bit vector type.
unsigned getScalarSizeInBits() const
Definition: ValueTypes.h:298
unsigned getSizeInBits() const
Return the size of the specified value type in bits.
Definition: ValueTypes.h:292
bool is2048BitVector() const
Return true if this is a 1024-bit vector type.
bool is16BitVector() const
Return true if this is a 16-bit vector type.
MVT getVectorElementType() const
bool isScalableVector() const
Return true if this is a vector value type where the runtime length is machine dependent.
bool is128BitVector() const
Return true if this is a 128-bit vector type.
bool bitsGT(EVT VT) const
Return true if this has more bits than VT.
Definition: ValueTypes.h:229
bool bitsGE(EVT VT) const
Return true if this has no less bits than VT.
Definition: ValueTypes.h:235
bool operator()(EVT L, EVT R) const
Definition: ValueTypes.h:401
Machine Value Type.
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
bool is512BitVector() const
Return true if this is a 512-bit vector type.
Definition: ValueTypes.h:192
unsigned getVectorNumElements() const
Given a vector type, return the number of elements it contains.
Definition: ValueTypes.h:273
bool isRound() const
Return true if the size is a power-of-two number of bytes.
Definition: ValueTypes.h:217
bool bitsLE(EVT VT) const
Return true if this has no more bits than VT.
Definition: ValueTypes.h:247
bool isScalarInteger() const
Return true if this is an integer, not including vectors.
static EVT getFloatingPointVT(unsigned BitWidth)
Returns the EVT that represents a floating-point type with the given number of bits.
Definition: ValueTypes.h:58
std::string getEVTString() const
This function returns value type as a string, e.g. "i32".
Definition: ValueTypes.cpp:120
bool is32BitVector() const
Return true if this is a 32-bit vector type.
Definition: ValueTypes.h:172
Extended Value Type.
Definition: ValueTypes.h:34
bool is2048BitVector() const
Return true if this is a 2048-bit vector type.
Definition: ValueTypes.h:202
bool isFloatingPoint() const
Return true if this is a FP or a vector FP type.
EVT getRoundIntegerType(LLVMContext &Context) const
Rounds the bit-width of the given integer EVT up to the nearest power of two (and at least to eight)...
Definition: ValueTypes.h:317
unsigned getStoreSizeInBits() const
Return the number of bits overwritten by a store of the specified value type.
Definition: ValueTypes.h:310
EVT getVectorElementType() const
Given a vector type, return the type of each element.
Definition: ValueTypes.h:265
EVT changeVectorElementTypeToInteger() const
Return a vector with the same number of elements as this vector, but with the element type converted ...
Definition: ValueTypes.h:96
EVT widenIntegerVectorElementType(LLVMContext &Context) const
Return a VT for an integer vector type with the size of the elements doubled.
Definition: ValueTypes.h:342
constexpr EVT()=default
static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements, bool IsScalable=false)
Returns the EVT that represents a vector NumElements in length, where each element is of type VT...
Definition: ValueTypes.h:73
bool bitsLT(EVT VT) const
Return true if this has less bits than VT.
Definition: ValueTypes.h:241
bool isOverloaded() const
Return true if this is an overloaded type for TableGen.
Definition: ValueTypes.h:207
bool is32BitVector() const
Return true if this is a 32-bit vector type.
bool is256BitVector() const
Return true if this is a 256-bit vector type.
Definition: ValueTypes.h:187
static EVT getVectorVT(LLVMContext &Context, EVT VT, MVT::ElementCount EC)
Returns the EVT that represents a vector EC.Min elements in length, where each element is of type VT...
Definition: ValueTypes.h:85
MVT::ElementCount getVectorElementCount() const
bool is64BitVector() const
Return true if this is a 64-bit vector type.
Definition: ValueTypes.h:177
bool isVector() const
Return true if this is a vector value type.
Definition: ValueTypes.h:151
bool is128BitVector() const
Return true if this is a 128-bit vector type.
Definition: ValueTypes.h:182
bool is512BitVector() const
Return true if this is a 512-bit vector type.
#define LLVM_READONLY
Definition: Compiler.h:168
static EVT getEVT(Type *Ty, bool HandleUnknown=false)
Return the value type corresponding to the specified type.
Definition: ValueTypes.cpp:311
bool is1024BitVector() const
Return true if this is a 1024-bit vector type.
Definition: ValueTypes.h:197
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
EVT changeTypeToInteger()
Return the type converted to an equivalently sized integer or vector with integer element type...
Definition: ValueTypes.h:115
intptr_t getRawBits() const
Definition: ValueTypes.h:391
bool bitsEq(EVT VT) const
Return true if this has the same number of bits as VT.
Definition: ValueTypes.h:223
bool isSimple() const
Test if the given EVT is simple (as opposed to being extended).
Definition: ValueTypes.h:126
static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth)
Returns the EVT that represents an integer with the given number of bits.
Definition: ValueTypes.h:64
bool isExtended() const
Test if the given EVT is extended (as opposed to being simple).
Definition: ValueTypes.h:131
constexpr EVT(MVT::SimpleValueType SVT)
Definition: ValueTypes.h:41
EVT getHalfSizedIntegerVT(LLVMContext &Context) const
Finds the smallest simple value type that is greater than or equal to half the width of this EVT...
Definition: ValueTypes.h:328