[MVT][SVE] Scalable vector MVTs (2/3)

[huntergr]

Summary

Adds scalable vector machine value types, and updates
the switch statements required for tablegen.

[huntergr]

See http://lists.llvm.org/pipermail/llvm-dev/2017-March/110772.html for earlier discussion on these types.

[craig.topper]

include/llvm/CodeGen/MachineValueType.h

31 ↗

(On Diff #95132)

I wonder if we should move INVALID_SIMPLE_VALUE_TYPE up to 0 and shift everything so we can keep this as a byte. Not sure if anything depends on Other being 0.

[rengolin]

include/llvm/CodeGen/MachineValueType.h

144 ↗

(On Diff #95132)

Are these values serialised in binary IR form?

If so, then reading previous IR would give you the wrong types, no?

[craig.topper]

They aren't serialized. They belong to the CodeGen implementation. IR doesn't use these.

[rengolin]

Right, then it looks ok.

[huntergr]

include/llvm/CodeGen/MachineValueType.h

31 ↗

(On Diff #95132)

I'll try that as an experiment and see if anything falls over.

[huntergr]

Changed SimpleValueType enum back to 8 bits, but made it unsigned. Renumbered all of them, with 0 now being the invalid value.

This passes 'make check-all' with all targets active, and passes lnt nightly tests.

[rengolin]

All three patches look good to me, now. Thanks Graham for the extended work on them, I think we have a solid foundation in which to start the SVE upstreaming.

llvm/trunk/include/llvm/CodeGen/MachineValueType.h

namespace llvm {
 
   class Type;
 
   /// Machine Value Type. Every type that is supported natively by some
   /// processor targeted by LLVM occurs here. This means that any legal value
   /// type can be represented by an MVT.
 class MVT {
   public:
-    enum SimpleValueType : int8_t {
-      // Simple value types less than zero are considered extended value types.
-      INVALID_SIMPLE_VALUE_TYPE = -1,
+    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          =   0,   // This is a non-standard value
-      i1             =   1,   // This is a 1 bit integer value
-      i8             =   2,   // This is an 8 bit integer value
-      i16            =   3,   // This is a 16 bit integer value
-      i32            =   4,   // This is a 32 bit integer value
-      i64            =   5,   // This is a 64 bit integer value
-      i128           =   6,   // This is a 128 bit integer value
+      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,
 
-      f16            =   7,   // This is a 16 bit floating point value
-      f32            =   8,   // This is a 32 bit floating point value
-      f64            =   9,   // This is a 64 bit floating point value
-      f80            =  10,   // This is a 80 bit floating point value
-      f128           =  11,   // This is a 128 bit floating point value
-      ppcf128        =  12,   // This is a PPC 128-bit floating point value
+      f16            =   8,   // This is a 16 bit floating point value
+      f32            =   9,   // This is a 32 bit floating point value
+      f64            =  10,   // This is a 64 bit floating point value
+      f80            =  11,   // This is a 80 bit floating point value
+      f128           =  12,   // This is a 128 bit floating point value
+      ppcf128        =  13,   // This is a PPC 128-bit floating point value
 
       FIRST_FP_VALUETYPE = f16,
       LAST_FP_VALUETYPE  = ppcf128,
 
-      v2i1           =  13,   //    2 x i1
-      v4i1           =  14,   //    4 x i1
-      v8i1           =  15,   //    8 x i1
-      v16i1          =  16,   //   16 x i1
-      v32i1          =  17,   //   32 x i1
-      v64i1          =  18,   //   64 x i1
-      v512i1         =  19,   //  512 x i1
-      v1024i1        =  20,   // 1024 x i1
-
-      v1i8           =  21,   //  1 x i8
-      v2i8           =  22,   //  2 x i8
-      v4i8           =  23,   //  4 x i8
-      v8i8           =  24,   //  8 x i8
-      v16i8          =  25,   // 16 x i8
-      v32i8          =  26,   // 32 x i8
-      v64i8          =  27,   // 64 x i8
-      v128i8         =  28,   //128 x i8
-      v256i8         =  29,   //256 x i8
-
-      v1i16          =  30,   //  1 x i16
-      v2i16          =  31,   //  2 x i16
-      v4i16          =  32,   //  4 x i16
-      v8i16          =  33,   //  8 x i16
-      v16i16         =  34,   // 16 x i16
-      v32i16         =  35,   // 32 x i16
-      v64i16         =  36,   // 64 x i16
-      v128i16        =  37,   //128 x i16
-
-      v1i32          =  38,   //  1 x i32
-      v2i32          =  39,   //  2 x i32
-      v4i32          =  40,   //  4 x i32
-      v8i32          =  41,   //  8 x i32
-      v16i32         =  42,   // 16 x i32
-      v32i32         =  43,   // 32 x i32
-      v64i32         =  44,   // 64 x i32
-
-      v1i64          =  45,   //  1 x i64
-      v2i64          =  46,   //  2 x i64
-      v4i64          =  47,   //  4 x i64
-      v8i64          =  48,   //  8 x i64
-      v16i64         =  49,   // 16 x i64
-      v32i64         =  50,   // 32 x i64
-
-      v1i128         =  51,   //  1 x i128
+      v2i1           =  14,   //    2 x i1
+      v4i1           =  15,   //    4 x i1
+      v8i1           =  16,   //    8 x i1
+      v16i1          =  17,   //   16 x i1
+      v32i1          =  18,   //   32 x i1
+      v64i1          =  19,   //   64 x i1
+      v512i1         =  20,   //  512 x i1
+      v1024i1        =  21,   // 1024 x i1
+
+      v1i8           =  22,   //  1 x i8
+      v2i8           =  23,   //  2 x i8
+      v4i8           =  24,   //  4 x i8
+      v8i8           =  25,   //  8 x i8
+      v16i8          =  26,   // 16 x i8
+      v32i8          =  27,   // 32 x i8
+      v64i8          =  28,   // 64 x i8
+      v128i8         =  29,   //128 x i8
+      v256i8         =  30,   //256 x i8
+
+      v1i16          =  31,   //  1 x i16
+      v2i16          =  32,   //  2 x i16
+      v4i16          =  33,   //  4 x i16
+      v8i16          =  34,   //  8 x i16
+      v16i16         =  35,   // 16 x i16
+      v32i16         =  36,   // 32 x i16
+      v64i16         =  37,   // 64 x i16
+      v128i16        =  38,   //128 x i16
+
+      v1i32          =  39,   //  1 x i32
+      v2i32          =  40,   //  2 x i32
+      v4i32          =  41,   //  4 x i32
+      v8i32          =  42,   //  8 x i32
+      v16i32         =  43,   // 16 x i32
+      v32i32         =  44,   // 32 x i32
+      v64i32         =  45,   // 64 x i32
+
+      v1i64          =  46,   //  1 x i64
+      v2i64          =  47,   //  2 x i64
+      v4i64          =  48,   //  4 x i64
+      v8i64          =  49,   //  8 x i64
+      v16i64         =  50,   // 16 x i64
+      v32i64         =  51,   // 32 x i64
+
+      v1i128         =  52,   //  1 x i128
+
+      // Scalable integer types
+      nxv2i1         =  53,   // n x  2 x i1
+      nxv4i1         =  54,   // n x  4 x i1
+      nxv8i1         =  55,   // n x  8 x i1
+      nxv16i1        =  56,   // n x 16 x i1
+      nxv32i1        =  57,   // n x 32 x i1
+
+      nxv1i8         =  58,   // n x  1 x i8
+      nxv2i8         =  59,   // n x  2 x i8
+      nxv4i8         =  60,   // n x  4 x i8
+      nxv8i8         =  61,   // n x  8 x i8
+      nxv16i8        =  62,   // n x 16 x i8
+      nxv32i8        =  63,   // n x 32 x i8
+
+      nxv1i16        =  64,   // n x  1 x i16
+      nxv2i16        =  65,   // n x  2 x i16
+      nxv4i16        =  66,   // n x  4 x i16
+      nxv8i16        =  67,   // n x  8 x i16
+      nxv16i16       =  68,   // n x 16 x i16
+      nxv32i16       =  69,   // n x 32 x i16
+
+      nxv1i32        =  70,   // n x  1 x i32
+      nxv2i32        =  71,   // n x  2 x i32
+      nxv4i32        =  72,   // n x  4 x i32
+      nxv8i32        =  73,   // n x  8 x i32
+      nxv16i32       =  74,   // n x 16 x i32
+      nxv32i32       =  75,   // n x 32 x i32
+
+      nxv1i64        =  76,   // n x  1 x i64
+      nxv2i64        =  77,   // n x  2 x i64
+      nxv4i64        =  78,   // n x  4 x i64
+      nxv8i64        =  79,   // n x  8 x i64
+      nxv16i64       =  80,   // n x 16 x i64
+      nxv32i64       =  81,   // n x 32 x i64
 
       FIRST_INTEGER_VECTOR_VALUETYPE = v2i1,
-      LAST_INTEGER_VECTOR_VALUETYPE = v1i128,
+      LAST_INTEGER_VECTOR_VALUETYPE = nxv32i64,
+
+      FIRST_INTEGER_SCALABLE_VALUETYPE = nxv2i1,
+      LAST_INTEGER_SCALABLE_VALUETYPE = nxv32i64,
 
-      v2f16          =  52,   //  2 x f16
-      v4f16          =  53,   //  4 x f16
-      v8f16          =  54,   //  8 x f16
-      v1f32          =  55,   //  1 x f32
-      v2f32          =  56,   //  2 x f32
-      v4f32          =  57,   //  4 x f32
-      v8f32          =  58,   //  8 x f32
-      v16f32         =  59,   // 16 x f32
-      v1f64          =  60,   //  1 x f64
-      v2f64          =  61,   //  2 x f64
-      v4f64          =  62,   //  4 x f64
-      v8f64          =  63,   //  8 x f64
+      v2f16          =  82,   //  2 x f16
+      v4f16          =  83,   //  4 x f16
+      v8f16          =  84,   //  8 x f16
+      v1f32          =  85,   //  1 x f32
+      v2f32          =  86,   //  2 x f32
+      v4f32          =  87,   //  4 x f32
+      v8f32          =  88,   //  8 x f32
+      v16f32         =  89,   // 16 x f32
+      v1f64          =  90,   //  1 x f64
+      v2f64          =  91,   //  2 x f64
+      v4f64          =  92,   //  4 x f64
+      v8f64          =  93,   //  8 x f64
+
+      nxv2f16        =  94,   // n x  2 x f16
+      nxv4f16        =  95,   // n x  4 x f16
+      nxv8f16        =  96,   // n x  8 x f16
+      nxv1f32        =  97,   // n x  1 x f32
+      nxv2f32        =  98,   // n x  2 x f32
+      nxv4f32        =  99,   // n x  4 x f32
+      nxv8f32        = 100,   // n x  8 x f32
+      nxv16f32       = 101,   // n x 16 x f32
+      nxv1f64        = 102,   // n x  1 x f64
+      nxv2f64        = 103,   // n x  2 x f64
+      nxv4f64        = 104,   // n x  4 x f64
+      nxv8f64        = 105,   // n x  8 x f64
 
       FIRST_FP_VECTOR_VALUETYPE = v2f16,
-      LAST_FP_VECTOR_VALUETYPE = v8f64,
+      LAST_FP_VECTOR_VALUETYPE = nxv8f64,
+
+      FIRST_FP_SCALABLE_VALUETYPE = nxv2f16,
+      LAST_FP_SCALABLE_VALUETYPE = nxv8f64,
 
       FIRST_VECTOR_VALUETYPE = v2i1,
-      LAST_VECTOR_VALUETYPE  = v8f64,
+      LAST_VECTOR_VALUETYPE  = nxv8f64,
 
-      x86mmx         =  64,   // This is an X86 MMX value
+      x86mmx         =  106,   // This is an X86 MMX value
 
-      Glue           =  65,   // This glues nodes together during pre-RA sched
+      Glue           =  107,   // This glues nodes together during pre-RA sched
 
-      isVoid         =  66,   // This has no value
+      isVoid         =  108,   // This has no value
 
-      Untyped        =  67,   // This value takes a register, but has
+      Untyped        =  109,   // This value takes a register, but has
                                // unspecified type.  The register class
                                // will be determined by the opcode.
 
-      FIRST_VALUETYPE = 0,    // This is always the beginning of the list.
-      LAST_VALUETYPE =  68,   // This always remains at the end of the list.
+      FIRST_VALUETYPE = 1,     // This is always the beginning of the list.
+      LAST_VALUETYPE =  110,   // 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 = 96,
+      MAX_ALLOWED_VALUETYPE = 128,
 
       // A value of type llvm::TokenTy
-      token          = 120,
+      token          = 248,
 
       // This is MDNode or MDString.
-      Metadata       = 121,
+      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        = 122,
+      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           = 123,
+      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           = 124,
+      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           = 125,
+      iAny           = 253,
 
       // An int value the size of the pointer of the current
       // target.  This should only be used internal to tblgen!
-      iPTR           = 126,
+      iPTR           = 254,
 
       // Any type. This is used for intrinsics that have overloadings.
       // This is only for tblgen's consumption!
-      Any            = 127
+      Any            = 255
     };
 
     SimpleValueType SimpleTy;
 
     constexpr MVT() : SimpleTy(INVALID_SIMPLE_VALUE_TYPE) {}
     constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {}
 
     bool operator>(const MVT& S)  const { return SimpleTy >  S.SimpleTy; }
MVT getVectorElementType() const {
         llvm_unreachable("Not a vector MVT!");
       case v2i1:
       case v4i1:
       case v8i1:
       case v16i1:
       case v32i1:
       case v64i1:
       case v512i1:
-      case v1024i1: return i1;
+      case v1024i1:
+      case nxv2i1:
+      case nxv4i1:
+      case nxv8i1:
+      case nxv16i1:
+      case nxv32i1: return i1;
       case v1i8:
       case v2i8:
       case v4i8:
       case v8i8:
       case v16i8:
       case v32i8:
       case v64i8:
       case v128i8:
-      case v256i8: return i8;
+      case v256i8:
+      case nxv1i8:
+      case nxv2i8:
+      case nxv4i8:
+      case nxv8i8:
+      case nxv16i8:
+      case nxv32i8: return i8;
       case v1i16:
       case v2i16:
       case v4i16:
       case v8i16:
       case v16i16:
       case v32i16:
       case v64i16:
-      case v128i16: return i16;
+      case v128i16:
+      case nxv1i16:
+      case nxv2i16:
+      case nxv4i16:
+      case nxv8i16:
+      case nxv16i16:
+      case nxv32i16: return i16;
       case v1i32:
       case v2i32:
       case v4i32:
       case v8i32:
       case v16i32:
       case v32i32:
-      case v64i32: return i32;
+      case v64i32:
+      case nxv1i32:
+      case nxv2i32:
+      case nxv4i32:
+      case nxv8i32:
+      case nxv16i32:
+      case nxv32i32: return i32;
       case v1i64:
       case v2i64:
       case v4i64:
       case v8i64:
       case v16i64:
-      case v32i64: return i64;
+      case v32i64:
+      case nxv1i64:
+      case nxv2i64:
+      case nxv4i64:
+      case nxv8i64:
+      case nxv16i64:
+      case nxv32i64: return i64;
       case v1i128: return i128;
       case v2f16:
       case v4f16:
-      case v8f16: return f16;
+      case v8f16:
+      case nxv2f16:
+      case nxv4f16:
+      case nxv8f16: return f16;
       case v1f32:
       case v2f32:
       case v4f32:
       case v8f32:
-      case v16f32: return f32;
+      case v16f32:
+      case nxv1f32:
+      case nxv2f32:
+      case nxv4f32:
+      case nxv8f32:
+      case nxv16f32: return f32;
       case v1f64:
       case v2f64:
       case v4f64:
-      case v8f64: return f64;
+      case v8f64:
+      case nxv1f64:
+      case nxv2f64:
+      case nxv4f64:
+      case nxv8f64: return f64;
       }
     }
 
     unsigned getVectorNumElements() const {
       switch (SimpleTy) {
       default:
         llvm_unreachable("Not a vector MVT!");
       case v1024i1: return 1024;
       case v512i1: return 512;
       case v256i8: return 256;
       case v128i8:
       case v128i16: return 128;
       case v64i1:
       case v64i8:
       case v64i16:
       case v64i32: return 64;
       case v32i1:
       case v32i8:
       case v32i16:
       case v32i32:
-      case v32i64: return 32;
+      case v32i64:
+      case nxv32i1:
+      case nxv32i8:
+      case nxv32i16:
+      case nxv32i32:
+      case nxv32i64: return 32;
       case v16i1:
       case v16i8:
       case v16i16:
       case v16i32:
       case v16i64:
-      case v16f32: return 16;
+      case v16f32:
+      case nxv16i1:
+      case nxv16i8:
+      case nxv16i16:
+      case nxv16i32:
+      case nxv16i64:
+      case nxv16f32: return 16;
       case v8i1:
       case v8i8:
       case v8i16:
       case v8i32:
       case v8i64:
       case v8f16:
       case v8f32:
-      case v8f64: return 8;
+      case v8f64:
+      case nxv8i1:
+      case nxv8i8:
+      case nxv8i16:
+      case nxv8i32:
+      case nxv8i64:
+      case nxv8f16:
+      case nxv8f32:
+      case nxv8f64: return 8;
       case v4i1:
       case v4i8:
       case v4i16:
       case v4i32:
       case v4i64:
       case v4f16:
       case v4f32:
-      case v4f64: return 4;
+      case v4f64:
+      case nxv4i1:
+      case nxv4i8:
+      case nxv4i16:
+      case nxv4i32:
+      case nxv4i64:
+      case nxv4f16:
+      case nxv4f32:
+      case nxv4f64: return 4;
       case v2i1:
       case v2i8:
       case v2i16:
       case v2i32:
       case v2i64:
       case v2f16:
       case v2f32:
-      case v2f64: return 2;
+      case v2f64:
+      case nxv2i1:
+      case nxv2i8:
+      case nxv2i16:
+      case nxv2i32:
+      case nxv2i64:
+      case nxv2f16:
+      case nxv2f32:
+      case nxv2f64: return 2;
       case v1i8:
       case v1i16:
       case v1i32:
       case v1i64:
       case v1i128:
       case v1f32:
-      case v1f64: return 1;
+      case v1f64:
+      case nxv1i8:
+      case nxv1i16:
+      case nxv1i32:
+      case nxv1i64:
+      case nxv1f32:
+      case nxv1f64: return 1;
       }
     }
 
     unsigned getSizeInBits() const {
       switch (SimpleTy) {
       default:
         llvm_unreachable("getSizeInBits called on extended MVT.");
       case Other:
         llvm_unreachable("Value type is non-standard value, Other.");
       case iPTR:
         llvm_unreachable("Value type size is target-dependent. Ask TLI.");
       case iPTRAny:
       case iAny:
       case fAny:
       case vAny:
       case Any:
         llvm_unreachable("Value type is overloaded.");
       case token:
         llvm_unreachable("Token type is a sentinel that cannot be used "
                          "in codegen and has no size");
       case Metadata:
         llvm_unreachable("Value type is metadata.");
       case i1  :  return 1;
-      case v2i1:  return 2;
-      case v4i1:  return 4;
+      case v2i1:
+      case nxv2i1: return 2;
+      case v4i1:
+      case nxv4i1: return 4;
       case i8  :
       case v1i8:
-      case v8i1: return 8;
+      case v8i1:
+      case nxv1i8:
+      case nxv8i1: return 8;
       case i16 :
       case f16:
       case v16i1:
       case v2i8:
-      case v1i16: return 16;
+      case v1i16:
+      case nxv16i1:
+      case nxv2i8:
+      case nxv1i16: return 16;
       case f32 :
       case i32 :
       case v32i1:
       case v4i8:
       case v2i16:
       case v2f16:
       case v1f32:
-      case v1i32: return 32;
+      case v1i32:
+      case nxv32i1:
+      case nxv4i8:
+      case nxv2i16:
+      case nxv1i32:
+      case nxv2f16:
+      case nxv1f32: return 32;
       case x86mmx:
       case f64 :
       case i64 :
       case v64i1:
       case v8i8:
       case v4i16:
       case v2i32:
       case v1i64:
       case v4f16:
       case v2f32:
-      case v1f64: return 64;
+      case v1f64:
+      case nxv8i8:
+      case nxv4i16:
+      case nxv2i32:
+      case nxv1i64:
+      case nxv4f16:
+      case nxv2f32:
+      case nxv1f64: return 64;
       case f80 :  return 80;
       case f128:
       case ppcf128:
       case i128:
       case v16i8:
       case v8i16:
       case v4i32:
       case v2i64:
       case v1i128:
       case v8f16:
       case v4f32:
-      case v2f64: return 128;
+      case v2f64:
+      case nxv16i8:
+      case nxv8i16:
+      case nxv4i32:
+      case nxv2i64:
+      case nxv8f16:
+      case nxv4f32:
+      case nxv2f64: return 128;
       case v32i8:
       case v16i16:
       case v8i32:
       case v4i64:
       case v8f32:
-      case v4f64: return 256;
+      case v4f64:
+      case nxv32i8:
+      case nxv16i16:
+      case nxv8i32:
+      case nxv4i64:
+      case nxv8f32:
+      case nxv4f64: return 256;
       case v512i1:
       case v64i8:
       case v32i16:
       case v16i32:
       case v8i64:
       case v16f32:
-      case v8f64: return 512;
+      case v8f64:
+      case nxv32i16:
+      case nxv16i32:
+      case nxv8i64:
+      case nxv16f32:
+      case nxv8f64: return 512;
       case v1024i1:
       case v128i8:
       case v64i16:
       case v32i32:
-      case v16i64: return 1024;
+      case v16i64:
+      case nxv32i32:
+      case nxv16i64: return 1024;
       case v256i8:
       case v128i16:
       case v64i32:
-      case v32i64: return 2048;
+      case v32i64:
+      case nxv32i64: return 2048;
       }
     }
 
     unsigned getScalarSizeInBits() const {
       return getScalarType().getSizeInBits();
     }
 
     /// Return the number of bytes overwritten by a store of the specified value

llvm/trunk/include/llvm/CodeGen/ValueTypes.h

public:
     constexpr EVT(MVT S) : V(S), LLVMTy(nullptr) {}
 
     bool operator==(EVT VT) const {
       return !(*this != VT);
     }
     bool operator!=(EVT VT) const {
       if (V.SimpleTy != VT.V.SimpleTy)
         return true;
-      if (V.SimpleTy < 0)
+      if (V.SimpleTy == MVT::INVALID_SIMPLE_VALUE_TYPE)
         return LLVMTy != VT.LLVMTy;
       return false;
     }
 
     /// Returns the EVT that represents a floating-point type with the given
     /// number of bits. There are two floating-point types with 128 bits - this
     /// returns f128 rather than ppcf128.
     static EVT getFloatingPointVT(unsigned BitWidth) {
       return MVT::getFloatingPointVT(BitWidth);
     }
 
     /// Returns the EVT that represents an integer with the given number of
     /// bits.
     static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth) {
       MVT M = MVT::getIntegerVT(BitWidth);
-      if (M.SimpleTy >= 0)
+      if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
         return M;
       return getExtendedIntegerVT(Context, BitWidth);
     }
 
     /// Returns the EVT that represents a vector NumElements in length, where
     /// each element is of type VT.
     static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements) {
       MVT M = MVT::getVectorVT(VT.V, NumElements);
-      if (M.SimpleTy >= 0)
+      if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
         return M;
       return getExtendedVectorVT(Context, VT, NumElements);
     }
 
     /// Return a vector with the same number of elements as this vector, but
     /// with the element type converted to an integer type with the same
     /// bitwidth.
     EVT changeVectorElementTypeToInteger() const {
EVT changeTypeToInteger() {
       if (isSimple())
         return MVT::getIntegerVT(getSizeInBits());
 
       return changeExtendedTypeToInteger();
     }
 
     /// Test if the given EVT is simple (as opposed to being extended).
     bool isSimple() const {
-      return V.SimpleTy >= 0;
+      return V.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE;
     }
 
     /// Test if the given EVT is extended (as opposed to being simple).
     bool isExtended() const {
       return !isSimple();
     }
 
     /// Return true if this is a FP or a vector FP type.

llvm/trunk/include/llvm/CodeGen/ValueTypes.td

 //===----------------------------------------------------------------------===//
 
 class ValueType<int size, int value> {
   string Namespace = "MVT";
   int Size = size;
   int Value = value;
 }
 
-def OtherVT: ValueType<0  ,  0>;   // "Other" value
-def i1     : ValueType<1  ,  1>;   // One bit boolean value
-def i8     : ValueType<8  ,  2>;   // 8-bit integer value
-def i16    : ValueType<16 ,  3>;   // 16-bit integer value
-def i32    : ValueType<32 ,  4>;   // 32-bit integer value
-def i64    : ValueType<64 ,  5>;   // 64-bit integer value
-def i128   : ValueType<128,  6>;   // 128-bit integer value
-def f16    : ValueType<16 ,  7>;   // 16-bit floating point value
-def f32    : ValueType<32 ,  8>;   // 32-bit floating point value
-def f64    : ValueType<64 ,  9>;   // 64-bit floating point value
-def f80    : ValueType<80 , 10>;   // 80-bit floating point value
-def f128   : ValueType<128, 11>;   // 128-bit floating point value
-def ppcf128: ValueType<128, 12>;   // PPC 128-bit floating point value
-
-def v2i1   : ValueType<2 ,  13>;   //   2 x i1 vector value
-def v4i1   : ValueType<4 ,  14>;   //   4 x i1 vector value
-def v8i1   : ValueType<8 ,  15>;   //   8 x i1 vector value
-def v16i1  : ValueType<16,  16>;   //  16 x i1 vector value
-def v32i1  : ValueType<32 , 17>;   //  32 x i1 vector value
-def v64i1  : ValueType<64 , 18>;   //  64 x i1 vector value
-def v512i1 : ValueType<512, 19>;   // 512 x i1 vector value
-def v1024i1: ValueType<1024,20>;   //1024 x i1 vector value
-
-def v1i8   : ValueType<16,  21>;   //  1 x i8  vector value
-def v2i8   : ValueType<16 , 22>;   //  2 x i8  vector value
-def v4i8   : ValueType<32 , 23>;   //  4 x i8  vector value
-def v8i8   : ValueType<64 , 24>;   //  8 x i8  vector value
-def v16i8  : ValueType<128, 25>;   // 16 x i8  vector value
-def v32i8  : ValueType<256, 26>;   // 32 x i8  vector value
-def v64i8  : ValueType<512, 27>;   // 64 x i8  vector value
-def v128i8 : ValueType<1024,28>;   //128 x i8  vector value
-def v256i8 : ValueType<2048,29>;   //256 x i8  vector value
-
-def v1i16  : ValueType<16 , 30>;   //  1 x i16 vector value
-def v2i16  : ValueType<32 , 31>;   //  2 x i16 vector value
-def v4i16  : ValueType<64 , 32>;   //  4 x i16 vector value
-def v8i16  : ValueType<128, 33>;   //  8 x i16 vector value
-def v16i16 : ValueType<256, 34>;   // 16 x i16 vector value
-def v32i16 : ValueType<512, 35>;   // 32 x i16 vector value
-def v64i16 : ValueType<1024,36>;   // 64 x i16 vector value
-def v128i16: ValueType<2048,37>;   //128 x i16 vector value
-
-def v1i32  : ValueType<32 , 38>;   //  1 x i32 vector value
-def v2i32  : ValueType<64 , 39>;   //  2 x i32 vector value
-def v4i32  : ValueType<128, 40>;   //  4 x i32 vector value
-def v8i32  : ValueType<256, 41>;   //  8 x i32 vector value
-def v16i32 : ValueType<512, 42>;   // 16 x i32 vector value
-def v32i32 : ValueType<1024,43>;   // 32 x i32 vector value
-def v64i32 : ValueType<2048,44>;   // 32 x i32 vector value
-
-def v1i64  : ValueType<64 , 45>;   //  1 x i64 vector value
-def v2i64  : ValueType<128, 46>;   //  2 x i64 vector value
-def v4i64  : ValueType<256, 47>;   //  4 x i64 vector value
-def v8i64  : ValueType<512, 48>;   //  8 x i64 vector value
-def v16i64 : ValueType<1024,49>;   // 16 x i64 vector value
-def v32i64 : ValueType<2048,50>;   // 32 x i64 vector value
-
-def v1i128 : ValueType<128, 51>;   //  1 x i128 vector value
-
-def v2f16  : ValueType<32 , 52>;   //  2 x f16 vector value
-def v4f16  : ValueType<64 , 53>;   //  4 x f16 vector value
-def v8f16  : ValueType<128, 54>;   //  8 x f16 vector value
-def v1f32  : ValueType<32 , 55>;   //  1 x f32 vector value
-def v2f32  : ValueType<64 , 56>;   //  2 x f32 vector value
-def v4f32  : ValueType<128, 57>;   //  4 x f32 vector value
-def v8f32  : ValueType<256, 58>;   //  8 x f32 vector value
-def v16f32 : ValueType<512, 59>;   // 16 x f32 vector value
-def v1f64  : ValueType<64,  60>;   //  1 x f64 vector value
-def v2f64  : ValueType<128, 61>;   //  2 x f64 vector value
-def v4f64  : ValueType<256, 62>;   //  4 x f64 vector value
-def v8f64  : ValueType<512, 63>;   //  8 x f64 vector value
-
-
-def x86mmx : ValueType<64 , 64>;   // X86 MMX value
-def FlagVT : ValueType<0  , 65>;   // Pre-RA sched glue
-def isVoid : ValueType<0  , 66>;   // Produces no value
-def untyped: ValueType<8  , 67>;   // Produces an untyped value
-def token  : ValueType<0  , 120>;  // TokenTy
-def MetadataVT: ValueType<0, 121>; // Metadata
+def OtherVT: ValueType<0  ,  1>;   // "Other" value
+def i1     : ValueType<1  ,  2>;   // One bit boolean value
+def i8     : ValueType<8  ,  3>;   // 8-bit integer value
+def i16    : ValueType<16 ,  4>;   // 16-bit integer value
+def i32    : ValueType<32 ,  5>;   // 32-bit integer value
+def i64    : ValueType<64 ,  6>;   // 64-bit integer value
+def i128   : ValueType<128,  7>;   // 128-bit integer value
+def f16    : ValueType<16 ,  8>;   // 16-bit floating point value
+def f32    : ValueType<32 ,  9>;   // 32-bit floating point value
+def f64    : ValueType<64 , 10>;   // 64-bit floating point value
+def f80    : ValueType<80 , 11>;   // 80-bit floating point value
+def f128   : ValueType<128, 12>;   // 128-bit floating point value
+def ppcf128: ValueType<128, 13>;   // PPC 128-bit floating point value
+
+def v2i1   : ValueType<2 ,  14>;   //   2 x i1 vector value
+def v4i1   : ValueType<4 ,  15>;   //   4 x i1 vector value
+def v8i1   : ValueType<8 ,  16>;   //   8 x i1 vector value
+def v16i1  : ValueType<16,  17>;   //  16 x i1 vector value
+def v32i1  : ValueType<32 , 18>;   //  32 x i1 vector value
+def v64i1  : ValueType<64 , 19>;   //  64 x i1 vector value
+def v512i1 : ValueType<512, 20>;   // 512 x i1 vector value
+def v1024i1: ValueType<1024,21>;   //1024 x i1 vector value
+
+def v1i8   : ValueType<16,  22>;   //  1 x i8  vector value
+def v2i8   : ValueType<16 , 23>;   //  2 x i8  vector value
+def v4i8   : ValueType<32 , 24>;   //  4 x i8  vector value
+def v8i8   : ValueType<64 , 25>;   //  8 x i8  vector value
+def v16i8  : ValueType<128, 26>;   // 16 x i8  vector value
+def v32i8  : ValueType<256, 27>;   // 32 x i8  vector value
+def v64i8  : ValueType<512, 28>;   // 64 x i8  vector value
+def v128i8 : ValueType<1024,29>;   //128 x i8  vector value
+def v256i8 : ValueType<2048,30>;   //256 x i8  vector value
+
+def v1i16  : ValueType<16 , 31>;   //  1 x i16 vector value
+def v2i16  : ValueType<32 , 32>;   //  2 x i16 vector value
+def v4i16  : ValueType<64 , 33>;   //  4 x i16 vector value
+def v8i16  : ValueType<128, 34>;   //  8 x i16 vector value
+def v16i16 : ValueType<256, 35>;   // 16 x i16 vector value
+def v32i16 : ValueType<512, 36>;   // 32 x i16 vector value
+def v64i16 : ValueType<1024,37>;   // 64 x i16 vector value
+def v128i16: ValueType<2048,38>;   //128 x i16 vector value
+
+def v1i32  : ValueType<32 , 39>;   //  1 x i32 vector value
+def v2i32  : ValueType<64 , 40>;   //  2 x i32 vector value
+def v4i32  : ValueType<128, 41>;   //  4 x i32 vector value
+def v8i32  : ValueType<256, 42>;   //  8 x i32 vector value
+def v16i32 : ValueType<512, 43>;   // 16 x i32 vector value
+def v32i32 : ValueType<1024,44>;   // 32 x i32 vector value
+def v64i32 : ValueType<2048,45>;   // 32 x i32 vector value
+
+def v1i64  : ValueType<64 , 46>;   //  1 x i64 vector value
+def v2i64  : ValueType<128, 47>;   //  2 x i64 vector value
+def v4i64  : ValueType<256, 48>;   //  4 x i64 vector value
+def v8i64  : ValueType<512, 49>;   //  8 x i64 vector value
+def v16i64 : ValueType<1024,50>;   // 16 x i64 vector value
+def v32i64 : ValueType<2048,51>;   // 32 x i64 vector value
+
+def v1i128 : ValueType<128, 52>;   //  1 x i128 vector value
+
+def nxv2i1  : ValueType<2,   53>;  // n x  2 x i1  vector value
+def nxv4i1  : ValueType<4,   54>;  // n x  4 x i1  vector value
+def nxv8i1  : ValueType<8,   55>;  // n x  8 x i1  vector value
+def nxv16i1 : ValueType<16,  56>;  // n x 16 x i1  vector value
+def nxv32i1 : ValueType<32,  57>;  // n x 32 x i1  vector value
+
+def nxv1i8  : ValueType<8,   58>;  // n x  1 x i8  vector value
+def nxv2i8  : ValueType<16,  59>;  // n x  2 x i8  vector value
+def nxv4i8  : ValueType<32,  60>;  // n x  4 x i8  vector value
+def nxv8i8  : ValueType<64,  61>;  // n x  8 x i8  vector value
+def nxv16i8 : ValueType<128, 62>;  // n x 16 x i8  vector value
+def nxv32i8 : ValueType<256, 63>;  // n x 32 x i8  vector value
+
+def nxv1i16 : ValueType<16,  64>;  // n x  1 x i16 vector value
+def nxv2i16 : ValueType<32,  65>;  // n x  2 x i16 vector value
+def nxv4i16 : ValueType<64,  66>;  // n x  4 x i16 vector value
+def nxv8i16 : ValueType<128, 67>;  // n x  8 x i16 vector value
+def nxv16i16: ValueType<256, 68>;  // n x 16 x i16 vector value
+def nxv32i16: ValueType<512, 69>;  // n x 32 x i16 vector value
+
+def nxv1i32 : ValueType<32,  70>;  // n x  1 x i32 vector value
+def nxv2i32 : ValueType<64,  71>;  // n x  2 x i32 vector value
+def nxv4i32 : ValueType<128, 72>;  // n x  4 x i32 vector value
+def nxv8i32 : ValueType<256, 73>;  // n x  8 x i32 vector value
+def nxv16i32: ValueType<512, 74>;  // n x 16 x i32 vector value
+def nxv32i32: ValueType<1024,75>;  // n x 32 x i32 vector value
+
+def nxv1i64 : ValueType<64,  76>;  // n x  1 x i64 vector value
+def nxv2i64 : ValueType<128, 77>;  // n x  2 x i64 vector value
+def nxv4i64 : ValueType<256, 78>;  // n x  4 x i64 vector value
+def nxv8i64 : ValueType<512, 79>;  // n x  8 x i64 vector value
+def nxv16i64: ValueType<1024,80>;  // n x 16 x i64 vector value
+def nxv32i64: ValueType<2048,81>;  // n x 32 x i64 vector value
+
+def v2f16  : ValueType<32 , 82>;   //  2 x f16 vector value
+def v4f16  : ValueType<64 , 83>;   //  4 x f16 vector value
+def v8f16  : ValueType<128, 84>;   //  8 x f16 vector value
+def v1f32  : ValueType<32 , 85>;   //  1 x f32 vector value
+def v2f32  : ValueType<64 , 86>;   //  2 x f32 vector value
+def v4f32  : ValueType<128, 87>;   //  4 x f32 vector value
+def v8f32  : ValueType<256, 88>;   //  8 x f32 vector value
+def v16f32 : ValueType<512, 89>;   // 16 x f32 vector value
+def v1f64  : ValueType<64,  90>;   //  1 x f64 vector value
+def v2f64  : ValueType<128, 91>;   //  2 x f64 vector value
+def v4f64  : ValueType<256, 92>;   //  4 x f64 vector value
+def v8f64  : ValueType<512, 93>;   //  8 x f64 vector value
+
+def nxv2f16  : ValueType<32 ,  94>; // n x  2 x f16 vector value
+def nxv4f16  : ValueType<64 ,  95>; // n x  4 x f16 vector value
+def nxv8f16  : ValueType<128,  96>; // n x  8 x f16 vector value
+def nxv1f32  : ValueType<32 ,  97>; // n x  1 x f32 vector value
+def nxv2f32  : ValueType<64 ,  98>; // n x  2 x f32 vector value
+def nxv4f32  : ValueType<128,  99>; // n x  4 x f32 vector value
+def nxv8f32  : ValueType<256, 100>; // n x  8 x f32 vector value
+def nxv16f32 : ValueType<512, 101>; // n x 16 x f32 vector value
+def nxv1f64  : ValueType<64,  102>; // n x  1 x f64 vector value
+def nxv2f64  : ValueType<128, 103>; // n x  2 x f64 vector value
+def nxv4f64  : ValueType<256, 104>; // n x  4 x f64 vector value
+def nxv8f64  : ValueType<512, 105>; // n x  8 x f64 vector value
+
+def x86mmx : ValueType<64 , 106>;   // X86 MMX value
+def FlagVT : ValueType<0  , 107>;   // Pre-RA sched glue
+def isVoid : ValueType<0  , 108>;   // Produces no value
+def untyped: ValueType<8  , 109>;   // Produces an untyped value
+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, 122>;
+def iPTRAny   : ValueType<0, 250>;
 
 // Pseudo valuetype to represent "vector of any size"
-def vAny   : ValueType<0  , 123>;
+def vAny   : ValueType<0  , 251>;
 
 // Pseudo valuetype to represent "float of any format"
-def fAny   : ValueType<0  , 124>;
+def fAny   : ValueType<0  , 252>;
 
 // Pseudo valuetype to represent "integer of any bit width"
-def iAny   : ValueType<0  , 125>;
+def iAny   : ValueType<0  , 253>;
 
 // Pseudo valuetype mapped to the current pointer size.
-def iPTR   : ValueType<0  , 126>;
+def iPTR   : ValueType<0  , 254>;
 
 // Pseudo valuetype to represent "any type of any size".
-def Any    : ValueType<0  , 127>;
+def Any    : ValueType<0  , 255>;

llvm/trunk/test/TableGen/intrinsic-long-name.td

class Intrinsic<string name, list<LLVMType> param_types = []> {
   string LLVMName = name;
   bit isTarget = 0;
   string TargetPrefix = "";
   list<LLVMType> RetTypes = [];
   list<LLVMType> ParamTypes = param_types;
   list<IntrinsicProperty> IntrProperties = [];
 }
 
-def iAny : ValueType<0, 125>;
+def iAny : ValueType<0, 253>;
 def llvm_anyint_ty : LLVMType<iAny>;
 
 // Make sure we generate the long name without crashing
 // CHECK: this_is_a_really_long_intrinsic_name_but_we_should_still_not_crash   // llvm.this.is.a.really.long.intrinsic.name.but.we.should.still.not.crash
 def int_foo : Intrinsic<"llvm.foo", [llvm_anyint_ty]>;
 def int_this_is_a_really_long_intrinsic_name_but_we_should_still_not_crash : Intrinsic<"llvm.this.is.a.really.long.intrinsic.name.but.we.should.still.not.crash", [llvm_anyint_ty]>;
 

llvm/trunk/test/TableGen/intrinsic-varargs.td

class Intrinsic<string name, list<LLVMType> param_types = []> {
   bit isTarget = 0;
   string TargetPrefix = "";
   list<LLVMType> RetTypes = [];
   list<LLVMType> ParamTypes = param_types;
   list<IntrinsicProperty> IntrProperties = [];
 }
 
 // isVoid needs to match the definition in ValueTypes.td
-def isVoid : ValueType<0, 66>;   // Produces no value
+def isVoid : ValueType<0, 108>;   // Produces no value
 def llvm_vararg_ty : LLVMType<isVoid>;   // this means vararg here
 
 // CHECK: /* 0 */ 0, 29, 0,
 def int_foo : Intrinsic<"llvm.foo", [llvm_vararg_ty]>;

llvm/trunk/utils/TableGen/CodeGenTarget.cpp

StringRef llvm::getEnumName(MVT::SimpleValueType T) {
   case MVT::v2f32:    return "MVT::v2f32";
   case MVT::v4f32:    return "MVT::v4f32";
   case MVT::v8f32:    return "MVT::v8f32";
   case MVT::v16f32:   return "MVT::v16f32";
   case MVT::v1f64:    return "MVT::v1f64";
   case MVT::v2f64:    return "MVT::v2f64";
   case MVT::v4f64:    return "MVT::v4f64";
   case MVT::v8f64:    return "MVT::v8f64";
+  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::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::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::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::nxv2f16:  return "MVT::nxv2f16";
+  case MVT::nxv4f16:  return "MVT::nxv4f16";
+  case MVT::nxv8f16:  return "MVT::nxv8f16";
+  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::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";
   case MVT::Untyped:  return "MVT::Untyped";
   default: llvm_unreachable("ILLEGAL VALUE TYPE!");
   }
 }