LLVM  14.0.0git
ValueTypes.h
Go to the documentation of this file.
1 //===- CodeGen/ValueTypes.h - Low-Level Target independ. 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 defines the set of low-level target independent types which various
10 // values in the code generator are. This allows the target specific behavior
11 // of instructions to be described to target independent passes.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CODEGEN_VALUETYPES_H
16 #define LLVM_CODEGEN_VALUETYPES_H
17 
18 #include "llvm/Support/Compiler.h"
21 #include "llvm/Support/TypeSize.h"
22 #include "llvm/Support/WithColor.h"
23 #include <cassert>
24 #include <cstdint>
25 #include <string>
26 
27 namespace llvm {
28 
29  class LLVMContext;
30  class Type;
31 
32  /// Extended Value Type. Capable of holding value types which are not native
33  /// for any processor (such as the i12345 type), as well as the types an MVT
34  /// can represent.
35  struct EVT {
36  private:
38  Type *LLVMTy = nullptr;
39 
40  public:
41  constexpr EVT() = default;
42  constexpr EVT(MVT::SimpleValueType SVT) : V(SVT) {}
43  constexpr EVT(MVT S) : V(S) {}
44 
45  bool operator==(EVT VT) const {
46  return !(*this != VT);
47  }
48  bool operator!=(EVT VT) const {
49  if (V.SimpleTy != VT.V.SimpleTy)
50  return true;
52  return LLVMTy != VT.LLVMTy;
53  return false;
54  }
55 
56  /// Returns the EVT that represents a floating-point type with the given
57  /// number of bits. There are two floating-point types with 128 bits - this
58  /// returns f128 rather than ppcf128.
59  static EVT getFloatingPointVT(unsigned BitWidth) {
61  }
62 
63  /// Returns the EVT that represents an integer with the given number of
64  /// bits.
67  if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
68  return M;
69  return getExtendedIntegerVT(Context, BitWidth);
70  }
71 
72  /// Returns the EVT that represents a vector NumElements in length, where
73  /// each element is of type VT.
74  static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements,
75  bool IsScalable = false) {
76  MVT M = MVT::getVectorVT(VT.V, NumElements, IsScalable);
77  if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
78  return M;
79  return getExtendedVectorVT(Context, VT, NumElements, IsScalable);
80  }
81 
82  /// Returns the EVT that represents a vector EC.Min elements in length,
83  /// where each element is of type VT.
85  MVT M = MVT::getVectorVT(VT.V, EC);
86  if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
87  return M;
88  return getExtendedVectorVT(Context, VT, EC);
89  }
90 
91  /// Return a vector with the same number of elements as this vector, but
92  /// with the element type converted to an integer type with the same
93  /// bitwidth.
95  if (isSimple())
97  return changeExtendedVectorElementTypeToInteger();
98  }
99 
100  /// Return a VT for a vector type whose attributes match ourselves
101  /// with the exception of the element type that is chosen by the caller.
103  if (isSimple()) {
104  assert(EltVT.isSimple() &&
105  "Can't change simple vector VT to have extended element VT");
107  }
108  return changeExtendedVectorElementType(EltVT);
109  }
110 
111  /// Return the type converted to an equivalently sized integer or vector
112  /// with integer element type. Similar to changeVectorElementTypeToInteger,
113  /// but also handles scalars.
115  if (isVector())
117 
118  if (isSimple())
119  return getSimpleVT().changeTypeToInteger();
120  return changeExtendedTypeToInteger();
121  }
122 
123  /// Test if the given EVT has zero size, this will fail if called on a
124  /// scalable type
125  bool isZeroSized() const {
126  return !isScalableVector() && getSizeInBits() == 0;
127  }
128 
129  /// Test if the given EVT is simple (as opposed to being extended).
130  bool isSimple() const {
132  }
133 
134  /// Test if the given EVT is extended (as opposed to being simple).
135  bool isExtended() const {
136  return !isSimple();
137  }
138 
139  /// Return true if this is a FP or a vector FP type.
140  bool isFloatingPoint() const {
141  return isSimple() ? V.isFloatingPoint() : isExtendedFloatingPoint();
142  }
143 
144  /// Return true if this is an integer or a vector integer type.
145  bool isInteger() const {
146  return isSimple() ? V.isInteger() : isExtendedInteger();
147  }
148 
149  /// Return true if this is an integer, but not a vector.
150  bool isScalarInteger() const {
151  return isSimple() ? V.isScalarInteger() : isExtendedScalarInteger();
152  }
153 
154  /// Return true if this is a vector value type.
155  bool isVector() const {
156  return isSimple() ? V.isVector() : isExtendedVector();
157  }
158 
159  /// Return true if this is a vector type where the runtime
160  /// length is machine dependent
161  bool isScalableVector() const {
162  return isSimple() ? V.isScalableVector() : isExtendedScalableVector();
163  }
164 
165  bool isFixedLengthVector() const {
166  return isSimple() ? V.isFixedLengthVector()
167  : isExtendedFixedLengthVector();
168  }
169 
170  /// Return true if this is a 16-bit vector type.
171  bool is16BitVector() const {
172  return isSimple() ? V.is16BitVector() : isExtended16BitVector();
173  }
174 
175  /// Return true if this is a 32-bit vector type.
176  bool is32BitVector() const {
177  return isSimple() ? V.is32BitVector() : isExtended32BitVector();
178  }
179 
180  /// Return true if this is a 64-bit vector type.
181  bool is64BitVector() const {
182  return isSimple() ? V.is64BitVector() : isExtended64BitVector();
183  }
184 
185  /// Return true if this is a 128-bit vector type.
186  bool is128BitVector() const {
187  return isSimple() ? V.is128BitVector() : isExtended128BitVector();
188  }
189 
190  /// Return true if this is a 256-bit vector type.
191  bool is256BitVector() const {
192  return isSimple() ? V.is256BitVector() : isExtended256BitVector();
193  }
194 
195  /// Return true if this is a 512-bit vector type.
196  bool is512BitVector() const {
197  return isSimple() ? V.is512BitVector() : isExtended512BitVector();
198  }
199 
200  /// Return true if this is a 1024-bit vector type.
201  bool is1024BitVector() const {
202  return isSimple() ? V.is1024BitVector() : isExtended1024BitVector();
203  }
204 
205  /// Return true if this is a 2048-bit vector type.
206  bool is2048BitVector() const {
207  return isSimple() ? V.is2048BitVector() : isExtended2048BitVector();
208  }
209 
210  /// Return true if this is an overloaded type for TableGen.
211  bool isOverloaded() const {
212  return (V==MVT::iAny || V==MVT::fAny || V==MVT::vAny || V==MVT::iPTRAny);
213  }
214 
215  /// Return true if the bit size is a multiple of 8.
216  bool isByteSized() const {
217  return !isZeroSized() && getSizeInBits().isKnownMultipleOf(8);
218  }
219 
220  /// Return true if the size is a power-of-two number of bytes.
221  bool isRound() const {
222  if (isScalableVector())
223  return false;
224  unsigned BitSize = getSizeInBits();
225  return BitSize >= 8 && !(BitSize & (BitSize - 1));
226  }
227 
228  /// Return true if this has the same number of bits as VT.
229  bool bitsEq(EVT VT) const {
230  if (EVT::operator==(VT)) return true;
231  return getSizeInBits() == VT.getSizeInBits();
232  }
233 
234  /// Return true if we know at compile time this has more bits than VT.
235  bool knownBitsGT(EVT VT) const {
237  }
238 
239  /// Return true if we know at compile time this has more than or the same
240  /// bits as VT.
241  bool knownBitsGE(EVT VT) const {
243  }
244 
245  /// Return true if we know at compile time this has fewer bits than VT.
246  bool knownBitsLT(EVT VT) const {
248  }
249 
250  /// Return true if we know at compile time this has fewer than or the same
251  /// bits as VT.
252  bool knownBitsLE(EVT VT) const {
254  }
255 
256  /// Return true if this has more bits than VT.
257  bool bitsGT(EVT VT) const {
258  if (EVT::operator==(VT)) return false;
260  "Comparison between scalable and fixed types");
261  return knownBitsGT(VT);
262  }
263 
264  /// Return true if this has no less bits than VT.
265  bool bitsGE(EVT VT) const {
266  if (EVT::operator==(VT)) return true;
268  "Comparison between scalable and fixed types");
269  return knownBitsGE(VT);
270  }
271 
272  /// Return true if this has less bits than VT.
273  bool bitsLT(EVT VT) const {
274  if (EVT::operator==(VT)) return false;
276  "Comparison between scalable and fixed types");
277  return knownBitsLT(VT);
278  }
279 
280  /// Return true if this has no more bits than VT.
281  bool bitsLE(EVT VT) const {
282  if (EVT::operator==(VT)) return true;
284  "Comparison between scalable and fixed types");
285  return knownBitsLE(VT);
286  }
287 
288  /// Return the SimpleValueType held in the specified simple EVT.
289  MVT getSimpleVT() const {
290  assert(isSimple() && "Expected a SimpleValueType!");
291  return V;
292  }
293 
294  /// If this is a vector type, return the element type, otherwise return
295  /// this.
296  EVT getScalarType() const {
297  return isVector() ? getVectorElementType() : *this;
298  }
299 
300  /// Given a vector type, return the type of each element.
302  assert(isVector() && "Invalid vector type!");
303  if (isSimple())
304  return V.getVectorElementType();
305  return getExtendedVectorElementType();
306  }
307 
308  /// Given a vector type, return the number of elements it contains.
309  unsigned getVectorNumElements() const {
310  assert(isVector() && "Invalid vector type!");
311 
312  if (isScalableVector())
314  "Possible incorrect use of EVT::getVectorNumElements() for "
315  "scalable vector. Scalable flag may be dropped, use "
316  "EVT::getVectorElementCount() instead");
317 
318  return isSimple() ? V.getVectorNumElements()
319  : getExtendedVectorNumElements();
320  }
321 
322  // Given a (possibly scalable) vector type, return the ElementCount
324  assert((isVector()) && "Invalid vector type!");
325  if (isSimple())
326  return V.getVectorElementCount();
327 
328  return getExtendedVectorElementCount();
329  }
330 
331  /// Given a vector type, return the minimum number of elements it contains.
332  unsigned getVectorMinNumElements() const {
334  }
335 
336  /// Return the size of the specified value type in bits.
337  ///
338  /// If the value type is a scalable vector type, the scalable property will
339  /// be set and the runtime size will be a positive integer multiple of the
340  /// base size.
342  if (isSimple())
343  return V.getSizeInBits();
344  return getExtendedSizeInBits();
345  }
346 
347  /// Return the size of the specified fixed width value type in bits. The
348  /// function will assert if the type is scalable.
350  return getSizeInBits().getFixedSize();
351  }
352 
355  }
356 
357  /// Return the number of bytes overwritten by a store of the specified value
358  /// type.
359  ///
360  /// If the value type is a scalable vector type, the scalable property will
361  /// be set and the runtime size will be a positive integer multiple of the
362  /// base size.
364  TypeSize BaseSize = getSizeInBits();
365  return {(BaseSize.getKnownMinSize() + 7) / 8, BaseSize.isScalable()};
366  }
367 
368  /// Return the number of bits overwritten by a store of the specified value
369  /// type.
370  ///
371  /// If the value type is a scalable vector type, the scalable property will
372  /// be set and the runtime size will be a positive integer multiple of the
373  /// base size.
375  return getStoreSize() * 8;
376  }
377 
378  /// Rounds the bit-width of the given integer EVT up to the nearest power of
379  /// two (and at least to eight), and returns the integer EVT with that
380  /// number of bits.
382  assert(isInteger() && !isVector() && "Invalid integer type!");
383  unsigned BitWidth = getSizeInBits();
384  if (BitWidth <= 8)
385  return EVT(MVT::i8);
386  return getIntegerVT(Context, 1 << Log2_32_Ceil(BitWidth));
387  }
388 
389  /// Finds the smallest simple value type that is greater than or equal to
390  /// half the width of this EVT. If no simple value type can be found, an
391  /// extended integer value type of half the size (rounded up) is returned.
393  assert(isInteger() && !isVector() && "Invalid integer type!");
394  unsigned EVTSize = getSizeInBits();
395  for (unsigned IntVT = MVT::FIRST_INTEGER_VALUETYPE;
396  IntVT <= MVT::LAST_INTEGER_VALUETYPE; ++IntVT) {
397  EVT HalfVT = EVT((MVT::SimpleValueType)IntVT);
398  if (HalfVT.getSizeInBits() * 2 >= EVTSize)
399  return HalfVT;
400  }
401  return getIntegerVT(Context, (EVTSize + 1) / 2);
402  }
403 
404  /// Return a VT for an integer vector type with the size of the
405  /// elements doubled. The typed returned may be an extended type.
407  EVT EltVT = getVectorElementType();
408  EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits());
410  }
411 
412  // Return a VT for a vector type with the same element type but
413  // half the number of elements. The type returned may be an
414  // extended type.
416  EVT EltVT = getVectorElementType();
417  auto EltCnt = getVectorElementCount();
418  assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!");
419  return EVT::getVectorVT(Context, EltVT, EltCnt.divideCoefficientBy(2));
420  }
421 
422  // Return a VT for a vector type with the same element type but
423  // double the number of elements. The type returned may be an
424  // extended type.
426  EVT EltVT = getVectorElementType();
427  auto EltCnt = getVectorElementCount();
428  return EVT::getVectorVT(Context, EltVT, EltCnt * 2);
429  }
430 
431  /// Returns true if the given vector is a power of 2.
432  bool isPow2VectorType() const {
433  unsigned NElts = getVectorMinNumElements();
434  return !(NElts & (NElts - 1));
435  }
436 
437  /// Widens the length of the given vector EVT up to the nearest power of 2
438  /// and returns that type.
440  if (!isPow2VectorType()) {
442  unsigned NewMinCount = 1 << Log2_32_Ceil(NElts.getKnownMinValue());
443  NElts = ElementCount::get(NewMinCount, NElts.isScalable());
445  }
446  else {
447  return *this;
448  }
449  }
450 
451  /// This function returns value type as a string, e.g. "i32".
452  std::string getEVTString() const;
453 
454  /// This method returns an LLVM type corresponding to the specified EVT.
455  /// For integer types, this returns an unsigned type. Note that this will
456  /// abort for types that cannot be represented.
458 
459  /// Return the value type corresponding to the specified type.
460  /// This returns all pointers as iPTR. If HandleUnknown is true, unknown
461  /// types are returned as Other, otherwise they are invalid.
462  static EVT getEVT(Type *Ty, bool HandleUnknown = false);
463 
465  if (isSimple())
466  return V.SimpleTy;
467  else
468  return (intptr_t)(LLVMTy);
469  }
470 
471  /// A meaningless but well-behaved order, useful for constructing
472  /// containers.
473  struct compareRawBits {
474  bool operator()(EVT L, EVT R) const {
475  if (L.V.SimpleTy == R.V.SimpleTy)
476  return L.LLVMTy < R.LLVMTy;
477  else
478  return L.V.SimpleTy < R.V.SimpleTy;
479  }
480  };
481 
482  private:
483  // Methods for handling the Extended-type case in functions above.
484  // These are all out-of-line to prevent users of this header file
485  // from having a dependency on Type.h.
486  EVT changeExtendedTypeToInteger() const;
487  EVT changeExtendedVectorElementType(EVT EltVT) const;
488  EVT changeExtendedVectorElementTypeToInteger() const;
489  static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth);
490  static EVT getExtendedVectorVT(LLVMContext &C, EVT VT, unsigned NumElements,
491  bool IsScalable);
492  static EVT getExtendedVectorVT(LLVMContext &Context, EVT VT,
493  ElementCount EC);
494  bool isExtendedFloatingPoint() const LLVM_READONLY;
495  bool isExtendedInteger() const LLVM_READONLY;
496  bool isExtendedScalarInteger() const LLVM_READONLY;
497  bool isExtendedVector() const LLVM_READONLY;
498  bool isExtended16BitVector() const LLVM_READONLY;
499  bool isExtended32BitVector() const LLVM_READONLY;
500  bool isExtended64BitVector() const LLVM_READONLY;
501  bool isExtended128BitVector() const LLVM_READONLY;
502  bool isExtended256BitVector() const LLVM_READONLY;
503  bool isExtended512BitVector() const LLVM_READONLY;
504  bool isExtended1024BitVector() const LLVM_READONLY;
505  bool isExtended2048BitVector() const LLVM_READONLY;
506  bool isExtendedFixedLengthVector() const LLVM_READONLY;
507  bool isExtendedScalableVector() const LLVM_READONLY;
508  EVT getExtendedVectorElementType() const;
509  unsigned getExtendedVectorNumElements() const LLVM_READONLY;
510  ElementCount getExtendedVectorElementCount() const LLVM_READONLY;
511  TypeSize getExtendedSizeInBits() const LLVM_READONLY;
512  };
513 
514 } // end namespace llvm
515 
516 #endif // LLVM_CODEGEN_VALUETYPES_H
llvm::MVT::getVectorElementType
MVT getVectorElementType() const
Definition: MachineValueType.h:519
llvm::EVT::knownBitsGT
bool knownBitsGT(EVT VT) const
Return true if we know at compile time this has more bits than VT.
Definition: ValueTypes.h:235
llvm::EVT::is32BitVector
bool is32BitVector() const
Return true if this is a 32-bit vector type.
Definition: ValueTypes.h:176
llvm::EVT::operator!=
bool operator!=(EVT VT) const
Definition: ValueTypes.h:48
LLVM_READONLY
#define LLVM_READONLY
Definition: Compiler.h:212
MathExtras.h
llvm::EVT::is16BitVector
bool is16BitVector() const
Return true if this is a 16-bit vector type.
Definition: ValueTypes.h:171
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::EVT::isScalarInteger
bool isScalarInteger() const
Return true if this is an integer, but not a vector.
Definition: ValueTypes.h:150
llvm::MVT::isFixedLengthVector
bool isFixedLengthVector() const
Definition: MachineValueType.h:378
llvm::MVT::isInteger
bool isInteger() const
Return true if this is an integer or a vector integer type.
Definition: MachineValueType.h:350
intptr_t
llvm::LinearPolySize< TypeSize >::isKnownGT
static bool isKnownGT(const LinearPolySize &LHS, const LinearPolySize &RHS)
Definition: TypeSize.h:335
llvm::EVT::compareRawBits
A meaningless but well-behaved order, useful for constructing containers.
Definition: ValueTypes.h:473
llvm::EVT::getVectorElementCount
ElementCount getVectorElementCount() const
Definition: ValueTypes.h:323
llvm::ElementCount
Definition: TypeSize.h:386
llvm::EVT::getFixedSizeInBits
uint64_t getFixedSizeInBits() const
Return the size of the specified fixed width value type in bits.
Definition: ValueTypes.h:349
llvm::TypeSize::getFixedSize
ScalarTy getFixedSize() const
Definition: TypeSize.h:426
llvm::MVT::is256BitVector
bool is256BitVector() const
Return true if this is a 256-bit vector type.
Definition: MachineValueType.h:416
TypeSize.h
llvm::LinearPolySize< TypeSize >::isKnownLE
static bool isKnownLE(const LinearPolySize &LHS, const LinearPolySize &RHS)
Definition: TypeSize.h:341
llvm::MVT::isVector
bool isVector() const
Return true if this is a vector value type.
Definition: MachineValueType.h:366
llvm::MVT::fAny
@ fAny
Definition: MachineValueType.h:303
llvm::EVT::isScalableVector
bool isScalableVector() const
Return true if this is a vector type where the runtime length is machine dependent.
Definition: ValueTypes.h:161
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::EVT::getVectorVT
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:74
llvm::EVT::isOverloaded
bool isOverloaded() const
Return true if this is an overloaded type for TableGen.
Definition: ValueTypes.h:211
llvm::EVT::bitsLE
bool bitsLE(EVT VT) const
Return true if this has no more bits than VT.
Definition: ValueTypes.h:281
llvm::EVT::isZeroSized
bool isZeroSized() const
Test if the given EVT has zero size, this will fail if called on a scalable type.
Definition: ValueTypes.h:125
llvm::EVT::getRoundIntegerType
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:381
llvm::LinearPolySize::isScalable
bool isScalable() const
Returns whether the size is scaled by a runtime quantity (vscale).
Definition: TypeSize.h:299
llvm::EVT::EVT
constexpr EVT(MVT::SimpleValueType SVT)
Definition: ValueTypes.h:42
llvm::MVT::is32BitVector
bool is32BitVector() const
Return true if this is a 32-bit vector type.
Definition: MachineValueType.h:390
llvm::EVT::changeTypeToInteger
EVT changeTypeToInteger()
Return the type converted to an equivalently sized integer or vector with integer element type.
Definition: ValueTypes.h:114
llvm::LinearPolySize< TypeSize >::isKnownLT
static bool isKnownLT(const LinearPolySize &LHS, const LinearPolySize &RHS)
Definition: TypeSize.h:329
llvm::MVT::isScalableVector
bool isScalableVector() const
Return true if this is a vector value type where the runtime length is machine dependent.
Definition: MachineValueType.h:373
llvm::EVT::isSimple
bool isSimple() const
Test if the given EVT is simple (as opposed to being extended).
Definition: ValueTypes.h:130
llvm::EVT::is256BitVector
bool is256BitVector() const
Return true if this is a 256-bit vector type.
Definition: ValueTypes.h:191
MachineValueType.h
llvm::MVT::SimpleValueType
SimpleValueType
Definition: MachineValueType.h:33
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::EVT::getStoreSize
TypeSize getStoreSize() const
Return the number of bytes overwritten by a store of the specified value type.
Definition: ValueTypes.h:363
llvm::LinearPolySize< ElementCount >::get
static ElementCount get(ScalarTy MinVal, bool Scalable)
Definition: TypeSize.h:290
llvm::MVT::changeTypeToInteger
MVT changeTypeToInteger()
Return the type converted to an equivalently sized integer or vector with integer element type.
Definition: MachineValueType.h:481
llvm::EVT::getPow2VectorType
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:439
llvm::EVT
Extended Value Type.
Definition: ValueTypes.h:35
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::EVT::is64BitVector
bool is64BitVector() const
Return true if this is a 64-bit vector type.
Definition: ValueTypes.h:181
llvm::EVT::getVectorNumElements
unsigned getVectorNumElements() const
Given a vector type, return the number of elements it contains.
Definition: ValueTypes.h:309
llvm::MVT::SimpleTy
SimpleValueType SimpleTy
Definition: MachineValueType.h:321
llvm::EVT::isInteger
bool isInteger() const
Return true if this is an integer or a vector integer type.
Definition: ValueTypes.h:145
llvm::EVT::getVectorVT
static EVT getVectorVT(LLVMContext &Context, EVT VT, ElementCount EC)
Returns the EVT that represents a vector EC.Min elements in length, where each element is of type VT.
Definition: ValueTypes.h:84
llvm::MVT::INVALID_SIMPLE_VALUE_TYPE
@ INVALID_SIMPLE_VALUE_TYPE
Definition: MachineValueType.h:38
llvm::EVT::changeVectorElementType
EVT changeVectorElementType(EVT EltVT) const
Return a VT for a vector type whose attributes match ourselves with the exception of the element type...
Definition: ValueTypes.h:102
llvm::EVT::EVT
constexpr EVT(MVT S)
Definition: ValueTypes.h:43
llvm::EVT::EVT
constexpr EVT()=default
llvm::MVT::FIRST_INTEGER_VALUETYPE
@ FIRST_INTEGER_VALUETYPE
Definition: MachineValueType.h:50
llvm::EVT::is1024BitVector
bool is1024BitVector() const
Return true if this is a 1024-bit vector type.
Definition: ValueTypes.h:201
llvm::EVT::changeVectorElementTypeToInteger
EVT changeVectorElementTypeToInteger() const
Return a vector with the same number of elements as this vector, but with the element type converted ...
Definition: ValueTypes.h:94
llvm::EVT::bitsLT
bool bitsLT(EVT VT) const
Return true if this has less bits than VT.
Definition: ValueTypes.h:273
llvm::EVT::getTypeForEVT
Type * getTypeForEVT(LLVMContext &Context) const
This method returns an LLVM type corresponding to the specified EVT.
Definition: ValueTypes.cpp:181
llvm::Log2_32_Ceil
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:609
llvm::EVT::isExtended
bool isExtended() const
Test if the given EVT is extended (as opposed to being simple).
Definition: ValueTypes.h:135
llvm::MVT::isFloatingPoint
bool isFloatingPoint() const
Return true if this is a FP or a vector FP type.
Definition: MachineValueType.h:340
llvm::EVT::getStoreSizeInBits
TypeSize getStoreSizeInBits() const
Return the number of bits overwritten by a store of the specified value type.
Definition: ValueTypes.h:374
llvm::MVT::iPTRAny
@ iPTRAny
Definition: MachineValueType.h:293
llvm::EVT::knownBitsLE
bool knownBitsLE(EVT VT) const
Return true if we know at compile time this has fewer than or the same bits as VT.
Definition: ValueTypes.h:252
llvm::EVT::getSizeInBits
TypeSize getSizeInBits() const
Return the size of the specified value type in bits.
Definition: ValueTypes.h:341
uint64_t
llvm::MVT::is16BitVector
bool is16BitVector() const
Return true if this is a 16-bit vector type.
Definition: MachineValueType.h:384
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::EVT::getEVT
static EVT getEVT(Type *Ty, bool HandleUnknown=false)
Return the value type corresponding to the specified type.
Definition: ValueTypes.cpp:558
llvm::EVT::getHalfSizedIntegerVT
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:392
llvm::EVT::getVectorMinNumElements
unsigned getVectorMinNumElements() const
Given a vector type, return the minimum number of elements it contains.
Definition: ValueTypes.h:332
TemplateParamKind::Type
@ Type
llvm::EVT::getRawBits
intptr_t getRawBits() const
Definition: ValueTypes.h:464
llvm::MVT::getVectorNumElements
unsigned getVectorNumElements() const
Definition: MachineValueType.h:850
llvm::MVT::i8
@ i8
Definition: MachineValueType.h:44
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::EVT::getIntegerVT
static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth)
Returns the EVT that represents an integer with the given number of bits.
Definition: ValueTypes.h:65
llvm::MVT::getSizeInBits
TypeSize getSizeInBits() const
Returns the size of the specified MVT in bits.
Definition: MachineValueType.h:860
llvm::LinearPolySize< TypeSize >::isKnownGE
static bool isKnownGE(const LinearPolySize &LHS, const LinearPolySize &RHS)
Definition: TypeSize.h:347
llvm::EVT::isByteSized
bool isByteSized() const
Return true if the bit size is a multiple of 8.
Definition: ValueTypes.h:216
llvm::MVT::getFloatingPointVT
static MVT getFloatingPointVT(unsigned BitWidth)
Definition: MachineValueType.h:1141
llvm::MVT
Machine Value Type.
Definition: MachineValueType.h:31
llvm::EVT::widenIntegerVectorElementType
EVT widenIntegerVectorElementType(LLVMContext &Context) const
Return a VT for an integer vector type with the size of the elements doubled.
Definition: ValueTypes.h:406
llvm::LinearPolySize::getKnownMinValue
ScalarTy getKnownMinValue() const
Returns the minimum value this size can represent.
Definition: TypeSize.h:297
llvm::LinearPolySize::isKnownMultipleOf
bool isKnownMultipleOf(ScalarTy RHS) const
This function tells the caller whether the element count is known at compile time to be a multiple of...
Definition: TypeSize.h:306
llvm::MVT::getVectorVT
static MVT getVectorVT(MVT VT, unsigned NumElements)
Definition: MachineValueType.h:1177
llvm::EVT::isVector
bool isVector() const
Return true if this is a vector value type.
Definition: ValueTypes.h:155
llvm::MVT::changeVectorElementTypeToInteger
MVT changeVectorElementTypeToInteger() const
Return a vector with the same number of elements as this vector, but with the element type converted ...
Definition: MachineValueType.h:460
llvm::EVT::getScalarSizeInBits
uint64_t getScalarSizeInBits() const
Definition: ValueTypes.h:353
llvm::MVT::is2048BitVector
bool is2048BitVector() const
Return true if this is a 2048-bit vector type.
Definition: MachineValueType.h:443
Compiler.h
llvm::MVT::is128BitVector
bool is128BitVector() const
Return true if this is a 128-bit vector type.
Definition: MachineValueType.h:407
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::MVT::is64BitVector
bool is64BitVector() const
Return true if this is a 64-bit vector type.
Definition: MachineValueType.h:398
llvm::EVT::operator==
bool operator==(EVT VT) const
Definition: ValueTypes.h:45
llvm::MVT::getVectorElementCount
ElementCount getVectorElementCount() const
Definition: MachineValueType.h:846
llvm::EVT::getEVTString
std::string getEVTString() const
This function returns value type as a string, e.g. "i32".
Definition: ValueTypes.cpp:151
llvm::EVT::is2048BitVector
bool is2048BitVector() const
Return true if this is a 2048-bit vector type.
Definition: ValueTypes.h:206
llvm::EVT::getHalfNumVectorElementsVT
EVT getHalfNumVectorElementsVT(LLVMContext &Context) const
Definition: ValueTypes.h:415
WithColor.h
llvm::EVT::getScalarType
EVT getScalarType() const
If this is a vector type, return the element type, otherwise return this.
Definition: ValueTypes.h:296
llvm::MVT::iAny
@ iAny
Definition: MachineValueType.h:308
llvm::EVT::compareRawBits::operator()
bool operator()(EVT L, EVT R) const
Definition: ValueTypes.h:474
llvm::TypeSize
Definition: TypeSize.h:417
llvm::BitWidth
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:147
llvm::EVT::is512BitVector
bool is512BitVector() const
Return true if this is a 512-bit vector type.
Definition: ValueTypes.h:196
llvm::EVT::getFloatingPointVT
static EVT getFloatingPointVT(unsigned BitWidth)
Returns the EVT that represents a floating-point type with the given number of bits.
Definition: ValueTypes.h:59
llvm::EVT::getVectorElementType
EVT getVectorElementType() const
Given a vector type, return the type of each element.
Definition: ValueTypes.h:301
llvm::MVT::isScalarInteger
bool isScalarInteger() const
Return true if this is an integer, not including vectors.
Definition: MachineValueType.h:360
llvm::EVT::isPow2VectorType
bool isPow2VectorType() const
Returns true if the given vector is a power of 2.
Definition: ValueTypes.h:432
llvm::MVT::changeVectorElementType
MVT changeVectorElementType(MVT EltVT) const
Return a VT for a vector type whose attributes match ourselves with the exception of the element type...
Definition: MachineValueType.h:471
llvm::TypeSize::getKnownMinSize
ScalarTy getKnownMinSize() const
Definition: TypeSize.h:427
llvm::MVT::is1024BitVector
bool is1024BitVector() const
Return true if this is a 1024-bit vector type.
Definition: MachineValueType.h:434
llvm::EVT::knownBitsGE
bool knownBitsGE(EVT VT) const
Return true if we know at compile time this has more than or the same bits as VT.
Definition: ValueTypes.h:241
llvm::EVT::bitsGT
bool bitsGT(EVT VT) const
Return true if this has more bits than VT.
Definition: ValueTypes.h:257
llvm::EVT::isRound
bool isRound() const
Return true if the size is a power-of-two number of bytes.
Definition: ValueTypes.h:221
llvm::EVT::bitsGE
bool bitsGE(EVT VT) const
Return true if this has no less bits than VT.
Definition: ValueTypes.h:265
llvm::EVT::is128BitVector
bool is128BitVector() const
Return true if this is a 128-bit vector type.
Definition: ValueTypes.h:186
llvm::MVT::LAST_INTEGER_VALUETYPE
@ LAST_INTEGER_VALUETYPE
Definition: MachineValueType.h:51
llvm::MVT::vAny
@ vAny
Definition: MachineValueType.h:298
llvm::EVT::getDoubleNumVectorElementsVT
EVT getDoubleNumVectorElementsVT(LLVMContext &Context) const
Definition: ValueTypes.h:425
llvm::EVT::isFixedLengthVector
bool isFixedLengthVector() const
Definition: ValueTypes.h:165
llvm::EVT::bitsEq
bool bitsEq(EVT VT) const
Return true if this has the same number of bits as VT.
Definition: ValueTypes.h:229
llvm::EVT::isFloatingPoint
bool isFloatingPoint() const
Return true if this is a FP or a vector FP type.
Definition: ValueTypes.h:140
llvm::EVT::knownBitsLT
bool knownBitsLT(EVT VT) const
Return true if we know at compile time this has fewer bits than VT.
Definition: ValueTypes.h:246
llvm::MVT::is512BitVector
bool is512BitVector() const
Return true if this is a 512-bit vector type.
Definition: MachineValueType.h:425
llvm::EVT::getSimpleVT
MVT getSimpleVT() const
Return the SimpleValueType held in the specified simple EVT.
Definition: ValueTypes.h:289
llvm::reportInvalidSizeRequest
void reportInvalidSizeRequest(const char *Msg)
Reports a diagnostic message to indicate an invalid size request has been done on a scalable vector.
Definition: TypeSize.cpp:38
llvm::MVT::getIntegerVT
static MVT getIntegerVT(unsigned BitWidth)
Definition: MachineValueType.h:1158