• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===- Support/MachineValueType.h - Machine-Level types ---------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the set of machine-level target independent types which
11 // legal values in the code generator use.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_SUPPORT_MACHINEVALUETYPE_H
16 #define LLVM_SUPPORT_MACHINEVALUETYPE_H
17 
18 #include "llvm/ADT/iterator_range.h"
19 #include "llvm/Support/ErrorHandling.h"
20 #include "llvm/Support/MathExtras.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       f16            =   8,   // This is a 16 bit floating point value
51       f32            =   9,   // This is a 32 bit floating point value
52       f64            =  10,   // This is a 64 bit floating point value
53       f80            =  11,   // This is a 80 bit floating point value
54       f128           =  12,   // This is a 128 bit floating point value
55       ppcf128        =  13,   // This is a PPC 128-bit floating point value
56 
57       FIRST_FP_VALUETYPE = f16,
58       LAST_FP_VALUETYPE  = ppcf128,
59 
60       v1i1           =  14,   //    1 x i1
61       v2i1           =  15,   //    2 x i1
62       v4i1           =  16,   //    4 x i1
63       v8i1           =  17,   //    8 x i1
64       v16i1          =  18,   //   16 x i1
65       v32i1          =  19,   //   32 x i1
66       v64i1          =  20,   //   64 x i1
67       v128i1         =  21,   //  128 x i1
68       v512i1         =  22,   //  512 x i1
69       v1024i1        =  23,   // 1024 x i1
70 
71       v1i8           =  24,   //  1 x i8
72       v2i8           =  25,   //  2 x i8
73       v4i8           =  26,   //  4 x i8
74       v8i8           =  27,   //  8 x i8
75       v16i8          =  28,   // 16 x i8
76       v32i8          =  29,   // 32 x i8
77       v64i8          =  30,   // 64 x i8
78       v128i8         =  31,   //128 x i8
79       v256i8         =  32,   //256 x i8
80 
81       v1i16          =  33,   //  1 x i16
82       v2i16          =  34,   //  2 x i16
83       v4i16          =  35,   //  4 x i16
84       v8i16          =  36,   //  8 x i16
85       v16i16         =  37,   // 16 x i16
86       v32i16         =  38,   // 32 x i16
87       v64i16         =  39,   // 64 x i16
88       v128i16        =  40,   //128 x i16
89 
90       v1i32          =  41,   //  1 x i32
91       v2i32          =  42,   //  2 x i32
92       v4i32          =  43,   //  4 x i32
93       v8i32          =  44,   //  8 x i32
94       v16i32         =  45,   // 16 x i32
95       v32i32         =  46,   // 32 x i32
96       v64i32         =  47,   // 64 x i32
97 
98       v1i64          =  48,   //  1 x i64
99       v2i64          =  49,   //  2 x i64
100       v4i64          =  50,   //  4 x i64
101       v8i64          =  51,   //  8 x i64
102       v16i64         =  52,   // 16 x i64
103       v32i64         =  53,   // 32 x i64
104 
105       v1i128         =  54,   //  1 x i128
106 
107       // Scalable integer types
108       nxv1i1         =  55,   // n x  1 x i1
109       nxv2i1         =  56,   // n x  2 x i1
110       nxv4i1         =  57,   // n x  4 x i1
111       nxv8i1         =  58,   // n x  8 x i1
112       nxv16i1        =  59,   // n x 16 x i1
113       nxv32i1        =  60,   // n x 32 x i1
114 
115       nxv1i8         =  61,   // n x  1 x i8
116       nxv2i8         =  62,   // n x  2 x i8
117       nxv4i8         =  63,   // n x  4 x i8
118       nxv8i8         =  64,   // n x  8 x i8
119       nxv16i8        =  65,   // n x 16 x i8
120       nxv32i8        =  66,   // n x 32 x i8
121 
122       nxv1i16        =  67,   // n x  1 x i16
123       nxv2i16        =  68,   // n x  2 x i16
124       nxv4i16        =  69,   // n x  4 x i16
125       nxv8i16        =  70,   // n x  8 x i16
126       nxv16i16       =  71,   // n x 16 x i16
127       nxv32i16       =  72,   // n x 32 x i16
128 
129       nxv1i32        =  73,   // n x  1 x i32
130       nxv2i32        =  74,   // n x  2 x i32
131       nxv4i32        =  75,   // n x  4 x i32
132       nxv8i32        =  76,   // n x  8 x i32
133       nxv16i32       =  77,   // n x 16 x i32
134       nxv32i32       =  78,   // n x 32 x i32
135 
136       nxv1i64        =  79,   // n x  1 x i64
137       nxv2i64        =  80,   // n x  2 x i64
138       nxv4i64        =  81,   // n x  4 x i64
139       nxv8i64        =  82,   // n x  8 x i64
140       nxv16i64       =  83,   // n x 16 x i64
141       nxv32i64       =  84,   // n x 32 x i64
142 
143       FIRST_INTEGER_VECTOR_VALUETYPE = v1i1,
144       LAST_INTEGER_VECTOR_VALUETYPE = nxv32i64,
145 
146       FIRST_INTEGER_SCALABLE_VALUETYPE = nxv1i1,
147       LAST_INTEGER_SCALABLE_VALUETYPE = nxv32i64,
148 
149       v2f16          =  85,   //  2 x f16
150       v4f16          =  86,   //  4 x f16
151       v8f16          =  87,   //  8 x f16
152       v1f32          =  88,   //  1 x f32
153       v2f32          =  89,   //  2 x f32
154       v4f32          =  90,   //  4 x f32
155       v8f32          =  91,   //  8 x f32
156       v16f32         =  92,   // 16 x f32
157       v1f64          =  93,   //  1 x f64
158       v2f64          =  94,   //  2 x f64
159       v4f64          =  95,   //  4 x f64
160       v8f64          =  96,   //  8 x f64
161 
162       nxv2f16        =  97,   // n x  2 x f16
163       nxv4f16        =  98,   // n x  4 x f16
164       nxv8f16        =  99,   // n x  8 x f16
165       nxv1f32        = 100,   // n x  1 x f32
166       nxv2f32        = 101,   // n x  2 x f32
167       nxv4f32        = 102,   // n x  4 x f32
168       nxv8f32        = 103,   // n x  8 x f32
169       nxv16f32       = 104,   // n x 16 x f32
170       nxv1f64        = 105,   // n x  1 x f64
171       nxv2f64        = 106,   // n x  2 x f64
172       nxv4f64        = 107,   // n x  4 x f64
173       nxv8f64        = 108,   // n x  8 x f64
174 
175       FIRST_FP_VECTOR_VALUETYPE = v2f16,
176       LAST_FP_VECTOR_VALUETYPE = nxv8f64,
177 
178       FIRST_FP_SCALABLE_VALUETYPE = nxv2f16,
179       LAST_FP_SCALABLE_VALUETYPE = nxv8f64,
180 
181       FIRST_VECTOR_VALUETYPE = v1i1,
182       LAST_VECTOR_VALUETYPE  = nxv8f64,
183 
184       x86mmx         =  109,   // This is an X86 MMX value
185 
186       Glue           =  110,   // This glues nodes together during pre-RA sched
187 
188       isVoid         =  111,   // This has no value
189 
190       Untyped        =  112,   // This value takes a register, but has
191                                // unspecified type.  The register class
192                                // will be determined by the opcode.
193 
194       ExceptRef      = 113,    // WebAssembly's except_ref type
195 
196       FIRST_VALUETYPE = 1,     // This is always the beginning of the list.
197       LAST_VALUETYPE =  114,   // This always remains at the end of the list.
198 
199       // This is the current maximum for LAST_VALUETYPE.
200       // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
201       // This value must be a multiple of 32.
202       MAX_ALLOWED_VALUETYPE = 128,
203 
204       // A value of type llvm::TokenTy
205       token          = 248,
206 
207       // This is MDNode or MDString.
208       Metadata       = 249,
209 
210       // An int value the size of the pointer of the current
211       // target to any address space. This must only be used internal to
212       // tblgen. Other than for overloading, we treat iPTRAny the same as iPTR.
213       iPTRAny        = 250,
214 
215       // A vector with any length and element size. This is used
216       // for intrinsics that have overloadings based on vector types.
217       // This is only for tblgen's consumption!
218       vAny           = 251,
219 
220       // Any floating-point or vector floating-point value. This is used
221       // for intrinsics that have overloadings based on floating-point types.
222       // This is only for tblgen's consumption!
223       fAny           = 252,
224 
225       // An integer or vector integer value of any bit width. This is
226       // used for intrinsics that have overloadings based on integer bit widths.
227       // This is only for tblgen's consumption!
228       iAny           = 253,
229 
230       // An int value the size of the pointer of the current
231       // target.  This should only be used internal to tblgen!
232       iPTR           = 254,
233 
234       // Any type. This is used for intrinsics that have overloadings.
235       // This is only for tblgen's consumption!
236       Any            = 255
237     };
238 
239     SimpleValueType SimpleTy = INVALID_SIMPLE_VALUE_TYPE;
240 
241     // A class to represent the number of elements in a vector
242     //
243     // For fixed-length vectors, the total number of elements is equal to 'Min'
244     // For scalable vectors, the total number of elements is a multiple of 'Min'
245     class ElementCount {
246     public:
247       unsigned Min;
248       bool Scalable;
249 
ElementCount(unsigned Min,bool Scalable)250       ElementCount(unsigned Min, bool Scalable)
251       : Min(Min), Scalable(Scalable) {}
252 
253       ElementCount operator*(unsigned RHS) {
254         return { Min * RHS, Scalable };
255       }
256 
257       ElementCount& operator*=(unsigned RHS) {
258         Min *= RHS;
259         return *this;
260       }
261 
262       ElementCount operator/(unsigned RHS) {
263         return { Min / RHS, Scalable };
264       }
265 
266       ElementCount& operator/=(unsigned RHS) {
267         Min /= RHS;
268         return *this;
269       }
270 
271       bool operator==(const ElementCount& RHS) {
272         return Min == RHS.Min && Scalable == RHS.Scalable;
273       }
274     };
275 
276     constexpr MVT() = default;
MVT(SimpleValueType SVT)277     constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {}
278 
279     bool operator>(const MVT& S)  const { return SimpleTy >  S.SimpleTy; }
280     bool operator<(const MVT& S)  const { return SimpleTy <  S.SimpleTy; }
281     bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; }
282     bool operator!=(const MVT& S) const { return SimpleTy != S.SimpleTy; }
283     bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; }
284     bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; }
285 
286     /// Return true if this is a valid simple valuetype.
isValid()287     bool isValid() const {
288       return (SimpleTy >= MVT::FIRST_VALUETYPE &&
289               SimpleTy < MVT::LAST_VALUETYPE);
290     }
291 
292     /// Return true if this is a FP or a vector FP type.
isFloatingPoint()293     bool isFloatingPoint() const {
294       return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE &&
295                SimpleTy <= MVT::LAST_FP_VALUETYPE) ||
296               (SimpleTy >= MVT::FIRST_FP_VECTOR_VALUETYPE &&
297                SimpleTy <= MVT::LAST_FP_VECTOR_VALUETYPE));
298     }
299 
300     /// Return true if this is an integer or a vector integer type.
isInteger()301     bool isInteger() const {
302       return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
303                SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) ||
304               (SimpleTy >= MVT::FIRST_INTEGER_VECTOR_VALUETYPE &&
305                SimpleTy <= MVT::LAST_INTEGER_VECTOR_VALUETYPE));
306     }
307 
308     /// Return true if this is an integer, not including vectors.
isScalarInteger()309     bool isScalarInteger() const {
310       return (SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
311               SimpleTy <= MVT::LAST_INTEGER_VALUETYPE);
312     }
313 
314     /// Return true if this is a vector value type.
isVector()315     bool isVector() const {
316       return (SimpleTy >= MVT::FIRST_VECTOR_VALUETYPE &&
317               SimpleTy <= MVT::LAST_VECTOR_VALUETYPE);
318     }
319 
320     /// Return true if this is a vector value type where the
321     /// runtime length is machine dependent
isScalableVector()322     bool isScalableVector() const {
323       return ((SimpleTy >= MVT::FIRST_INTEGER_SCALABLE_VALUETYPE &&
324                SimpleTy <= MVT::LAST_INTEGER_SCALABLE_VALUETYPE) ||
325               (SimpleTy >= MVT::FIRST_FP_SCALABLE_VALUETYPE &&
326                SimpleTy <= MVT::LAST_FP_SCALABLE_VALUETYPE));
327     }
328 
329     /// Return true if this is a 16-bit vector type.
is16BitVector()330     bool is16BitVector() const {
331       return (SimpleTy == MVT::v2i8  || SimpleTy == MVT::v1i16 ||
332               SimpleTy == MVT::v16i1);
333     }
334 
335     /// Return true if this is a 32-bit vector type.
is32BitVector()336     bool is32BitVector() const {
337       return (SimpleTy == MVT::v32i1 || SimpleTy == MVT::v4i8  ||
338               SimpleTy == MVT::v2i16 || SimpleTy == MVT::v1i32 ||
339               SimpleTy == MVT::v2f16 || SimpleTy == MVT::v1f32);
340     }
341 
342     /// Return true if this is a 64-bit vector type.
is64BitVector()343     bool is64BitVector() const {
344       return (SimpleTy == MVT::v64i1 || SimpleTy == MVT::v8i8  ||
345               SimpleTy == MVT::v4i16 || SimpleTy == MVT::v2i32 ||
346               SimpleTy == MVT::v1i64 || SimpleTy == MVT::v4f16 ||
347               SimpleTy == MVT::v2f32 || SimpleTy == MVT::v1f64);
348     }
349 
350     /// Return true if this is a 128-bit vector type.
is128BitVector()351     bool is128BitVector() const {
352       return (SimpleTy == MVT::v128i1 || SimpleTy == MVT::v16i8  ||
353               SimpleTy == MVT::v8i16  || SimpleTy == MVT::v4i32  ||
354               SimpleTy == MVT::v2i64  || SimpleTy == MVT::v1i128 ||
355               SimpleTy == MVT::v8f16  || SimpleTy == MVT::v4f32  ||
356               SimpleTy == MVT::v2f64);
357     }
358 
359     /// Return true if this is a 256-bit vector type.
is256BitVector()360     bool is256BitVector() const {
361       return (SimpleTy == MVT::v8f32 || SimpleTy == MVT::v4f64  ||
362               SimpleTy == MVT::v32i8 || SimpleTy == MVT::v16i16 ||
363               SimpleTy == MVT::v8i32 || SimpleTy == MVT::v4i64);
364     }
365 
366     /// Return true if this is a 512-bit vector type.
is512BitVector()367     bool is512BitVector() const {
368       return (SimpleTy == MVT::v16f32 || SimpleTy == MVT::v8f64  ||
369               SimpleTy == MVT::v512i1 || SimpleTy == MVT::v64i8  ||
370               SimpleTy == MVT::v32i16 || SimpleTy == MVT::v16i32 ||
371               SimpleTy == MVT::v8i64);
372     }
373 
374     /// Return true if this is a 1024-bit vector type.
is1024BitVector()375     bool is1024BitVector() const {
376       return (SimpleTy == MVT::v1024i1 || SimpleTy == MVT::v128i8 ||
377               SimpleTy == MVT::v64i16  || SimpleTy == MVT::v32i32 ||
378               SimpleTy == MVT::v16i64);
379     }
380 
381     /// Return true if this is a 2048-bit vector type.
is2048BitVector()382     bool is2048BitVector() const {
383       return (SimpleTy == MVT::v256i8 || SimpleTy == MVT::v128i16 ||
384               SimpleTy == MVT::v64i32 || SimpleTy == MVT::v32i64);
385     }
386 
387     /// Return true if this is an overloaded type for TableGen.
isOverloaded()388     bool isOverloaded() const {
389       return (SimpleTy==MVT::Any  ||
390               SimpleTy==MVT::iAny || SimpleTy==MVT::fAny ||
391               SimpleTy==MVT::vAny || SimpleTy==MVT::iPTRAny);
392     }
393 
394     /// Returns true if the given vector is a power of 2.
isPow2VectorType()395     bool isPow2VectorType() const {
396       unsigned NElts = getVectorNumElements();
397       return !(NElts & (NElts - 1));
398     }
399 
400     /// Widens the length of the given vector MVT up to the nearest power of 2
401     /// and returns that type.
getPow2VectorType()402     MVT getPow2VectorType() const {
403       if (isPow2VectorType())
404         return *this;
405 
406       unsigned NElts = getVectorNumElements();
407       unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts);
408       return MVT::getVectorVT(getVectorElementType(), Pow2NElts);
409     }
410 
411     /// If this is a vector, return the element type, otherwise return this.
getScalarType()412     MVT getScalarType() const {
413       return isVector() ? getVectorElementType() : *this;
414     }
415 
getVectorElementType()416     MVT getVectorElementType() const {
417       switch (SimpleTy) {
418       default:
419         llvm_unreachable("Not a vector MVT!");
420       case v1i1:
421       case v2i1:
422       case v4i1:
423       case v8i1:
424       case v16i1:
425       case v32i1:
426       case v64i1:
427       case v128i1:
428       case v512i1:
429       case v1024i1:
430       case nxv1i1:
431       case nxv2i1:
432       case nxv4i1:
433       case nxv8i1:
434       case nxv16i1:
435       case nxv32i1: return i1;
436       case v1i8:
437       case v2i8:
438       case v4i8:
439       case v8i8:
440       case v16i8:
441       case v32i8:
442       case v64i8:
443       case v128i8:
444       case v256i8:
445       case nxv1i8:
446       case nxv2i8:
447       case nxv4i8:
448       case nxv8i8:
449       case nxv16i8:
450       case nxv32i8: return i8;
451       case v1i16:
452       case v2i16:
453       case v4i16:
454       case v8i16:
455       case v16i16:
456       case v32i16:
457       case v64i16:
458       case v128i16:
459       case nxv1i16:
460       case nxv2i16:
461       case nxv4i16:
462       case nxv8i16:
463       case nxv16i16:
464       case nxv32i16: return i16;
465       case v1i32:
466       case v2i32:
467       case v4i32:
468       case v8i32:
469       case v16i32:
470       case v32i32:
471       case v64i32:
472       case nxv1i32:
473       case nxv2i32:
474       case nxv4i32:
475       case nxv8i32:
476       case nxv16i32:
477       case nxv32i32: return i32;
478       case v1i64:
479       case v2i64:
480       case v4i64:
481       case v8i64:
482       case v16i64:
483       case v32i64:
484       case nxv1i64:
485       case nxv2i64:
486       case nxv4i64:
487       case nxv8i64:
488       case nxv16i64:
489       case nxv32i64: return i64;
490       case v1i128: return i128;
491       case v2f16:
492       case v4f16:
493       case v8f16:
494       case nxv2f16:
495       case nxv4f16:
496       case nxv8f16: return f16;
497       case v1f32:
498       case v2f32:
499       case v4f32:
500       case v8f32:
501       case v16f32:
502       case nxv1f32:
503       case nxv2f32:
504       case nxv4f32:
505       case nxv8f32:
506       case nxv16f32: return f32;
507       case v1f64:
508       case v2f64:
509       case v4f64:
510       case v8f64:
511       case nxv1f64:
512       case nxv2f64:
513       case nxv4f64:
514       case nxv8f64: return f64;
515       }
516     }
517 
getVectorNumElements()518     unsigned getVectorNumElements() const {
519       switch (SimpleTy) {
520       default:
521         llvm_unreachable("Not a vector MVT!");
522       case v1024i1: return 1024;
523       case v512i1: return 512;
524       case v256i8: return 256;
525       case v128i1:
526       case v128i8:
527       case v128i16: return 128;
528       case v64i1:
529       case v64i8:
530       case v64i16:
531       case v64i32: return 64;
532       case v32i1:
533       case v32i8:
534       case v32i16:
535       case v32i32:
536       case v32i64:
537       case nxv32i1:
538       case nxv32i8:
539       case nxv32i16:
540       case nxv32i32:
541       case nxv32i64: return 32;
542       case v16i1:
543       case v16i8:
544       case v16i16:
545       case v16i32:
546       case v16i64:
547       case v16f32:
548       case nxv16i1:
549       case nxv16i8:
550       case nxv16i16:
551       case nxv16i32:
552       case nxv16i64:
553       case nxv16f32: return 16;
554       case v8i1:
555       case v8i8:
556       case v8i16:
557       case v8i32:
558       case v8i64:
559       case v8f16:
560       case v8f32:
561       case v8f64:
562       case nxv8i1:
563       case nxv8i8:
564       case nxv8i16:
565       case nxv8i32:
566       case nxv8i64:
567       case nxv8f16:
568       case nxv8f32:
569       case nxv8f64: return 8;
570       case v4i1:
571       case v4i8:
572       case v4i16:
573       case v4i32:
574       case v4i64:
575       case v4f16:
576       case v4f32:
577       case v4f64:
578       case nxv4i1:
579       case nxv4i8:
580       case nxv4i16:
581       case nxv4i32:
582       case nxv4i64:
583       case nxv4f16:
584       case nxv4f32:
585       case nxv4f64: return 4;
586       case v2i1:
587       case v2i8:
588       case v2i16:
589       case v2i32:
590       case v2i64:
591       case v2f16:
592       case v2f32:
593       case v2f64:
594       case nxv2i1:
595       case nxv2i8:
596       case nxv2i16:
597       case nxv2i32:
598       case nxv2i64:
599       case nxv2f16:
600       case nxv2f32:
601       case nxv2f64: return 2;
602       case v1i1:
603       case v1i8:
604       case v1i16:
605       case v1i32:
606       case v1i64:
607       case v1i128:
608       case v1f32:
609       case v1f64:
610       case nxv1i1:
611       case nxv1i8:
612       case nxv1i16:
613       case nxv1i32:
614       case nxv1i64:
615       case nxv1f32:
616       case nxv1f64: return 1;
617       }
618     }
619 
getVectorElementCount()620     MVT::ElementCount getVectorElementCount() const {
621       return { getVectorNumElements(), isScalableVector() };
622     }
623 
getSizeInBits()624     unsigned getSizeInBits() const {
625       switch (SimpleTy) {
626       default:
627         llvm_unreachable("getSizeInBits called on extended MVT.");
628       case Other:
629         llvm_unreachable("Value type is non-standard value, Other.");
630       case iPTR:
631         llvm_unreachable("Value type size is target-dependent. Ask TLI.");
632       case iPTRAny:
633       case iAny:
634       case fAny:
635       case vAny:
636       case Any:
637         llvm_unreachable("Value type is overloaded.");
638       case token:
639         llvm_unreachable("Token type is a sentinel that cannot be used "
640                          "in codegen and has no size");
641       case Metadata:
642         llvm_unreachable("Value type is metadata.");
643       case i1:
644       case v1i1:
645       case nxv1i1: return 1;
646       case v2i1:
647       case nxv2i1: return 2;
648       case v4i1:
649       case nxv4i1: return 4;
650       case i8  :
651       case v1i8:
652       case v8i1:
653       case nxv1i8:
654       case nxv8i1: return 8;
655       case i16 :
656       case f16:
657       case v16i1:
658       case v2i8:
659       case v1i16:
660       case nxv16i1:
661       case nxv2i8:
662       case nxv1i16: return 16;
663       case f32 :
664       case i32 :
665       case v32i1:
666       case v4i8:
667       case v2i16:
668       case v2f16:
669       case v1f32:
670       case v1i32:
671       case nxv32i1:
672       case nxv4i8:
673       case nxv2i16:
674       case nxv1i32:
675       case nxv2f16:
676       case nxv1f32: return 32;
677       case x86mmx:
678       case f64 :
679       case i64 :
680       case v64i1:
681       case v8i8:
682       case v4i16:
683       case v2i32:
684       case v1i64:
685       case v4f16:
686       case v2f32:
687       case v1f64:
688       case nxv8i8:
689       case nxv4i16:
690       case nxv2i32:
691       case nxv1i64:
692       case nxv4f16:
693       case nxv2f32:
694       case nxv1f64: return 64;
695       case f80 :  return 80;
696       case f128:
697       case ppcf128:
698       case i128:
699       case v128i1:
700       case v16i8:
701       case v8i16:
702       case v4i32:
703       case v2i64:
704       case v1i128:
705       case v8f16:
706       case v4f32:
707       case v2f64:
708       case nxv16i8:
709       case nxv8i16:
710       case nxv4i32:
711       case nxv2i64:
712       case nxv8f16:
713       case nxv4f32:
714       case nxv2f64: return 128;
715       case v32i8:
716       case v16i16:
717       case v8i32:
718       case v4i64:
719       case v8f32:
720       case v4f64:
721       case nxv32i8:
722       case nxv16i16:
723       case nxv8i32:
724       case nxv4i64:
725       case nxv8f32:
726       case nxv4f64: return 256;
727       case v512i1:
728       case v64i8:
729       case v32i16:
730       case v16i32:
731       case v8i64:
732       case v16f32:
733       case v8f64:
734       case nxv32i16:
735       case nxv16i32:
736       case nxv8i64:
737       case nxv16f32:
738       case nxv8f64: return 512;
739       case v1024i1:
740       case v128i8:
741       case v64i16:
742       case v32i32:
743       case v16i64:
744       case nxv32i32:
745       case nxv16i64: return 1024;
746       case v256i8:
747       case v128i16:
748       case v64i32:
749       case v32i64:
750       case nxv32i64: return 2048;
751       case ExceptRef: return 0; // opaque type
752       }
753     }
754 
getScalarSizeInBits()755     unsigned getScalarSizeInBits() const {
756       return getScalarType().getSizeInBits();
757     }
758 
759     /// Return the number of bytes overwritten by a store of the specified value
760     /// type.
getStoreSize()761     unsigned getStoreSize() const {
762       return (getSizeInBits() + 7) / 8;
763     }
764 
765     /// Return the number of bits overwritten by a store of the specified value
766     /// type.
getStoreSizeInBits()767     unsigned getStoreSizeInBits() const {
768       return getStoreSize() * 8;
769     }
770 
771     /// Return true if this has more bits than VT.
bitsGT(MVT VT)772     bool bitsGT(MVT VT) const {
773       return getSizeInBits() > VT.getSizeInBits();
774     }
775 
776     /// Return true if this has no less bits than VT.
bitsGE(MVT VT)777     bool bitsGE(MVT VT) const {
778       return getSizeInBits() >= VT.getSizeInBits();
779     }
780 
781     /// Return true if this has less bits than VT.
bitsLT(MVT VT)782     bool bitsLT(MVT VT) const {
783       return getSizeInBits() < VT.getSizeInBits();
784     }
785 
786     /// Return true if this has no more bits than VT.
bitsLE(MVT VT)787     bool bitsLE(MVT VT) const {
788       return getSizeInBits() <= VT.getSizeInBits();
789     }
790 
getFloatingPointVT(unsigned BitWidth)791     static MVT getFloatingPointVT(unsigned BitWidth) {
792       switch (BitWidth) {
793       default:
794         llvm_unreachable("Bad bit width!");
795       case 16:
796         return MVT::f16;
797       case 32:
798         return MVT::f32;
799       case 64:
800         return MVT::f64;
801       case 80:
802         return MVT::f80;
803       case 128:
804         return MVT::f128;
805       }
806     }
807 
getIntegerVT(unsigned BitWidth)808     static MVT getIntegerVT(unsigned BitWidth) {
809       switch (BitWidth) {
810       default:
811         return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
812       case 1:
813         return MVT::i1;
814       case 8:
815         return MVT::i8;
816       case 16:
817         return MVT::i16;
818       case 32:
819         return MVT::i32;
820       case 64:
821         return MVT::i64;
822       case 128:
823         return MVT::i128;
824       }
825     }
826 
getVectorVT(MVT VT,unsigned NumElements)827     static MVT getVectorVT(MVT VT, unsigned NumElements) {
828       switch (VT.SimpleTy) {
829       default:
830         break;
831       case MVT::i1:
832         if (NumElements == 1)    return MVT::v1i1;
833         if (NumElements == 2)    return MVT::v2i1;
834         if (NumElements == 4)    return MVT::v4i1;
835         if (NumElements == 8)    return MVT::v8i1;
836         if (NumElements == 16)   return MVT::v16i1;
837         if (NumElements == 32)   return MVT::v32i1;
838         if (NumElements == 64)   return MVT::v64i1;
839         if (NumElements == 128)  return MVT::v128i1;
840         if (NumElements == 512)  return MVT::v512i1;
841         if (NumElements == 1024) return MVT::v1024i1;
842         break;
843       case MVT::i8:
844         if (NumElements == 1)   return MVT::v1i8;
845         if (NumElements == 2)   return MVT::v2i8;
846         if (NumElements == 4)   return MVT::v4i8;
847         if (NumElements == 8)   return MVT::v8i8;
848         if (NumElements == 16)  return MVT::v16i8;
849         if (NumElements == 32)  return MVT::v32i8;
850         if (NumElements == 64)  return MVT::v64i8;
851         if (NumElements == 128) return MVT::v128i8;
852         if (NumElements == 256) return MVT::v256i8;
853         break;
854       case MVT::i16:
855         if (NumElements == 1)   return MVT::v1i16;
856         if (NumElements == 2)   return MVT::v2i16;
857         if (NumElements == 4)   return MVT::v4i16;
858         if (NumElements == 8)   return MVT::v8i16;
859         if (NumElements == 16)  return MVT::v16i16;
860         if (NumElements == 32)  return MVT::v32i16;
861         if (NumElements == 64)  return MVT::v64i16;
862         if (NumElements == 128) return MVT::v128i16;
863         break;
864       case MVT::i32:
865         if (NumElements == 1)  return MVT::v1i32;
866         if (NumElements == 2)  return MVT::v2i32;
867         if (NumElements == 4)  return MVT::v4i32;
868         if (NumElements == 8)  return MVT::v8i32;
869         if (NumElements == 16) return MVT::v16i32;
870         if (NumElements == 32) return MVT::v32i32;
871         if (NumElements == 64) return MVT::v64i32;
872         break;
873       case MVT::i64:
874         if (NumElements == 1)  return MVT::v1i64;
875         if (NumElements == 2)  return MVT::v2i64;
876         if (NumElements == 4)  return MVT::v4i64;
877         if (NumElements == 8)  return MVT::v8i64;
878         if (NumElements == 16) return MVT::v16i64;
879         if (NumElements == 32) return MVT::v32i64;
880         break;
881       case MVT::i128:
882         if (NumElements == 1)  return MVT::v1i128;
883         break;
884       case MVT::f16:
885         if (NumElements == 2)  return MVT::v2f16;
886         if (NumElements == 4)  return MVT::v4f16;
887         if (NumElements == 8)  return MVT::v8f16;
888         break;
889       case MVT::f32:
890         if (NumElements == 1)  return MVT::v1f32;
891         if (NumElements == 2)  return MVT::v2f32;
892         if (NumElements == 4)  return MVT::v4f32;
893         if (NumElements == 8)  return MVT::v8f32;
894         if (NumElements == 16) return MVT::v16f32;
895         break;
896       case MVT::f64:
897         if (NumElements == 1)  return MVT::v1f64;
898         if (NumElements == 2)  return MVT::v2f64;
899         if (NumElements == 4)  return MVT::v4f64;
900         if (NumElements == 8)  return MVT::v8f64;
901         break;
902       }
903       return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
904     }
905 
getScalableVectorVT(MVT VT,unsigned NumElements)906     static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
907       switch(VT.SimpleTy) {
908         default:
909           break;
910         case MVT::i1:
911           if (NumElements == 1)  return MVT::nxv1i1;
912           if (NumElements == 2)  return MVT::nxv2i1;
913           if (NumElements == 4)  return MVT::nxv4i1;
914           if (NumElements == 8)  return MVT::nxv8i1;
915           if (NumElements == 16) return MVT::nxv16i1;
916           if (NumElements == 32) return MVT::nxv32i1;
917           break;
918         case MVT::i8:
919           if (NumElements == 1)  return MVT::nxv1i8;
920           if (NumElements == 2)  return MVT::nxv2i8;
921           if (NumElements == 4)  return MVT::nxv4i8;
922           if (NumElements == 8)  return MVT::nxv8i8;
923           if (NumElements == 16) return MVT::nxv16i8;
924           if (NumElements == 32) return MVT::nxv32i8;
925           break;
926         case MVT::i16:
927           if (NumElements == 1)  return MVT::nxv1i16;
928           if (NumElements == 2)  return MVT::nxv2i16;
929           if (NumElements == 4)  return MVT::nxv4i16;
930           if (NumElements == 8)  return MVT::nxv8i16;
931           if (NumElements == 16) return MVT::nxv16i16;
932           if (NumElements == 32) return MVT::nxv32i16;
933           break;
934         case MVT::i32:
935           if (NumElements == 1)  return MVT::nxv1i32;
936           if (NumElements == 2)  return MVT::nxv2i32;
937           if (NumElements == 4)  return MVT::nxv4i32;
938           if (NumElements == 8)  return MVT::nxv8i32;
939           if (NumElements == 16) return MVT::nxv16i32;
940           if (NumElements == 32) return MVT::nxv32i32;
941           break;
942         case MVT::i64:
943           if (NumElements == 1)  return MVT::nxv1i64;
944           if (NumElements == 2)  return MVT::nxv2i64;
945           if (NumElements == 4)  return MVT::nxv4i64;
946           if (NumElements == 8)  return MVT::nxv8i64;
947           if (NumElements == 16) return MVT::nxv16i64;
948           if (NumElements == 32) return MVT::nxv32i64;
949           break;
950         case MVT::f16:
951           if (NumElements == 2)  return MVT::nxv2f16;
952           if (NumElements == 4)  return MVT::nxv4f16;
953           if (NumElements == 8)  return MVT::nxv8f16;
954           break;
955         case MVT::f32:
956           if (NumElements == 1)  return MVT::nxv1f32;
957           if (NumElements == 2)  return MVT::nxv2f32;
958           if (NumElements == 4)  return MVT::nxv4f32;
959           if (NumElements == 8)  return MVT::nxv8f32;
960           if (NumElements == 16) return MVT::nxv16f32;
961           break;
962         case MVT::f64:
963           if (NumElements == 1)  return MVT::nxv1f64;
964           if (NumElements == 2)  return MVT::nxv2f64;
965           if (NumElements == 4)  return MVT::nxv4f64;
966           if (NumElements == 8)  return MVT::nxv8f64;
967           break;
968       }
969       return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
970     }
971 
getVectorVT(MVT VT,unsigned NumElements,bool IsScalable)972     static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable) {
973       if (IsScalable)
974         return getScalableVectorVT(VT, NumElements);
975       return getVectorVT(VT, NumElements);
976     }
977 
getVectorVT(MVT VT,MVT::ElementCount EC)978     static MVT getVectorVT(MVT VT, MVT::ElementCount EC) {
979       if (EC.Scalable)
980         return getScalableVectorVT(VT, EC.Min);
981       return getVectorVT(VT, EC.Min);
982     }
983 
984     /// Return the value type corresponding to the specified type.  This returns
985     /// all pointers as iPTR.  If HandleUnknown is true, unknown types are
986     /// returned as Other, otherwise they are invalid.
987     static MVT getVT(Type *Ty, bool HandleUnknown = false);
988 
989   private:
990     /// A simple iterator over the MVT::SimpleValueType enum.
991     struct mvt_iterator {
992       SimpleValueType VT;
993 
mvt_iteratormvt_iterator994       mvt_iterator(SimpleValueType VT) : VT(VT) {}
995 
996       MVT operator*() const { return VT; }
997       bool operator!=(const mvt_iterator &LHS) const { return VT != LHS.VT; }
998 
999       mvt_iterator& operator++() {
1000         VT = (MVT::SimpleValueType)((int)VT + 1);
1001         assert((int)VT <= MVT::MAX_ALLOWED_VALUETYPE &&
1002                "MVT iterator overflowed.");
1003         return *this;
1004       }
1005     };
1006 
1007     /// A range of the MVT::SimpleValueType enum.
1008     using mvt_range = iterator_range<mvt_iterator>;
1009 
1010   public:
1011     /// SimpleValueType Iteration
1012     /// @{
all_valuetypes()1013     static mvt_range all_valuetypes() {
1014       return mvt_range(MVT::FIRST_VALUETYPE, MVT::LAST_VALUETYPE);
1015     }
1016 
integer_valuetypes()1017     static mvt_range integer_valuetypes() {
1018       return mvt_range(MVT::FIRST_INTEGER_VALUETYPE,
1019                        (MVT::SimpleValueType)(MVT::LAST_INTEGER_VALUETYPE + 1));
1020     }
1021 
fp_valuetypes()1022     static mvt_range fp_valuetypes() {
1023       return mvt_range(MVT::FIRST_FP_VALUETYPE,
1024                        (MVT::SimpleValueType)(MVT::LAST_FP_VALUETYPE + 1));
1025     }
1026 
vector_valuetypes()1027     static mvt_range vector_valuetypes() {
1028       return mvt_range(MVT::FIRST_VECTOR_VALUETYPE,
1029                        (MVT::SimpleValueType)(MVT::LAST_VECTOR_VALUETYPE + 1));
1030     }
1031 
integer_vector_valuetypes()1032     static mvt_range integer_vector_valuetypes() {
1033       return mvt_range(
1034           MVT::FIRST_INTEGER_VECTOR_VALUETYPE,
1035           (MVT::SimpleValueType)(MVT::LAST_INTEGER_VECTOR_VALUETYPE + 1));
1036     }
1037 
fp_vector_valuetypes()1038     static mvt_range fp_vector_valuetypes() {
1039       return mvt_range(
1040           MVT::FIRST_FP_VECTOR_VALUETYPE,
1041           (MVT::SimpleValueType)(MVT::LAST_FP_VECTOR_VALUETYPE + 1));
1042     }
1043 
integer_scalable_vector_valuetypes()1044     static mvt_range integer_scalable_vector_valuetypes() {
1045       return mvt_range(MVT::FIRST_INTEGER_SCALABLE_VALUETYPE,
1046               (MVT::SimpleValueType)(MVT::LAST_INTEGER_SCALABLE_VALUETYPE + 1));
1047     }
1048 
fp_scalable_vector_valuetypes()1049     static mvt_range fp_scalable_vector_valuetypes() {
1050       return mvt_range(MVT::FIRST_FP_SCALABLE_VALUETYPE,
1051                    (MVT::SimpleValueType)(MVT::LAST_FP_SCALABLE_VALUETYPE + 1));
1052     }
1053     /// @}
1054   };
1055 
1056 } // end namespace llvm
1057 
1058 #endif // LLVM_CODEGEN_MACHINEVALUETYPE_H
1059