[Backport to 14] Implement SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate (#3839)

Backport of
#3815

Author: Qi-Ye-079

include/LLVMSPIRVExtensions.inc

@@ -77,6 +77,7 @@ EXT(SPV_INTEL_2d_block_io)
 EXT(SPV_INTEL_subgroup_matrix_multiply_accumulate)
 EXT(SPV_INTEL_subgroup_matrix_multiply_accumulate_float4)
 EXT(SPV_INTEL_subgroup_matrix_multiply_accumulate_float8)
+EXT(SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate)
 EXT(SPV_KHR_bfloat16)
 EXT(SPV_INTEL_bfloat16_arithmetic)
 EXT(SPV_INTEL_16bit_atomics)

lib/SPIRV/libSPIRV/SPIRVInstruction.h

@@ -4132,16 +4132,19 @@ class SPIRVSubgroupMatrixMultiplyAccumulateINTELInst
   }
 
 protected:
+  virtual unsigned getOperandsLiteralIndex() const { return 4; }
+
   void validate() const override {
     SPIRVInstTemplateBase::validate();
 
     // Check if FP4 or FP8 matrix operands are used
-    // Operands parameter is the last operand (index 4)
+    // Operands parameter is the last operand.
     auto *NonConstThis =
         const_cast<SPIRVSubgroupMatrixMultiplyAccumulateINTELInst *>(this);
-    if (NonConstThis->getOperands().size() > 4) {
-      const SPIRVConstant *OperandsConst =
-          static_cast<const SPIRVConstant *>(NonConstThis->getOperand(4));
+    const unsigned OperandsIdx = getOperandsLiteralIndex();
+    if (NonConstThis->getOperands().size() > OperandsIdx) {
+      const SPIRVConstant *OperandsConst = static_cast<const SPIRVConstant *>(
+          NonConstThis->getOperand(OperandsIdx));
       uint64_t OperandsMask = OperandsConst->getZExtIntValue();
 
       // FP4 operand bits
@@ -4162,15 +4165,16 @@ class SPIRVSubgroupMatrixMultiplyAccumulateINTELInst
           spv::internal::
               IMatrixMultiplyAccumulateOperandsMatrixBPackedFloat8E5M2INTELMask;
 
+      std::string InstName = OpCodeNameMap::map(getOpCode());
+
       if ((OperandsMask & FP4Mask) != 0) {
         getModule()->getErrorLog().checkError(
             getModule()->isAllowedToUseExtension(
                 ExtensionID::
                     SPV_INTEL_subgroup_matrix_multiply_accumulate_float4),
             SPIRVEC_RequiresExtension,
-            "SPV_INTEL_subgroup_matrix_multiply_accumulate_float4\n"
-            "SubgroupMatrixMultiplyAccumulateINTEL with FP4 operand flags "
-            "requires this extension");
+            "SPV_INTEL_subgroup_matrix_multiply_accumulate_float4\n" +
+                InstName + " with FP4 operand flags requires this extension");
         getModule()->addExtension(
             ExtensionID::SPV_INTEL_subgroup_matrix_multiply_accumulate_float4);
       }
@@ -4181,9 +4185,8 @@ class SPIRVSubgroupMatrixMultiplyAccumulateINTELInst
                 ExtensionID::
                     SPV_INTEL_subgroup_matrix_multiply_accumulate_float8),
             SPIRVEC_RequiresExtension,
-            "SPV_INTEL_subgroup_matrix_multiply_accumulate_float8\n"
-            "SubgroupMatrixMultiplyAccumulateINTEL with FP8 operand flags "
-            "requires this extension");
+            "SPV_INTEL_subgroup_matrix_multiply_accumulate_float8\n" +
+                InstName + " with FP8 operand flags requires this extension");
         getModule()->addExtension(
             ExtensionID::SPV_INTEL_subgroup_matrix_multiply_accumulate_float8);
       }
@@ -4202,6 +4205,47 @@ class SPIRVSubgroupMatrixMultiplyAccumulateINTELInst
 _SPIRV_OP(SubgroupMatrixMultiplyAccumulate, true, 7, true, 4)
 #undef _SPIRV_OP
 
+class SPIRVSubgroupScaledMatrixMultiplyAccumulateINTELInst
+    : public SPIRVSubgroupMatrixMultiplyAccumulateINTELInst {
+public:
+  llvm::Optional<ExtensionID> getRequiredExtension() const override {
+    return ExtensionID::SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate;
+  }
+
+protected:
+  unsigned getOperandsLiteralIndex() const override { return 6; }
+
+  void validate() const override {
+    SPIRVSubgroupMatrixMultiplyAccumulateINTELInst::validate();
+
+    // The Matrix Multiply Accumulate Operands literal is defined by the parent
+    // extension, so its extension and capability must be present too.
+    getModule()->getErrorLog().checkError(
+        getModule()->isAllowedToUseExtension(
+            ExtensionID::SPV_INTEL_subgroup_matrix_multiply_accumulate),
+        SPIRVEC_RequiresExtension,
+        "SPV_INTEL_subgroup_matrix_multiply_accumulate\n"
+        "SubgroupScaledMatrixMultiplyAccumulateINTEL depends on this "
+        "extension");
+    getModule()->addExtension(
+        ExtensionID::SPV_INTEL_subgroup_matrix_multiply_accumulate);
+    getModule()->addCapability(CapabilitySubgroupMatrixMultiplyAccumulateINTEL);
+  }
+
+  SPIRVCapVec getRequiredCapability() const override {
+    return getVec(
+        internal::CapabilitySubgroupScaledMatrixMultiplyAccumulateINTEL);
+  }
+};
+
+#define _SPIRV_OP(x, ...)                                                      \
+  typedef SPIRVInstTemplate<                                                   \
+      SPIRVSubgroupScaledMatrixMultiplyAccumulateINTELInst,                    \
+      internal::Op##x##INTEL, __VA_ARGS__>                                     \
+      SPIRV##x##INTEL;
+_SPIRV_OP(SubgroupScaledMatrixMultiplyAccumulate, true, 9, true, 6)
+#undef _SPIRV_OP
+
 class SPIRVPredicatedIOINTELInst : public SPIRVInstTemplateBase {
 public:
   llvm::Optional<ExtensionID> getRequiredExtension() const override {

lib/SPIRV/libSPIRV/SPIRVNameMapEnum.h

@@ -674,6 +674,8 @@ template <> inline void SPIRVMap<Capability, std::string>::init() {
       "FloatConversionsFtoFINTEL");
   add(internal::CapabilityFloatConversionsFtoSINTEL,
       "FloatConversionsFtoSINTEL");
+  add(internal::CapabilitySubgroupScaledMatrixMultiplyAccumulateINTEL,
+      "SubgroupScaledMatrixMultiplyAccumulateINTEL");
   add(CapabilityRoundedDivideSqrtINTEL, "RoundedDivideSqrtINTEL");
 }
 SPIRV_DEF_NAMEMAP(Capability, SPIRVCapabilityNameMap)

lib/SPIRV/libSPIRV/SPIRVOpCodeEnumInternal.h

@@ -42,3 +42,5 @@ _SPIRV_OP_INTERNAL(ClampConvertFToSINTEL,
                    internal::OpClampConvertFToSINTEL)
 _SPIRV_OP_INTERNAL(ClampStochasticRoundFToSINTEL,
                    internal::OpClampStochasticRoundFToSINTEL)
+_SPIRV_OP_INTERNAL(SubgroupScaledMatrixMultiplyAccumulateINTEL,
+                   internal::OpSubgroupScaledMatrixMultiplyAccumulateINTEL)

lib/SPIRV/libSPIRV/spirv_internal.hpp

@@ -74,6 +74,7 @@ enum InternalOp {
   IOpCooperativeMatrixConstructCheckedINTEL = 6195,
   IOpStochasticRoundFToFINTEL = 6217,
   IOpClampStochasticRoundFToSINTEL = 6219,
+  IOpSubgroupScaledMatrixMultiplyAccumulateINTEL = 6264,
   IOpJointMatrixWorkItemLengthINTEL = 6410,
   IOpComplexFMulINTEL = 6415,
   IOpComplexFDivINTEL = 6416,
@@ -129,6 +130,7 @@ enum InternalCapability {
   ICapabilityAtomicInt16CompareExchangeINTEL = 6260,
   ICapabilityInt16AtomicsINTEL = 6261,
   ICapabilityAtomicBFloat16LoadStoreINTEL = 6262,
+  ICapabilitySubgroupScaledMatrixMultiplyAccumulateINTEL = 6263,
   ICapabilityCooperativeMatrixPrefetchINTEL = 6411,
   ICapabilityComplexFloatMulDivINTEL = 6414,
   ICapabilityTensorFloat32RoundingINTEL = 6425,
@@ -182,6 +184,9 @@ enum InternalMatrixMultiplyAccumulateOperandsMask {
   // FP4 matrix operands
   IMatrixMultiplyAccumulateOperandsMatrixAPackedFloat4E2M1INTELMask = 0x40000,
   IMatrixMultiplyAccumulateOperandsMatrixBPackedFloat4E2M1INTELMask = 0x80000,
+  // Scale factors for SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate.
+  IMatrixMultiplyAccumulateOperandsScaleAFloat8E8M0INTELMask = 0x100000,
+  IMatrixMultiplyAccumulateOperandsScaleBFloat8E8M0INTELMask = 0x200000,
 };
 
 enum class LoadCacheControlINTEL {
@@ -261,6 +266,9 @@ _SPIRV_OP(Op, StochasticRoundFToFINTEL)
 _SPIRV_OP(Capability, FloatConversionsFtoSINTEL)
 _SPIRV_OP(Op, ClampConvertFToSINTEL)
 _SPIRV_OP(Op, ClampStochasticRoundFToSINTEL)
+
+_SPIRV_OP(Capability, SubgroupScaledMatrixMultiplyAccumulateINTEL)
+_SPIRV_OP(Op, SubgroupScaledMatrixMultiplyAccumulateINTEL)
 #undef _SPIRV_OP
 
 constexpr SourceLanguage SourceLanguagePython =

test/extensions/INTEL/SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate/subgroup_scaled_matrix_multiply_accumulate_fp4.ll

@@ -0,0 +1,43 @@
+; TODO: add spirv-val once SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate
+; is registered with Khronos and SPIRV-Tools recognizes its capability/opcode.
+
+; RUN: llvm-as %s -o %t.bc
+; RUN: llvm-spirv %t.bc -o %t.spv --spirv-ext=+SPV_INTEL_subgroup_matrix_multiply_accumulate,+SPV_INTEL_subgroup_matrix_multiply_accumulate_float4,+SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate
+; RUN: llvm-spirv %t.spv --to-text -o - | FileCheck %s --check-prefix=CHECK-SPIRV
+
+; RUN: llvm-spirv %t.spv -r --spirv-target-env=SPV-IR -o - | llvm-dis | FileCheck %s --check-prefix=CHECK-LLVM
+
+; RUN: not llvm-spirv %t.bc --spirv-ext=+SPV_INTEL_subgroup_matrix_multiply_accumulate,+SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate -o %t.fail.spv 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR-FP4
+; CHECK-ERROR-FP4: RequiresExtension: Feature requires the following SPIR-V extension:
+; CHECK-ERROR-FP4: SPV_INTEL_subgroup_matrix_multiply_accumulate_float4
+; CHECK-ERROR-FP4: SubgroupScaledMatrixMultiplyAccumulateINTEL with FP4 operand flags
+
+target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024"
+target triple = "spir64-unknown-unknown"
+
+; CHECK-SPIRV-DAG: Capability SubgroupMatrixMultiplyAccumulateINTEL
+; CHECK-SPIRV-DAG: Capability SubgroupScaledMatrixMultiplyAccumulateINTEL
+; CHECK-SPIRV-DAG: Extension "SPV_INTEL_subgroup_matrix_multiply_accumulate"
+; CHECK-SPIRV-DAG: Extension "SPV_INTEL_subgroup_matrix_multiply_accumulate_float4"
+; CHECK-SPIRV-DAG: Extension "SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate"
+
+; CHECK-SPIRV: SubgroupScaledMatrixMultiplyAccumulateINTEL
+
+; CHECK-LLVM: %{{.*}} = call spir_func <8 x float> @_Z51__spirv_SubgroupScaledMatrixMultiplyAccumulateINTELiDv8_sDv8_iDv8_fDv2_cS2_i(i32 64, <8 x i16> %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}}, <2 x i8> %{{.*}}, <2 x i8> %{{.*}}, i32 3932160)
+
+define spir_func void @foo(<8 x i16> %sM8, <8 x i32> %iM8, <8 x float> %fM8,
+                           <2 x i8> %sA, <2 x i8> %sB) {
+entry:
+  ; Operands: ScaleA/BFloat8E8M0INTEL (0x300000) | MatrixAPackedFloat4E2M1INTEL (0x40000) | MatrixBPackedFloat4E2M1INTEL (0x80000)
+  ;         = 0x3C0000 = 3932160
+  %call = call spir_func <8 x float> @_Z51__spirv_SubgroupScaledMatrixMultiplyAccumulateINTELiDv8_sDv8_iDv8_fDv2_cS2_i(i32 64, <8 x i16> %sM8, <8 x i32> %iM8, <8 x float> %fM8, <2 x i8> %sA, <2 x i8> %sB, i32 3932160)
+  ret void
+}
+
+declare spir_func <8 x float> @_Z51__spirv_SubgroupScaledMatrixMultiplyAccumulateINTELiDv8_sDv8_iDv8_fDv2_cS2_i(i32, <8 x i16>, <8 x i32>, <8 x float>, <2 x i8>, <2 x i8>, i32)
+
+!opencl.spir.version = !{!0}
+!spirv.Source = !{!1}
+
+!0 = !{i32 1, i32 0}
+!1 = !{i32 4, i32 100000}

test/extensions/INTEL/SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate/subgroup_scaled_matrix_multiply_accumulate_fp8.ll

@@ -0,0 +1,43 @@
+; TODO: add spirv-val once SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate
+; is registered with Khronos and SPIRV-Tools recognizes its capability/opcode.
+
+; RUN: llvm-as %s -o %t.bc
+; RUN: llvm-spirv %t.bc -o %t.spv --spirv-ext=+SPV_INTEL_subgroup_matrix_multiply_accumulate,+SPV_INTEL_subgroup_matrix_multiply_accumulate_float8,+SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate
+; RUN: llvm-spirv %t.spv --to-text -o - | FileCheck %s --check-prefix=CHECK-SPIRV
+
+; RUN: llvm-spirv %t.spv -r --spirv-target-env=SPV-IR -o - | llvm-dis | FileCheck %s --check-prefix=CHECK-LLVM
+
+; RUN: not llvm-spirv %t.bc --spirv-ext=+SPV_INTEL_subgroup_matrix_multiply_accumulate,+SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate -o %t.fail.spv 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR-FP8
+; CHECK-ERROR-FP8: RequiresExtension: Feature requires the following SPIR-V extension:
+; CHECK-ERROR-FP8: SPV_INTEL_subgroup_matrix_multiply_accumulate_float8
+; CHECK-ERROR-FP8: SubgroupScaledMatrixMultiplyAccumulateINTEL with FP8 operand flags
+
+target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024"
+target triple = "spir64-unknown-unknown"
+
+; CHECK-SPIRV-DAG: Capability SubgroupMatrixMultiplyAccumulateINTEL
+; CHECK-SPIRV-DAG: Capability SubgroupScaledMatrixMultiplyAccumulateINTEL
+; CHECK-SPIRV-DAG: Extension "SPV_INTEL_subgroup_matrix_multiply_accumulate"
+; CHECK-SPIRV-DAG: Extension "SPV_INTEL_subgroup_matrix_multiply_accumulate_float8"
+; CHECK-SPIRV-DAG: Extension "SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate"
+
+; CHECK-SPIRV: SubgroupScaledMatrixMultiplyAccumulateINTEL
+
+; CHECK-LLVM: %{{.*}} = call spir_func <8 x float> @_Z51__spirv_SubgroupScaledMatrixMultiplyAccumulateINTELiDv8_sDv8_iDv8_fcci(i32 32, <8 x i16> %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}}, i8 %{{.*}}, i8 %{{.*}}, i32 3194880)
+
+define spir_func void @foo(<8 x i16> %sM8, <8 x i32> %iM8, <8 x float> %fM8,
+                           i8 %sA, i8 %sB) {
+entry:
+  ; Operands: ScaleA/BFloat8E8M0INTEL (0x300000) | MatrixAPackedFloat8E4M3INTEL (0x4000) | MatrixBPackedFloat8E4M3INTEL (0x8000)
+  ;         = 0x30C000 = 3194880
+  %call = call spir_func <8 x float> @_Z51__spirv_SubgroupScaledMatrixMultiplyAccumulateINTELiDv8_sDv8_iDv8_fcci(i32 32, <8 x i16> %sM8, <8 x i32> %iM8, <8 x float> %fM8, i8 %sA, i8 %sB, i32 3194880)
+  ret void
+}
+
+declare spir_func <8 x float> @_Z51__spirv_SubgroupScaledMatrixMultiplyAccumulateINTELiDv8_sDv8_iDv8_fcci(i32, <8 x i16>, <8 x i32>, <8 x float>, i8, i8, i32)
+
+!opencl.spir.version = !{!0}
+!spirv.Source = !{!1}
+
+!0 = !{i32 1, i32 0}
+!1 = !{i32 4, i32 100000}

test/extensions/INTEL/SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate/subgroup_scaled_matrix_multiply_accumulate_generic.ll

@@ -0,0 +1,65 @@
+; Source (OpenCL C, conceptual):
+; float8 __spirv_SubgroupScaledMatrixMultiplyAccumulateINTEL(
+;     int K_Dim, short8 Matrix_A, int8 Matrix_B, float8 Matrix_C,
+;     uchar Scale_A, uchar Scale_B, int Operands);
+; int __spirv_SubgroupScaledMatrixMultiplyAccumulateINTEL(
+;     int K_Dim, int Matrix_A, int8 Matrix_B, int Matrix_C,
+;     uchar Scale_A, uchar Scale_B);
+
+; TODO: add spirv-val once SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate
+; is registered with Khronos and SPIRV-Tools recognizes its capability/opcode.
+
+; RUN: llvm-as %s -o %t.bc
+; RUN: llvm-spirv %t.bc -o %t.spv --spirv-ext=+SPV_INTEL_subgroup_matrix_multiply_accumulate,+SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate
+; RUN: llvm-spirv %t.spv --to-text -o - | FileCheck %s --check-prefix=CHECK-SPIRV
+
+; RUN: llvm-spirv %t.spv -r --spirv-target-env=SPV-IR -o - | llvm-dis | FileCheck %s --check-prefix=CHECK-LLVM
+
+; RUN: not llvm-spirv %t.bc -o %t.fail.spv 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR
+; CHECK-ERROR: RequiresExtension: Feature requires the following SPIR-V extension:
+; CHECK-ERROR: SPV_INTEL_subgroup_matrix_multiply_accumulate
+
+; RUN: not llvm-spirv %t.bc --spirv-ext=+SPV_INTEL_subgroup_matrix_multiply_accumulate -o %t.fail.spv 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR-NEW
+; CHECK-ERROR-NEW: RequiresExtension: Feature requires the following SPIR-V extension:
+; CHECK-ERROR-NEW: SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate
+
+target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024"
+target triple = "spir64-unknown-unknown"
+
+; CHECK-SPIRV-DAG: Capability SubgroupMatrixMultiplyAccumulateINTEL
+; CHECK-SPIRV-DAG: Capability SubgroupScaledMatrixMultiplyAccumulateINTEL
+; CHECK-SPIRV-DAG: Extension "SPV_INTEL_subgroup_matrix_multiply_accumulate"
+; CHECK-SPIRV-DAG: Extension "SPV_INTEL_subgroup_scaled_matrix_multiply_accumulate"
+
+; CHECK-SPIRV-DAG: TypeInt [[#Int32Ty:]] 32 0
+; CHECK-SPIRV-DAG: Constant [[#Int32Ty]] [[#Const16:]] 16
+; CHECK-SPIRV-DAG: TypeFloat [[#FloatTy:]] 32
+; CHECK-SPIRV-DAG: TypeVector [[#Vec8FloatTy:]] [[#FloatTy]] 8
+
+; fp16 x fp16 + fp32 with e8m0 scales (operands mask = 0x30000A: MatrixA/BPackedFloat16 (0xA) + ScaleA/BFloat8E8M0 (0x300000)).
+; CHECK-SPIRV: SubgroupScaledMatrixMultiplyAccumulateINTEL [[#Vec8FloatTy]] [[#]] [[#Const16]] [[#]] [[#iM8:]] [[#]] [[#sA:]] [[#sB:]] {{[0-9]+}}
+; CHECK-SPIRV: SubgroupScaledMatrixMultiplyAccumulateINTEL [[#Int32Ty]] [[#]] [[#Const16]] [[#]] [[#iM8]] [[#]] [[#sA]] [[#sB]] {{$}}
+
+; CHECK-LLVM: %{{.*}} = call spir_func <8 x float> @_Z51__spirv_SubgroupScaledMatrixMultiplyAccumulateINTELiDv8_sDv8_iDv8_fcci(i32 16, <8 x i16> %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}}, i8 %{{.*}}, i8 %{{.*}}, i32 3145738)
+; CHECK-LLVM: %{{.*}} = call spir_func i32 @_Z51__spirv_SubgroupScaledMatrixMultiplyAccumulateINTELiiDv8_iicc(i32 16, i32 %{{.*}}, <8 x i32> %{{.*}}, i32 %{{.*}}, i8 %{{.*}}, i8 %{{.*}})
+
+define spir_func void @foo(<8 x i16> %sM8, <8 x i32> %iM8, <8 x float> %fM8,
+                           i8 %sA, i8 %sB, i32 %iA, i32 %iC) {
+entry:
+  ; Operands: ScaleAFloat8E8M0INTEL (0x100000) | ScaleBFloat8E8M0INTEL (0x200000)
+  ;         | MatrixAPackedFloat16INTEL (0x2)  | MatrixBPackedFloat16INTEL (0x8)
+  ;         = 0x30000A = 3145738
+  %call = call spir_func <8 x float> @_Z51__spirv_SubgroupScaledMatrixMultiplyAccumulateINTELiDv8_sDv8_iDv8_fcci(i32 16, <8 x i16> %sM8, <8 x i32> %iM8, <8 x float> %fM8, i8 %sA, i8 %sB, i32 3145738)
+  %call2 = call spir_func i32 @_Z51__spirv_SubgroupScaledMatrixMultiplyAccumulateINTELiiDv8_iicc(i32 16, i32 %iA, <8 x i32> %iM8, i32 %iC, i8 %sA, i8 %sB)
+  ret void
+}
+
+declare spir_func <8 x float> @_Z51__spirv_SubgroupScaledMatrixMultiplyAccumulateINTELiDv8_sDv8_iDv8_fcci(i32, <8 x i16>, <8 x i32>, <8 x float>, i8, i8, i32)
+
+declare spir_func i32 @_Z51__spirv_SubgroupScaledMatrixMultiplyAccumulateINTELiiDv8_iicc(i32, i32, <8 x i32>, i32, i8, i8)
+
+!opencl.spir.version = !{!0}
+!spirv.Source = !{!1}
+
+!0 = !{i32 1, i32 0}
+!1 = !{i32 4, i32 100000}