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/CodeGenTypes/MachineValueType.h"
19#include "llvm/Support/Compiler.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 struct fltSemantics;
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:
37 MVT V = MVT::INVALID_SIMPLE_VALUE_TYPE;
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 return V.SimpleTy != VT.V.SimpleTy || LLVMTy != VT.LLVMTy;
50 }
51
52 /// Returns the EVT that represents a floating-point type with the given
53 /// number of bits. There are two floating-point types with 128 bits - this
54 /// returns f128 rather than ppcf128.
55 static EVT getFloatingPointVT(unsigned BitWidth) {
56 return MVT::getFloatingPointVT(BitWidth);
57 }
58
59 /// Returns the EVT that represents an integer with the given number of
60 /// bits.
61 static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth) {
62 MVT M = MVT::getIntegerVT(BitWidth);
63 if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
64 return M;
65 return getExtendedIntegerVT(C&: Context, BitWidth);
66 }
67
68 /// Returns the EVT that represents a vector NumElements in length, where
69 /// each element is of type VT.
70 static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements,
71 bool IsScalable = false) {
72 MVT M = MVT::getVectorVT(VT: VT.V, NumElements, IsScalable);
73 if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
74 return M;
75 return getExtendedVectorVT(C&: Context, VT, NumElements, IsScalable);
76 }
77
78 /// Returns the EVT that represents a vector EC.Min elements in length,
79 /// where each element is of type VT.
80 static EVT getVectorVT(LLVMContext &Context, EVT VT, ElementCount EC) {
81 MVT M = MVT::getVectorVT(VT: VT.V, EC);
82 if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
83 return M;
84 return getExtendedVectorVT(Context, VT, EC);
85 }
86
87 /// Return a vector with the same number of elements as this vector, but
88 /// with the element type converted to an integer type with the same
89 /// bitwidth.
90 EVT changeVectorElementTypeToInteger() const {
91 if (isSimple())
92 return getSimpleVT().changeVectorElementTypeToInteger();
93 return changeExtendedVectorElementTypeToInteger();
94 }
95
96 /// Return a VT for a vector type whose attributes match ourselves
97 /// with the exception of the element type that is chosen by the caller.
98 EVT changeVectorElementType(LLVMContext &Context, EVT EltVT) const {
99 if (isSimple() && EltVT.isSimple()) {
100 MVT M = MVT::getVectorVT(VT: EltVT.getSimpleVT(), EC: getVectorElementCount());
101 if (M != MVT::INVALID_SIMPLE_VALUE_TYPE)
102 return M;
103 }
104 return getVectorVT(Context, VT: EltVT, EC: getVectorElementCount());
105 }
106
107 /// Return a VT for a vector type whose attributes match ourselves
108 /// with the exception of the element count that is chosen by the caller.
109 EVT changeVectorElementCount(LLVMContext &Context, ElementCount EC) const {
110 assert(isVector() && "Not a vector EVT!");
111 if (isSimple()) {
112 MVT M = getSimpleVT().changeVectorElementCount(EC);
113 if (M != MVT::INVALID_SIMPLE_VALUE_TYPE)
114 return M;
115 }
116 return getVectorVT(Context, VT: getVectorElementType(), EC);
117 }
118
119 /// Return a VT for a type whose attributes match ourselves with the
120 /// exception of the element type that is chosen by the caller.
121 EVT changeElementType(LLVMContext &Context, EVT EltVT) const {
122 EltVT = EltVT.getScalarType();
123 return isVector() ? changeVectorElementType(Context, EltVT) : EltVT;
124 }
125
126 /// Return the type converted to an equivalently sized integer or vector
127 /// with integer element type. Similar to changeVectorElementTypeToInteger,
128 /// but also handles scalars.
129 EVT changeTypeToInteger() const {
130 if (isVector())
131 return changeVectorElementTypeToInteger();
132
133 if (isSimple())
134 return getSimpleVT().changeTypeToInteger();
135 return changeExtendedTypeToInteger();
136 }
137
138 /// Test if the given EVT has zero size, this will fail if called on a
139 /// scalable type
140 bool isZeroSized() const {
141 return getSizeInBits().isZero();
142 }
143
144 /// Test if the given EVT is simple (as opposed to being extended).
145 bool isSimple() const {
146 return V.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE;
147 }
148
149 /// Test if the given EVT is extended (as opposed to being simple).
150 bool isExtended() const {
151 return !isSimple();
152 }
153
154 /// Return true if this is a FP or a vector FP type.
155 bool isFloatingPoint() const {
156 return isSimple() ? V.isFloatingPoint() : isExtendedFloatingPoint();
157 }
158
159 /// Return true if this is an integer or a vector integer type.
160 bool isInteger() const {
161 return isSimple() ? V.isInteger() : isExtendedInteger();
162 }
163
164 /// Return true if this is an integer, but not a vector.
165 bool isScalarInteger() const {
166 return isSimple() ? V.isScalarInteger() : isExtendedScalarInteger();
167 }
168
169 /// Return true if this is a vector type where the runtime
170 /// length is machine dependent
171 bool isScalableTargetExtVT() const {
172 return isSimple() && V.isScalableTargetExtVT();
173 }
174
175 /// Return true if this is a vector value type.
176 bool isVector() const {
177 return isSimple() ? V.isVector() : isExtendedVector();
178 }
179
180 /// Return true if this is a vector with matching element type.
181 bool isVectorOf(EVT EltVT) const {
182 return isVector() && getVectorElementType() == EltVT;
183 }
184
185 /// Return true if this is a vector type where the runtime
186 /// length is machine dependent
187 bool isScalableVector() const {
188 return isSimple() ? V.isScalableVector() : isExtendedScalableVector();
189 }
190
191 /// Return true if this is a scalable vector with matching element type.
192 bool isScalableVectorOf(EVT EltVT) const {
193 return isScalableVector() && getVectorElementType() == EltVT;
194 }
195
196 /// Return true if this is a vector value type.
197 bool isRISCVVectorTuple() const { return V.isRISCVVectorTuple(); }
198
199 bool isFixedLengthVector() const {
200 return isSimple() ? V.isFixedLengthVector()
201 : isExtendedFixedLengthVector();
202 }
203
204 /// Return true if this is a fixed length vector with matching element type.
205 bool isFixedLengthVectorOf(EVT EltVT) const {
206 return isFixedLengthVector() && getVectorElementType() == EltVT;
207 }
208
209 /// Return true if the type is a scalable type.
210 bool isScalableVT() const {
211 return isScalableVector() || isScalableTargetExtVT();
212 }
213
214 /// Return true if this is a 16-bit vector type.
215 bool is16BitVector() const {
216 return isSimple() ? V.is16BitVector() : isExtended16BitVector();
217 }
218
219 /// Return true if this is a 32-bit vector type.
220 bool is32BitVector() const {
221 return isSimple() ? V.is32BitVector() : isExtended32BitVector();
222 }
223
224 /// Return true if this is a 64-bit vector type.
225 bool is64BitVector() const {
226 return isSimple() ? V.is64BitVector() : isExtended64BitVector();
227 }
228
229 /// Return true if this is a 128-bit vector type.
230 bool is128BitVector() const {
231 return isSimple() ? V.is128BitVector() : isExtended128BitVector();
232 }
233
234 /// Return true if this is a 256-bit vector type.
235 bool is256BitVector() const {
236 return isSimple() ? V.is256BitVector() : isExtended256BitVector();
237 }
238
239 /// Return true if this is a 512-bit vector type.
240 bool is512BitVector() const {
241 return isSimple() ? V.is512BitVector() : isExtended512BitVector();
242 }
243
244 /// Return true if this is a 1024-bit vector type.
245 bool is1024BitVector() const {
246 return isSimple() ? V.is1024BitVector() : isExtended1024BitVector();
247 }
248
249 /// Return true if this is a 2048-bit vector type.
250 bool is2048BitVector() const {
251 return isSimple() ? V.is2048BitVector() : isExtended2048BitVector();
252 }
253
254 /// Return true if this is a capability type.
255 bool isCheriCapability() const {
256 return isSimple() ? V.isCheriCapability() : false;
257 }
258
259 /// Return true if this is an overloaded type for TableGen.
260 bool isOverloaded() const {
261 return (V == MVT::iAny || V == MVT::fAny || V == MVT::vAny ||
262 V == MVT::pAny);
263 }
264
265 /// Return true if the bit size is a multiple of 8.
266 bool isByteSized() const {
267 return !isZeroSized() && getSizeInBits().isKnownMultipleOf(RHS: 8);
268 }
269
270 /// Return true if the size is a power-of-two number of bytes.
271 bool isRound() const {
272 if (isScalableVector())
273 return false;
274 unsigned BitSize = getSizeInBits();
275 return BitSize >= 8 && !(BitSize & (BitSize - 1));
276 }
277
278 /// Return true if this has the same number of bits as VT.
279 bool bitsEq(EVT VT) const {
280 if (EVT::operator==(VT)) return true;
281 return getSizeInBits() == VT.getSizeInBits();
282 }
283
284 /// Return true if we know at compile time this has more bits than VT.
285 bool knownBitsGT(EVT VT) const {
286 return TypeSize::isKnownGT(LHS: getSizeInBits(), RHS: VT.getSizeInBits());
287 }
288
289 /// Return true if we know at compile time this has more than or the same
290 /// bits as VT.
291 bool knownBitsGE(EVT VT) const {
292 return TypeSize::isKnownGE(LHS: getSizeInBits(), RHS: VT.getSizeInBits());
293 }
294
295 /// Return true if we know at compile time this has fewer bits than VT.
296 bool knownBitsLT(EVT VT) const {
297 return TypeSize::isKnownLT(LHS: getSizeInBits(), RHS: VT.getSizeInBits());
298 }
299
300 /// Return true if we know at compile time this has fewer than or the same
301 /// bits as VT.
302 bool knownBitsLE(EVT VT) const {
303 return TypeSize::isKnownLE(LHS: getSizeInBits(), RHS: VT.getSizeInBits());
304 }
305
306 /// Return true if this has more bits than VT.
307 bool bitsGT(EVT VT) const {
308 if (EVT::operator==(VT)) return false;
309 assert(isScalableVector() == VT.isScalableVector() &&
310 "Comparison between scalable and fixed types");
311 return knownBitsGT(VT);
312 }
313
314 /// Return true if this has no less bits than VT.
315 bool bitsGE(EVT VT) const {
316 if (EVT::operator==(VT)) return true;
317 assert(isScalableVector() == VT.isScalableVector() &&
318 "Comparison between scalable and fixed types");
319 return knownBitsGE(VT);
320 }
321
322 /// Return true if this has less bits than VT.
323 bool bitsLT(EVT VT) const {
324 if (EVT::operator==(VT)) return false;
325 assert(isScalableVector() == VT.isScalableVector() &&
326 "Comparison between scalable and fixed types");
327 return knownBitsLT(VT);
328 }
329
330 /// Return true if this has no more bits than VT.
331 bool bitsLE(EVT VT) const {
332 if (EVT::operator==(VT)) return true;
333 assert(isScalableVector() == VT.isScalableVector() &&
334 "Comparison between scalable and fixed types");
335 return knownBitsLE(VT);
336 }
337
338 /// Return the SimpleValueType held in the specified simple EVT.
339 MVT getSimpleVT() const {
340 assert(isSimple() && "Expected a SimpleValueType!");
341 return V;
342 }
343
344 /// If this is a vector type, return the element type, otherwise return
345 /// this.
346 EVT getScalarType() const {
347 return isVector() ? getVectorElementType() : *this;
348 }
349
350 /// Given a vector type, return the type of each element.
351 EVT getVectorElementType() const {
352 assert(isVector() && "Invalid vector type!");
353 if (isSimple())
354 return V.getVectorElementType();
355 return getExtendedVectorElementType();
356 }
357
358 /// Given a vector type, return the number of elements it contains.
359 unsigned getVectorNumElements() const {
360 assert(isVector() && "Invalid vector type!");
361
362 if (isScalableVector())
363 llvm::reportFatalInternalError(
364 reason: "Possible incorrect use of EVT::getVectorNumElements() for "
365 "scalable vector. Scalable flag may be dropped, use "
366 "EVT::getVectorElementCount() instead");
367
368 return isSimple() ? V.getVectorNumElements()
369 : getExtendedVectorNumElements();
370 }
371
372 // Given a (possibly scalable) vector type, return the ElementCount
373 ElementCount getVectorElementCount() const {
374 assert((isVector()) && "Invalid vector type!");
375 if (isSimple())
376 return V.getVectorElementCount();
377
378 return getExtendedVectorElementCount();
379 }
380
381 /// Given a vector type, return the minimum number of elements it contains.
382 unsigned getVectorMinNumElements() const {
383 return getVectorElementCount().getKnownMinValue();
384 }
385
386 /// Given a RISCV vector tuple type, return the num_fields.
387 unsigned getRISCVVectorTupleNumFields() const {
388 return V.getRISCVVectorTupleNumFields();
389 }
390
391 /// Return the size of the specified value type in bits.
392 ///
393 /// If the value type is a scalable vector type, the scalable property will
394 /// be set and the runtime size will be a positive integer multiple of the
395 /// base size.
396 TypeSize getSizeInBits() const {
397 if (isSimple())
398 return V.getSizeInBits();
399 return getExtendedSizeInBits();
400 }
401
402 /// Return the size of the specified fixed width value type in bits. The
403 /// function will assert if the type is scalable.
404 uint64_t getFixedSizeInBits() const {
405 return getSizeInBits().getFixedValue();
406 }
407
408 uint64_t getScalarSizeInBits() const {
409 return getScalarType().getSizeInBits().getFixedValue();
410 }
411
412 /// Return the number of bytes overwritten by a store of the specified value
413 /// type.
414 ///
415 /// If the value type is a scalable vector type, the scalable property will
416 /// be set and the runtime size will be a positive integer multiple of the
417 /// base size.
418 TypeSize getStoreSize() const {
419 TypeSize BaseSize = getSizeInBits();
420 return {(BaseSize.getKnownMinValue() + 7) / 8, BaseSize.isScalable()};
421 }
422
423 // Return the number of bytes overwritten by a store of this value type or
424 // this value type's element type in the case of a vector.
425 uint64_t getScalarStoreSize() const {
426 return getScalarType().getStoreSize().getFixedValue();
427 }
428
429 /// Return the number of bits overwritten by a store of the specified value
430 /// type.
431 ///
432 /// If the value type is a scalable vector type, the scalable property will
433 /// be set and the runtime size will be a positive integer multiple of the
434 /// base size.
435 TypeSize getStoreSizeInBits() const {
436 return getStoreSize() * 8;
437 }
438
439 /// Rounds the bit-width of the given integer EVT up to the nearest power of
440 /// two (and at least to eight), and returns the integer EVT with that
441 /// number of bits.
442 EVT getRoundIntegerType(LLVMContext &Context) const {
443 assert(isInteger() && !isVector() && "Invalid integer type!");
444 unsigned BitWidth = getSizeInBits();
445 if (BitWidth <= 8)
446 return EVT(MVT::i8);
447 return getIntegerVT(Context, BitWidth: llvm::bit_ceil(Value: BitWidth));
448 }
449
450 /// Finds the smallest simple value type that is greater than or equal to
451 /// half the width of this EVT. If no simple value type can be found, an
452 /// extended integer value type of half the size (rounded up) is returned.
453 EVT getHalfSizedIntegerVT(LLVMContext &Context) const {
454 assert(isInteger() && !isVector() && "Invalid integer type!");
455 unsigned EVTSize = getSizeInBits();
456 for (unsigned IntVT = MVT::FIRST_INTEGER_VALUETYPE;
457 IntVT <= MVT::LAST_INTEGER_VALUETYPE; ++IntVT) {
458 EVT HalfVT = EVT((MVT::SimpleValueType)IntVT);
459 if (HalfVT.getSizeInBits() * 2 >= EVTSize)
460 return HalfVT;
461 }
462 return getIntegerVT(Context, BitWidth: (EVTSize + 1) / 2);
463 }
464
465 /// Return a VT for an integer element type with doubled bit width.
466 /// The type returned may be an extended type.
467 EVT widenIntegerElementType(LLVMContext &Context) const {
468 unsigned EVTSize = getScalarSizeInBits();
469 EVT EltVT = EVT::getIntegerVT(Context, BitWidth: 2 * EVTSize);
470 return changeElementType(Context, EltVT);
471 }
472
473 /// Return a VT for an integer vector type with the size of the
474 /// elements doubled. The type returned may be an extended type.
475 EVT widenIntegerVectorElementType(LLVMContext &Context) const {
476 EVT EltVT = getVectorElementType();
477 EltVT = EVT::getIntegerVT(Context, BitWidth: 2 * EltVT.getSizeInBits());
478 return EVT::getVectorVT(Context, VT: EltVT, EC: getVectorElementCount());
479 }
480
481 // Return a VT for a vector type with the same element type but
482 // half the number of elements. The type returned may be an
483 // extended type.
484 EVT getHalfNumVectorElementsVT(LLVMContext &Context) const {
485 EVT EltVT = getVectorElementType();
486 auto EltCnt = getVectorElementCount();
487 assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!");
488 return EVT::getVectorVT(Context, VT: EltVT, EC: EltCnt.divideCoefficientBy(RHS: 2));
489 }
490
491 // Return a VT for a vector type with the same element type but
492 // double the number of elements. The type returned may be an
493 // extended type.
494 EVT getDoubleNumVectorElementsVT(LLVMContext &Context) const {
495 EVT EltVT = getVectorElementType();
496 auto EltCnt = getVectorElementCount();
497 return EVT::getVectorVT(Context, VT: EltVT, EC: EltCnt * 2);
498 }
499
500 /// Returns true if the given vector is a power of 2.
501 bool isPow2VectorType() const {
502 unsigned NElts = getVectorMinNumElements();
503 return !(NElts & (NElts - 1));
504 }
505
506 /// Widens the length of the given vector EVT up to the nearest power of 2
507 /// and returns that type.
508 EVT getPow2VectorType(LLVMContext &Context) const {
509 if (!isPow2VectorType()) {
510 ElementCount NElts = getVectorElementCount();
511 unsigned NewMinCount = 1 << Log2_32_Ceil(Value: NElts.getKnownMinValue());
512 NElts = ElementCount::get(MinVal: NewMinCount, Scalable: NElts.isScalable());
513 return EVT::getVectorVT(Context, VT: getVectorElementType(), EC: NElts);
514 }
515 else {
516 return *this;
517 }
518 }
519
520 /// This function returns value type as a string, e.g. "i32".
521 LLVM_ABI std::string getEVTString() const;
522
523 /// Support for debugging, callable in GDB: VT.dump()
524 LLVM_ABI void dump() const;
525
526 /// Implement operator<<.
527 void print(raw_ostream &OS) const {
528 OS << getEVTString();
529 }
530
531 /// This method returns an LLVM type corresponding to the specified EVT.
532 /// For integer types, this returns an unsigned type. Note that this will
533 /// abort for types that cannot be represented.
534 LLVM_ABI Type *getTypeForEVT(LLVMContext &Context) const;
535
536 /// Return the value type corresponding to the specified type.
537 /// If HandleUnknown is true, unknown types are returned as Other,
538 /// otherwise they are invalid.
539 /// NB: This includes pointer types, which require a DataLayout to convert
540 /// to a concrete value type.
541 LLVM_ABI static EVT getEVT(Type *Ty, bool HandleUnknown = false);
542
543 intptr_t getRawBits() const {
544 if (isSimple())
545 return V.SimpleTy;
546 else
547 return (intptr_t)(LLVMTy);
548 }
549
550 /// A meaningless but well-behaved order, useful for constructing
551 /// containers.
552 struct compareRawBits {
553 bool operator()(EVT L, EVT R) const {
554 if (L.V.SimpleTy == R.V.SimpleTy)
555 return L.LLVMTy < R.LLVMTy;
556 else
557 return L.V.SimpleTy < R.V.SimpleTy;
558 }
559 };
560
561 /// Returns an APFloat semantics tag appropriate for the value type. If this
562 /// is a vector type, the element semantics are returned.
563 LLVM_ABI const fltSemantics &getFltSemantics() const;
564
565 private:
566 // Methods for handling the Extended-type case in functions above.
567 // These are all out-of-line to prevent users of this header file
568 // from having a dependency on Type.h.
569 LLVM_ABI EVT changeExtendedTypeToInteger() const;
570 LLVM_ABI EVT changeExtendedVectorElementType(EVT EltVT) const;
571 LLVM_ABI EVT changeExtendedVectorElementTypeToInteger() const;
572 LLVM_ABI static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth);
573 LLVM_ABI static EVT getExtendedVectorVT(LLVMContext &C, EVT VT,
574 unsigned NumElements,
575 bool IsScalable);
576 LLVM_ABI static EVT getExtendedVectorVT(LLVMContext &Context, EVT VT,
577 ElementCount EC);
578 LLVM_ABI bool isExtendedFloatingPoint() const LLVM_READONLY;
579 LLVM_ABI bool isExtendedInteger() const LLVM_READONLY;
580 LLVM_ABI bool isExtendedScalarInteger() const LLVM_READONLY;
581 LLVM_ABI bool isExtendedVector() const LLVM_READONLY;
582 LLVM_ABI bool isExtended16BitVector() const LLVM_READONLY;
583 LLVM_ABI bool isExtended32BitVector() const LLVM_READONLY;
584 LLVM_ABI bool isExtended64BitVector() const LLVM_READONLY;
585 LLVM_ABI bool isExtended128BitVector() const LLVM_READONLY;
586 LLVM_ABI bool isExtended256BitVector() const LLVM_READONLY;
587 LLVM_ABI bool isExtended512BitVector() const LLVM_READONLY;
588 LLVM_ABI bool isExtended1024BitVector() const LLVM_READONLY;
589 LLVM_ABI bool isExtended2048BitVector() const LLVM_READONLY;
590 LLVM_ABI bool isExtendedFixedLengthVector() const LLVM_READONLY;
591 LLVM_ABI bool isExtendedScalableVector() const LLVM_READONLY;
592 LLVM_ABI EVT getExtendedVectorElementType() const;
593 LLVM_ABI unsigned getExtendedVectorNumElements() const LLVM_READONLY;
594 LLVM_ABI ElementCount getExtendedVectorElementCount() const LLVM_READONLY;
595 LLVM_ABI TypeSize getExtendedSizeInBits() const LLVM_READONLY;
596 };
597
598 inline raw_ostream &operator<<(raw_ostream &OS, const EVT &V) {
599 V.print(OS);
600 return OS;
601 }
602} // end namespace llvm
603
604#endif // LLVM_CODEGEN_VALUETYPES_H
605