LLVM 19.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
22#include <cassert>
23#include <cstdint>
24#include <string>
25
26namespace 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;
50 if (V.SimpleTy == MVT::INVALID_SIMPLE_VALUE_TYPE)
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) {
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) {
66 if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
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);
76 if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
77 return M;
78 return getExtendedVectorVT(Context, VT, NumElements, IsScalable);
79 }
80
81 /// Returns the EVT that represents a vector EC.Min elements in length,
82 /// where each element is of type VT.
83 static EVT getVectorVT(LLVMContext &Context, EVT VT, ElementCount EC) {
84 MVT M = MVT::getVectorVT(VT.V, EC);
85 if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
86 return M;
87 return getExtendedVectorVT(Context, VT, EC);
88 }
89
90 /// Return a vector with the same number of elements as this vector, but
91 /// with the element type converted to an integer type with the same
92 /// bitwidth.
94 if (isSimple())
96 return changeExtendedVectorElementTypeToInteger();
97 }
98
99 /// Return a VT for a vector type whose attributes match ourselves
100 /// with the exception of the element type that is chosen by the caller.
102 if (isSimple()) {
103 assert(EltVT.isSimple() &&
104 "Can't change simple vector VT to have extended element VT");
106 }
107 return changeExtendedVectorElementType(EltVT);
108 }
109
110 /// Return a VT for a type whose attributes match ourselves with the
111 /// exception of the element type that is chosen by the caller.
112 EVT changeElementType(EVT EltVT) const {
113 EltVT = EltVT.getScalarType();
114 return isVector() ? changeVectorElementType(EltVT) : EltVT;
115 }
116
117 /// Return the type converted to an equivalently sized integer or vector
118 /// with integer element type. Similar to changeVectorElementTypeToInteger,
119 /// but also handles scalars.
121 if (isVector())
123
124 if (isSimple())
126 return changeExtendedTypeToInteger();
127 }
128
129 /// Test if the given EVT has zero size, this will fail if called on a
130 /// scalable type
131 bool isZeroSized() const {
132 return getSizeInBits().isZero();
133 }
134
135 /// Test if the given EVT is simple (as opposed to being extended).
136 bool isSimple() const {
137 return V.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE;
138 }
139
140 /// Test if the given EVT is extended (as opposed to being simple).
141 bool isExtended() const {
142 return !isSimple();
143 }
144
145 /// Return true if this is a FP or a vector FP type.
146 bool isFloatingPoint() const {
147 return isSimple() ? V.isFloatingPoint() : isExtendedFloatingPoint();
148 }
149
150 /// Return true if this is an integer or a vector integer type.
151 bool isInteger() const {
152 return isSimple() ? V.isInteger() : isExtendedInteger();
153 }
154
155 /// Return true if this is an integer, but not a vector.
156 bool isScalarInteger() const {
157 return isSimple() ? V.isScalarInteger() : isExtendedScalarInteger();
158 }
159
160 /// Return true if this is a vector type where the runtime
161 /// length is machine dependent
163 return isSimple() && V.isScalableTargetExtVT();
164 }
165
166 /// Return true if this is a vector value type.
167 bool isVector() const {
168 return isSimple() ? V.isVector() : isExtendedVector();
169 }
170
171 /// Return true if this is a vector type where the runtime
172 /// length is machine dependent
173 bool isScalableVector() const {
174 return isSimple() ? V.isScalableVector() : isExtendedScalableVector();
175 }
176
177 bool isFixedLengthVector() const {
178 return isSimple() ? V.isFixedLengthVector()
179 : isExtendedFixedLengthVector();
180 }
181
182 /// Return true if the type is a scalable type.
183 bool isScalableVT() const {
185 }
186
187 /// Return true if this is a 16-bit vector type.
188 bool is16BitVector() const {
189 return isSimple() ? V.is16BitVector() : isExtended16BitVector();
190 }
191
192 /// Return true if this is a 32-bit vector type.
193 bool is32BitVector() const {
194 return isSimple() ? V.is32BitVector() : isExtended32BitVector();
195 }
196
197 /// Return true if this is a 64-bit vector type.
198 bool is64BitVector() const {
199 return isSimple() ? V.is64BitVector() : isExtended64BitVector();
200 }
201
202 /// Return true if this is a 128-bit vector type.
203 bool is128BitVector() const {
204 return isSimple() ? V.is128BitVector() : isExtended128BitVector();
205 }
206
207 /// Return true if this is a 256-bit vector type.
208 bool is256BitVector() const {
209 return isSimple() ? V.is256BitVector() : isExtended256BitVector();
210 }
211
212 /// Return true if this is a 512-bit vector type.
213 bool is512BitVector() const {
214 return isSimple() ? V.is512BitVector() : isExtended512BitVector();
215 }
216
217 /// Return true if this is a 1024-bit vector type.
218 bool is1024BitVector() const {
219 return isSimple() ? V.is1024BitVector() : isExtended1024BitVector();
220 }
221
222 /// Return true if this is a 2048-bit vector type.
223 bool is2048BitVector() const {
224 return isSimple() ? V.is2048BitVector() : isExtended2048BitVector();
225 }
226
227 /// Return true if this is an overloaded type for TableGen.
228 bool isOverloaded() const {
229 return (V==MVT::iAny || V==MVT::fAny || V==MVT::vAny || V==MVT::iPTRAny);
230 }
231
232 /// Return true if the bit size is a multiple of 8.
233 bool isByteSized() const {
235 }
236
237 /// Return true if the size is a power-of-two number of bytes.
238 bool isRound() const {
239 if (isScalableVector())
240 return false;
241 unsigned BitSize = getSizeInBits();
242 return BitSize >= 8 && !(BitSize & (BitSize - 1));
243 }
244
245 /// Return true if this has the same number of bits as VT.
246 bool bitsEq(EVT VT) const {
247 if (EVT::operator==(VT)) return true;
248 return getSizeInBits() == VT.getSizeInBits();
249 }
250
251 /// Return true if we know at compile time this has more bits than VT.
252 bool knownBitsGT(EVT VT) const {
254 }
255
256 /// Return true if we know at compile time this has more than or the same
257 /// bits as VT.
258 bool knownBitsGE(EVT VT) const {
260 }
261
262 /// Return true if we know at compile time this has fewer bits than VT.
263 bool knownBitsLT(EVT VT) const {
265 }
266
267 /// Return true if we know at compile time this has fewer than or the same
268 /// bits as VT.
269 bool knownBitsLE(EVT VT) const {
271 }
272
273 /// Return true if this has more bits than VT.
274 bool bitsGT(EVT VT) const {
275 if (EVT::operator==(VT)) return false;
277 "Comparison between scalable and fixed types");
278 return knownBitsGT(VT);
279 }
280
281 /// Return true if this has no less bits than VT.
282 bool bitsGE(EVT VT) const {
283 if (EVT::operator==(VT)) return true;
285 "Comparison between scalable and fixed types");
286 return knownBitsGE(VT);
287 }
288
289 /// Return true if this has less bits than VT.
290 bool bitsLT(EVT VT) const {
291 if (EVT::operator==(VT)) return false;
293 "Comparison between scalable and fixed types");
294 return knownBitsLT(VT);
295 }
296
297 /// Return true if this has no more bits than VT.
298 bool bitsLE(EVT VT) const {
299 if (EVT::operator==(VT)) return true;
301 "Comparison between scalable and fixed types");
302 return knownBitsLE(VT);
303 }
304
305 /// Return the SimpleValueType held in the specified simple EVT.
306 MVT getSimpleVT() const {
307 assert(isSimple() && "Expected a SimpleValueType!");
308 return V;
309 }
310
311 /// If this is a vector type, return the element type, otherwise return
312 /// this.
314 return isVector() ? getVectorElementType() : *this;
315 }
316
317 /// Given a vector type, return the type of each element.
319 assert(isVector() && "Invalid vector type!");
320 if (isSimple())
321 return V.getVectorElementType();
322 return getExtendedVectorElementType();
323 }
324
325 /// Given a vector type, return the number of elements it contains.
326 unsigned getVectorNumElements() const {
327 assert(isVector() && "Invalid vector type!");
328
329 if (isScalableVector())
331 "Possible incorrect use of EVT::getVectorNumElements() for "
332 "scalable vector. Scalable flag may be dropped, use "
333 "EVT::getVectorElementCount() instead");
334
335 return isSimple() ? V.getVectorNumElements()
336 : getExtendedVectorNumElements();
337 }
338
339 // Given a (possibly scalable) vector type, return the ElementCount
341 assert((isVector()) && "Invalid vector type!");
342 if (isSimple())
343 return V.getVectorElementCount();
344
345 return getExtendedVectorElementCount();
346 }
347
348 /// Given a vector type, return the minimum number of elements it contains.
349 unsigned getVectorMinNumElements() const {
351 }
352
353 /// Return the size of the specified value type in bits.
354 ///
355 /// If the value type is a scalable vector type, the scalable property will
356 /// be set and the runtime size will be a positive integer multiple of the
357 /// base size.
359 if (isSimple())
360 return V.getSizeInBits();
361 return getExtendedSizeInBits();
362 }
363
364 /// Return the size of the specified fixed width value type in bits. The
365 /// function will assert if the type is scalable.
367 return getSizeInBits().getFixedValue();
368 }
369
372 }
373
374 /// Return the number of bytes overwritten by a store of the specified value
375 /// type.
376 ///
377 /// If the value type is a scalable vector type, the scalable property will
378 /// be set and the runtime size will be a positive integer multiple of the
379 /// base size.
381 TypeSize BaseSize = getSizeInBits();
382 return {(BaseSize.getKnownMinValue() + 7) / 8, BaseSize.isScalable()};
383 }
384
385 // Return the number of bytes overwritten by a store of this value type or
386 // this value type's element type in the case of a vector.
389 }
390
391 /// Return the number of bits overwritten by a store of the specified value
392 /// type.
393 ///
394 /// If the value type is a scalable vector type, the scalable property will
395 /// be set and the runtime size will be a positive integer multiple of the
396 /// base size.
398 return getStoreSize() * 8;
399 }
400
401 /// Rounds the bit-width of the given integer EVT up to the nearest power of
402 /// two (and at least to eight), and returns the integer EVT with that
403 /// number of bits.
405 assert(isInteger() && !isVector() && "Invalid integer type!");
406 unsigned BitWidth = getSizeInBits();
407 if (BitWidth <= 8)
408 return EVT(MVT::i8);
410 }
411
412 /// Finds the smallest simple value type that is greater than or equal to
413 /// half the width of this EVT. If no simple value type can be found, an
414 /// extended integer value type of half the size (rounded up) is returned.
416 assert(isInteger() && !isVector() && "Invalid integer type!");
417 unsigned EVTSize = getSizeInBits();
418 for (unsigned IntVT = MVT::FIRST_INTEGER_VALUETYPE;
419 IntVT <= MVT::LAST_INTEGER_VALUETYPE; ++IntVT) {
420 EVT HalfVT = EVT((MVT::SimpleValueType)IntVT);
421 if (HalfVT.getSizeInBits() * 2 >= EVTSize)
422 return HalfVT;
423 }
424 return getIntegerVT(Context, (EVTSize + 1) / 2);
425 }
426
427 /// Return a VT for an integer vector type with the size of the
428 /// elements doubled. The typed returned may be an extended type.
430 EVT EltVT = getVectorElementType();
431 EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits());
433 }
434
435 // Return a VT for a vector type with the same element type but
436 // half the number of elements. The type returned may be an
437 // extended type.
439 EVT EltVT = getVectorElementType();
440 auto EltCnt = getVectorElementCount();
441 assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!");
442 return EVT::getVectorVT(Context, EltVT, EltCnt.divideCoefficientBy(2));
443 }
444
445 // Return a VT for a vector type with the same element type but
446 // double the number of elements. The type returned may be an
447 // extended type.
449 EVT EltVT = getVectorElementType();
450 auto EltCnt = getVectorElementCount();
451 return EVT::getVectorVT(Context, EltVT, EltCnt * 2);
452 }
453
454 /// Returns true if the given vector is a power of 2.
455 bool isPow2VectorType() const {
456 unsigned NElts = getVectorMinNumElements();
457 return !(NElts & (NElts - 1));
458 }
459
460 /// Widens the length of the given vector EVT up to the nearest power of 2
461 /// and returns that type.
463 if (!isPow2VectorType()) {
465 unsigned NewMinCount = 1 << Log2_32_Ceil(NElts.getKnownMinValue());
466 NElts = ElementCount::get(NewMinCount, NElts.isScalable());
468 }
469 else {
470 return *this;
471 }
472 }
473
474 /// This function returns value type as a string, e.g. "i32".
475 std::string getEVTString() const;
476
477 /// Support for debugging, callable in GDB: VT.dump()
478 void dump() const;
479
480 /// Implement operator<<.
481 void print(raw_ostream &OS) const {
482 OS << getEVTString();
483 }
484
485 /// This method returns an LLVM type corresponding to the specified EVT.
486 /// For integer types, this returns an unsigned type. Note that this will
487 /// abort for types that cannot be represented.
488 Type *getTypeForEVT(LLVMContext &Context) const;
489
490 /// Return the value type corresponding to the specified type.
491 /// If HandleUnknown is true, unknown types are returned as Other,
492 /// otherwise they are invalid.
493 /// NB: This includes pointer types, which require a DataLayout to convert
494 /// to a concrete value type.
495 static EVT getEVT(Type *Ty, bool HandleUnknown = false);
496
497 intptr_t getRawBits() const {
498 if (isSimple())
499 return V.SimpleTy;
500 else
501 return (intptr_t)(LLVMTy);
502 }
503
504 /// A meaningless but well-behaved order, useful for constructing
505 /// containers.
507 bool operator()(EVT L, EVT R) const {
508 if (L.V.SimpleTy == R.V.SimpleTy)
509 return L.LLVMTy < R.LLVMTy;
510 else
511 return L.V.SimpleTy < R.V.SimpleTy;
512 }
513 };
514
515 private:
516 // Methods for handling the Extended-type case in functions above.
517 // These are all out-of-line to prevent users of this header file
518 // from having a dependency on Type.h.
519 EVT changeExtendedTypeToInteger() const;
520 EVT changeExtendedVectorElementType(EVT EltVT) const;
521 EVT changeExtendedVectorElementTypeToInteger() const;
522 static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth);
523 static EVT getExtendedVectorVT(LLVMContext &C, EVT VT, unsigned NumElements,
524 bool IsScalable);
525 static EVT getExtendedVectorVT(LLVMContext &Context, EVT VT,
526 ElementCount EC);
527 bool isExtendedFloatingPoint() const LLVM_READONLY;
528 bool isExtendedInteger() const LLVM_READONLY;
529 bool isExtendedScalarInteger() const LLVM_READONLY;
530 bool isExtendedVector() const LLVM_READONLY;
531 bool isExtended16BitVector() const LLVM_READONLY;
532 bool isExtended32BitVector() const LLVM_READONLY;
533 bool isExtended64BitVector() const LLVM_READONLY;
534 bool isExtended128BitVector() const LLVM_READONLY;
535 bool isExtended256BitVector() const LLVM_READONLY;
536 bool isExtended512BitVector() const LLVM_READONLY;
537 bool isExtended1024BitVector() const LLVM_READONLY;
538 bool isExtended2048BitVector() const LLVM_READONLY;
539 bool isExtendedFixedLengthVector() const LLVM_READONLY;
540 bool isExtendedScalableVector() const LLVM_READONLY;
541 EVT getExtendedVectorElementType() const;
542 unsigned getExtendedVectorNumElements() const LLVM_READONLY;
543 ElementCount getExtendedVectorElementCount() const LLVM_READONLY;
544 TypeSize getExtendedSizeInBits() const LLVM_READONLY;
545 };
546
548 V.print(OS);
549 return OS;
550 }
551} // end namespace llvm
552
553#endif // LLVM_CODEGEN_VALUETYPES_H
aarch64 promote const
always inline
RelocType Type
Definition: COFFYAML.cpp:391
#define LLVM_READONLY
Definition: Compiler.h:227
LLVMContext & Context
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
static constexpr ElementCount get(ScalarTy MinVal, bool Scalable)
Definition: TypeSize.h:314
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
Machine Value Type.
static MVT getFloatingPointVT(unsigned BitWidth)
SimpleValueType SimpleTy
MVT changeVectorElementType(MVT EltVT) const
Return a VT for a vector type whose attributes match ourselves with the exception of the element type...
@ INVALID_SIMPLE_VALUE_TYPE
MVT changeTypeToInteger()
Return the type converted to an equivalently sized integer or vector with integer element type.
static MVT getVectorVT(MVT VT, unsigned NumElements)
static MVT getIntegerVT(unsigned BitWidth)
MVT changeVectorElementTypeToInteger() const
Return a vector with the same number of elements as this vector, but with the element type converted ...
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
constexpr 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:180
constexpr ScalarTy getFixedValue() const
Definition: TypeSize.h:199
static constexpr bool isKnownLE(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
Definition: TypeSize.h:229
static constexpr bool isKnownLT(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
Definition: TypeSize.h:215
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
Definition: TypeSize.h:171
constexpr ScalarTy getKnownMinValue() const
Returns the minimum value this quantity can represent.
Definition: TypeSize.h:168
constexpr bool isZero() const
Definition: TypeSize.h:156
static constexpr bool isKnownGT(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
Definition: TypeSize.h:222
static constexpr bool isKnownGE(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
Definition: TypeSize.h:236
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
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:337
T bit_ceil(T Value)
Returns the smallest integral power of two no smaller than Value if Value is nonzero.
Definition: bit.h:342
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
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:191
A meaningless but well-behaved order, useful for constructing containers.
Definition: ValueTypes.h:506
bool operator()(EVT L, EVT R) const
Definition: ValueTypes.h:507
Extended Value Type.
Definition: ValueTypes.h:34
EVT changeVectorElementTypeToInteger() const
Return a vector with the same number of elements as this vector, but with the element type converted ...
Definition: ValueTypes.h:93
constexpr EVT()=default
TypeSize getStoreSize() const
Return the number of bytes overwritten by a store of the specified value type.
Definition: ValueTypes.h:380
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:462
bool isSimple() const
Test if the given EVT is simple (as opposed to being extended).
Definition: ValueTypes.h:136
constexpr EVT(MVT::SimpleValueType SVT)
Definition: ValueTypes.h:41
intptr_t getRawBits() const
Definition: ValueTypes.h:497
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:269
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
EVT changeTypeToInteger() const
Return the type converted to an equivalently sized integer or vector with integer element type.
Definition: ValueTypes.h:120
uint64_t getScalarStoreSize() const
Definition: ValueTypes.h:387
bool isOverloaded() const
Return true if this is an overloaded type for TableGen.
Definition: ValueTypes.h:228
bool bitsGT(EVT VT) const
Return true if this has more bits than VT.
Definition: ValueTypes.h:274
bool bitsLT(EVT VT) const
Return true if this has less bits than VT.
Definition: ValueTypes.h:290
bool isFloatingPoint() const
Return true if this is a FP or a vector FP type.
Definition: ValueTypes.h:146
ElementCount getVectorElementCount() const
Definition: ValueTypes.h:340
EVT getDoubleNumVectorElementsVT(LLVMContext &Context) const
Definition: ValueTypes.h:448
bool is32BitVector() const
Return true if this is a 32-bit vector type.
Definition: ValueTypes.h:193
TypeSize getSizeInBits() const
Return the size of the specified value type in bits.
Definition: ValueTypes.h:358
bool isByteSized() const
Return true if the bit size is a multiple of 8.
Definition: ValueTypes.h:233
EVT changeElementType(EVT EltVT) const
Return a VT for a type whose attributes match ourselves with the exception of the element type that i...
Definition: ValueTypes.h:112
bool is1024BitVector() const
Return true if this is a 1024-bit vector type.
Definition: ValueTypes.h:218
bool knownBitsGT(EVT VT) const
Return true if we know at compile time this has more bits than VT.
Definition: ValueTypes.h:252
unsigned getVectorMinNumElements() const
Given a vector type, return the minimum number of elements it contains.
Definition: ValueTypes.h:349
uint64_t getScalarSizeInBits() const
Definition: ValueTypes.h:370
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:415
bool isPow2VectorType() const
Returns true if the given vector is a power of 2.
Definition: ValueTypes.h:455
static EVT getEVT(Type *Ty, bool HandleUnknown=false)
Return the value type corresponding to the specified type.
Definition: ValueTypes.cpp:631
TypeSize getStoreSizeInBits() const
Return the number of bits overwritten by a store of the specified value type.
Definition: ValueTypes.h:397
MVT getSimpleVT() const
Return the SimpleValueType held in the specified simple EVT.
Definition: ValueTypes.h:306
void dump() const
Support for debugging, callable in GDB: VT.dump()
Definition: ValueTypes.cpp:193
constexpr EVT(MVT S)
Definition: ValueTypes.h:42
bool is128BitVector() const
Return true if this is a 128-bit vector type.
Definition: ValueTypes.h:203
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 is2048BitVector() const
Return true if this is a 2048-bit vector type.
Definition: ValueTypes.h:223
uint64_t getFixedSizeInBits() const
Return the size of the specified fixed width value type in bits.
Definition: ValueTypes.h:366
EVT widenIntegerVectorElementType(LLVMContext &Context) const
Return a VT for an integer vector type with the size of the elements doubled.
Definition: ValueTypes.h:429
bool knownBitsLT(EVT VT) const
Return true if we know at compile time this has fewer bits than VT.
Definition: ValueTypes.h:263
bool isScalableVT() const
Return true if the type is a scalable type.
Definition: ValueTypes.h:183
bool is512BitVector() const
Return true if this is a 512-bit vector type.
Definition: ValueTypes.h:213
bool isFixedLengthVector() const
Definition: ValueTypes.h:177
std::string getEVTString() const
This function returns value type as a string, e.g. "i32".
Definition: ValueTypes.cpp:161
static EVT getFloatingPointVT(unsigned BitWidth)
Returns the EVT that represents a floating-point type with the given number of bits.
Definition: ValueTypes.h:58
bool operator!=(EVT VT) const
Definition: ValueTypes.h:47
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:404
bool isVector() const
Return true if this is a vector value type.
Definition: ValueTypes.h:167
EVT getScalarType() const
If this is a vector type, return the element type, otherwise return this.
Definition: ValueTypes.h:313
bool is16BitVector() const
Return true if this is a 16-bit vector type.
Definition: ValueTypes.h:188
bool bitsGE(EVT VT) const
Return true if this has no less bits than VT.
Definition: ValueTypes.h:282
bool is256BitVector() const
Return true if this is a 256-bit vector type.
Definition: ValueTypes.h:208
bool bitsEq(EVT VT) const
Return true if this has the same number of bits as VT.
Definition: ValueTypes.h:246
Type * getTypeForEVT(LLVMContext &Context) const
This method returns an LLVM type corresponding to the specified EVT.
Definition: ValueTypes.cpp:202
bool isRound() const
Return true if the size is a power-of-two number of bytes.
Definition: ValueTypes.h:238
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:83
bool isScalableVector() const
Return true if this is a vector type where the runtime length is machine dependent.
Definition: ValueTypes.h:173
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:258
EVT getVectorElementType() const
Given a vector type, return the type of each element.
Definition: ValueTypes.h:318
bool isExtended() const
Test if the given EVT is extended (as opposed to being simple).
Definition: ValueTypes.h:141
void print(raw_ostream &OS) const
Implement operator<<.
Definition: ValueTypes.h:481
bool isScalableTargetExtVT() const
Return true if this is a vector type where the runtime length is machine dependent.
Definition: ValueTypes.h:162
bool isScalarInteger() const
Return true if this is an integer, but not a vector.
Definition: ValueTypes.h:156
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:101
unsigned getVectorNumElements() const
Given a vector type, return the number of elements it contains.
Definition: ValueTypes.h:326
bool operator==(EVT VT) const
Definition: ValueTypes.h:44
bool isZeroSized() const
Test if the given EVT has zero size, this will fail if called on a scalable type.
Definition: ValueTypes.h:131
bool bitsLE(EVT VT) const
Return true if this has no more bits than VT.
Definition: ValueTypes.h:298
EVT getHalfNumVectorElementsVT(LLVMContext &Context) const
Definition: ValueTypes.h:438
bool isInteger() const
Return true if this is an integer or a vector integer type.
Definition: ValueTypes.h:151
bool is64BitVector() const
Return true if this is a 64-bit vector type.
Definition: ValueTypes.h:198