[ValueTypes] Add MVT for nxv1bf16.

[frasercrmck]

llvm/include/llvm/CodeGen/ValueTypes.td

179

typo here: x 2 -> x 1?

[sdesmalen]

Fixed typo.

[frasercrmck]

LGTM. I've always disliked how finicky adding a new MVT is but that's neither here nor there :)

[sdesmalen]

In D96249#2550759, @frasercrmck wrote:

LGTM. I've always disliked how finicky adding a new MVT is but that's neither here nor there :)

Yes, definitely not the most elegant part of LLVM :) Thanks for the review!

llvm/include/llvm/CodeGen/ValueTypes.td

 
 def nxv1i64 : ValueType<64,  133>; // n x  1 x i64 vector value
 def nxv2i64 : ValueType<128, 134>; // n x  2 x i64 vector value
 def nxv4i64 : ValueType<256, 135>; // n x  4 x i64 vector value
 def nxv8i64 : ValueType<512, 136>; // n x  8 x i64 vector value
 def nxv16i64: ValueType<1024,137>; // n x 16 x i64 vector value
 def nxv32i64: ValueType<2048,138>; // n x 32 x i64 vector value
 
-def nxv1f16   : ValueType<16, 139>; // n x   1 x f16 vector value
-def nxv2f16  : ValueType<32 , 140>; // n x  2 x f16 vector value
-def nxv4f16  : ValueType<64 , 141>; // n x  4 x f16 vector value
-def nxv8f16  : ValueType<128, 142>; // n x  8 x f16 vector value
-def nxv16f16  : ValueType<256,143>; // n x  16 x f16 vector value
-def nxv32f16  : ValueType<512,144>; // n x  32 x f16 vector value
-def nxv2bf16 : ValueType<32 , 145>; // n x  2 x bf16 vector value
-def nxv4bf16 : ValueType<64 , 146>; // n x  4 x bf16 vector value
-def nxv8bf16 : ValueType<128, 147>; // n x  8 x bf16 vector value
-def nxv1f32  : ValueType<32 , 148>; // n x  1 x f32 vector value
-def nxv2f32  : ValueType<64 , 149>; // n x  2 x f32 vector value
-def nxv4f32  : ValueType<128, 150>; // n x  4 x f32 vector value
-def nxv8f32  : ValueType<256, 151>; // n x  8 x f32 vector value
-def nxv16f32 : ValueType<512, 152>; // n x 16 x f32 vector value
-def nxv1f64  : ValueType<64,  153>; // n x  1 x f64 vector value
-def nxv2f64  : ValueType<128, 154>; // n x  2 x f64 vector value
-def nxv4f64  : ValueType<256, 155>; // n x  4 x f64 vector value
-def nxv8f64  : ValueType<512, 156>; // n x  8 x f64 vector value
-
-def x86mmx : ValueType<64 , 157>;   // X86 MMX value
-def FlagVT : ValueType<0  , 158>;   // Pre-RA sched glue
-def isVoid : ValueType<0  , 159>;   // Produces no value
-def untyped: ValueType<8  , 160>;   // Produces an untyped value
-def funcref : ValueType<0  , 161>;   // WebAssembly's funcref type
-def externref : ValueType<0  , 162>;   // WebAssembly's externref type
-def x86amx : ValueType<8192, 163>;   // X86 AMX value
+def nxv1f16  : ValueType<16, 139>; // n x  1 x  f16 vector value
+def nxv2f16  : ValueType<32, 140>; // n x  2 x  f16 vector value
+def nxv4f16  : ValueType<64, 141>; // n x  4 x  f16 vector value
+def nxv8f16  : ValueType<128,142>; // n x  8 x  f16 vector value
+def nxv16f16 : ValueType<256,143>; // n x 16 x  f16 vector value
+def nxv32f16 : ValueType<512,144>; // n x 32 x  f16 vector value
+def nxv1bf16 : ValueType<16, 145>; // n x  2 x bf16 vector value
+def nxv2bf16 : ValueType<32, 146>; // n x  2 x bf16 vector value
+def nxv4bf16 : ValueType<64, 147>; // n x  4 x bf16 vector value
+def nxv8bf16 : ValueType<128,148>; // n x  8 x bf16 vector value
+def nxv1f32  : ValueType<32, 149>; // n x  1 x  f32 vector value
+def nxv2f32  : ValueType<64, 150>; // n x  2 x  f32 vector value
+def nxv4f32  : ValueType<128,151>; // n x  4 x  f32 vector value
+def nxv8f32  : ValueType<256,152>; // n x  8 x  f32 vector value
+def nxv16f32 : ValueType<512,153>; // n x 16 x  f32 vector value
+def nxv1f64  : ValueType<64, 154>; // n x  1 x  f64 vector value
+def nxv2f64  : ValueType<128,155>; // n x  2 x  f64 vector value
+def nxv4f64  : ValueType<256,156>; // n x  4 x  f64 vector value
+def nxv8f64  : ValueType<512,157>; // n x  8 x  f64 vector value
+
+def x86mmx : ValueType<64,   158>; // X86 MMX value
+def FlagVT : ValueType<0,    159>; // Pre-RA sched glue
+def isVoid : ValueType<0,    160>; // Produces no value
+def untyped: ValueType<8,    161>; // Produces an untyped value
+def funcref : ValueType<0,   162>; // WebAssembly's funcref type
+def externref : ValueType<0, 163>; // WebAssembly's externref type
+def x86amx : ValueType<8192, 164>; // X86 AMX value
 
 
 def token  : ValueType<0  , 248>;   // TokenTy
-def MetadataVT: ValueType<0, 249>;  // Metadata
+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"
 def vAny   : ValueType<0  , 251>;
 

llvm/include/llvm/Support/MachineValueType.h

enum SimpleValueType : uint8_t {
       LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv32i64,
 
       nxv1f16        = 139,   // n x   1 x f16
       nxv2f16        = 140,  // n x  2 x f16
       nxv4f16        = 141,  // n x  4 x f16
       nxv8f16        = 142,  // n x  8 x f16
       nxv16f16       = 143,   // n x  16 x f16
       nxv32f16       = 144,   // n x  32 x f16
-      nxv2bf16       = 145,  // n x  2 x bf16
-      nxv4bf16       = 146,  // n x  4 x bf16
-      nxv8bf16       = 147,  // n x  8 x bf16
-      nxv1f32        = 148,  // n x  1 x f32
-      nxv2f32        = 149,  // n x  2 x f32
-      nxv4f32        = 150,  // n x  4 x f32
-      nxv8f32        = 151,  // n x  8 x f32
-      nxv16f32       = 152,  // n x 16 x f32
-      nxv1f64        = 153,  // n x  1 x f64
-      nxv2f64        = 154,  // n x  2 x f64
-      nxv4f64        = 155,  // n x  4 x f64
-      nxv8f64        = 156,  // n x  8 x f64
+      nxv1bf16       = 145,  // n x  1 x bf16
+      nxv2bf16       = 146,  // n x  2 x bf16
+      nxv4bf16       = 147,  // n x  4 x bf16
+      nxv8bf16       = 148,  // n x  8 x bf16
+      nxv1f32        = 149,  // n x  1 x f32
+      nxv2f32        = 150,  // n x  2 x f32
+      nxv4f32        = 151,  // n x  4 x f32
+      nxv8f32        = 152,  // n x  8 x f32
+      nxv16f32       = 153,  // n x 16 x f32
+      nxv1f64        = 154,  // n x  1 x f64
+      nxv2f64        = 155,  // n x  2 x f64
+      nxv4f64        = 156,  // n x  4 x f64
+      nxv8f64        = 157,  // 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         = 157,   // This is an X86 MMX value
+      x86mmx         = 158,   // This is an X86 MMX value
 
-      Glue           = 158,   // This glues nodes together during pre-RA sched
+      Glue           = 159,   // This glues nodes together during pre-RA sched
 
-      isVoid         = 159,   // This has no value
+      isVoid         = 160,   // This has no value
 
-      Untyped        = 160,   // This value takes a register, but has
+      Untyped        = 161,   // This value takes a register, but has
                               // unspecified type.  The register class
                               // will be determined by the opcode.
 
-      funcref        = 161,   // WebAssembly's funcref type
-      externref      = 162,   // WebAssembly's externref type
-      x86amx         = 163,   // This is an X86 AMX value
+      funcref        = 162,   // WebAssembly's funcref type
+      externref      = 163,   // WebAssembly's externref type
+      x86amx         = 164,   // This is an X86 AMX value
 
       FIRST_VALUETYPE =  1,   // This is always the beginning of the list.
-      LAST_VALUETYPE = 164,   // This always remains at the end of the list.
+      LAST_VALUETYPE = 165,   // 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 = 192,
 
       // A value of type llvm::TokenTy
       token          = 248,
MVT getVectorElementType() const {
       case v2bf16:
       case v3bf16:
       case v4bf16:
       case v8bf16:
       case v16bf16:
       case v32bf16:
       case v64bf16:
       case v128bf16:
+      case nxv1bf16:
       case nxv2bf16:
       case nxv4bf16:
       case nxv8bf16: return bf16;
       case v1f32:
       case v2f32:
       case v3f32:
       case v4f32:
       case v5f32:
unsigned getVectorNumElements() const {
       case v1f32:
       case v1f64:
       case nxv1i1:
       case nxv1i8:
       case nxv1i16:
       case nxv1i32:
       case nxv1i64:
       case nxv1f16:
+      case nxv1bf16:
       case nxv1f32:
       case nxv1f64: return 1;
       }
     }
 
     ElementCount getVectorElementCount() const {
       return ElementCount::get(getVectorNumElements(), isScalableVector());
     }
TypeSize getSizeInBits() const {
       case f16:
       case bf16:
       case v16i1:
       case v2i8:
       case v1i16: return TypeSize::Fixed(16);
       case nxv16i1:
       case nxv2i8:
       case nxv1i16:
+      case nxv1bf16:
       case nxv1f16: return TypeSize::Scalable(16);
       case f32 :
       case i32 :
       case v32i1:
       case v4i8:
       case v2i16:
       case v2f16:
       case v2bf16:
static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
           if (NumElements == 1)  return MVT::nxv1f16;
           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 == 1)  return MVT::nxv1bf16;
           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;

llvm/lib/CodeGen/ValueTypes.cpp

Type *EVT::getTypeForEVT(LLVMContext &Context) const {
   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::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::nxv1f32:
     return ScalableVectorType::get(Type::getFloatTy(Context), 1);