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