[ValueTypes] Add types for nxv16bf16 and nxv32bf16.

[craig.topper]

Summary

This is needed by our downstream and makes bf16 and f16 have the
same set of scalable vector types.

[Amir]

This diff breaks MSVC build: https://lab.llvm.org/buildbot/#/builders/222/builds/1268. Can you please take a look?

[craig.topper]

In D127877#3590136, @Amir wrote:

This diff breaks MSVC build: https://lab.llvm.org/buildbot/#/builders/222/builds/1268. Can you please take a look?

It feels like llvm-tblgen didn't get rebuilt and is out of sync with ValueTypes.td. Is that possible?

The last time these files were updated this same bot failed with a tablegen error from build 896 through at least build 1130.

[Amir]

In D127877#3590347, @craig.topper wrote:

In D127877#3590136, @Amir wrote:

This diff breaks MSVC build: https://lab.llvm.org/buildbot/#/builders/222/builds/1268. Can you please take a look?

It feels like llvm-tblgen didn't get rebuilt and is out of sync with ValueTypes.td. Is that possible?

The last time these files were updated this same bot failed with a tablegen error from build 896 through at least build 1130.

Thanks for looking! You're right, llvm-tblgen is not rebuilt (it's a cross-compilation setup). Will address that

llvm/include/llvm/CodeGen/ValueTypes.td

 def nxv8f16  : ValueType<128, 159>;  // n x  8 x  f16 vector value
 def nxv16f16 : ValueType<256, 160>;  // n x 16 x  f16 vector value
 def nxv32f16 : ValueType<512, 161>;  // n x 32 x  f16 vector value
 
 def nxv1bf16 : ValueType<16,  162>;  // n x  1 x bf16 vector value
 def nxv2bf16 : ValueType<32,  163>;  // n x  2 x bf16 vector value
 def nxv4bf16 : ValueType<64,  164>;  // n x  4 x bf16 vector value
 def nxv8bf16 : ValueType<128, 165>;  // n x  8 x bf16 vector value
+def nxv16bf16 : ValueType<256, 166>;  // n x 16 x bf16 vector value
+def nxv32bf16 : ValueType<512, 167>;  // n x 32 x bf16 vector value
 
-def nxv1f32  : ValueType<32,  166>;  // n x  1 x  f32 vector value
-def nxv2f32  : ValueType<64,  167>;  // n x  2 x  f32 vector value
-def nxv4f32  : ValueType<128, 168>;  // n x  4 x  f32 vector value
-def nxv8f32  : ValueType<256, 169>;  // n x  8 x  f32 vector value
-def nxv16f32 : ValueType<512, 170>;  // n x 16 x  f32 vector value
-
-def nxv1f64  : ValueType<64,  171>;  // n x  1 x  f64 vector value
-def nxv2f64  : ValueType<128, 172>;  // n x  2 x  f64 vector value
-def nxv4f64  : ValueType<256, 173>;  // n x  4 x  f64 vector value
-def nxv8f64  : ValueType<512, 174>;  // n x  8 x  f64 vector value
-
-def x86mmx    : ValueType<64,   175>;  // X86 MMX value
-def FlagVT    : ValueType<0,    176>;  // Pre-RA sched glue
-def isVoid    : ValueType<0,    177>;  // Produces no value
-def untyped   : ValueType<8,    178>;  // Produces an untyped value
-def funcref   : ValueType<0,    179>;  // WebAssembly's funcref type
-def externref : ValueType<0,    180>;  // WebAssembly's externref type
-def x86amx    : ValueType<8192, 181>;  // X86 AMX value
-def i64x8     : ValueType<512,  182>;  // 8 Consecutive GPRs (AArch64)
+def nxv1f32  : ValueType<32,  168>;  // n x  1 x  f32 vector value
+def nxv2f32  : ValueType<64,  169>;  // n x  2 x  f32 vector value
+def nxv4f32  : ValueType<128, 170>;  // n x  4 x  f32 vector value
+def nxv8f32  : ValueType<256, 171>;  // n x  8 x  f32 vector value
+def nxv16f32 : ValueType<512, 172>;  // n x 16 x  f32 vector value
+
+def nxv1f64  : ValueType<64,  173>;  // n x  1 x  f64 vector value
+def nxv2f64  : ValueType<128, 174>;  // n x  2 x  f64 vector value
+def nxv4f64  : ValueType<256, 175>;  // n x  4 x  f64 vector value
+def nxv8f64  : ValueType<512, 176>;  // n x  8 x  f64 vector value
+
+def x86mmx    : ValueType<64,   177>;  // X86 MMX value
+def FlagVT    : ValueType<0,    178>;  // Pre-RA sched glue
+def isVoid    : ValueType<0,    179>;  // Produces no value
+def untyped   : ValueType<8,    180>;  // Produces an untyped value
+def funcref   : ValueType<0,    181>;  // WebAssembly's funcref type
+def externref : ValueType<0,    182>;  // WebAssembly's externref type
+def x86amx    : ValueType<8192, 183>;  // X86 AMX value
+def i64x8     : ValueType<512,  184>;  // 8 Consecutive GPRs (AArch64)
 
 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>;
 

llvm/include/llvm/Support/MachineValueType.h

enum SimpleValueType : uint8_t {
       nxv8f16        = 159,  // n x  8 x f16
       nxv16f16       = 160,  // n x 16 x f16
       nxv32f16       = 161,  // n x 32 x f16
 
       nxv1bf16       = 162,  // n x  1 x bf16
       nxv2bf16       = 163,  // n x  2 x bf16
       nxv4bf16       = 164,  // n x  4 x bf16
       nxv8bf16       = 165,  // n x  8 x bf16
+      nxv16bf16      = 166,  // n x 16 x bf16
+      nxv32bf16      = 167,  // n x 32 x bf16
 
-      nxv1f32        = 166,  // n x  1 x f32
-      nxv2f32        = 167,  // n x  2 x f32
-      nxv4f32        = 168,  // n x  4 x f32
-      nxv8f32        = 169,  // n x  8 x f32
-      nxv16f32       = 170,  // n x 16 x f32
-
-      nxv1f64        = 171,  // n x  1 x f64
-      nxv2f64        = 172,  // n x  2 x f64
-      nxv4f64        = 173,  // n x  4 x f64
-      nxv8f64        = 174,  // n x  8 x f64
+      nxv1f32        = 168,  // n x  1 x f32
+      nxv2f32        = 169,  // n x  2 x f32
+      nxv4f32        = 170,  // n x  4 x f32
+      nxv8f32        = 171,  // n x  8 x f32
+      nxv16f32       = 172,  // n x 16 x f32
+
+      nxv1f64        = 173,  // n x  1 x f64
+      nxv2f64        = 174,  // n x  2 x f64
+      nxv4f64        = 175,  // n x  4 x f64
+      nxv8f64        = 176,  // n x  8 x f64
 
       FIRST_FP_SCALABLE_VECTOR_VALUETYPE = nxv1f16,
       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         = 175,    // This is an X86 MMX value
+      x86mmx         = 177,    // This is an X86 MMX value
 
-      Glue           = 176,    // This glues nodes together during pre-RA sched
+      Glue           = 178,    // This glues nodes together during pre-RA sched
 
-      isVoid         = 177,    // This has no value
+      isVoid         = 179,    // This has no value
 
-      Untyped        = 178,    // This value takes a register, but has
+      Untyped        = 180,    // This value takes a register, but has
                                // unspecified type.  The register class
                                // will be determined by the opcode.
 
-      funcref        = 179,    // WebAssembly's funcref type
-      externref      = 180,    // WebAssembly's externref type
-      x86amx         = 181,    // This is an X86 AMX value
-      i64x8          = 182,    // 8 Consecutive GPRs (AArch64)
+      funcref        = 181,    // WebAssembly's funcref type
+      externref      = 182,    // WebAssembly's externref type
+      x86amx         = 183,    // This is an X86 AMX value
+      i64x8          = 184,    // 8 Consecutive GPRs (AArch64)
 
       FIRST_VALUETYPE =  1,    // This is always the beginning of the list.
       LAST_VALUETYPE = i64x8,  // This always remains at the end of the list.
       VALUETYPE_SIZE = LAST_VALUETYPE + 1,
 
       // 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.
MVT getVectorElementType() const {
       case v8bf16:
       case v16bf16:
       case v32bf16:
       case v64bf16:
       case v128bf16:
       case nxv1bf16:
       case nxv2bf16:
       case nxv4bf16:
-      case nxv8bf16: return bf16;
+      case nxv8bf16:
+      case nxv16bf16:
+      case nxv32bf16: return bf16;
       case v1f32:
       case v2f32:
       case v3f32:
       case v4f32:
       case v5f32:
       case v6f32:
       case v7f32:
       case v8f32:
unsigned getVectorMinNumElements() const {
       case v32bf16:
       case v32f32:
       case v32f64:
       case nxv32i1:
       case nxv32i8:
       case nxv32i16:
       case nxv32i32:
       case nxv32i64:
-      case nxv32f16: return 32;
+      case nxv32f16:
+      case nxv32bf16: 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 nxv16bf16:
       case nxv16f32: return 16;
       case v8i1:
       case v8i8:
       case v8i16:
       case v8i32:
       case v8i64:
       case v8f16:
       case v8bf16:
TypeSize getSizeInBits() const {
       case v16bf16:
       case v8f32:
       case v4f64: return TypeSize::Fixed(256);
       case nxv32i8:
       case nxv16i16:
       case nxv8i32:
       case nxv4i64:
       case nxv16f16:
+      case nxv16bf16:
       case nxv8f32:
       case nxv4f64: return TypeSize::Scalable(256);
       case i64x8:
       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 nxv32bf16:
       case nxv16f32:
       case nxv8f64: return TypeSize::Scalable(512);
       case v1024i1:
       case v128i8:
       case v64i16:
       case v32i32:
       case v16i64:
       case v64f16:
static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
           if (NumElements == 16)  return MVT::nxv16f16;
           if (NumElements == 32)  return MVT::nxv32f16;
           break;
         case MVT::bf16:
           if (NumElements == 1)  return MVT::nxv1bf16;
           if (NumElements == 2)  return MVT::nxv2bf16;
           if (NumElements == 4)  return MVT::nxv4bf16;
           if (NumElements == 8)  return MVT::nxv8bf16;
+          if (NumElements == 16)  return MVT::nxv16bf16;
+          if (NumElements == 32)  return MVT::nxv32bf16;
           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;
           break;

llvm/lib/CodeGen/ValueTypes.cpp

Type *EVT::getTypeForEVT(LLVMContext &Context) const {
   case MVT::nxv1bf16:
     return ScalableVectorType::get(Type::getBFloatTy(Context), 1);
   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::nxv16bf16:
+    return ScalableVectorType::get(Type::getBFloatTy(Context), 16);
+  case MVT::nxv32bf16:
+    return ScalableVectorType::get(Type::getBFloatTy(Context), 32);
   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);

llvm/utils/TableGen/CodeGenTarget.cpp

StringRef llvm::getEnumName(MVT::SimpleValueType T) {
   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::nxv1bf16:  return "MVT::nxv1bf16";
   case MVT::nxv2bf16:  return "MVT::nxv2bf16";
   case MVT::nxv4bf16:  return "MVT::nxv4bf16";
   case MVT::nxv8bf16:  return "MVT::nxv8bf16";
+  case MVT::nxv16bf16: return "MVT::nxv16bf16";
+  case MVT::nxv32bf16: return "MVT::nxv32bf16";
   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";