Add support for SPV_INTEL_bfloat16_conversion extension

This extension provides instructions to convert single-precision 32-bit
floating-point value to bfloat16 format and vice versa.
It doesn't introduce bfloat16 type in SPIR-V, instead instructions below
use 16-bit integer type whose bit pattern represents (bitcasted from)
a bfloat16 value.

Spec: https://github.com/intel/llvm/blob/f587bbfb8a742bd55c80b12e01505ed085a0748f/sycl/doc/extensions/SPIRV/SPV_INTEL_bf16_convert.asciidoc

Signed-off-by: Mikhail Lychkov <[email protected]>

Author: mlychkov

include/LLVMSPIRVExtensions.inc

@@ -43,3 +43,4 @@ EXT(SPV_INTEL_token_type)
 EXT(SPV_INTEL_debug_module)
 EXT(SPV_INTEL_runtime_aligned)
 EXT(SPV_INTEL_arithmetic_fence)
+EXT(SPV_INTEL_bfloat16_conversion)

lib/SPIRV/libSPIRV/SPIRVInstruction.h

@@ -3073,6 +3073,77 @@ _SPIRV_OP(VariableLengthArray, true, 4)
 _SPIRV_OP(SaveMemory, true, 3)
 _SPIRV_OP(RestoreMemory, false, 2)
 #undef _SPIRV_OP
+
+template <Op OC>
+class SPIRVBfloat16ConversionINTELInstBase : public SPIRVUnaryInst<OC> {
+protected:
+  SPIRVCapVec getRequiredCapability() const override {
+    return getVec(internal::CapabilityBfloat16ConversionINTEL);
+  }
+
+  llvm::Optional<ExtensionID> getRequiredExtension() const override {
+    return ExtensionID::SPV_INTEL_bfloat16_conversion;
+  }
+
+  void validate() const override {
+    SPIRVUnaryInst<OC>::validate();
+
+    SPIRVType *ResCompTy = this->getType();
+    SPIRVWord ResCompCount = 1;
+    if (ResCompTy->isTypeVector()) {
+      ResCompCount = ResCompTy->getVectorComponentCount();
+      ResCompTy = ResCompTy->getVectorComponentType();
+    }
+
+    // validate is a const method, whilst getOperand is non-const method
+    // because it may call a method of class Module that may modify LiteralMap
+    // of Module field. That modification is not impacting validate method for
+    // these instructions, so const_cast is safe here.
+    using SPVBf16ConvTy = SPIRVBfloat16ConversionINTELInstBase<OC>;
+    SPIRVValue *Input = const_cast<SPVBf16ConvTy *>(this)->getOperand(0);
+
+    SPIRVType *InCompTy = Input->getType();
+    SPIRVWord InCompCount = 1;
+    if (InCompTy->isTypeVector()) {
+      InCompCount = InCompTy->getVectorComponentCount();
+      InCompTy = InCompTy->getVectorComponentType();
+    }
+
+    auto InstName = OpCodeNameMap::map(OC);
+    SPIRVErrorLog &SPVErrLog = this->getModule()->getErrorLog();
+
+    if (OC == internal::OpConvertFToBF16INTEL) {
+      SPVErrLog.checkError(
+          ResCompTy->isTypeInt(16), SPIRVEC_InvalidInstruction,
+          InstName + "\nResult value must be a scalar or vector of integer "
+                     "16-bit type\n");
+      SPVErrLog.checkError(
+          InCompTy->isTypeFloat(32), SPIRVEC_InvalidInstruction,
+          InstName + "\nInput value must be a scalar or vector of "
+                     "floating-point 32-bit type\n");
+    } else {
+      SPVErrLog.checkError(
+          ResCompTy->isTypeFloat(32), SPIRVEC_InvalidInstruction,
+          InstName + "\nResult value must be a scalar or vector of "
+                     "floating-point 32-bit type\n");
+      SPVErrLog.checkError(
+          InCompTy->isTypeInt(16), SPIRVEC_InvalidInstruction,
+          InstName + "\nInput value must be a scalar or vector of integer "
+                     "16-bit type\n");
+    }
+
+    SPVErrLog.checkError(
+        ResCompCount == InCompCount, SPIRVEC_InvalidInstruction,
+        InstName + "\nInput type must have the same number of components as "
+                   "result type\n");
+  }
+};
+
+#define _SPIRV_OP(x)                                                           \
+  typedef SPIRVBfloat16ConversionINTELInstBase<internal::Op##x> SPIRV##x;
+_SPIRV_OP(ConvertFToBF16INTEL)
+_SPIRV_OP(ConvertBF16ToFINTEL)
+#undef _SPIRV_OP
 } // namespace SPIRV
 
 #endif // SPIRV_LIBSPIRV_SPIRVINSTRUCTION_H

lib/SPIRV/libSPIRV/SPIRVModule.cpp

@@ -583,7 +583,11 @@ SPIRVValue *SPIRVModuleImpl::addPipeStorageConstant(SPIRVType *TheType,
 void SPIRVModuleImpl::addExtension(ExtensionID Ext) {
   std::string ExtName;
   SPIRVMap<ExtensionID, std::string>::find(Ext, &ExtName);
-  assert(isAllowedToUseExtension(Ext));
+  if (!getErrorLog().checkError(isAllowedToUseExtension(Ext),
+                                SPIRVEC_RequiresExtension, ExtName)) {
+    setInvalid();
+    return;
+  }
   SPIRVExt.insert(ExtName);
 }
 

lib/SPIRV/libSPIRV/SPIRVNameMapEnum.h

@@ -578,6 +578,7 @@ template <> inline void SPIRVMap<Capability, std::string>::init() {
       "RuntimeAlignedAttributeINTEL");
   add(CapabilityMax, "Max");
   add(internal::CapabilityFPArithmeticFenceINTEL, "FPArithmeticFenceINTEL");
+  add(internal::CapabilityBfloat16ConversionINTEL, "Bfloat16ConversionINTEL");
 }
 SPIRV_DEF_NAMEMAP(Capability, SPIRVCapabilityNameMap)
 

lib/SPIRV/libSPIRV/SPIRVOpCodeEnumInternal.h

@@ -6,3 +6,5 @@ _SPIRV_OP_INTERNAL(AliasScopeDeclINTEL, internal::OpAliasScopeDeclINTEL)
 _SPIRV_OP_INTERNAL(AliasScopeListDeclINTEL, internal::OpAliasScopeListDeclINTEL)
 _SPIRV_OP_INTERNAL(TypeTokenINTEL, internal::OpTypeTokenINTEL)
 _SPIRV_OP_INTERNAL(ArithmeticFenceINTEL, internal::OpArithmeticFenceINTEL)
+_SPIRV_OP_INTERNAL(ConvertFToBF16INTEL, internal::OpConvertFToBF16INTEL)
+_SPIRV_OP_INTERNAL(ConvertBF16ToFINTEL, internal::OpConvertBF16ToFINTEL)

lib/SPIRV/libSPIRV/spirv_internal.hpp

@@ -39,6 +39,8 @@ enum InternalOp {
   IOpAliasScopeDeclINTEL = 5912,
   IOpAliasScopeListDeclINTEL = 5913,
   IOpTypeTokenINTEL = 6113,
+  IOpConvertFToBF16INTEL = 6116,
+  IOpConvertBF16ToFINTEL = 6117,
   IOpArithmeticFenceINTEL = 6145,
   IOpPrev = OpMax - 2,
   IOpForward
@@ -63,6 +65,7 @@ enum InternalCapability {
   ICapFastCompositeINTEL = 6093,
   ICapOptNoneINTEL = 6094,
   ICapTokenTypeINTEL = 6112,
+  ICapBfloat16ConversionINTEL = 6115,
   ICapFPArithmeticFenceINTEL = 6144
 };
 
@@ -87,6 +90,8 @@ constexpr Op OpAliasScopeListDeclINTEL =
     static_cast<Op>(IOpAliasScopeListDeclINTEL);
 constexpr Op OpTypeTokenINTEL = static_cast<Op>(IOpTypeTokenINTEL);
 constexpr Op OpArithmeticFenceINTEL = static_cast<Op>(IOpArithmeticFenceINTEL);
+constexpr Op OpConvertFToBF16INTEL = static_cast<Op>(IOpConvertFToBF16INTEL);
+constexpr Op OpConvertBF16ToFINTEL = static_cast<Op>(IOpConvertBF16ToFINTEL);
 
 constexpr Decoration DecorationAliasScopeINTEL =
     static_cast<Decoration>(IDecAliasScopeINTEL );
@@ -119,6 +124,8 @@ constexpr Capability CapabilityRuntimeAlignedAttributeINTEL =
     static_cast<Capability>(ICapRuntimeAlignedAttributeINTEL);
 constexpr Capability CapabilityFPArithmeticFenceINTEL =
     static_cast<Capability>(ICapFPArithmeticFenceINTEL);
+constexpr Capability CapabilityBfloat16ConversionINTEL =
+    static_cast<Capability>(ICapBfloat16ConversionINTEL);
 
 constexpr FunctionControlMask FunctionControlOptNoneINTELMask =
     static_cast<FunctionControlMask>(IFunctionControlOptNoneINTELMask);

test/negative/SPV_INTEL_bfloat16_conversion/bf16tof_inval_input_ty.ll

@@ -0,0 +1,28 @@
+; RUN: llvm-as %s -o %t.bc
+; RUN: not llvm-spirv %t.bc --spirv-ext=+SPV_INTEL_bfloat16_conversion 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-ERROR
+
+; CHECK-ERROR: InvalidInstruction: Can't translate llvm instruction:
+; CHECK-ERROR-NEXT: ConvertBF16ToFINTEL
+; CHECK-ERROR-NEXT: Input type must have the same number of components as result type
+
+
+target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-n8:16:32:64"
+target triple = "spir64-unknown-unknown"
+
+define spir_func void @_Z1f() {
+  %1 = alloca <2 x i16>, align 4
+  %2 = load <2 x i16>, <2 x i16>* %1, align 4
+  %3 = tail call spir_func float @_Z27__spirv_ConvertBF16ToFINTELf(<2 x i16> %2)
+  ret void
+}
+
+declare spir_func float @_Z27__spirv_ConvertBF16ToFINTELf(<2 x i16>)
+
+!opencl.spir.version = !{!0}
+!spirv.Source = !{!1}
+!llvm.ident = !{!2}
+
+!0 = !{i32 1, i32 2}
+!1 = !{i32 4, i32 100000}
+!2 = !{!"clang version 13.0.0"}

test/negative/SPV_INTEL_bfloat16_conversion/bf16tof_inval_input_ty.spt

@@ -0,0 +1,39 @@
+; RUN: not llvm-spirv %s -to-binary -o %t.spv 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR
+
+; CHECK-ERROR: InvalidInstruction: Can't translate llvm instruction:
+; CHECK-ERROR-NEXT: ConvertBF16ToFINTEL
+; CHECK-ERROR-NEXT: Input value must be a scalar or vector of integer 16-bit type
+
+119734787 65536 393230 14 0
+2 Capability Addresses
+2 Capability Linkage
+2 Capability Kernel
+2 Capability Int64
+2 Capability Bfloat16ConversionINTEL
+9 Extension "SPV_INTEL_bfloat16_conversion"
+5 ExtInstImport 1 "OpenCL.std"
+3 MemoryModel 2 2
+3 Source 4 100000
+4 Name 4 "_Z1f"
+
+6 Decorate 4 LinkageAttributes "_Z1f" Export
+4 Decorate 11 Alignment 4
+4 TypeInt 6 64 0
+5 Constant 6 7 32 0
+2 TypeVoid 2
+3 TypeFunction 3 2
+2 TypeBool 8
+4 TypeArray 9 8 7
+4 TypePointer 10 7 9
+3 TypeFloat 12 32
+
+
+
+5 Function 2 4 0 3
+
+2 Label 5
+4 Variable 10 11 7
+4 ConvertBF16ToFINTEL 12 13 11
+1 Return
+
+1 FunctionEnd

test/negative/SPV_INTEL_bfloat16_conversion/bf16tof_inval_output_ty.ll

@@ -0,0 +1,27 @@
+; RUN: llvm-as %s -o %t.bc
+; RUN: not llvm-spirv %t.bc --spirv-ext=+SPV_INTEL_bfloat16_conversion 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-ERROR
+
+; CHECK-ERROR: InvalidInstruction: Can't translate llvm instruction:
+; CHECK-ERROR-NEXT: ConvertBF16ToFINTEL
+; CHECK-ERROR-NEXT: Input value must be a scalar or vector of integer 16-bit type
+
+
+target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-n8:16:32:64"
+target triple = "spir64-unknown-unknown"
+
+define spir_func void @_Z1f() {
+  %1 = alloca [3 x i32], align 4
+  %2 = tail call spir_func float @_Z27__spirv_ConvertBF16ToFINTELf([3 x i32]* %1)
+  ret void
+}
+
+declare spir_func float @_Z27__spirv_ConvertBF16ToFINTELf([3 x i32]*)
+
+!opencl.spir.version = !{!0}
+!spirv.Source = !{!1}
+!llvm.ident = !{!2}
+
+!0 = !{i32 1, i32 2}
+!1 = !{i32 4, i32 100000}
+!2 = !{!"clang version 13.0.0"}

test/negative/SPV_INTEL_bfloat16_conversion/bf16tof_inval_output_ty.spt

@@ -0,0 +1,41 @@
+; RUN: not llvm-spirv %s -to-binary -o %t.spv 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR
+
+; CHECK-ERROR: InvalidInstruction: Can't translate llvm instruction:
+; CHECK-ERROR-NEXT: ConvertBF16ToFINTEL
+; CHECK-ERROR-NEXT: Result value must be a scalar or vector of floating-point 32-bit type
+
+119734787 65536 393230 16 0
+2 Capability Addresses
+2 Capability Linkage
+2 Capability Kernel
+2 Capability Int64
+2 Capability Bfloat16ConversionINTEL
+9 Extension "SPV_INTEL_bfloat16_conversion"
+5 ExtInstImport 1 "OpenCL.std"
+3 MemoryModel 2 2
+3 Source 4 100000
+4 Name 4 "_Z1f"
+
+6 Decorate 4 LinkageAttributes "_Z1f" Export
+4 Decorate 8 Alignment 4
+4 TypeInt 10 64 0
+4 TypeInt 12 32 0
+5 Constant 10 11 3 0
+2 TypeVoid 2
+3 TypeFunction 3 2
+3 TypeFloat 6 32
+4 TypePointer 7 7 6
+4 TypeArray 13 12 11
+4 TypePointer 14 7 13
+
+
+
+5 Function 2 4 0 3
+
+2 Label 5
+4 Variable 7 8 7
+6 Load 6 9 8 2 4
+4 ConvertBF16ToFINTEL 14 15 9
+1 Return
+
+1 FunctionEnd

test/negative/SPV_INTEL_bfloat16_conversion/bf16tof_inval_params.spt

@@ -0,0 +1,39 @@
+; RUN: not llvm-spirv %s -to-binary -o %t.spv 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR
+
+; CHECK-ERROR: InvalidInstruction: Can't translate llvm instruction:
+; CHECK-ERROR-NEXT: ConvertBF16ToFINTEL
+; CHECK-ERROR-NEXT: Input type must have the same number of components as result type
+
+119734787 65536 393230 14 0
+2 Capability Addresses
+2 Capability Linkage
+2 Capability Kernel
+2 Capability Int16
+2 Capability Bfloat16ConversionINTEL
+9 Extension "SPV_INTEL_bfloat16_conversion"
+5 ExtInstImport 1 "OpenCL.std"
+3 MemoryModel 2 2
+3 Source 4 100000
+4 Name 4 "_Z1f"
+
+6 Decorate 4 LinkageAttributes "_Z1f" Export
+4 Decorate 9 Alignment 4
+4 TypeInt 6 16 0
+2 TypeVoid 2
+3 TypeFunction 3 2
+4 TypeVector 7 6 4
+4 TypePointer 8 7 7
+3 TypeFloat 11 32
+4 TypeVector 12 11 3
+
+
+
+5 Function 2 4 0 3
+
+2 Label 5
+4 Variable 8 9 7
+6 Load 7 10 9 2 4
+4 ConvertBF16ToFINTEL 12 13 10
+1 Return
+
+1 FunctionEnd

test/negative/SPV_INTEL_bfloat16_conversion/f2bf16_inval_input_ty.ll

@@ -0,0 +1,28 @@
+; RUN: llvm-as %s -o %t.bc
+; RUN: not llvm-spirv %t.bc --spirv-ext=+SPV_INTEL_bfloat16_conversion 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-ERROR
+
+; CHECK-ERROR: InvalidInstruction: Can't translate llvm instruction:
+; CHECK-ERROR-NEXT: ConvertFToBF16INTEL
+; CHECK-ERROR-NEXT: Input value must be a scalar or vector of floating-point 32-bit type
+
+
+target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-n8:16:32:64"
+target triple = "spir64-unknown-unknown"
+
+define spir_func void @_Z1f() {
+  %1 = alloca double, align 8
+  %2 = load double, double* %1, align 8
+  %3 = tail call spir_func zeroext i16 @_Z27__spirv_ConvertFToBF16INTELf(double %2)
+  ret void
+}
+
+declare spir_func zeroext i16 @_Z27__spirv_ConvertFToBF16INTELf(double)
+
+!opencl.spir.version = !{!0}
+!spirv.Source = !{!1}
+!llvm.ident = !{!2}
+
+!0 = !{i32 1, i32 2}
+!1 = !{i32 4, i32 100000}
+!2 = !{!"clang version 13.0.0"}

test/negative/SPV_INTEL_bfloat16_conversion/f2bf16_inval_input_ty.spt

@@ -0,0 +1,37 @@
+; RUN: not llvm-spirv %s -to-binary -o %t.spv 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR
+
+; CHECK-ERROR: InvalidInstruction: Can't translate llvm instruction:
+; CHECK-ERROR-NEXT: ConvertFToBF16INTEL
+; CHECK-ERROR-NEXT: Input value must be a scalar or vector of floating-point 32-bit type
+
+119734787 65536 393230 12 0
+2 Capability Addresses
+2 Capability Linkage
+2 Capability Kernel
+2 Capability Int16
+2 Capability Bfloat16ConversionINTEL
+9 Extension "SPV_INTEL_bfloat16_conversion"
+5 ExtInstImport 1 "OpenCL.std"
+3 MemoryModel 2 2
+3 Source 4 100000
+4 Name 4 "_Z1f"
+
+6 Decorate 4 LinkageAttributes "_Z1f" Export
+4 Decorate 8 Alignment 4
+4 TypeInt 10 16 0
+2 TypeVoid 2
+3 TypeFunction 3 2
+3 TypeInt 6 32 0
+4 TypePointer 7 7 6
+
+
+
+5 Function 2 4 0 3
+
+2 Label 5
+4 Variable 7 8 7
+6 Load 6 9 8 2 4
+4 ConvertFToBF16INTEL 10 11 9
+1 Return
+
+1 FunctionEnd