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 
26 namespace llvm {
27 
28   class LLVMContext;
29   class Type;
30 
31   /// Extended Value Type. Capable of holding value types which are not native
32   /// for any processor (such as the i12345 type), as well as the types an MVT
33   /// can represent.
34   struct EVT {
35   private:
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