1 //===- Support/MachineValueType.h - Machine-Level 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 machine-level target independent types which
10 // legal values in the code generator use.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_SUPPORT_MACHINEVALUETYPE_H
15 #define LLVM_SUPPORT_MACHINEVALUETYPE_H
16 
17 #include "llvm/ADT/iterator_range.h"
18 #include "llvm/Support/ErrorHandling.h"
19 #include "llvm/Support/MathExtras.h"
20 #include "llvm/Support/TypeSize.h"
21 #include <cassert>
22 
23 namespace llvm {
24 
25   class Type;
26 
27   /// Machine Value Type. Every type that is supported natively by some
28   /// processor targeted by LLVM occurs here. This means that any legal value
29   /// type can be represented by an MVT.
30   class MVT {
31   public:
32     enum SimpleValueType : uint8_t {
33       // Simple value types that aren't explicitly part of this enumeration
34       // are considered extended value types.
35       INVALID_SIMPLE_VALUE_TYPE = 0,
36 
37       // If you change this numbering, you must change the values in
38       // ValueTypes.td as well!
39       Other          =   1,   // This is a non-standard value
40       i1             =   2,   // This is a 1 bit integer value
41       i8             =   3,   // This is an 8 bit integer value
42       i16            =   4,   // This is a 16 bit integer value
43       i32            =   5,   // This is a 32 bit integer value
44       i64            =   6,   // This is a 64 bit integer value
45       i128           =   7,   // This is a 128 bit integer value
46 
47       FIRST_INTEGER_VALUETYPE = i1,
48       LAST_INTEGER_VALUETYPE  = i128,
49 
50       bf16           =   8,   // This is a 16 bit brain floating point value
51       f16            =   9,   // This is a 16 bit floating point value
52       f32            =  10,   // This is a 32 bit floating point value
53       f64            =  11,   // This is a 64 bit floating point value
54       f80            =  12,   // This is a 80 bit floating point value
55       f128           =  13,   // This is a 128 bit floating point value
56       ppcf128        =  14,   // This is a PPC 128-bit floating point value
57 
58       FIRST_FP_VALUETYPE = bf16,
59       LAST_FP_VALUETYPE  = ppcf128,
60 
61       v1i1           =  15,   //    1 x i1
62       v2i1           =  16,   //    2 x i1
63       v4i1           =  17,   //    4 x i1
64       v8i1           =  18,   //    8 x i1
65       v16i1          =  19,   //   16 x i1
66       v32i1          =  20,   //   32 x i1
67       v64i1          =  21,   //   64 x i1
68       v128i1         =  22,   //  128 x i1
69       v256i1         =  23,   //  256 x i1
70       v512i1         =  24,   //  512 x i1
71       v1024i1        =  25,   // 1024 x i1
72 
73       v1i8           =  26,   //  1 x i8
74       v2i8           =  27,   //  2 x i8
75       v4i8           =  28,   //  4 x i8
76       v8i8           =  29,   //  8 x i8
77       v16i8          =  30,   // 16 x i8
78       v32i8          =  31,   // 32 x i8
79       v64i8          =  32,   // 64 x i8
80       v128i8         =  33,   //128 x i8
81       v256i8         =  34,   //256 x i8
82 
83       v1i16          =  35,   //  1 x i16
84       v2i16          =  36,   //  2 x i16
85       v3i16          =  37,   //  3 x i16
86       v4i16          =  38,   //  4 x i16
87       v8i16          =  39,   //  8 x i16
88       v16i16         =  40,   // 16 x i16
89       v32i16         =  41,   // 32 x i16
90       v64i16         =  42,   // 64 x i16
91       v128i16        =  43,   //128 x i16
92 
93       v1i32          =  44,   //    1 x i32
94       v2i32          =  45,   //    2 x i32
95       v3i32          =  46,   //    3 x i32
96       v4i32          =  47,   //    4 x i32
97       v5i32          =  48,   //    5 x i32
98       v8i32          =  49,   //    8 x i32
99       v16i32         =  50,   //   16 x i32
100       v32i32         =  51,   //   32 x i32
101       v64i32         =  52,   //   64 x i32
102       v128i32        =  53,   //  128 x i32
103       v256i32        =  54,   //  256 x i32
104       v512i32        =  55,   //  512 x i32
105       v1024i32       =  56,   // 1024 x i32
106       v2048i32       =  57,   // 2048 x i32
107 
108       v1i64          =  58,   //  1 x i64
109       v2i64          =  59,   //  2 x i64
110       v4i64          =  60,   //  4 x i64
111       v8i64          =  61,   //  8 x i64
112       v16i64         =  62,   // 16 x i64
113       v32i64         =  63,   // 32 x i64
114       v64i64         =  64,   // 64 x i64
115       v128i64        =  65,   // 128 x i64
116       v256i64        =  66,   // 256 x i64
117 
118       v1i128         =  67,   //  1 x i128
119 
120       FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
121       LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i128,
122 
123       v2f16          =  68,   //    2 x f16
124       v3f16          =  69,   //    3 x f16
125       v4f16          =  70,   //    4 x f16
126       v8f16          =  71,   //    8 x f16
127       v16f16         =  72,   //   16 x f16
128       v32f16         =  73,   //   32 x f16
129       v64f16         =  74,   //   64 x f16
130       v128f16        =  75,   //  128 x f16
131       v2bf16         =  76,   //    2 x bf16
132       v3bf16         =  77,   //    3 x bf16
133       v4bf16         =  78,   //    4 x bf16
134       v8bf16         =  79,   //    8 x bf16
135       v16bf16        =  80,   //   16 x bf16
136       v32bf16        =  81,   //   32 x bf16
137       v64bf16        =  82,   //   64 x bf16
138       v128bf16       =  83,   //  128 x bf16
139       v1f32          =  84,   //    1 x f32
140       v2f32          =  85,   //    2 x f32
141       v3f32          =  86,   //    3 x f32
142       v4f32          =  87,   //    4 x f32
143       v5f32          =  88,   //    5 x f32
144       v8f32          =  89,   //    8 x f32
145       v16f32         =  90,   //   16 x f32
146       v32f32         =  91,   //   32 x f32
147       v64f32         =  92,   //   64 x f32
148       v128f32        =  93,   //  128 x f32
149       v256f32        =  94,   //  256 x f32
150       v512f32        =  95,   //  512 x f32
151       v1024f32       =  96,   // 1024 x f32
152       v2048f32       =  97,   // 2048 x f32
153       v1f64          =  98,   //    1 x f64
154       v2f64          =  99,   //    2 x f64
155       v4f64          = 100,   //    4 x f64
156       v8f64          = 101,   //    8 x f64
157       v16f64         = 102,   //   16 x f64
158       v32f64         = 103,   //   32 x f64
159       v64f64         = 104,   //   64 x f64
160       v128f64        = 105,   //  128 x f64
161       v256f64        = 106,   //  256 x f64
162 
163       FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE = v2f16,
164       LAST_FP_FIXEDLEN_VECTOR_VALUETYPE = v256f64,
165 
166       FIRST_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
167       LAST_FIXEDLEN_VECTOR_VALUETYPE = v256f64,
168 
169       nxv1i1         = 107,   // n x  1 x i1
170       nxv2i1         = 108,   // n x  2 x i1
171       nxv4i1         = 109,   // n x  4 x i1
172       nxv8i1         = 110,   // n x  8 x i1
173       nxv16i1        = 111,   // n x 16 x i1
174       nxv32i1        = 112,   // n x 32 x i1
175       nxv64i1        = 113,   // n x  64 x i1
176 
177       nxv1i8         = 114,   // n x  1 x i8
178       nxv2i8         = 115,   // n x  2 x i8
179       nxv4i8         = 116,   // n x  4 x i8
180       nxv8i8         = 117,   // n x  8 x i8
181       nxv16i8        = 118,   // n x 16 x i8
182       nxv32i8        = 119,   // n x 32 x i8
183       nxv64i8        = 120,   // n x  64 x i8
184 
185       nxv1i16        = 121,  // n x  1 x i16
186       nxv2i16        = 122,  // n x  2 x i16
187       nxv4i16        = 123,  // n x  4 x i16
188       nxv8i16        = 124,  // n x  8 x i16
189       nxv16i16       = 125,  // n x 16 x i16
190       nxv32i16       = 126,  // n x 32 x i16
191 
192       nxv1i32        = 127,  // n x  1 x i32
193       nxv2i32        = 128,  // n x  2 x i32
194       nxv4i32        = 129,  // n x  4 x i32
195       nxv8i32        = 130,  // n x  8 x i32
196       nxv16i32       = 131,  // n x 16 x i32
197       nxv32i32       = 132,  // n x 32 x i32
198 
199       nxv1i64        = 133,  // n x  1 x i64
200       nxv2i64        = 134,  // n x  2 x i64
201       nxv4i64        = 135,  // n x  4 x i64
202       nxv8i64        = 136,  // n x  8 x i64
203       nxv16i64       = 137,  // n x 16 x i64
204       nxv32i64       = 138,  // n x 32 x i64
205 
206       FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
207       LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv32i64,
208 
209       nxv1f16        = 139,   // n x   1 x f16
210       nxv2f16        = 140,  // n x  2 x f16
211       nxv4f16        = 141,  // n x  4 x f16
212       nxv8f16        = 142,  // n x  8 x f16
213       nxv16f16       = 143,   // n x  16 x f16
214       nxv32f16       = 144,   // n x  32 x f16
215       nxv2bf16       = 145,  // n x  2 x bf16
216       nxv4bf16       = 146,  // n x  4 x bf16
217       nxv8bf16       = 147,  // n x  8 x bf16
218       nxv1f32        = 148,  // n x  1 x f32
219       nxv2f32        = 149,  // n x  2 x f32
220       nxv4f32        = 150,  // n x  4 x f32
221       nxv8f32        = 151,  // n x  8 x f32
222       nxv16f32       = 152,  // n x 16 x f32
223       nxv1f64        = 153,  // n x  1 x f64
224       nxv2f64        = 154,  // n x  2 x f64
225       nxv4f64        = 155,  // n x  4 x f64
226       nxv8f64        = 156,  // n x  8 x f64
227 
228       FIRST_FP_SCALABLE_VECTOR_VALUETYPE = nxv1f16,
229       LAST_FP_SCALABLE_VECTOR_VALUETYPE = nxv8f64,
230 
231       FIRST_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
232       LAST_SCALABLE_VECTOR_VALUETYPE = nxv8f64,
233 
234       FIRST_VECTOR_VALUETYPE = v1i1,
235       LAST_VECTOR_VALUETYPE  = nxv8f64,
236 
237       x86mmx         = 157,   // This is an X86 MMX value
238 
239       Glue           = 158,   // This glues nodes together during pre-RA sched
240 
241       isVoid         = 159,   // This has no value
242 
243       Untyped        = 160,   // This value takes a register, but has
244                               // unspecified type.  The register class
245                               // will be determined by the opcode.
246 
247       exnref         = 161,   // WebAssembly's exnref type
248       funcref        = 162,   // WebAssembly's funcref type
249       externref      = 163,   // WebAssembly's externref type
250 
251       FIRST_VALUETYPE =  1,   // This is always the beginning of the list.
252       LAST_VALUETYPE = 164,   // This always remains at the end of the list.
253 
254       // This is the current maximum for LAST_VALUETYPE.
255       // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
256       // This value must be a multiple of 32.
257       MAX_ALLOWED_VALUETYPE = 192,
258 
259       // A value of type llvm::TokenTy
260       token          = 248,
261 
262       // This is MDNode or MDString.
263       Metadata       = 249,
264 
265       // An int value the size of the pointer of the current
266       // target to any address space. This must only be used internal to
267       // tblgen. Other than for overloading, we treat iPTRAny the same as iPTR.
268       iPTRAny        = 250,
269 
270       // A vector with any length and element size. This is used
271       // for intrinsics that have overloadings based on vector types.
272       // This is only for tblgen's consumption!
273       vAny           = 251,
274 
275       // Any floating-point or vector floating-point value. This is used
276       // for intrinsics that have overloadings based on floating-point types.
277       // This is only for tblgen's consumption!
278       fAny           = 252,
279 
280       // An integer or vector integer value of any bit width. This is
281       // used for intrinsics that have overloadings based on integer bit widths.
282       // This is only for tblgen's consumption!
283       iAny           = 253,
284 
285       // An int value the size of the pointer of the current
286       // target.  This should only be used internal to tblgen!
287       iPTR           = 254,
288 
289       // Any type. This is used for intrinsics that have overloadings.
290       // This is only for tblgen's consumption!
291       Any            = 255
292     };
293 
294     SimpleValueType SimpleTy = INVALID_SIMPLE_VALUE_TYPE;
295 
296     constexpr MVT() = default;
MVT(SimpleValueType SVT)297     constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {}
298 
299     bool operator>(const MVT& S)  const { return SimpleTy >  S.SimpleTy; }
300     bool operator<(const MVT& S)  const { return SimpleTy <  S.SimpleTy; }
301     bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; }
302     bool operator!=(const MVT& S) const { return SimpleTy != S.SimpleTy; }
303     bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; }
304     bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; }
305 
306     /// Return true if this is a valid simple valuetype.
isValid()307     bool isValid() const {
308       return (SimpleTy >= MVT::FIRST_VALUETYPE &&
309               SimpleTy < MVT::LAST_VALUETYPE);
310     }
311 
312     /// Return true if this is a FP or a vector FP type.
isFloatingPoint()313     bool isFloatingPoint() const {
314       return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE &&
315                SimpleTy <= MVT::LAST_FP_VALUETYPE) ||
316               (SimpleTy >= MVT::FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE &&
317                SimpleTy <= MVT::LAST_FP_FIXEDLEN_VECTOR_VALUETYPE) ||
318               (SimpleTy >= MVT::FIRST_FP_SCALABLE_VECTOR_VALUETYPE &&
319                SimpleTy <= MVT::LAST_FP_SCALABLE_VECTOR_VALUETYPE));
320     }
321 
322     /// Return true if this is an integer or a vector integer type.
isInteger()323     bool isInteger() const {
324       return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
325                SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) ||
326               (SimpleTy >= MVT::FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE &&
327                SimpleTy <= MVT::LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE) ||
328               (SimpleTy >= MVT::FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE &&
329                SimpleTy <= MVT::LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE));
330     }
331 
332     /// Return true if this is an integer, not including vectors.
isScalarInteger()333     bool isScalarInteger() const {
334       return (SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
335               SimpleTy <= MVT::LAST_INTEGER_VALUETYPE);
336     }
337 
338     /// Return true if this is a vector value type.
isVector()339     bool isVector() const {
340       return (SimpleTy >= MVT::FIRST_VECTOR_VALUETYPE &&
341               SimpleTy <= MVT::LAST_VECTOR_VALUETYPE);
342     }
343 
344     /// Return true if this is a vector value type where the
345     /// runtime length is machine dependent
isScalableVector()346     bool isScalableVector() const {
347       return (SimpleTy >= MVT::FIRST_SCALABLE_VECTOR_VALUETYPE &&
348               SimpleTy <= MVT::LAST_SCALABLE_VECTOR_VALUETYPE);
349     }
350 
isFixedLengthVector()351     bool isFixedLengthVector() const {
352       return (SimpleTy >= MVT::FIRST_FIXEDLEN_VECTOR_VALUETYPE &&
353               SimpleTy <= MVT::LAST_FIXEDLEN_VECTOR_VALUETYPE);
354     }
355 
356     /// Return true if this is a 16-bit vector type.
is16BitVector()357     bool is16BitVector() const {
358       return (SimpleTy == MVT::v2i8  || SimpleTy == MVT::v1i16 ||
359               SimpleTy == MVT::v16i1);
360     }
361 
362     /// Return true if this is a 32-bit vector type.
is32BitVector()363     bool is32BitVector() const {
364       return (SimpleTy == MVT::v32i1 || SimpleTy == MVT::v4i8   ||
365               SimpleTy == MVT::v2i16 || SimpleTy == MVT::v1i32  ||
366               SimpleTy == MVT::v2f16 || SimpleTy == MVT::v2bf16 ||
367               SimpleTy == MVT::v1f32);
368     }
369 
370     /// Return true if this is a 64-bit vector type.
is64BitVector()371     bool is64BitVector() const {
372       return (SimpleTy == MVT::v64i1  || SimpleTy == MVT::v8i8  ||
373               SimpleTy == MVT::v4i16  || SimpleTy == MVT::v2i32 ||
374               SimpleTy == MVT::v1i64  || SimpleTy == MVT::v4f16 ||
375               SimpleTy == MVT::v4bf16 ||SimpleTy == MVT::v2f32  ||
376               SimpleTy == MVT::v1f64);
377     }
378 
379     /// Return true if this is a 128-bit vector type.
is128BitVector()380     bool is128BitVector() const {
381       return (SimpleTy == MVT::v128i1 || SimpleTy == MVT::v16i8  ||
382               SimpleTy == MVT::v8i16  || SimpleTy == MVT::v4i32  ||
383               SimpleTy == MVT::v2i64  || SimpleTy == MVT::v1i128 ||
384               SimpleTy == MVT::v8f16  || SimpleTy == MVT::v8bf16 ||
385               SimpleTy == MVT::v4f32  || SimpleTy == MVT::v2f64);
386     }
387 
388     /// Return true if this is a 256-bit vector type.
is256BitVector()389     bool is256BitVector() const {
390       return (SimpleTy == MVT::v16f16 || SimpleTy == MVT::v16bf16 ||
391               SimpleTy == MVT::v8f32  || SimpleTy == MVT::v4f64   ||
392               SimpleTy == MVT::v32i8  || SimpleTy == MVT::v16i16  ||
393               SimpleTy == MVT::v8i32  || SimpleTy == MVT::v4i64   ||
394               SimpleTy == MVT::v256i1);
395     }
396 
397     /// Return true if this is a 512-bit vector type.
is512BitVector()398     bool is512BitVector() const {
399       return (SimpleTy == MVT::v32f16 || SimpleTy == MVT::v32bf16 ||
400               SimpleTy == MVT::v16f32 || SimpleTy == MVT::v8f64   ||
401               SimpleTy == MVT::v512i1 || SimpleTy == MVT::v64i8   ||
402               SimpleTy == MVT::v32i16 || SimpleTy == MVT::v16i32  ||
403               SimpleTy == MVT::v8i64);
404     }
405 
406     /// Return true if this is a 1024-bit vector type.
is1024BitVector()407     bool is1024BitVector() const {
408       return (SimpleTy == MVT::v1024i1 || SimpleTy == MVT::v128i8 ||
409               SimpleTy == MVT::v64i16  || SimpleTy == MVT::v32i32 ||
410               SimpleTy == MVT::v16i64  || SimpleTy == MVT::v64f16 ||
411               SimpleTy == MVT::v32f32  || SimpleTy == MVT::v16f64 ||
412               SimpleTy == MVT::v64bf16);
413     }
414 
415     /// Return true if this is a 2048-bit vector type.
is2048BitVector()416     bool is2048BitVector() const {
417       return (SimpleTy == MVT::v256i8  || SimpleTy == MVT::v128i16 ||
418               SimpleTy == MVT::v64i32  || SimpleTy == MVT::v32i64  ||
419               SimpleTy == MVT::v128f16 || SimpleTy == MVT::v64f32  ||
420               SimpleTy == MVT::v32f64  || SimpleTy == MVT::v128bf16);
421     }
422 
423     /// Return true if this is an overloaded type for TableGen.
isOverloaded()424     bool isOverloaded() const {
425       return (SimpleTy == MVT::Any || SimpleTy == MVT::iAny ||
426               SimpleTy == MVT::fAny || SimpleTy == MVT::vAny ||
427               SimpleTy == MVT::iPTRAny);
428     }
429 
430     /// Return a vector with the same number of elements as this vector, but
431     /// with the element type converted to an integer type with the same
432     /// bitwidth.
changeVectorElementTypeToInteger()433     MVT changeVectorElementTypeToInteger() const {
434       MVT EltTy = getVectorElementType();
435       MVT IntTy = MVT::getIntegerVT(EltTy.getSizeInBits());
436       MVT VecTy = MVT::getVectorVT(IntTy, getVectorElementCount());
437       assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&
438              "Simple vector VT not representable by simple integer vector VT!");
439       return VecTy;
440     }
441 
442     /// Return a VT for a vector type whose attributes match ourselves
443     /// with the exception of the element type that is chosen by the caller.
changeVectorElementType(MVT EltVT)444     MVT changeVectorElementType(MVT EltVT) const {
445       MVT VecTy = MVT::getVectorVT(EltVT, getVectorElementCount());
446       assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&
447              "Simple vector VT not representable by simple integer vector VT!");
448       return VecTy;
449     }
450 
451     /// Return the type converted to an equivalently sized integer or vector
452     /// with integer element type. Similar to changeVectorElementTypeToInteger,
453     /// but also handles scalars.
changeTypeToInteger()454     MVT changeTypeToInteger() {
455       if (isVector())
456         return changeVectorElementTypeToInteger();
457       return MVT::getIntegerVT(getSizeInBits());
458     }
459 
460     /// Return a VT for a vector type with the same element type but
461     /// half the number of elements.
getHalfNumVectorElementsVT()462     MVT getHalfNumVectorElementsVT() const {
463       MVT EltVT = getVectorElementType();
464       auto EltCnt = getVectorElementCount();
465       assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!");
466       return getVectorVT(EltVT, EltCnt.divideCoefficientBy(2));
467     }
468 
469     /// Returns true if the given vector is a power of 2.
isPow2VectorType()470     bool isPow2VectorType() const {
471       unsigned NElts = getVectorNumElements();
472       return !(NElts & (NElts - 1));
473     }
474 
475     /// Widens the length of the given vector MVT up to the nearest power of 2
476     /// and returns that type.
getPow2VectorType()477     MVT getPow2VectorType() const {
478       if (isPow2VectorType())
479         return *this;
480 
481       unsigned NElts = getVectorNumElements();
482       unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts);
483       return MVT::getVectorVT(getVectorElementType(), Pow2NElts);
484     }
485 
486     /// If this is a vector, return the element type, otherwise return this.
getScalarType()487     MVT getScalarType() const {
488       return isVector() ? getVectorElementType() : *this;
489     }
490 
getVectorElementType()491     MVT getVectorElementType() const {
492       switch (SimpleTy) {
493       default:
494         llvm_unreachable("Not a vector MVT!");
495       case v1i1:
496       case v2i1:
497       case v4i1:
498       case v8i1:
499       case v16i1:
500       case v32i1:
501       case v64i1:
502       case v128i1:
503       case v256i1:
504       case v512i1:
505       case v1024i1:
506       case nxv1i1:
507       case nxv2i1:
508       case nxv4i1:
509       case nxv8i1:
510       case nxv16i1:
511       case nxv32i1:
512       case nxv64i1: return i1;
513       case v1i8:
514       case v2i8:
515       case v4i8:
516       case v8i8:
517       case v16i8:
518       case v32i8:
519       case v64i8:
520       case v128i8:
521       case v256i8:
522       case nxv1i8:
523       case nxv2i8:
524       case nxv4i8:
525       case nxv8i8:
526       case nxv16i8:
527       case nxv32i8:
528       case nxv64i8: return i8;
529       case v1i16:
530       case v2i16:
531       case v3i16:
532       case v4i16:
533       case v8i16:
534       case v16i16:
535       case v32i16:
536       case v64i16:
537       case v128i16:
538       case nxv1i16:
539       case nxv2i16:
540       case nxv4i16:
541       case nxv8i16:
542       case nxv16i16:
543       case nxv32i16: return i16;
544       case v1i32:
545       case v2i32:
546       case v3i32:
547       case v4i32:
548       case v5i32:
549       case v8i32:
550       case v16i32:
551       case v32i32:
552       case v64i32:
553       case v128i32:
554       case v256i32:
555       case v512i32:
556       case v1024i32:
557       case v2048i32:
558       case nxv1i32:
559       case nxv2i32:
560       case nxv4i32:
561       case nxv8i32:
562       case nxv16i32:
563       case nxv32i32: return i32;
564       case v1i64:
565       case v2i64:
566       case v4i64:
567       case v8i64:
568       case v16i64:
569       case v32i64:
570       case v64i64:
571       case v128i64:
572       case v256i64:
573       case nxv1i64:
574       case nxv2i64:
575       case nxv4i64:
576       case nxv8i64:
577       case nxv16i64:
578       case nxv32i64: return i64;
579       case v1i128: return i128;
580       case v2f16:
581       case v3f16:
582       case v4f16:
583       case v8f16:
584       case v16f16:
585       case v32f16:
586       case v64f16:
587       case v128f16:
588       case nxv1f16:
589       case nxv2f16:
590       case nxv4f16:
591       case nxv8f16:
592       case nxv16f16:
593       case nxv32f16: return f16;
594       case v2bf16:
595       case v3bf16:
596       case v4bf16:
597       case v8bf16:
598       case v16bf16:
599       case v32bf16:
600       case v64bf16:
601       case v128bf16:
602       case nxv2bf16:
603       case nxv4bf16:
604       case nxv8bf16: return bf16;
605       case v1f32:
606       case v2f32:
607       case v3f32:
608       case v4f32:
609       case v5f32:
610       case v8f32:
611       case v16f32:
612       case v32f32:
613       case v64f32:
614       case v128f32:
615       case v256f32:
616       case v512f32:
617       case v1024f32:
618       case v2048f32:
619       case nxv1f32:
620       case nxv2f32:
621       case nxv4f32:
622       case nxv8f32:
623       case nxv16f32: return f32;
624       case v1f64:
625       case v2f64:
626       case v4f64:
627       case v8f64:
628       case v16f64:
629       case v32f64:
630       case v64f64:
631       case v128f64:
632       case v256f64:
633       case nxv1f64:
634       case nxv2f64:
635       case nxv4f64:
636       case nxv8f64: return f64;
637       }
638     }
639 
getVectorNumElements()640     unsigned getVectorNumElements() const {
641       switch (SimpleTy) {
642       default:
643         llvm_unreachable("Not a vector MVT!");
644       case v2048i32:
645       case v2048f32: return 2048;
646       case v1024i1:
647       case v1024i32:
648       case v1024f32: return 1024;
649       case v512i1:
650       case v512i32:
651       case v512f32: return 512;
652       case v256i1:
653       case v256i8:
654       case v256i32:
655       case v256i64:
656       case v256f32:
657       case v256f64: return 256;
658       case v128i1:
659       case v128i8:
660       case v128i16:
661       case v128i32:
662       case v128i64:
663       case v128f16:
664       case v128bf16:
665       case v128f32:
666       case v128f64: return 128;
667       case v64i1:
668       case v64i8:
669       case v64i16:
670       case v64i32:
671       case v64i64:
672       case v64f16:
673       case v64bf16:
674       case v64f32:
675       case v64f64:
676       case nxv64i1:
677       case nxv64i8: return 64;
678       case v32i1:
679       case v32i8:
680       case v32i16:
681       case v32i32:
682       case v32i64:
683       case v32f16:
684       case v32bf16:
685       case v32f32:
686       case v32f64:
687       case nxv32i1:
688       case nxv32i8:
689       case nxv32i16:
690       case nxv32i32:
691       case nxv32i64:
692       case nxv32f16: return 32;
693       case v16i1:
694       case v16i8:
695       case v16i16:
696       case v16i32:
697       case v16i64:
698       case v16f16:
699       case v16bf16:
700       case v16f32:
701       case v16f64:
702       case nxv16i1:
703       case nxv16i8:
704       case nxv16i16:
705       case nxv16i32:
706       case nxv16i64:
707       case nxv16f16:
708       case nxv16f32: return 16;
709       case v8i1:
710       case v8i8:
711       case v8i16:
712       case v8i32:
713       case v8i64:
714       case v8f16:
715       case v8bf16:
716       case v8f32:
717       case v8f64:
718       case nxv8i1:
719       case nxv8i8:
720       case nxv8i16:
721       case nxv8i32:
722       case nxv8i64:
723       case nxv8f16:
724       case nxv8bf16:
725       case nxv8f32:
726       case nxv8f64: return 8;
727       case v5i32:
728       case v5f32: return 5;
729       case v4i1:
730       case v4i8:
731       case v4i16:
732       case v4i32:
733       case v4i64:
734       case v4f16:
735       case v4bf16:
736       case v4f32:
737       case v4f64:
738       case nxv4i1:
739       case nxv4i8:
740       case nxv4i16:
741       case nxv4i32:
742       case nxv4i64:
743       case nxv4f16:
744       case nxv4bf16:
745       case nxv4f32:
746       case nxv4f64: return 4;
747       case v3i16:
748       case v3i32:
749       case v3f16:
750       case v3bf16:
751       case v3f32: return 3;
752       case v2i1:
753       case v2i8:
754       case v2i16:
755       case v2i32:
756       case v2i64:
757       case v2f16:
758       case v2bf16:
759       case v2f32:
760       case v2f64:
761       case nxv2i1:
762       case nxv2i8:
763       case nxv2i16:
764       case nxv2i32:
765       case nxv2i64:
766       case nxv2f16:
767       case nxv2bf16:
768       case nxv2f32:
769       case nxv2f64: return 2;
770       case v1i1:
771       case v1i8:
772       case v1i16:
773       case v1i32:
774       case v1i64:
775       case v1i128:
776       case v1f32:
777       case v1f64:
778       case nxv1i1:
779       case nxv1i8:
780       case nxv1i16:
781       case nxv1i32:
782       case nxv1i64:
783       case nxv1f16:
784       case nxv1f32:
785       case nxv1f64: return 1;
786       }
787     }
788 
getVectorElementCount()789     ElementCount getVectorElementCount() const {
790       return ElementCount::get(getVectorNumElements(), isScalableVector());
791     }
792 
793     /// Given a vector type, return the minimum number of elements it contains.
getVectorMinNumElements()794     unsigned getVectorMinNumElements() const {
795       return getVectorElementCount().getKnownMinValue();
796     }
797 
798     /// Returns the size of the specified MVT in bits.
799     ///
800     /// If the value type is a scalable vector type, the scalable property will
801     /// be set and the runtime size will be a positive integer multiple of the
802     /// base size.
getSizeInBits()803     TypeSize getSizeInBits() const {
804       switch (SimpleTy) {
805       default:
806         llvm_unreachable("getSizeInBits called on extended MVT.");
807       case Other:
808         llvm_unreachable("Value type is non-standard value, Other.");
809       case iPTR:
810         llvm_unreachable("Value type size is target-dependent. Ask TLI.");
811       case iPTRAny:
812       case iAny:
813       case fAny:
814       case vAny:
815       case Any:
816         llvm_unreachable("Value type is overloaded.");
817       case token:
818         llvm_unreachable("Token type is a sentinel that cannot be used "
819                          "in codegen and has no size");
820       case Metadata:
821         llvm_unreachable("Value type is metadata.");
822       case i1:
823       case v1i1: return TypeSize::Fixed(1);
824       case nxv1i1: return TypeSize::Scalable(1);
825       case v2i1: return TypeSize::Fixed(2);
826       case nxv2i1: return TypeSize::Scalable(2);
827       case v4i1: return TypeSize::Fixed(4);
828       case nxv4i1: return TypeSize::Scalable(4);
829       case i8  :
830       case v1i8:
831       case v8i1: return TypeSize::Fixed(8);
832       case nxv1i8:
833       case nxv8i1: return TypeSize::Scalable(8);
834       case i16 :
835       case f16:
836       case bf16:
837       case v16i1:
838       case v2i8:
839       case v1i16: return TypeSize::Fixed(16);
840       case nxv16i1:
841       case nxv2i8:
842       case nxv1i16:
843       case nxv1f16: return TypeSize::Scalable(16);
844       case f32 :
845       case i32 :
846       case v32i1:
847       case v4i8:
848       case v2i16:
849       case v2f16:
850       case v2bf16:
851       case v1f32:
852       case v1i32: return TypeSize::Fixed(32);
853       case nxv32i1:
854       case nxv4i8:
855       case nxv2i16:
856       case nxv1i32:
857       case nxv2f16:
858       case nxv2bf16:
859       case nxv1f32: return TypeSize::Scalable(32);
860       case v3i16:
861       case v3f16:
862       case v3bf16: return TypeSize::Fixed(48);
863       case x86mmx:
864       case f64 :
865       case i64 :
866       case v64i1:
867       case v8i8:
868       case v4i16:
869       case v2i32:
870       case v1i64:
871       case v4f16:
872       case v4bf16:
873       case v2f32:
874       case v1f64: return TypeSize::Fixed(64);
875       case nxv64i1:
876       case nxv8i8:
877       case nxv4i16:
878       case nxv2i32:
879       case nxv1i64:
880       case nxv4f16:
881       case nxv4bf16:
882       case nxv2f32:
883       case nxv1f64: return TypeSize::Scalable(64);
884       case f80 :  return TypeSize::Fixed(80);
885       case v3i32:
886       case v3f32: return TypeSize::Fixed(96);
887       case f128:
888       case ppcf128:
889       case i128:
890       case v128i1:
891       case v16i8:
892       case v8i16:
893       case v4i32:
894       case v2i64:
895       case v1i128:
896       case v8f16:
897       case v8bf16:
898       case v4f32:
899       case v2f64: return TypeSize::Fixed(128);
900       case nxv16i8:
901       case nxv8i16:
902       case nxv4i32:
903       case nxv2i64:
904       case nxv8f16:
905       case nxv8bf16:
906       case nxv4f32:
907       case nxv2f64: return TypeSize::Scalable(128);
908       case v5i32:
909       case v5f32: return TypeSize::Fixed(160);
910       case v256i1:
911       case v32i8:
912       case v16i16:
913       case v8i32:
914       case v4i64:
915       case v16f16:
916       case v16bf16:
917       case v8f32:
918       case v4f64: return TypeSize::Fixed(256);
919       case nxv32i8:
920       case nxv16i16:
921       case nxv8i32:
922       case nxv4i64:
923       case nxv16f16:
924       case nxv8f32:
925       case nxv4f64: return TypeSize::Scalable(256);
926       case v512i1:
927       case v64i8:
928       case v32i16:
929       case v16i32:
930       case v8i64:
931       case v32f16:
932       case v32bf16:
933       case v16f32:
934       case v8f64: return TypeSize::Fixed(512);
935       case nxv64i8:
936       case nxv32i16:
937       case nxv16i32:
938       case nxv8i64:
939       case nxv32f16:
940       case nxv16f32:
941       case nxv8f64: return TypeSize::Scalable(512);
942       case v1024i1:
943       case v128i8:
944       case v64i16:
945       case v32i32:
946       case v16i64:
947       case v64f16:
948       case v64bf16:
949       case v32f32:
950       case v16f64: return TypeSize::Fixed(1024);
951       case nxv32i32:
952       case nxv16i64: return TypeSize::Scalable(1024);
953       case v256i8:
954       case v128i16:
955       case v64i32:
956       case v32i64:
957       case v128f16:
958       case v128bf16:
959       case v64f32:
960       case v32f64: return TypeSize::Fixed(2048);
961       case nxv32i64: return TypeSize::Scalable(2048);
962       case v128i32:
963       case v64i64:
964       case v128f32:
965       case v64f64:  return TypeSize::Fixed(4096);
966       case v256i32:
967       case v128i64:
968       case v256f32:
969       case v128f64:  return TypeSize::Fixed(8192);
970       case v512i32:
971       case v256i64:
972       case v512f32:
973       case v256f64:  return TypeSize::Fixed(16384);
974       case v1024i32:
975       case v1024f32:  return TypeSize::Fixed(32768);
976       case v2048i32:
977       case v2048f32:  return TypeSize::Fixed(65536);
978       case exnref:
979       case funcref:
980       case externref: return TypeSize::Fixed(0); // opaque type
981       }
982     }
983 
984     /// Return the size of the specified fixed width value type in bits. The
985     /// function will assert if the type is scalable.
getFixedSizeInBits()986     uint64_t getFixedSizeInBits() const {
987       return getSizeInBits().getFixedSize();
988     }
989 
getScalarSizeInBits()990     uint64_t getScalarSizeInBits() const {
991       return getScalarType().getSizeInBits().getFixedSize();
992     }
993 
994     /// Return the number of bytes overwritten by a store of the specified value
995     /// type.
996     ///
997     /// If the value type is a scalable vector type, the scalable property will
998     /// be set and the runtime size will be a positive integer multiple of the
999     /// base size.
getStoreSize()1000     TypeSize getStoreSize() const {
1001       TypeSize BaseSize = getSizeInBits();
1002       return {(BaseSize.getKnownMinSize() + 7) / 8, BaseSize.isScalable()};
1003     }
1004 
1005     /// Return the number of bits overwritten by a store of the specified value
1006     /// type.
1007     ///
1008     /// If the value type is a scalable vector type, the scalable property will
1009     /// be set and the runtime size will be a positive integer multiple of the
1010     /// base size.
getStoreSizeInBits()1011     TypeSize getStoreSizeInBits() const {
1012       return getStoreSize() * 8;
1013     }
1014 
1015     /// Returns true if the number of bits for the type is a multiple of an
1016     /// 8-bit byte.
isByteSized()1017     bool isByteSized() const { return getSizeInBits().isKnownMultipleOf(8); }
1018 
1019     /// Return true if we know at compile time this has more bits than VT.
knownBitsGT(MVT VT)1020     bool knownBitsGT(MVT VT) const {
1021       return TypeSize::isKnownGT(getSizeInBits(), VT.getSizeInBits());
1022     }
1023 
1024     /// Return true if we know at compile time this has more than or the same
1025     /// bits as VT.
knownBitsGE(MVT VT)1026     bool knownBitsGE(MVT VT) const {
1027       return TypeSize::isKnownGE(getSizeInBits(), VT.getSizeInBits());
1028     }
1029 
1030     /// Return true if we know at compile time this has fewer bits than VT.
knownBitsLT(MVT VT)1031     bool knownBitsLT(MVT VT) const {
1032       return TypeSize::isKnownLT(getSizeInBits(), VT.getSizeInBits());
1033     }
1034 
1035     /// Return true if we know at compile time this has fewer than or the same
1036     /// bits as VT.
knownBitsLE(MVT VT)1037     bool knownBitsLE(MVT VT) const {
1038       return TypeSize::isKnownLE(getSizeInBits(), VT.getSizeInBits());
1039     }
1040 
1041     /// Return true if this has more bits than VT.
bitsGT(MVT VT)1042     bool bitsGT(MVT VT) const {
1043       assert(isScalableVector() == VT.isScalableVector() &&
1044              "Comparison between scalable and fixed types");
1045       return knownBitsGT(VT);
1046     }
1047 
1048     /// Return true if this has no less bits than VT.
bitsGE(MVT VT)1049     bool bitsGE(MVT VT) const {
1050       assert(isScalableVector() == VT.isScalableVector() &&
1051              "Comparison between scalable and fixed types");
1052       return knownBitsGE(VT);
1053     }
1054 
1055     /// Return true if this has less bits than VT.
bitsLT(MVT VT)1056     bool bitsLT(MVT VT) const {
1057       assert(isScalableVector() == VT.isScalableVector() &&
1058              "Comparison between scalable and fixed types");
1059       return knownBitsLT(VT);
1060     }
1061 
1062     /// Return true if this has no more bits than VT.
bitsLE(MVT VT)1063     bool bitsLE(MVT VT) const {
1064       assert(isScalableVector() == VT.isScalableVector() &&
1065              "Comparison between scalable and fixed types");
1066       return knownBitsLE(VT);
1067     }
1068 
getFloatingPointVT(unsigned BitWidth)1069     static MVT getFloatingPointVT(unsigned BitWidth) {
1070       switch (BitWidth) {
1071       default:
1072         llvm_unreachable("Bad bit width!");
1073       case 16:
1074         return MVT::f16;
1075       case 32:
1076         return MVT::f32;
1077       case 64:
1078         return MVT::f64;
1079       case 80:
1080         return MVT::f80;
1081       case 128:
1082         return MVT::f128;
1083       }
1084     }
1085 
getIntegerVT(unsigned BitWidth)1086     static MVT getIntegerVT(unsigned BitWidth) {
1087       switch (BitWidth) {
1088       default:
1089         return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
1090       case 1:
1091         return MVT::i1;
1092       case 8:
1093         return MVT::i8;
1094       case 16:
1095         return MVT::i16;
1096       case 32:
1097         return MVT::i32;
1098       case 64:
1099         return MVT::i64;
1100       case 128:
1101         return MVT::i128;
1102       }
1103     }
1104 
getVectorVT(MVT VT,unsigned NumElements)1105     static MVT getVectorVT(MVT VT, unsigned NumElements) {
1106       switch (VT.SimpleTy) {
1107       default:
1108         break;
1109       case MVT::i1:
1110         if (NumElements == 1)    return MVT::v1i1;
1111         if (NumElements == 2)    return MVT::v2i1;
1112         if (NumElements == 4)    return MVT::v4i1;
1113         if (NumElements == 8)    return MVT::v8i1;
1114         if (NumElements == 16)   return MVT::v16i1;
1115         if (NumElements == 32)   return MVT::v32i1;
1116         if (NumElements == 64)   return MVT::v64i1;
1117         if (NumElements == 128)  return MVT::v128i1;
1118         if (NumElements == 256)  return MVT::v256i1;
1119         if (NumElements == 512)  return MVT::v512i1;
1120         if (NumElements == 1024) return MVT::v1024i1;
1121         break;
1122       case MVT::i8:
1123         if (NumElements == 1)   return MVT::v1i8;
1124         if (NumElements == 2)   return MVT::v2i8;
1125         if (NumElements == 4)   return MVT::v4i8;
1126         if (NumElements == 8)   return MVT::v8i8;
1127         if (NumElements == 16)  return MVT::v16i8;
1128         if (NumElements == 32)  return MVT::v32i8;
1129         if (NumElements == 64)  return MVT::v64i8;
1130         if (NumElements == 128) return MVT::v128i8;
1131         if (NumElements == 256) return MVT::v256i8;
1132         break;
1133       case MVT::i16:
1134         if (NumElements == 1)   return MVT::v1i16;
1135         if (NumElements == 2)   return MVT::v2i16;
1136         if (NumElements == 3)   return MVT::v3i16;
1137         if (NumElements == 4)   return MVT::v4i16;
1138         if (NumElements == 8)   return MVT::v8i16;
1139         if (NumElements == 16)  return MVT::v16i16;
1140         if (NumElements == 32)  return MVT::v32i16;
1141         if (NumElements == 64)  return MVT::v64i16;
1142         if (NumElements == 128) return MVT::v128i16;
1143         break;
1144       case MVT::i32:
1145         if (NumElements == 1)    return MVT::v1i32;
1146         if (NumElements == 2)    return MVT::v2i32;
1147         if (NumElements == 3)    return MVT::v3i32;
1148         if (NumElements == 4)    return MVT::v4i32;
1149         if (NumElements == 5)    return MVT::v5i32;
1150         if (NumElements == 8)    return MVT::v8i32;
1151         if (NumElements == 16)   return MVT::v16i32;
1152         if (NumElements == 32)   return MVT::v32i32;
1153         if (NumElements == 64)   return MVT::v64i32;
1154         if (NumElements == 128)  return MVT::v128i32;
1155         if (NumElements == 256)  return MVT::v256i32;
1156         if (NumElements == 512)  return MVT::v512i32;
1157         if (NumElements == 1024) return MVT::v1024i32;
1158         if (NumElements == 2048) return MVT::v2048i32;
1159         break;
1160       case MVT::i64:
1161         if (NumElements == 1)  return MVT::v1i64;
1162         if (NumElements == 2)  return MVT::v2i64;
1163         if (NumElements == 4)  return MVT::v4i64;
1164         if (NumElements == 8)  return MVT::v8i64;
1165         if (NumElements == 16) return MVT::v16i64;
1166         if (NumElements == 32) return MVT::v32i64;
1167         if (NumElements == 64) return MVT::v64i64;
1168         if (NumElements == 128) return MVT::v128i64;
1169         if (NumElements == 256) return MVT::v256i64;
1170         break;
1171       case MVT::i128:
1172         if (NumElements == 1)  return MVT::v1i128;
1173         break;
1174       case MVT::f16:
1175         if (NumElements == 2)   return MVT::v2f16;
1176         if (NumElements == 3)   return MVT::v3f16;
1177         if (NumElements == 4)   return MVT::v4f16;
1178         if (NumElements == 8)   return MVT::v8f16;
1179         if (NumElements == 16)  return MVT::v16f16;
1180         if (NumElements == 32)  return MVT::v32f16;
1181         if (NumElements == 64)  return MVT::v64f16;
1182         if (NumElements == 128) return MVT::v128f16;
1183         break;
1184       case MVT::bf16:
1185         if (NumElements == 2)   return MVT::v2bf16;
1186         if (NumElements == 3)   return MVT::v3bf16;
1187         if (NumElements == 4)   return MVT::v4bf16;
1188         if (NumElements == 8)   return MVT::v8bf16;
1189         if (NumElements == 16)  return MVT::v16bf16;
1190         if (NumElements == 32)  return MVT::v32bf16;
1191         if (NumElements == 64)  return MVT::v64bf16;
1192         if (NumElements == 128) return MVT::v128bf16;
1193         break;
1194       case MVT::f32:
1195         if (NumElements == 1)    return MVT::v1f32;
1196         if (NumElements == 2)    return MVT::v2f32;
1197         if (NumElements == 3)    return MVT::v3f32;
1198         if (NumElements == 4)    return MVT::v4f32;
1199         if (NumElements == 5)    return MVT::v5f32;
1200         if (NumElements == 8)    return MVT::v8f32;
1201         if (NumElements == 16)   return MVT::v16f32;
1202         if (NumElements == 32)   return MVT::v32f32;
1203         if (NumElements == 64)   return MVT::v64f32;
1204         if (NumElements == 128)  return MVT::v128f32;
1205         if (NumElements == 256)  return MVT::v256f32;
1206         if (NumElements == 512)  return MVT::v512f32;
1207         if (NumElements == 1024) return MVT::v1024f32;
1208         if (NumElements == 2048) return MVT::v2048f32;
1209         break;
1210       case MVT::f64:
1211         if (NumElements == 1)  return MVT::v1f64;
1212         if (NumElements == 2)  return MVT::v2f64;
1213         if (NumElements == 4)  return MVT::v4f64;
1214         if (NumElements == 8)  return MVT::v8f64;
1215         if (NumElements == 16) return MVT::v16f64;
1216         if (NumElements == 32) return MVT::v32f64;
1217         if (NumElements == 64) return MVT::v64f64;
1218         if (NumElements == 128) return MVT::v128f64;
1219         if (NumElements == 256) return MVT::v256f64;
1220         break;
1221       }
1222       return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
1223     }
1224 
getScalableVectorVT(MVT VT,unsigned NumElements)1225     static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
1226       switch(VT.SimpleTy) {
1227         default:
1228           break;
1229         case MVT::i1:
1230           if (NumElements == 1)  return MVT::nxv1i1;
1231           if (NumElements == 2)  return MVT::nxv2i1;
1232           if (NumElements == 4)  return MVT::nxv4i1;
1233           if (NumElements == 8)  return MVT::nxv8i1;
1234           if (NumElements == 16) return MVT::nxv16i1;
1235           if (NumElements == 32) return MVT::nxv32i1;
1236           if (NumElements == 64) return MVT::nxv64i1;
1237           break;
1238         case MVT::i8:
1239           if (NumElements == 1)  return MVT::nxv1i8;
1240           if (NumElements == 2)  return MVT::nxv2i8;
1241           if (NumElements == 4)  return MVT::nxv4i8;
1242           if (NumElements == 8)  return MVT::nxv8i8;
1243           if (NumElements == 16) return MVT::nxv16i8;
1244           if (NumElements == 32) return MVT::nxv32i8;
1245           if (NumElements == 64) return MVT::nxv64i8;
1246           break;
1247         case MVT::i16:
1248           if (NumElements == 1)  return MVT::nxv1i16;
1249           if (NumElements == 2)  return MVT::nxv2i16;
1250           if (NumElements == 4)  return MVT::nxv4i16;
1251           if (NumElements == 8)  return MVT::nxv8i16;
1252           if (NumElements == 16) return MVT::nxv16i16;
1253           if (NumElements == 32) return MVT::nxv32i16;
1254           break;
1255         case MVT::i32:
1256           if (NumElements == 1)  return MVT::nxv1i32;
1257           if (NumElements == 2)  return MVT::nxv2i32;
1258           if (NumElements == 4)  return MVT::nxv4i32;
1259           if (NumElements == 8)  return MVT::nxv8i32;
1260           if (NumElements == 16) return MVT::nxv16i32;
1261           if (NumElements == 32) return MVT::nxv32i32;
1262           break;
1263         case MVT::i64:
1264           if (NumElements == 1)  return MVT::nxv1i64;
1265           if (NumElements == 2)  return MVT::nxv2i64;
1266           if (NumElements == 4)  return MVT::nxv4i64;
1267           if (NumElements == 8)  return MVT::nxv8i64;
1268           if (NumElements == 16) return MVT::nxv16i64;
1269           if (NumElements == 32) return MVT::nxv32i64;
1270           break;
1271         case MVT::f16:
1272           if (NumElements == 1)  return MVT::nxv1f16;
1273           if (NumElements == 2)  return MVT::nxv2f16;
1274           if (NumElements == 4)  return MVT::nxv4f16;
1275           if (NumElements == 8)  return MVT::nxv8f16;
1276           if (NumElements == 16)  return MVT::nxv16f16;
1277           if (NumElements == 32)  return MVT::nxv32f16;
1278           break;
1279         case MVT::bf16:
1280           if (NumElements == 2)  return MVT::nxv2bf16;
1281           if (NumElements == 4)  return MVT::nxv4bf16;
1282           if (NumElements == 8)  return MVT::nxv8bf16;
1283           break;
1284         case MVT::f32:
1285           if (NumElements == 1)  return MVT::nxv1f32;
1286           if (NumElements == 2)  return MVT::nxv2f32;
1287           if (NumElements == 4)  return MVT::nxv4f32;
1288           if (NumElements == 8)  return MVT::nxv8f32;
1289           if (NumElements == 16) return MVT::nxv16f32;
1290           break;
1291         case MVT::f64:
1292           if (NumElements == 1)  return MVT::nxv1f64;
1293           if (NumElements == 2)  return MVT::nxv2f64;
1294           if (NumElements == 4)  return MVT::nxv4f64;
1295           if (NumElements == 8)  return MVT::nxv8f64;
1296           break;
1297       }
1298       return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
1299     }
1300 
getVectorVT(MVT VT,unsigned NumElements,bool IsScalable)1301     static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable) {
1302       if (IsScalable)
1303         return getScalableVectorVT(VT, NumElements);
1304       return getVectorVT(VT, NumElements);
1305     }
1306 
getVectorVT(MVT VT,ElementCount EC)1307     static MVT getVectorVT(MVT VT, ElementCount EC) {
1308       if (EC.isScalable())
1309         return getScalableVectorVT(VT, EC.getKnownMinValue());
1310       return getVectorVT(VT, EC.getKnownMinValue());
1311     }
1312 
1313     /// Return the value type corresponding to the specified type.  This returns
1314     /// all pointers as iPTR.  If HandleUnknown is true, unknown types are
1315     /// returned as Other, otherwise they are invalid.
1316     static MVT getVT(Type *Ty, bool HandleUnknown = false);
1317 
1318   private:
1319     /// A simple iterator over the MVT::SimpleValueType enum.
1320     struct mvt_iterator {
1321       SimpleValueType VT;
1322 
mvt_iteratormvt_iterator1323       mvt_iterator(SimpleValueType VT) : VT(VT) {}
1324 
1325       MVT operator*() const { return VT; }
1326       bool operator!=(const mvt_iterator &LHS) const { return VT != LHS.VT; }
1327 
1328       mvt_iterator& operator++() {
1329         VT = (MVT::SimpleValueType)((int)VT + 1);
1330         assert((int)VT <= MVT::MAX_ALLOWED_VALUETYPE &&
1331                "MVT iterator overflowed.");
1332         return *this;
1333       }
1334     };
1335 
1336     /// A range of the MVT::SimpleValueType enum.
1337     using mvt_range = iterator_range<mvt_iterator>;
1338 
1339   public:
1340     /// SimpleValueType Iteration
1341     /// @{
all_valuetypes()1342     static mvt_range all_valuetypes() {
1343       return mvt_range(MVT::FIRST_VALUETYPE, MVT::LAST_VALUETYPE);
1344     }
1345 
integer_valuetypes()1346     static mvt_range integer_valuetypes() {
1347       return mvt_range(MVT::FIRST_INTEGER_VALUETYPE,
1348                        (MVT::SimpleValueType)(MVT::LAST_INTEGER_VALUETYPE + 1));
1349     }
1350 
fp_valuetypes()1351     static mvt_range fp_valuetypes() {
1352       return mvt_range(MVT::FIRST_FP_VALUETYPE,
1353                        (MVT::SimpleValueType)(MVT::LAST_FP_VALUETYPE + 1));
1354     }
1355 
vector_valuetypes()1356     static mvt_range vector_valuetypes() {
1357       return mvt_range(MVT::FIRST_VECTOR_VALUETYPE,
1358                        (MVT::SimpleValueType)(MVT::LAST_VECTOR_VALUETYPE + 1));
1359     }
1360 
fixedlen_vector_valuetypes()1361     static mvt_range fixedlen_vector_valuetypes() {
1362       return mvt_range(
1363                MVT::FIRST_FIXEDLEN_VECTOR_VALUETYPE,
1364                (MVT::SimpleValueType)(MVT::LAST_FIXEDLEN_VECTOR_VALUETYPE + 1));
1365     }
1366 
scalable_vector_valuetypes()1367     static mvt_range scalable_vector_valuetypes() {
1368       return mvt_range(
1369                MVT::FIRST_SCALABLE_VECTOR_VALUETYPE,
1370                (MVT::SimpleValueType)(MVT::LAST_SCALABLE_VECTOR_VALUETYPE + 1));
1371     }
1372 
integer_fixedlen_vector_valuetypes()1373     static mvt_range integer_fixedlen_vector_valuetypes() {
1374       return mvt_range(
1375        MVT::FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE,
1376        (MVT::SimpleValueType)(MVT::LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE + 1));
1377     }
1378 
fp_fixedlen_vector_valuetypes()1379     static mvt_range fp_fixedlen_vector_valuetypes() {
1380       return mvt_range(
1381           MVT::FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE,
1382           (MVT::SimpleValueType)(MVT::LAST_FP_FIXEDLEN_VECTOR_VALUETYPE + 1));
1383     }
1384 
integer_scalable_vector_valuetypes()1385     static mvt_range integer_scalable_vector_valuetypes() {
1386       return mvt_range(
1387        MVT::FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE,
1388        (MVT::SimpleValueType)(MVT::LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE + 1));
1389     }
1390 
fp_scalable_vector_valuetypes()1391     static mvt_range fp_scalable_vector_valuetypes() {
1392       return mvt_range(
1393             MVT::FIRST_FP_SCALABLE_VECTOR_VALUETYPE,
1394             (MVT::SimpleValueType)(MVT::LAST_FP_SCALABLE_VECTOR_VALUETYPE + 1));
1395     }
1396     /// @}
1397   };
1398 
1399 } // end namespace llvm
1400 
1401 #endif // LLVM_CODEGEN_MACHINEVALUETYPE_H
1402