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"
19#include "llvm/Support/MachineValueType.h"
20#include "llvm/Support/MathExtras.h"
21#include "llvm/Support/TypeSize.h"
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:
36 MVT V = MVT::INVALID_SIMPLE_VALUE_TYPE;
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) {
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);
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.
93 EVT changeVectorElementTypeToInteger() const {
94 if (isSimple())
95 return getSimpleVT().changeVectorElementTypeToInteger();
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.
101 EVT changeVectorElementType(EVT EltVT) const {
102 if (isSimple()) {
103 assert(EltVT.isSimple() &&
104 "Can't change simple vector VT to have extended element VT");
105 return getSimpleVT().changeVectorElementType(EltVT.getSimpleVT());
106 }
107 return changeExtendedVectorElementType(EltVT);
108 }
109
110 /// Return the type converted to an equivalently sized integer or vector
111 /// with integer element type. Similar to changeVectorElementTypeToInteger,
112 /// but also handles scalars.
113 EVT changeTypeToInteger() {
114 if (isVector())
115 return changeVectorElementTypeToInteger();
116
117 if (isSimple())
118 return getSimpleVT().changeTypeToInteger();
119 return changeExtendedTypeToInteger();
120 }
121
122 /// Test if the given EVT has zero size, this will fail if called on a
123 /// scalable type
124 bool isZeroSized() const {
125 return !isScalableVector() && getSizeInBits() == 0;
126 }
127
128 /// Test if the given EVT is simple (as opposed to being extended).
129 bool isSimple() const {
130 return V.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE;
131 }
132
133 /// Test if the given EVT is extended (as opposed to being simple).
134 bool isExtended() const {
135 return !isSimple();
136 }
137
138 /// Return true if this is a FP or a vector FP type.
139 bool isFloatingPoint() const {
140 return isSimple() ? V.isFloatingPoint() : isExtendedFloatingPoint();
141 }
142
143 /// Return true if this is an integer or a vector integer type.
144 bool isInteger() const {
145 return isSimple() ? V.isInteger() : isExtendedInteger();
146 }
147
148 /// Return true if this is an integer, but not a vector.
149 bool isScalarInteger() const {
150 return isSimple() ? V.isScalarInteger() : isExtendedScalarInteger();
151 }
152
153 /// Return true if this is a vector value type.
154 bool isVector() const {
155 return isSimple() ? V.isVector() : isExtendedVector();
156 }
157
158 /// Return true if this is a vector type where the runtime
159 /// length is machine dependent
160 bool isScalableVector() const {
161 return isSimple() ? V.isScalableVector() : isExtendedScalableVector();
162 }
163
164 bool isFixedLengthVector() const {
165 return isSimple() ? V.isFixedLengthVector()
166 : isExtendedFixedLengthVector();
167 }
168
169 /// Return true if this is a 16-bit vector type.
170 bool is16BitVector() const {
171 return isSimple() ? V.is16BitVector() : isExtended16BitVector();
172 }
173
174 /// Return true if this is a 32-bit vector type.
175 bool is32BitVector() const {
176 return isSimple() ? V.is32BitVector() : isExtended32BitVector();
177 }
178
179 /// Return true if this is a 64-bit vector type.
180 bool is64BitVector() const {
181 return isSimple() ? V.is64BitVector() : isExtended64BitVector();
182 }
183
184 /// Return true if this is a 128-bit vector type.
185 bool is128BitVector() const {
186 return isSimple() ? V.is128BitVector() : isExtended128BitVector();
187 }
188
189 /// Return true if this is a 256-bit vector type.
190 bool is256BitVector() const {
191 return isSimple() ? V.is256BitVector() : isExtended256BitVector();
192 }
193
194 /// Return true if this is a 512-bit vector type.
195 bool is512BitVector() const {
196 return isSimple() ? V.is512BitVector() : isExtended512BitVector();
197 }
198
199 /// Return true if this is a 1024-bit vector type.
200 bool is1024BitVector() const {
201 return isSimple() ? V.is1024BitVector() : isExtended1024BitVector();
202 }
203
204 /// Return true if this is a 2048-bit vector type.
205 bool is2048BitVector() const {
206 return isSimple() ? V.is2048BitVector() : isExtended2048BitVector();
207 }
208
209 /// Return true if this is an overloaded type for TableGen.
210 bool isOverloaded() const {
211 return (V==MVT::iAny || V==MVT::fAny || V==MVT::vAny || V==MVT::iPTRAny);
212 }
213
214 /// Return true if the bit size is a multiple of 8.
215 bool isByteSized() const {
216 return !isZeroSized() && getSizeInBits().isKnownMultipleOf(8);
217 }
218
219 /// Return true if the size is a power-of-two number of bytes.
220 bool isRound() const {
221 if (isScalableVector())
222 return false;
223 unsigned BitSize = getSizeInBits();
224 return BitSize >= 8 && !(BitSize & (BitSize - 1));
225 }
226
227 /// Return true if this has the same number of bits as VT.
228 bool bitsEq(EVT VT) const {
229 if (EVT::operator==(VT)) return true;
230 return getSizeInBits() == VT.getSizeInBits();
231 }
232
233 /// Return true if we know at compile time this has more bits than VT.
234 bool knownBitsGT(EVT VT) const {
235 return TypeSize::isKnownGT(getSizeInBits(), VT.getSizeInBits());
236 }
237
238 /// Return true if we know at compile time this has more than or the same
239 /// bits as VT.
240 bool knownBitsGE(EVT VT) const {
241 return TypeSize::isKnownGE(getSizeInBits(), VT.getSizeInBits());
242 }
243
244 /// Return true if we know at compile time this has fewer bits than VT.
245 bool knownBitsLT(EVT VT) const {
246 return TypeSize::isKnownLT(getSizeInBits(), VT.getSizeInBits());
247 }
248
249 /// Return true if we know at compile time this has fewer than or the same
250 /// bits as VT.
251 bool knownBitsLE(EVT VT) const {
252 return TypeSize::isKnownLE(getSizeInBits(), VT.getSizeInBits());
253 }
254
255 /// Return true if this has more bits than VT.
256 bool bitsGT(EVT VT) const {
257 if (EVT::operator==(VT)) return false;
258 assert(isScalableVector() == VT.isScalableVector() &&
259 "Comparison between scalable and fixed types");
260 return knownBitsGT(VT);
261 }
262
263 /// Return true if this has no less bits than VT.
264 bool bitsGE(EVT VT) const {
265 if (EVT::operator==(VT)) return true;
266 assert(isScalableVector() == VT.isScalableVector() &&
267 "Comparison between scalable and fixed types");
268 return knownBitsGE(VT);
269 }
270
271 /// Return true if this has less bits than VT.
272 bool bitsLT(EVT VT) const {
273 if (EVT::operator==(VT)) return false;
274 assert(isScalableVector() == VT.isScalableVector() &&
275 "Comparison between scalable and fixed types");
276 return knownBitsLT(VT);
277 }
278
279 /// Return true if this has no more bits than VT.
280 bool bitsLE(EVT VT) const {
281 if (EVT::operator==(VT)) return true;
282 assert(isScalableVector() == VT.isScalableVector() &&
283 "Comparison between scalable and fixed types");
284 return knownBitsLE(VT);
285 }
286
287 /// Return the SimpleValueType held in the specified simple EVT.
288 MVT getSimpleVT() const {
289 assert(isSimple() && "Expected a SimpleValueType!");
290 return V;
291 }
292
293 /// If this is a vector type, return the element type, otherwise return
294 /// this.
295 EVT getScalarType() const {
296 return isVector() ? getVectorElementType() : *this;
297 }
298
299 /// Given a vector type, return the type of each element.
300 EVT getVectorElementType() const {
301 assert(isVector() && "Invalid vector type!");
302 if (isSimple())
303 return V.getVectorElementType();
304 return getExtendedVectorElementType();
305 }
306
307 /// Given a vector type, return the number of elements it contains.
308 unsigned getVectorNumElements() const {
309 assert(isVector() && "Invalid vector type!");
310
311 if (isScalableVector())
312 llvm::reportInvalidSizeRequest(
313 "Possible incorrect use of EVT::getVectorNumElements() for "
314 "scalable vector. Scalable flag may be dropped, use "
315 "EVT::getVectorElementCount() instead");
316
317 return isSimple() ? V.getVectorNumElements()
318 : getExtendedVectorNumElements();
319 }
320
321 // Given a (possibly scalable) vector type, return the ElementCount
322 ElementCount getVectorElementCount() const {
323 assert((isVector()) && "Invalid vector type!");
324 if (isSimple())
325 return V.getVectorElementCount();
326
327 return getExtendedVectorElementCount();
328 }
329
330 /// Given a vector type, return the minimum number of elements it contains.
331 unsigned getVectorMinNumElements() const {
332 return getVectorElementCount().getKnownMinValue();
333 }
334
335 /// Return the size of the specified value type in bits.
336 ///
337 /// If the value type is a scalable vector type, the scalable property will
338 /// be set and the runtime size will be a positive integer multiple of the
339 /// base size.
340 TypeSize getSizeInBits() const {
341 if (isSimple())
342 return V.getSizeInBits();
343 return getExtendedSizeInBits();
344 }
345
346 /// Return the size of the specified fixed width value type in bits. The
347 /// function will assert if the type is scalable.
348 uint64_t getFixedSizeInBits() const {
349 return getSizeInBits().getFixedSize();
350 }
351
352 uint64_t getScalarSizeInBits() const {
353 return getScalarType().getSizeInBits().getFixedSize();
354 }
355
356 /// Return the number of bytes overwritten by a store of the specified value
357 /// type.
358 ///
359 /// If the value type is a scalable vector type, the scalable property will
360 /// be set and the runtime size will be a positive integer multiple of the
361 /// base size.
362 TypeSize getStoreSize() const {
363 TypeSize BaseSize = getSizeInBits();
364 return {(BaseSize.getKnownMinSize() + 7) / 8, BaseSize.isScalable()};
365 }
366
367 // Return the number of bytes overwritten by a store of this value type or
368 // this value type's element type in the case of a vector.
369 uint64_t getScalarStoreSize() const {
370 return getScalarType().getStoreSize().getFixedSize();
371 }
372
373 /// Return the number of bits overwritten by a store of the specified value
374 /// type.
375 ///
376 /// If the value type is a scalable vector type, the scalable property will
377 /// be set and the runtime size will be a positive integer multiple of the
378 /// base size.
379 TypeSize getStoreSizeInBits() const {
380 return getStoreSize() * 8;
381 }
382
383 /// Rounds the bit-width of the given integer EVT up to the nearest power of
384 /// two (and at least to eight), and returns the integer EVT with that
385 /// number of bits.
386 EVT getRoundIntegerType(LLVMContext &Context) const {
387 assert(isInteger() && !isVector() && "Invalid integer type!");
388 unsigned BitWidth = getSizeInBits();
389 if (BitWidth <= 8)
390 return EVT(MVT::i8);
391 return getIntegerVT(Context, 1 << Log2_32_Ceil(BitWidth));
392 }
393
394 /// Finds the smallest simple value type that is greater than or equal to
395 /// half the width of this EVT. If no simple value type can be found, an
396 /// extended integer value type of half the size (rounded up) is returned.
397 EVT getHalfSizedIntegerVT(LLVMContext &Context) const {
398 assert(isInteger() && !isVector() && "Invalid integer type!");
399 unsigned EVTSize = getSizeInBits();
400 for (unsigned IntVT = MVT::FIRST_INTEGER_VALUETYPE;
401 IntVT <= MVT::LAST_INTEGER_VALUETYPE; ++IntVT) {
402 EVT HalfVT = EVT((MVT::SimpleValueType)IntVT);
403 if (HalfVT.getSizeInBits() * 2 >= EVTSize)
404 return HalfVT;
405 }
406 return getIntegerVT(Context, (EVTSize + 1) / 2);
407 }
408
409 /// Return a VT for an integer vector type with the size of the
410 /// elements doubled. The typed returned may be an extended type.
411 EVT widenIntegerVectorElementType(LLVMContext &Context) const {
412 EVT EltVT = getVectorElementType();
413 EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits());
414 return EVT::getVectorVT(Context, EltVT, getVectorElementCount());
415 }
416
417 // Return a VT for a vector type with the same element type but
418 // half the number of elements. The type returned may be an
419 // extended type.
420 EVT getHalfNumVectorElementsVT(LLVMContext &Context) const {
421 EVT EltVT = getVectorElementType();
422 auto EltCnt = getVectorElementCount();
423 assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!");
424 return EVT::getVectorVT(Context, EltVT, EltCnt.divideCoefficientBy(2));
425 }
426
427 // Return a VT for a vector type with the same element type but
428 // double the number of elements. The type returned may be an
429 // extended type.
430 EVT getDoubleNumVectorElementsVT(LLVMContext &Context) const {
431 EVT EltVT = getVectorElementType();
432 auto EltCnt = getVectorElementCount();
433 return EVT::getVectorVT(Context, EltVT, EltCnt * 2);
434 }
435
436 /// Returns true if the given vector is a power of 2.
437 bool isPow2VectorType() const {
438 unsigned NElts = getVectorMinNumElements();
439 return !(NElts & (NElts - 1));
440 }
441
442 /// Widens the length of the given vector EVT up to the nearest power of 2
443 /// and returns that type.
444 EVT getPow2VectorType(LLVMContext &Context) const {
445 if (!isPow2VectorType()) {
446 ElementCount NElts = getVectorElementCount();
447 unsigned NewMinCount = 1 << Log2_32_Ceil(NElts.getKnownMinValue());
448 NElts = ElementCount::get(NewMinCount, NElts.isScalable());
449 return EVT::getVectorVT(Context, getVectorElementType(), NElts);
450 }
451 else {
452 return *this;
453 }
454 }
455
456 /// This function returns value type as a string, e.g. "i32".
457 std::string getEVTString() const;
458
459 /// This method returns an LLVM type corresponding to the specified EVT.
460 /// For integer types, this returns an unsigned type. Note that this will
461 /// abort for types that cannot be represented.
462 Type *getTypeForEVT(LLVMContext &Context) const;
463
464 /// Return the value type corresponding to the specified type.
465 /// This returns all pointers as iPTR. If HandleUnknown is true, unknown
466 /// types are returned as Other, otherwise they are invalid.
467 static EVT getEVT(Type *Ty, bool HandleUnknown = false);
468
469 intptr_t getRawBits() const {
470 if (isSimple())
471 return V.SimpleTy;
472 else
473 return (intptr_t)(LLVMTy);
474 }
475
476 /// A meaningless but well-behaved order, useful for constructing
477 /// containers.
478 struct compareRawBits {
479 bool operator()(EVT L, EVT R) const {
480 if (L.V.SimpleTy == R.V.SimpleTy)
481 return L.LLVMTy < R.LLVMTy;
482 else
483 return L.V.SimpleTy < R.V.SimpleTy;
484 }
485 };
486
487 private:
488 // Methods for handling the Extended-type case in functions above.
489 // These are all out-of-line to prevent users of this header file
490 // from having a dependency on Type.h.
491 EVT changeExtendedTypeToInteger() const;
492 EVT changeExtendedVectorElementType(EVT EltVT) const;
493 EVT changeExtendedVectorElementTypeToInteger() const;
494 static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth);
495 static EVT getExtendedVectorVT(LLVMContext &C, EVT VT, unsigned NumElements,
496 bool IsScalable);
497 static EVT getExtendedVectorVT(LLVMContext &Context, EVT VT,
498 ElementCount EC);
499 bool isExtendedFloatingPoint() const LLVM_READONLY;
500 bool isExtendedInteger() const LLVM_READONLY;
501 bool isExtendedScalarInteger() const LLVM_READONLY;
502 bool isExtendedVector() const LLVM_READONLY;
503 bool isExtended16BitVector() const LLVM_READONLY;
504 bool isExtended32BitVector() const LLVM_READONLY;
505 bool isExtended64BitVector() const LLVM_READONLY;
506 bool isExtended128BitVector() const LLVM_READONLY;
507 bool isExtended256BitVector() const LLVM_READONLY;
508 bool isExtended512BitVector() const LLVM_READONLY;
509 bool isExtended1024BitVector() const LLVM_READONLY;
510 bool isExtended2048BitVector() const LLVM_READONLY;
511 bool isExtendedFixedLengthVector() const LLVM_READONLY;
512 bool isExtendedScalableVector() const LLVM_READONLY;
513 EVT getExtendedVectorElementType() const;
514 unsigned getExtendedVectorNumElements() const LLVM_READONLY;
515 ElementCount getExtendedVectorElementCount() const LLVM_READONLY;
516 TypeSize getExtendedSizeInBits() const LLVM_READONLY;
517 };
518
519} // end namespace llvm
520
521#endif // LLVM_CODEGEN_VALUETYPES_H
522

source code of llvm/include/llvm/CodeGen/ValueTypes.h