Home | History | Annotate | Download | only in Support 
      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 
    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;
    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.
    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.
    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.
    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.
    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.
    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
    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.
    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.
    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.
    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.
    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.
    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.
    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.
    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.
    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.
    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.
    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.
    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.
    412     MVT getScalarType() const {
    413       return isVector() ? getVectorElementType() : *this;
    414     }
    415 
    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 
    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 
    620     MVT::ElementCount getVectorElementCount() const {
    621       return { getVectorNumElements(), isScalableVector() };
    622     }
    623 
    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 
    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.
    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.
    767     unsigned getStoreSizeInBits() const {
    768       return getStoreSize() * 8;
    769     }
    770 
    771     /// Return true if this has more bits than 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.
    777     bool bitsGE(MVT VT) const {
    778       return getSizeInBits() >= VT.getSizeInBits();
    779     }
    780 
    781     /// Return true if this has less bits than 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.
    787     bool bitsLE(MVT VT) const {
    788       return getSizeInBits() <= VT.getSizeInBits();
    789     }
    790 
    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 
    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 
    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 
    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 
    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 
    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 
    994       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     /// @{
   1013     static mvt_range all_valuetypes() {
   1014       return mvt_range(MVT::FIRST_VALUETYPE, MVT::LAST_VALUETYPE);
   1015     }
   1016 
   1017     static mvt_range integer_valuetypes() {
   1018       return mvt_range(MVT::FIRST_INTEGER_VALUETYPE,
   1019                        (MVT::SimpleValueType)(MVT::LAST_INTEGER_VALUETYPE + 1));
   1020     }
   1021 
   1022     static mvt_range fp_valuetypes() {
   1023       return mvt_range(MVT::FIRST_FP_VALUETYPE,
   1024                        (MVT::SimpleValueType)(MVT::LAST_FP_VALUETYPE + 1));
   1025     }
   1026 
   1027     static mvt_range vector_valuetypes() {
   1028       return mvt_range(MVT::FIRST_VECTOR_VALUETYPE,
   1029                        (MVT::SimpleValueType)(MVT::LAST_VECTOR_VALUETYPE + 1));
   1030     }
   1031 
   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 
   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 
   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 
   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