[MVT] Add new MVT types for RISC-V vector.

[HsiangKai]

Summary

In RISC-V vector extension, users could group multiple vector registers as one pseudo register. In mixed width operations, users could use partial vector registers to reduce the register pressure. The parameter to control register grouping and partial use is called LMUL. LMUL is a part of the type. So, we have a bunch of vector types. In order to support all these types, we need new MVT types in LLVM. In this patch, I added several MVT types that are used in RISC-V vector implementation. This is a standalone patch for MVT types without RISC-V related implementation.

[rogfer01]

llvm/lib/IR/Function.cpp

752 ↗

(On Diff #270334)

Ditto, see comment below.

llvm/utils/TableGen/IntrinsicEmitter.cpp

250 ↗

(On Diff #270334)

I wonder if we better preserve the existing numbering here, just in case these numbers have got already been serialized somewhere.

That would be my impression given the unusual ordering of some of the existing enumerators like IIT_V512 and IIT_V128.

[HsiangKai]

llvm/utils/TableGen/IntrinsicEmitter.cpp

250 ↗

(On Diff #270334)

Good point. I didn't aware of this.

[HsiangKai]

Remove redundant types.

[HsiangKai]

Add nxv1f16.

[evandro]

It LGTM, but it's better to wait for an OK from a couple or so of other reviewers to chime in.

[craig.topper]

LGTM

llvm/include/llvm/CodeGen/ValueTypes.td

 def v1024f32 : ValueType<32768, 89>;  // 1024 x f32 vector value
 def v2048f32 : ValueType<65536, 90>;  // 2048 x f32 vector value
 def v1f64    : ValueType<64, 91>;     //    1 x f64 vector value
 def v2f64    : ValueType<128, 92>;    //    2 x f64 vector value
 def v4f64    : ValueType<256, 93>;    //    4 x f64 vector value
 def v8f64    : ValueType<512, 94>;    //    8 x f64 vector value
 def v16f64   : ValueType<1024, 95>;   //   16 x f64 vector value
 
-def nxv1i1  : ValueType<1,   96>;  // n x  1 x i1  vector value
-def nxv2i1  : ValueType<2,   97>;  // n x  2 x i1  vector value
-def nxv4i1  : ValueType<4,   98>;  // n x  4 x i1  vector value
-def nxv8i1  : ValueType<8,   99>;  // n x  8 x i1  vector value
-def nxv16i1 : ValueType<16, 100>;  // n x 16 x i1  vector value
-def nxv32i1 : ValueType<32, 101>;  // n x 32 x i1  vector value
+def nxv1i1   : ValueType<1,    96>;  // n x   1 x i1  vector value
+def nxv2i1   : ValueType<2,    97>;  // n x   2 x i1  vector value
+def nxv4i1   : ValueType<4,    98>;  // n x   4 x i1  vector value
+def nxv8i1   : ValueType<8,    99>;  // n x   8 x i1  vector value
+def nxv16i1  : ValueType<16,  100>;  // n x  16 x i1  vector value
+def nxv32i1  : ValueType<32,  101>;  // n x  32 x i1  vector value
+def nxv64i1  : ValueType<64,  102>;  // n x  64 x i1  vector value
 
-def nxv1i8  : ValueType<8,   102>;  // n x  1 x i8  vector value
-def nxv2i8  : ValueType<16,  103>;  // n x  2 x i8  vector value
-def nxv4i8  : ValueType<32,  104>;  // n x  4 x i8  vector value
-def nxv8i8  : ValueType<64,  105>;  // n x  8 x i8  vector value
-def nxv16i8 : ValueType<128, 106>;  // n x 16 x i8  vector value
-def nxv32i8 : ValueType<256, 107>;  // n x 32 x i8  vector value
-
-def nxv1i16 : ValueType<16,  108>; // n x  1 x i16 vector value
-def nxv2i16 : ValueType<32,  109>; // n x  2 x i16 vector value
-def nxv4i16 : ValueType<64,  110>; // n x  4 x i16 vector value
-def nxv8i16 : ValueType<128, 111>; // n x  8 x i16 vector value
-def nxv16i16: ValueType<256, 112>; // n x 16 x i16 vector value
-def nxv32i16: ValueType<512, 113>; // n x 32 x i16 vector value
-
-def nxv1i32 : ValueType<32,  114>; // n x  1 x i32 vector value
-def nxv2i32 : ValueType<64,  115>; // n x  2 x i32 vector value
-def nxv4i32 : ValueType<128, 116>; // n x  4 x i32 vector value
-def nxv8i32 : ValueType<256, 117>; // n x  8 x i32 vector value
-def nxv16i32: ValueType<512, 118>; // n x 16 x i32 vector value
-def nxv32i32: ValueType<1024,119>; // n x 32 x i32 vector value
-
-def nxv1i64 : ValueType<64,  120>; // n x  1 x i64 vector value
-def nxv2i64 : ValueType<128, 121>; // n x  2 x i64 vector value
-def nxv4i64 : ValueType<256, 122>; // n x  4 x i64 vector value
-def nxv8i64 : ValueType<512, 123>; // n x  8 x i64 vector value
-def nxv16i64: ValueType<1024,124>; // n x 16 x i64 vector value
-def nxv32i64: ValueType<2048,125>; // n x 32 x i64 vector value
-
-def nxv2f16  : ValueType<32 , 126>; // n x  2 x f16 vector value
-def nxv4f16  : ValueType<64 , 127>; // n x  4 x f16 vector value
-def nxv8f16  : ValueType<128, 128>; // n x  8 x f16 vector value
-def nxv2bf16 : ValueType<32 , 129>; // n x  2 x bf16 vector value
-def nxv4bf16 : ValueType<64 , 130>; // n x  4 x bf16 vector value
-def nxv8bf16 : ValueType<128, 131>; // n x  8 x bf16 vector value
-def nxv1f32  : ValueType<32 , 132>; // n x  1 x f32 vector value
-def nxv2f32  : ValueType<64 , 133>; // n x  2 x f32 vector value
-def nxv4f32  : ValueType<128, 134>; // n x  4 x f32 vector value
-def nxv8f32  : ValueType<256, 135>; // n x  8 x f32 vector value
-def nxv16f32 : ValueType<512, 136>; // n x 16 x f32 vector value
-def nxv1f64  : ValueType<64,  137>; // n x  1 x f64 vector value
-def nxv2f64  : ValueType<128, 138>; // n x  2 x f64 vector value
-def nxv4f64  : ValueType<256, 139>; // n x  4 x f64 vector value
-def nxv8f64  : ValueType<512, 140>; // n x  8 x f64 vector value
-
-def x86mmx : ValueType<64 , 141>;   // X86 MMX value
-def FlagVT : ValueType<0  , 142>;   // Pre-RA sched glue
-def isVoid : ValueType<0  , 143>;   // Produces no value
-def untyped: ValueType<8  , 144>;   // Produces an untyped value
-def exnref : ValueType<0  , 145>;      // WebAssembly's exnref type
+def nxv1i8   : ValueType<8,    103>;  // n x   1 x i8  vector value
+def nxv2i8   : ValueType<16,   104>;  // n x   2 x i8  vector value
+def nxv4i8   : ValueType<32,   105>;  // n x   4 x i8  vector value
+def nxv8i8   : ValueType<64,   106>;  // n x   8 x i8  vector value
+def nxv16i8  : ValueType<128,  107>;  // n x  16 x i8  vector value
+def nxv32i8  : ValueType<256,  108>;  // n x  32 x i8  vector value
+def nxv64i8  : ValueType<512,  109>;  // n x  64 x i8  vector value
+
+def nxv1i16   : ValueType<16,   110>; // n x   1 x i16 vector value
+def nxv2i16   : ValueType<32,   111>; // n x   2 x i16 vector value
+def nxv4i16   : ValueType<64,   112>; // n x   4 x i16 vector value
+def nxv8i16   : ValueType<128,  113>; // n x   8 x i16 vector value
+def nxv16i16  : ValueType<256,  114>; // n x  16 x i16 vector value
+def nxv32i16  : ValueType<512,  115>; // n x  32 x i16 vector value
+
+def nxv1i32   : ValueType<32,   116>; // n x   1 x i32 vector value
+def nxv2i32   : ValueType<64,   117>; // n x   2 x i32 vector value
+def nxv4i32   : ValueType<128,  118>; // n x   4 x i32 vector value
+def nxv8i32   : ValueType<256,  119>; // n x   8 x i32 vector value
+def nxv16i32  : ValueType<512,  120>; // n x  16 x i32 vector value
+def nxv32i32  : ValueType<1024, 121>; // n x  32 x i32 vector value
+
+def nxv1i64  : ValueType<64,   122>; // n x  1 x i64 vector value
+def nxv2i64  : ValueType<128,  123>; // n x  2 x i64 vector value
+def nxv4i64  : ValueType<256,  124>; // n x  4 x i64 vector value
+def nxv8i64  : ValueType<512,  125>; // n x  8 x i64 vector value
+def nxv16i64 : ValueType<1024, 126>; // n x 16 x i64 vector value
+def nxv32i64 : ValueType<2048, 127>; // n x 32 x i64 vector value
+
+def nxv2f16   : ValueType<32,   128>; // n x   2 x f16 vector value
+def nxv4f16   : ValueType<64,   129>; // n x   4 x f16 vector value
+def nxv8f16   : ValueType<128,  130>; // n x   8 x f16 vector value
+def nxv16f16  : ValueType<256,  131>; // n x  16 x f16 vector value
+def nxv32f16  : ValueType<512,  132>; // n x  32 x f16 vector value
+def nxv2bf16  : ValueType<32,   133>; // n x   2 x bf16 vector value
+def nxv4bf16  : ValueType<64,   134>; // n x   4 x bf16 vector value
+def nxv8bf16  : ValueType<128,  135>; // n x   8 x bf16 vector value
+def nxv1f32   : ValueType<32,   136>; // n x   1 x f32 vector value
+def nxv2f32   : ValueType<64,   137>; // n x   2 x f32 vector value
+def nxv4f32   : ValueType<128,  138>; // n x   4 x f32 vector value
+def nxv8f32   : ValueType<256,  139>; // n x   8 x f32 vector value
+def nxv16f32  : ValueType<512,  140>; // n x  16 x f32 vector value
+def nxv32f32  : ValueType<1024, 141>; // n x  32 x f32 vector value
+def nxv1f64   : ValueType<64,   142>; // n x   1 x f64 vector value
+def nxv2f64   : ValueType<128,  143>; // n x   2 x f64 vector value
+def nxv4f64   : ValueType<256,  144>; // n x   4 x f64 vector value
+def nxv8f64   : ValueType<512,  145>; // n x   8 x f64 vector value
+
+def x86mmx : ValueType<64 , 146>;   // X86 MMX value
+def FlagVT : ValueType<0  , 147>;   // Pre-RA sched glue
+def isVoid : ValueType<0  , 148>;   // Produces no value
+def untyped: ValueType<8  , 149>;   // Produces an untyped value
+def exnref : ValueType<0  , 150>;      // WebAssembly's exnref type
 def token  : ValueType<0  , 248>;   // TokenTy
 def MetadataVT: ValueType<0, 249>;  // Metadata
 
 // Pseudo valuetype mapped to the current pointer size to any address space.
 // Should only be used in TableGen.
 def iPTRAny   : ValueType<0, 250>;
 
 // Pseudo valuetype to represent "vector of any size"

llvm/include/llvm/Support/MachineValueType.h

namespace llvm {
   public:
     enum SimpleValueType : uint8_t {
       // Simple value types that aren't explicitly part of this enumeration
       // are considered extended value types.
       INVALID_SIMPLE_VALUE_TYPE = 0,
 
       // If you change this numbering, you must change the values in
       // ValueTypes.td as well!
       Other          =   1,   // This is a non-standard value
       i1             =   2,   // This is a 1 bit integer value
       i8             =   3,   // This is an 8 bit integer value
       i16            =   4,   // This is a 16 bit integer value
       i32            =   5,   // This is a 32 bit integer value
       i64            =   6,   // This is a 64 bit integer value
       i128           =   7,   // This is a 128 bit integer value
 
       FIRST_INTEGER_VALUETYPE = i1,
       LAST_INTEGER_VALUETYPE  = i128,
 
       bf16           =   8,   // This is a 16 bit brain floating point value
       f16            =   9,   // This is a 16 bit floating point value
       f32            =  10,   // This is a 32 bit floating point value
       f64            =  11,   // This is a 64 bit floating point value
       f80            =  12,   // This is a 80 bit floating point value
       f128           =  13,   // This is a 128 bit floating point value
       ppcf128        =  14,   // This is a PPC 128-bit floating point value
 
       FIRST_FP_VALUETYPE = bf16,
       LAST_FP_VALUETYPE  = ppcf128,
 
       v1i1           =  15,   //    1 x i1
       v2i1           =  16,   //    2 x i1
       v4i1           =  17,   //    4 x i1
       v8i1           =  18,   //    8 x i1
       v16i1          =  19,   //   16 x i1
       v32i1          =  20,   //   32 x i1
       v64i1          =  21,   //   64 x i1
enum SimpleValueType : uint8_t {
       v16i64         =  62,   // 16 x i64
       v32i64         =  63,   // 32 x i64
 
       v1i128         =  64,   //  1 x i128
 
       FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
       LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i128,
 
       v2f16          =  65,   //    2 x f16
       v3f16          =  66,   //    3 x f16
       v4f16          =  67,   //    4 x f16
       v8f16          =  68,   //    8 x f16
       v16f16         =  69,   //   16 x f16
       v32f16         =  70,   //   32 x f16
       v2bf16         =  71,   //    2 x bf16
       v3bf16         =  72,   //    3 x bf16
       v4bf16         =  73,   //    4 x bf16
enum SimpleValueType : uint8_t {
       v16f64         =  95,   //   16 x f64
 
       FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE = v2f16,
       LAST_FP_FIXEDLEN_VECTOR_VALUETYPE = v16f64,
 
       FIRST_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
       LAST_FIXEDLEN_VECTOR_VALUETYPE = v16f64,
 
-      nxv1i1         =  96,   // n x  1 x i1
-      nxv2i1         =  97,   // n x  2 x i1
-      nxv4i1         =  98,   // n x  4 x i1
-      nxv8i1         =  99,   // n x  8 x i1
-      nxv16i1        = 100,   // n x 16 x i1
-      nxv32i1        = 101,   // n x 32 x i1
+      nxv1i1         = 96,    // n x   1 x i1
+      nxv2i1         = 97,    // n x   2 x i1
+      nxv4i1         = 98,    // n x   4 x i1
+      nxv8i1         = 99,    // n x   8 x i1
+      nxv16i1        = 100,   // n x  16 x i1
+      nxv32i1        = 101,   // n x  32 x i1
+      nxv64i1        = 102,   // n x  64 x i1
 
-      nxv1i8         = 102,   // n x  1 x i8
-      nxv2i8         = 103,   // n x  2 x i8
-      nxv4i8         = 104,   // n x  4 x i8
-      nxv8i8         = 105,   // n x  8 x i8
-      nxv16i8        = 106,   // n x 16 x i8
-      nxv32i8        = 107,   // n x 32 x i8
-
-      nxv1i16        = 108,  // n x  1 x i16
-      nxv2i16        = 109,  // n x  2 x i16
-      nxv4i16        = 110,  // n x  4 x i16
-      nxv8i16        = 111,  // n x  8 x i16
-      nxv16i16       = 112,  // n x 16 x i16
-      nxv32i16       = 113,  // n x 32 x i16
-
-      nxv1i32        = 114,  // n x  1 x i32
-      nxv2i32        = 115,  // n x  2 x i32
-      nxv4i32        = 116,  // n x  4 x i32
-      nxv8i32        = 117,  // n x  8 x i32
-      nxv16i32       = 118,  // n x 16 x i32
-      nxv32i32       = 119,  // n x 32 x i32
-
-      nxv1i64        = 120,  // n x  1 x i64
-      nxv2i64        = 121,  // n x  2 x i64
-      nxv4i64        = 122,  // n x  4 x i64
-      nxv8i64        = 123,  // n x  8 x i64
-      nxv16i64       = 124,  // n x 16 x i64
-      nxv32i64       = 125,  // n x 32 x i64
+      nxv1i8         = 103,   // n x   1 x i8
+      nxv2i8         = 104,   // n x   2 x i8
+      nxv4i8         = 105,   // n x   4 x i8
+      nxv8i8         = 106,   // n x   8 x i8
+      nxv16i8        = 107,   // n x  16 x i8
+      nxv32i8        = 108,   // n x  32 x i8
+      nxv64i8        = 109,   // n x  64 x i8
+
+      nxv1i16        = 110,   // n x   1 x i16
+      nxv2i16        = 111,   // n x   2 x i16
+      nxv4i16        = 112,   // n x   4 x i16
+      nxv8i16        = 113,   // n x   8 x i16
+      nxv16i16       = 114,   // n x  16 x i16
+      nxv32i16       = 115,   // n x  32 x i16
+
+      nxv1i32        = 116,   // n x   1 x i32
+      nxv2i32        = 117,   // n x   2 x i32
+      nxv4i32        = 118,   // n x   4 x i32
+      nxv8i32        = 119,   // n x   8 x i32
+      nxv16i32       = 120,   // n x  16 x i32
+      nxv32i32       = 121,   // n x  32 x i32
+
+      nxv1i64        = 122,   // n x  1 x i64
+      nxv2i64        = 123,   // n x  2 x i64
+      nxv4i64        = 124,   // n x  4 x i64
+      nxv8i64        = 125,   // n x  8 x i64
+      nxv16i64       = 126,   // n x 16 x i64
+      nxv32i64       = 127,   // n x 32 x i64
 
       FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
       LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv32i64,
 
-      nxv2f16        = 126,  // n x  2 x f16
-      nxv4f16        = 127,  // n x  4 x f16
-      nxv8f16        = 128,  // n x  8 x f16
-      nxv2bf16       = 129,  // n x  2 x bf16
-      nxv4bf16       = 130,  // n x  4 x bf16
-      nxv8bf16       = 131,  // n x  8 x bf16
-      nxv1f32        = 132,  // n x  1 x f32
-      nxv2f32        = 133,  // n x  2 x f32
-      nxv4f32        = 134,  // n x  4 x f32
-      nxv8f32        = 135,  // n x  8 x f32
-      nxv16f32       = 136,  // n x 16 x f32
-      nxv1f64        = 137,  // n x  1 x f64
-      nxv2f64        = 138,  // n x  2 x f64
-      nxv4f64        = 139,  // n x  4 x f64
-      nxv8f64        = 140,  // n x  8 x f64
+      nxv2f16        = 128,   // n x   2 x f16
+      nxv4f16        = 129,   // n x   4 x f16
+      nxv8f16        = 130,   // n x   8 x f16
+      nxv16f16       = 131,   // n x  16 x f16
+      nxv32f16       = 132,   // n x  32 x f16
+      nxv2bf16       = 133,   // n x   2 x bf16
+      nxv4bf16       = 134,   // n x   4 x bf16
+      nxv8bf16       = 135,   // n x   8 x bf16
+      nxv1f32        = 136,   // n x   1 x f32
+      nxv2f32        = 137,   // n x   2 x f32
+      nxv4f32        = 138,   // n x   4 x f32
+      nxv8f32        = 139,   // n x   8 x f32
+      nxv16f32       = 140,   // n x  16 x f32
+      nxv32f32       = 141,   // n x  32 x f32
+      nxv1f64        = 142,   // n x   1 x f64
+      nxv2f64        = 143,   // n x   2 x f64
+      nxv4f64        = 144,   // n x   4 x f64
+      nxv8f64        = 145,   // n x   8 x f64
 
       FIRST_FP_SCALABLE_VECTOR_VALUETYPE = nxv2f16,
       LAST_FP_SCALABLE_VECTOR_VALUETYPE = nxv8f64,
 
       FIRST_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
       LAST_SCALABLE_VECTOR_VALUETYPE = nxv8f64,
 
       FIRST_VECTOR_VALUETYPE = v1i1,
       LAST_VECTOR_VALUETYPE  = nxv8f64,
 
-      x86mmx         = 141,   // This is an X86 MMX value
+      x86mmx         = 146,   // This is an X86 MMX value
 
-      Glue           = 142,   // This glues nodes together during pre-RA sched
+      Glue           = 147,   // This glues nodes together during pre-RA sched
 
-      isVoid         = 143,   // This has no value
+      isVoid         = 148,   // This has no value
 
-      Untyped        = 144,   // This value takes a register, but has
+      Untyped        = 149,   // This value takes a register, but has
                                // unspecified type.  The register class
                                // will be determined by the opcode.
 
-      exnref         = 145,   // WebAssembly's exnref type
+      exnref         = 150,   // WebAssembly's exnref type
 
       FIRST_VALUETYPE = 1,     // This is always the beginning of the list.
-      LAST_VALUETYPE = 146,   // This always remains at the end of the list.
+      LAST_VALUETYPE = 151,   // This always remains at the end of the list.
 
       // This is the current maximum for LAST_VALUETYPE.
       // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
       // This value must be a multiple of 32.
       MAX_ALLOWED_VALUETYPE = 160,
 
       // A value of type llvm::TokenTy
       token          = 248,
 
       // This is MDNode or MDString.
       Metadata       = 249,
 
       // An int value the size of the pointer of the current
       // target to any address space. This must only be used internal to
       // tblgen. Other than for overloading, we treat iPTRAny the same as iPTR.
       iPTRAny        = 250,
 
       // A vector with any length and element size. This is used
       // for intrinsics that have overloadings based on vector types.
       // This is only for tblgen's consumption!
       vAny           = 251,
 
       // Any floating-point or vector floating-point value. This is used
       // for intrinsics that have overloadings based on floating-point types.
       // This is only for tblgen's consumption!
       fAny           = 252,
 
       // An integer or vector integer value of any bit width. This is
       // used for intrinsics that have overloadings based on integer bit widths.
       // This is only for tblgen's consumption!
       iAny           = 253,
 
       // An int value the size of the pointer of the current
       // target.  This should only be used internal to tblgen!
       iPTR           = 254,
 
       // Any type. This is used for intrinsics that have overloadings.
       // This is only for tblgen's consumption!
       Any            = 255
     };
 
     SimpleValueType SimpleTy = INVALID_SIMPLE_VALUE_TYPE;
 
     constexpr MVT() = default;
     constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {}
 
     bool operator>(const MVT& S)  const { return SimpleTy >  S.SimpleTy; }
public:
     /// Return true if this is a 2048-bit vector type.
     bool is2048BitVector() const {
       return (SimpleTy == MVT::v256i8 || SimpleTy == MVT::v128i16 ||
               SimpleTy == MVT::v64i32 || SimpleTy == MVT::v32i64);
     }
 
     /// Return true if this is an overloaded type for TableGen.
     bool isOverloaded() const {
-      return (SimpleTy==MVT::Any  ||
-              SimpleTy==MVT::iAny || SimpleTy==MVT::fAny ||
-              SimpleTy==MVT::vAny || SimpleTy==MVT::iPTRAny);
+      return (SimpleTy == MVT::Any || SimpleTy == MVT::iAny ||
+              SimpleTy == MVT::fAny || SimpleTy == MVT::vAny ||
+              SimpleTy == MVT::iPTRAny);
     }
 
     /// Return a VT for a vector type with the same element type but
     /// half the number of elements.
     MVT getHalfNumVectorElementsVT() const {
       MVT EltVT = getVectorElementType();
       auto EltCnt = getVectorElementCount();
       assert(!(EltCnt.Min & 1) && "Splitting vector, but not in half!");
MVT getVectorElementType() const {
       case v256i1:
       case v512i1:
       case v1024i1:
       case nxv1i1:
       case nxv2i1:
       case nxv4i1:
       case nxv8i1:
       case nxv16i1:
-      case nxv32i1: return i1;
+      case nxv32i1:
+      case nxv64i1: return i1;
       case v1i8:
       case v2i8:
       case v4i8:
       case v8i8:
       case v16i8:
       case v32i8:
       case v64i8:
       case v128i8:
       case v256i8:
       case nxv1i8:
       case nxv2i8:
       case nxv4i8:
       case nxv8i8:
       case nxv16i8:
-      case nxv32i8: return i8;
+      case nxv32i8:
+      case nxv64i8: return i8;
       case v1i16:
       case v2i16:
       case v3i16:
       case v4i16:
       case v8i16:
       case v16i16:
       case v32i16:
       case v64i16:
MVT getVectorElementType() const {
       case v2f16:
       case v3f16:
       case v4f16:
       case v8f16:
       case v16f16:
       case v32f16:
       case nxv2f16:
       case nxv4f16:
-      case nxv8f16: return f16;
+      case nxv8f16:
+      case nxv16f16:
+      case nxv32f16: return f16;
       case v2bf16:
       case v3bf16:
       case v4bf16:
       case v8bf16:
       case v16bf16:
       case v32bf16:
       case nxv2bf16:
       case nxv4bf16:
MVT getVectorElementType() const {
       case v256f32:
       case v512f32:
       case v1024f32:
       case v2048f32:
       case nxv1f32:
       case nxv2f32:
       case nxv4f32:
       case nxv8f32:
-      case nxv16f32: return f32;
+      case nxv16f32:
+      case nxv32f32: return f32;
       case v1f64:
       case v2f64:
       case v4f64:
       case v8f64:
       case v16f64:
       case nxv1f64:
       case nxv2f64:
       case nxv4f64:
unsigned getVectorNumElements() const {
       case v128i8:
       case v128i16:
       case v128i32:
       case v128f32: return 128;
       case v64i1:
       case v64i8:
       case v64i16:
       case v64i32:
-      case v64f32: return 64;
+      case v64f32:
+      case nxv64i1:
+      case nxv64i8: return 64;
       case v32i1:
       case v32i8:
       case v32i16:
       case v32i32:
       case v32i64:
       case v32f16:
       case v32bf16:
       case v32f32:
       case nxv32i1:
       case nxv32i8:
       case nxv32i16:
       case nxv32i32:
-      case nxv32i64: return 32;
+      case nxv32i64:
+      case nxv32f16:
+      case nxv32f32: return 32;
       case v16i1:
       case v16i8:
       case v16i16:
       case v16i32:
       case v16i64:
       case v16f16:
       case v16bf16:
       case v16f32:
       case v16f64:
       case nxv16i1:
       case nxv16i8:
       case nxv16i16:
       case nxv16i32:
       case nxv16i64:
+      case nxv16f16:
       case nxv16f32: return 16;
       case v8i1:
       case v8i8:
       case v8i16:
       case v8i32:
       case v8i64:
       case v8f16:
       case v8bf16:
TypeSize getSizeInBits() const {
       case v8i8:
       case v4i16:
       case v2i32:
       case v1i64:
       case v4f16:
       case v4bf16:
       case v2f32:
       case v1f64: return TypeSize::Fixed(64);
+      case nxv64i1:
       case nxv8i8:
       case nxv4i16:
       case nxv2i32:
       case nxv1i64:
       case nxv4f16:
       case nxv4bf16:
       case nxv2f32:
       case nxv1f64: return TypeSize::Scalable(64);
TypeSize getSizeInBits() const {
       case v16f16:
       case v16bf16:
       case v8f32:
       case v4f64: return TypeSize::Fixed(256);
       case nxv32i8:
       case nxv16i16:
       case nxv8i32:
       case nxv4i64:
+      case nxv16f16:
       case nxv8f32:
       case nxv4f64: return TypeSize::Scalable(256);
       case v512i1:
       case v64i8:
       case v32i16:
       case v16i32:
       case v8i64:
       case v32f16:
       case v32bf16:
       case v16f32:
       case v8f64: return TypeSize::Fixed(512);
+      case nxv64i8:
       case nxv32i16:
       case nxv16i32:
       case nxv8i64:
+      case nxv32f16:
       case nxv16f32:
       case nxv8f64: return TypeSize::Scalable(512);
       case v1024i1:
       case v128i8:
       case v64i16:
       case v32i32:
       case v16i64:
       case v16f64:
       case v32f32: return TypeSize::Fixed(1024);
       case nxv32i32:
-      case nxv16i64: return TypeSize::Scalable(1024);
+      case nxv16i64:
+      case nxv32f32: return TypeSize::Scalable(1024);
       case v256i8:
       case v128i16:
       case v64i32:
       case v32i64:
       case v64f32: return TypeSize::Fixed(2048);
       case nxv32i64: return TypeSize::Scalable(2048);
       case v128i32:
       case v128f32:  return TypeSize::Fixed(4096);
static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
           break;
         case MVT::i1:
           if (NumElements == 1)  return MVT::nxv1i1;
           if (NumElements == 2)  return MVT::nxv2i1;
           if (NumElements == 4)  return MVT::nxv4i1;
           if (NumElements == 8)  return MVT::nxv8i1;
           if (NumElements == 16) return MVT::nxv16i1;
           if (NumElements == 32) return MVT::nxv32i1;
+          if (NumElements == 64) return MVT::nxv64i1;
           break;
         case MVT::i8:
           if (NumElements == 1)  return MVT::nxv1i8;
           if (NumElements == 2)  return MVT::nxv2i8;
           if (NumElements == 4)  return MVT::nxv4i8;
           if (NumElements == 8)  return MVT::nxv8i8;
           if (NumElements == 16) return MVT::nxv16i8;
           if (NumElements == 32) return MVT::nxv32i8;
+          if (NumElements == 64) return MVT::nxv64i8;
           break;
         case MVT::i16:
           if (NumElements == 1)  return MVT::nxv1i16;
           if (NumElements == 2)  return MVT::nxv2i16;
           if (NumElements == 4)  return MVT::nxv4i16;
           if (NumElements == 8)  return MVT::nxv8i16;
           if (NumElements == 16) return MVT::nxv16i16;
           if (NumElements == 32) return MVT::nxv32i16;
static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
           if (NumElements == 8)  return MVT::nxv8i64;
           if (NumElements == 16) return MVT::nxv16i64;
           if (NumElements == 32) return MVT::nxv32i64;
           break;
         case MVT::f16:
           if (NumElements == 2)  return MVT::nxv2f16;
           if (NumElements == 4)  return MVT::nxv4f16;
           if (NumElements == 8)  return MVT::nxv8f16;
+          if (NumElements == 16)  return MVT::nxv16f16;
+          if (NumElements == 32)  return MVT::nxv32f16;
           break;
         case MVT::bf16:
           if (NumElements == 2)  return MVT::nxv2bf16;
           if (NumElements == 4)  return MVT::nxv4bf16;
           if (NumElements == 8)  return MVT::nxv8bf16;
           break;
         case MVT::f32:
           if (NumElements == 1)  return MVT::nxv1f32;
           if (NumElements == 2)  return MVT::nxv2f32;
           if (NumElements == 4)  return MVT::nxv4f32;
           if (NumElements == 8)  return MVT::nxv8f32;
           if (NumElements == 16) return MVT::nxv16f32;
+          if (NumElements == 32) return MVT::nxv32f32;
           break;
         case MVT::f64:
           if (NumElements == 1)  return MVT::nxv1f64;
           if (NumElements == 2)  return MVT::nxv2f64;
           if (NumElements == 4)  return MVT::nxv4f64;
           if (NumElements == 8)  return MVT::nxv8f64;
           break;
       }

llvm/lib/CodeGen/ValueTypes.cpp

Type *EVT::getTypeForEVT(LLVMContext &Context) const {
   case MVT::nxv4i1:
     return ScalableVectorType::get(Type::getInt1Ty(Context), 4);
   case MVT::nxv8i1:
     return ScalableVectorType::get(Type::getInt1Ty(Context), 8);
   case MVT::nxv16i1:
     return ScalableVectorType::get(Type::getInt1Ty(Context), 16);
   case MVT::nxv32i1:
     return ScalableVectorType::get(Type::getInt1Ty(Context), 32);
+  case MVT::nxv64i1:
+    return ScalableVectorType::get(Type::getInt1Ty(Context), 64);
   case MVT::nxv1i8:
     return ScalableVectorType::get(Type::getInt8Ty(Context), 1);
   case MVT::nxv2i8:
     return ScalableVectorType::get(Type::getInt8Ty(Context), 2);
   case MVT::nxv4i8:
     return ScalableVectorType::get(Type::getInt8Ty(Context), 4);
   case MVT::nxv8i8:
     return ScalableVectorType::get(Type::getInt8Ty(Context), 8);
   case MVT::nxv16i8:
     return ScalableVectorType::get(Type::getInt8Ty(Context), 16);
   case MVT::nxv32i8:
     return ScalableVectorType::get(Type::getInt8Ty(Context), 32);
+  case MVT::nxv64i8:
+    return ScalableVectorType::get(Type::getInt8Ty(Context), 64);
   case MVT::nxv1i16:
     return ScalableVectorType::get(Type::getInt16Ty(Context), 1);
   case MVT::nxv2i16:
     return ScalableVectorType::get(Type::getInt16Ty(Context), 2);
   case MVT::nxv4i16:
     return ScalableVectorType::get(Type::getInt16Ty(Context), 4);
   case MVT::nxv8i16:
     return ScalableVectorType::get(Type::getInt16Ty(Context), 8);
Type *EVT::getTypeForEVT(LLVMContext &Context) const {
   case MVT::nxv32i64:
     return ScalableVectorType::get(Type::getInt64Ty(Context), 32);
   case MVT::nxv2f16:
     return ScalableVectorType::get(Type::getHalfTy(Context), 2);
   case MVT::nxv4f16:
     return ScalableVectorType::get(Type::getHalfTy(Context), 4);
   case MVT::nxv8f16:
     return ScalableVectorType::get(Type::getHalfTy(Context), 8);
+  case MVT::nxv16f16:
+    return ScalableVectorType::get(Type::getHalfTy(Context), 16);
+  case MVT::nxv32f16:
+    return ScalableVectorType::get(Type::getHalfTy(Context), 32);
   case MVT::nxv2bf16:
     return ScalableVectorType::get(Type::getBFloatTy(Context), 2);
   case MVT::nxv4bf16:
     return ScalableVectorType::get(Type::getBFloatTy(Context), 4);
   case MVT::nxv8bf16:
     return ScalableVectorType::get(Type::getBFloatTy(Context), 8);
   case MVT::nxv1f32:
     return ScalableVectorType::get(Type::getFloatTy(Context), 1);
   case MVT::nxv2f32:
     return ScalableVectorType::get(Type::getFloatTy(Context), 2);
   case MVT::nxv4f32:
     return ScalableVectorType::get(Type::getFloatTy(Context), 4);
   case MVT::nxv8f32:
     return ScalableVectorType::get(Type::getFloatTy(Context), 8);
   case MVT::nxv16f32:
     return ScalableVectorType::get(Type::getFloatTy(Context), 16);
+  case MVT::nxv32f32:
+    return ScalableVectorType::get(Type::getFloatTy(Context), 32);
   case MVT::nxv1f64:
     return ScalableVectorType::get(Type::getDoubleTy(Context), 1);
   case MVT::nxv2f64:
     return ScalableVectorType::get(Type::getDoubleTy(Context), 2);
   case MVT::nxv4f64:
     return ScalableVectorType::get(Type::getDoubleTy(Context), 4);
   case MVT::nxv8f64:
     return ScalableVectorType::get(Type::getDoubleTy(Context), 8);

llvm/utils/TableGen/CodeGenTarget.cpp

StringRef llvm::getEnumName(MVT::SimpleValueType T) {
   case MVT::v8f64:    return "MVT::v8f64";
   case MVT::v16f64:   return "MVT::v16f64";
   case MVT::nxv1i1:   return "MVT::nxv1i1";
   case MVT::nxv2i1:   return "MVT::nxv2i1";
   case MVT::nxv4i1:   return "MVT::nxv4i1";
   case MVT::nxv8i1:   return "MVT::nxv8i1";
   case MVT::nxv16i1:  return "MVT::nxv16i1";
   case MVT::nxv32i1:  return "MVT::nxv32i1";
+  case MVT::nxv64i1:  return "MVT::nxv64i1";
   case MVT::nxv1i8:   return "MVT::nxv1i8";
   case MVT::nxv2i8:   return "MVT::nxv2i8";
   case MVT::nxv4i8:   return "MVT::nxv4i8";
   case MVT::nxv8i8:   return "MVT::nxv8i8";
   case MVT::nxv16i8:  return "MVT::nxv16i8";
   case MVT::nxv32i8:  return "MVT::nxv32i8";
+  case MVT::nxv64i8:  return "MVT::nxv64i8";
   case MVT::nxv1i16:  return "MVT::nxv1i16";
   case MVT::nxv2i16:  return "MVT::nxv2i16";
   case MVT::nxv4i16:  return "MVT::nxv4i16";
   case MVT::nxv8i16:  return "MVT::nxv8i16";
   case MVT::nxv16i16: return "MVT::nxv16i16";
   case MVT::nxv32i16: return "MVT::nxv32i16";
   case MVT::nxv1i32:  return "MVT::nxv1i32";
   case MVT::nxv2i32:  return "MVT::nxv2i32";
   case MVT::nxv4i32:  return "MVT::nxv4i32";
   case MVT::nxv8i32:  return "MVT::nxv8i32";
   case MVT::nxv16i32: return "MVT::nxv16i32";
+  case MVT::nxv32i32: return "MVT::nxv32i32";
   case MVT::nxv1i64:  return "MVT::nxv1i64";
   case MVT::nxv2i64:  return "MVT::nxv2i64";
   case MVT::nxv4i64:  return "MVT::nxv4i64";
   case MVT::nxv8i64:  return "MVT::nxv8i64";
   case MVT::nxv16i64: return "MVT::nxv16i64";
+  case MVT::nxv32i64: return "MVT::nxv32i64";
   case MVT::nxv2f16:  return "MVT::nxv2f16";
   case MVT::nxv4f16:  return "MVT::nxv4f16";
   case MVT::nxv8f16:  return "MVT::nxv8f16";
+  case MVT::nxv16f16: return "MVT::nxv16f16";
+  case MVT::nxv32f16: return "MVT::nxv32f16";
   case MVT::nxv2bf16:  return "MVT::nxv2bf16";
   case MVT::nxv4bf16:  return "MVT::nxv4bf16";
   case MVT::nxv8bf16:  return "MVT::nxv8bf16";
   case MVT::nxv1f32:  return "MVT::nxv1f32";
   case MVT::nxv2f32:  return "MVT::nxv2f32";
   case MVT::nxv4f32:  return "MVT::nxv4f32";
   case MVT::nxv8f32:  return "MVT::nxv8f32";
   case MVT::nxv16f32: return "MVT::nxv16f32";
+  case MVT::nxv32f32: return "MVT::nxv32f32";
   case MVT::nxv1f64:  return "MVT::nxv1f64";
   case MVT::nxv2f64:  return "MVT::nxv2f64";
   case MVT::nxv4f64:  return "MVT::nxv4f64";
   case MVT::nxv8f64:  return "MVT::nxv8f64";
   case MVT::token:    return "MVT::token";
   case MVT::Metadata: return "MVT::Metadata";
   case MVT::iPTR:     return "MVT::iPTR";
   case MVT::iPTRAny:  return "MVT::iPTRAny";