[mlir][spirv] Change vendor op mnemonics to `spv.VENDOR.name`

[kuhar]

Summary

Make vendor ops more consistent with the naming scheme within the SPIR-V
dialect.

Issue: https://github.com/llvm/llvm-project/issues/56863

[antiagainst]

Awesome, thanks for taking care of this!

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAtomicOps.td

let description = [{
 
     The type of Value must be the same as Result Type. The type of the value
     pointed to by Pointer must be the same as Result Type.
 
     Memory must be a valid memory Scope.
 
     ```
     atomic-fadd-op ::=
-        `spv.AtomicFAddEXT` scope memory-semantics
+        `spv.EXT.AtomicFAdd` scope memory-semantics
                             ssa-use `,` ssa-use `:` spv-pointer-type
     ```
 
     #### Example:
 
     ```mlir
-    %0 = spv.AtomicFAddEXT "Device" "None" %pointer, %value :
+    %0 = spv.EXT.AtomicFAdd "Device" "None" %pointer, %value :
                            !spv.ptr<f32, StorageBuffer>
     ```mlir
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_6>,
     Extension<[SPV_EXT_shader_atomic_float_add]>,

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td

class SPV_ExtInstOp<string mnemonic, string setPrefix, string setName,
   // Name used to import the extended instruction set.
   string extendedInstSetName = setName;
 }
 
 // Base classes for SPIR-V vendor ops. These have opcode in the form of
 // Op<Name><VENDOR>, e.g., OpCooperativeMatrixStoreNV.
 class SPV_VendorOp<string mnemonic, string vendorName,
                    list<Trait> traits = []> :
-  SPV_Op<mnemonic # vendorName, traits> {
+  SPV_Op<vendorName # "." # mnemonic, traits> {
   string spirvOpName = "Op" # mnemonic # vendorName;
 }
 
 class SPV_ExtVendorOp<string mnemonic, list<Trait> traits = []> :
   SPV_VendorOp<mnemonic, "EXT", traits> {
 }
 
 class SPV_KhrVendorOp<string mnemonic, list<Trait> traits = []> :

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCooperativeMatrixOps.td

let description = [{
     Number of components of a cooperative matrix type accessible to each
     invocation when treated as a composite.
 
     Result Type must be an OpTypeInt with 32-bit Width and 0 Signedness.
 
     Type is a cooperative matrix type.
 
     ``` {.ebnf}
-    cooperative-matrix-length-op ::= ssa-id `=` `spv.CooperativeMatrixLengthNV
+    cooperative-matrix-length-op ::= ssa-id `=` `spv.NV.CooperativeMatrixLength
                                     ` : ` cooperative-matrix-type
     ```
 
     For example:
 
     ```
-    %0 = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<Subgroup, i32, 8, 16>
+    %0 = spv.NV.CooperativeMatrixLength : !spv.coopmatrix<Subgroup, i32, 8, 16>
     ```
   }];
 
   let assemblyFormat = "attr-dict `:` $type";
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_6>,
let description = [{
     instruction must be the same for all invocations in a given scope instance
     (where the scope is the scope the cooperative matrix type was created with).
     All invocations in a given scope instance must be active or all must be
     inactive.
 
     ### Custom assembly form
 
     ``` {.ebnf}
-    cooperative-matrixload-op ::= ssa-id `=` `spv.CooperativeMatrixLoadNV`
+    cooperative-matrixload-op ::= ssa-id `=` `spv.NV.CooperativeMatrixLoad`
                               ssa-use `,` ssa-use `,` ssa-use
                               (`[` memory-access `]`)? ` : `
                               pointer-type `as`
                               cooperative-matrix-type
     ```
 
     For example:
 
     ```
-    %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %colMajor
+    %0 = spv.NV.CooperativeMatrixLoad %ptr, %stride, %colMajor
          : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<i32, Workgroup, 16, 8>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_6>,
     Extension<[SPV_NV_cooperative_matrix]>,
let description = [{
     components are treated as signed if its Component Type has Signedness of 1
     and are treated as unsigned otherwise.
 
     For a given dynamic instance of this instruction, all invocations in a given
     scope instance must be active or all must be inactive (where the scope is
     the scope of the operation).
 
     ``` {.ebnf}
-    cooperative-matrixmuladd-op ::= ssa-id `=` `spv.CooperativeMatrixMulAddNV`
+    cooperative-matrixmuladd-op ::= ssa-id `=` `spv.NV.CooperativeMatrixMulAdd`
                               ssa-use `,` ssa-use `,` ssa-use ` : `
                               a-cooperative-matrix-type,
                               b-cooperative-matrix-type ->
                               result-cooperative-matrix-type
     ```
     For example:
 
     ```
-    %0 = spv.CooperativeMatrixMulAddNV %arg0, %arg1, %arg2,  :
+    %0 = spv.NV.CooperativeMatrixMulAdd %arg0, %arg1, %arg2,  :
       !spv.coopmatrix<Subgroup, i32, 8, 16>
     ```
   }];
 
   let assemblyFormat = [{
     operands attr-dict`:` type($a) `,` type($b) `->` type($c)
   }];
 
let description = [{
     ColumnMajor indicates whether the values stored to memory are arranged in
     column-major or row-major order. It must be a boolean constant instruction,
     with false indicating row major and true indicating column major.
 
     Memory Access must be a Memory Access literal. If not present, it is the
     same as specifying None.
 
     ``` {.ebnf}
-    coop-matrix-store-op ::= `spv.CooperativeMatrixStoreNV `
+    coop-matrix-store-op ::= `spv.NV.CooperativeMatrixStore `
                               ssa-use `, ` ssa-use `, `
                               ssa-use `, ` ssa-use `, `
                               (`[` memory-access `]`)? `:`
                               pointer-type `,` spirv-element-type
     ```
 
     For example:
 
     ```
-      spv.CooperativeMatrixStoreNV %arg0, %arg2, %arg1, %arg3 :
+      spv.NV.CooperativeMatrixStore %arg0, %arg2, %arg1, %arg3 :
         !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<Workgroup, i32, 16, 8>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_6>,
     Extension<[SPV_NV_cooperative_matrix]>,

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVGroupOps.td

let description = [{
     Result is a set of bitfields where the first invocation is represented in bit
     0 of the first vector component and the last (up to SubgroupSize) is the
     higher bit number of the last bitmask needed to represent all bits of the
     subgroup invocations.
 
     <!-- End of AutoGen section -->
 
     ```
-    subgroup-ballot-op ::= ssa-id `=` `spv.SubgroupBallotKHR`
+    subgroup-ballot-op ::= ssa-id `=` `spv.KHR.SubgroupBallot`
                                 ssa-use `:` `vector` `<` 4 `x` `i32` `>`
     ```
 
     #### Example:
 
     ```mlir
-    %0 = spv.SubgroupBallotKHR %predicate : vector<4xi32>
+    %0 = spv.KHR.SubgroupBallot %predicate : vector<4xi32>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_6>,
     Extension<[SPV_KHR_shader_ballot]>,
     Capability<[SPV_C_SubgroupBallotKHR]>
let description = [{
     Result Type may be a scalar or vector type, and its component type must be
     equal to the type pointed to by Ptr.
 
     The type of Ptr must be a pointer type, and must point to a scalar type.
 
     <!-- End of AutoGen section -->
 
     ```
-    subgroup-block-read-INTEL-op ::= ssa-id `=` `spv.SubgroupBlockReadINTEL`
+    subgroup-block-read-INTEL-op ::= ssa-id `=` `spv.INTEL.SubgroupBlockRead`
                                 storage-class ssa_use `:` spirv-element-type
     ```mlir
 
     #### Example:
 
     ```
-    %0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : i32
+    %0 = spv.INTEL.SubgroupBlockRead "StorageBuffer" %ptr : i32
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_6>,
     Extension<[SPV_INTEL_subgroups]>,
     Capability<[SPV_C_SubgroupBufferBlockIOINTEL]>
let description = [{
 
     The type of Ptr must be a pointer type, and must point to a scalar type.
 
     The component type of Data must be equal to the type pointed to by Ptr.
 
     <!-- End of AutoGen section -->
 
     ```
-    subgroup-block-write-INTEL-op ::= ssa-id `=` `spv.SubgroupBlockWriteINTEL`
+    subgroup-block-write-INTEL-op ::= ssa-id `=` `spv.INTEL.SubgroupBlockWrite`
                       storage-class ssa_use `,` ssa-use `:` spirv-element-type
     ```mlir
 
     #### Example:
 
     ```
-    spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : i32
+    spv.INTEL.SubgroupBlockWrite "StorageBuffer" %ptr, %value : i32
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_6>,
     Extension<[SPV_INTEL_subgroups]>,
     Capability<[SPV_C_SubgroupBufferBlockIOINTEL]>

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVJointMatrixOps.td

let description = [{
     Return number of components owned by the current work-item in
     a joint matrix.
 
     Result Type must be an 32-bit unsigned integer type scalar.
 
     Type is a joint matrix type.
 
     ``` {.ebnf}
-    joint-matrix-length-op ::= ssa-id `=` `spv.JointMatrixWorkItemLengthINTEL
+    joint-matrix-length-op ::= ssa-id `=` `spv.INTEL.JointMatrixWorkItemLength
                                     ` : ` joint-matrix-type
     ```
 
     For example:
 
     ```
-    %0 = spv.JointMatrixWorkItemLengthINTEL : !spv.jointmatrix<Subgroup, i32, 8, 16>
+    %0 = spv.INTEL.JointMatrixWorkItemLength : !spv.jointmatrix<Subgroup, i32, 8, 16>
     ```
   }];
 
   let assemblyFormat = "attr-dict `:` $type";
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_6>,
let description = [{
     Scope is syncronization scope for operation on the matrix. It must be the result
     of a constant instruction with scalar integer type.
 
     If present, any Memory Operands must begin with a memory operand literal. If not
     present, it is the same as specifying the memory operand None.
 
     #### Example:
     ```mlir
-    %0 = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> %ptr, %stride
+    %0 = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> %ptr, %stride
          {memory_access = #spv.memory_access<Volatile>} :
          (!spv.ptr<i32, CrossWorkgroup>, i32) ->
          !spv.jointmatrix<8x16xi32, ColumnMajor, Subgroup>
     ```
   }];
 
   let assemblyFormat = [{
     $scope $layout operands attr-dict `:` `(` type(operands) `)` `->` type($result)
let description = [{
     Count equals to M and Column Count equals to N
 
     Scope is syncronization scope for operation on the matrix.
     It must be the result of a constant instruction with scalar
     integer type.
 
     #### Example:
     ```mlir
-    %r = spv.JointMatrixMadINTEL <Subgroup> %a, %b, %c :
+    %r = spv.INTEL.JointMatrixMad <Subgroup> %a, %b, %c :
          !spv.jointmatrix<8x32xi8, RowMajor, Subgroup>,
          !spv.jointmatrix<32x8xi8, ColumnMajor, Subgroup>
          -> !spv.jointmatrix<8x8xi32,  RowMajor, Subgroup>
     ```
 
   }];
 
   let assemblyFormat = [{
let description = [{
     integer type.
 
     If present, any Memory Operands must begin with a memory operand
     literal. If not present, it is the same as specifying the memory
     operand None.
 
     #### Example:
     ```mlir
-    spv.JointMatrixStoreINTEL <Subgroup> <ColumnMajor> %ptr, %m, %stride
+    spv.INTEL.JointMatrixStore <Subgroup> <ColumnMajor> %ptr, %m, %stride
     {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, Workgroup>,
     !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, i32)
     ```
 
   }];
 
    let assemblyFormat = [{
     $scope $layout operands attr-dict `:` `(` type(operands) `)`

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVMiscOps.td

def SPV_KHRAssumeTrueOp : SPV_KhrVendorOp<"AssumeTrue", []> {
   let summary = "TBD";
 
   let description = [{
 
 
     <!-- End of AutoGen section -->
 
     ```
-    assumetruekhr-op ::= `spv.AssumeTrueKHR` ssa-use
+    assumetruekhr-op ::= `spv.KHR.AssumeTrue` ssa-use
     ```mlir
 
     #### Example:
 
     ```
-    spv.AssumeTrueKHR %arg
+    spv.KHR.AssumeTrue %arg
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_6>,
     Extension<[SPV_KHR_expect_assume]>,
     Capability<[SPV_C_ExpectAssumeKHR]>

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

ParseResult spirv::AtomicIAddOp::parse(OpAsmParser &parser,
                                        OperationState &result) {
   return ::parseAtomicUpdateOp(parser, result, true);
 }
 void spirv::AtomicIAddOp::print(OpAsmPrinter &p) {
   ::printAtomicUpdateOp(*this, p);
 }
 
 //===----------------------------------------------------------------------===//
-// spv.AtomicFAddEXTOp
+// spv.EXT.AtomicFAddOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::EXTAtomicFAddOp::verify() {
   return ::verifyAtomicUpdateOp<FloatType>(getOperation());
 }
 
 ParseResult spirv::EXTAtomicFAddOp::parse(OpAsmParser &parser,
                                           OperationState &result) {

 LogicalResult spirv::GroupNonUniformShuffleUpOp::verify() {
   return verifyGroupNonUniformShuffleOp(*this);
 }
 LogicalResult spirv::GroupNonUniformShuffleXorOp::verify() {
   return verifyGroupNonUniformShuffleOp(*this);
 }
 
 //===----------------------------------------------------------------------===//
-// spv.SubgroupBlockReadINTEL
+// spv.INTEL.SubgroupBlockRead
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::INTELSubgroupBlockReadOp::parse(OpAsmParser &parser,
                                                    OperationState &result) {
   // Parse the storage class specification
   spirv::StorageClass storageClass;
   OpAsmParser::UnresolvedOperand ptrInfo;
   Type elementType;

 LogicalResult spirv::INTELSubgroupBlockReadOp::verify() {
   if (failed(verifyBlockReadWritePtrAndValTypes(*this, ptr(), value())))
     return failure();
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
-// spv.SubgroupBlockWriteINTEL
+// spv.INTEL.SubgroupBlockWrite
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::INTELSubgroupBlockWriteOp::parse(OpAsmParser &parser,
                                                     OperationState &result) {
   // Parse the storage class specification
   spirv::StorageClass storageClass;
   SmallVector<OpAsmParser::UnresolvedOperand, 2> operandInfo;
   auto loc = parser.getCurrentLocation();
if (index >= totalSrcElements &&
       return emitOpError("component selector ")
              << index << " out of range: expected to be in [0, "
              << totalSrcElements << ") or 0xffffffff";
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
-// spv.CooperativeMatrixLoadNV
+// spv.NV.CooperativeMatrixLoad
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::NVCooperativeMatrixLoadOp::parse(OpAsmParser &parser,
                                                     OperationState &result) {
   SmallVector<OpAsmParser::UnresolvedOperand, 3> operandInfo;
   Type strideType = parser.getBuilder().getIntegerType(32);
   Type columnMajorType = parser.getBuilder().getIntegerType(1);
   Type ptrType;

 }
 
 LogicalResult spirv::NVCooperativeMatrixLoadOp::verify() {
   return verifyPointerAndCoopMatrixType(*this, pointer().getType(),
                                         result().getType());
 }
 
 //===----------------------------------------------------------------------===//
-// spv.CooperativeMatrixStoreNV
+// spv.NV.CooperativeMatrixStore
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::NVCooperativeMatrixStoreOp::parse(OpAsmParser &parser,
                                                      OperationState &result) {
   SmallVector<OpAsmParser::UnresolvedOperand, 4> operandInfo;
   Type strideType = parser.getBuilder().getIntegerType(32);
   Type columnMajorType = parser.getBuilder().getIntegerType(1);
   Type ptrType;

 }
 
 LogicalResult spirv::NVCooperativeMatrixStoreOp::verify() {
   return verifyPointerAndCoopMatrixType(*this, pointer().getType(),
                                         object().getType());
 }
 
 //===----------------------------------------------------------------------===//
-// spv.CooperativeMatrixMulAddNV
+// spv.NV.CooperativeMatrixMulAdd
 //===----------------------------------------------------------------------===//
 
 static LogicalResult
 verifyCoopMatrixMulAdd(spirv::NVCooperativeMatrixMulAddOp op) {
   if (op.c().getType() != op.result().getType())
     return op.emitOpError("result and third operand must have the same type");
   auto typeA = op.a().getType().cast<spirv::CooperativeMatrixNVType>();
   auto typeB = op.b().getType().cast<spirv::CooperativeMatrixNVType>();
if (storage != spirv::StorageClass::Workgroup &&
       storage != spirv::StorageClass::Generic)
     return op->emitError("Pointer storage class must be Workgroup or "
                          "CrossWorkgroup but provided ")
            << stringifyStorageClass(storage);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
-// spv.JointMatrixLoadINTEL
+// spv.INTEL.JointMatrixLoad
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::INTELJointMatrixLoadOp::verify() {
   return verifyPointerAndJointMatrixType(*this, pointer().getType(),
                                          result().getType());
 }
 
 //===----------------------------------------------------------------------===//
-// spv.JointMatrixStoreINTEL
+// spv.INTEL.JointMatrixStore
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::INTELJointMatrixStoreOp::verify() {
   return verifyPointerAndJointMatrixType(*this, pointer().getType(),
                                          object().getType());
 }
 
 //===----------------------------------------------------------------------===//
-// spv.JointMatrixMadINTEL
+// spv.INTEL.JointMatrixMad
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verifyJointMatrixMad(spirv::INTELJointMatrixMadOp op) {
   if (op.c().getType() != op.result().getType())
     return op.emitOpError("result and third operand must have the same type");
   auto typeA = op.a().getType().cast<spirv::JointMatrixINTELType>();
   auto typeB = op.b().getType().cast<spirv::JointMatrixINTELType>();
   auto typeC = op.c().getType().cast<spirv::JointMatrixINTELType>();

mlir/test/Dialect/SPIRV/IR/atomic-ops.mlir

func.func @atomic_xor(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 {
   // CHECK: spv.AtomicXor "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer>
   %0 = spv.AtomicXor "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer>
   return %0 : i32
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.AtomicFAddEXT
+// spv.EXT.AtomicFAdd
 //===----------------------------------------------------------------------===//
 
 func.func @atomic_fadd(%ptr : !spv.ptr<f32, StorageBuffer>, %value : f32) -> f32 {
-  // CHECK: spv.AtomicFAddEXT "Device" "None" %{{.*}}, %{{.*}} : !spv.ptr<f32, StorageBuffer>
-  %0 = spv.AtomicFAddEXT "Device" "None" %ptr, %value : !spv.ptr<f32, StorageBuffer>
+  // CHECK: spv.EXT.AtomicFAdd "Device" "None" %{{.*}}, %{{.*}} : !spv.ptr<f32, StorageBuffer>
+  %0 = spv.EXT.AtomicFAdd "Device" "None" %ptr, %value : !spv.ptr<f32, StorageBuffer>
   return %0 : f32
 }
 
 // -----
 
 func.func @atomic_fadd(%ptr : !spv.ptr<i32, StorageBuffer>, %value : f32) -> f32 {
   // expected-error @+1 {{pointer operand must point to an float value, found 'i32'}}
-  %0 = "spv.AtomicFAddEXT"(%ptr, %value) {memory_scope = #spv.scope<Workgroup>, semantics = #spv.memory_semantics<AcquireRelease>} : (!spv.ptr<i32, StorageBuffer>, f32) -> (f32)
+  %0 = "spv.EXT.AtomicFAdd"(%ptr, %value) {memory_scope = #spv.scope<Workgroup>, semantics = #spv.memory_semantics<AcquireRelease>} : (!spv.ptr<i32, StorageBuffer>, f32) -> (f32)
   return %0 : f32
 }
 
 // -----
 
 func.func @atomic_fadd(%ptr : !spv.ptr<f32, StorageBuffer>, %value : f64) -> f64 {
   // expected-error @+1 {{expected value to have the same type as the pointer operand's pointee type 'f32', but found 'f64'}}
-  %0 = "spv.AtomicFAddEXT"(%ptr, %value) {memory_scope = #spv.scope<Device>, semantics = #spv.memory_semantics<AcquireRelease>} : (!spv.ptr<f32, StorageBuffer>, f64) -> (f64)
+  %0 = "spv.EXT.AtomicFAdd"(%ptr, %value) {memory_scope = #spv.scope<Device>, semantics = #spv.memory_semantics<AcquireRelease>} : (!spv.ptr<f32, StorageBuffer>, f64) -> (f64)
   return %0 : f64
 }
 
 // -----
 
 func.func @atomic_fadd(%ptr : !spv.ptr<f32, StorageBuffer>, %value : f32) -> f32 {
   // expected-error @+1 {{expected at most one of these four memory constraints to be set: `Acquire`, `Release`,`AcquireRelease` or `SequentiallyConsistent`}}
-  %0 = spv.AtomicFAddEXT "Device" "Acquire|Release" %ptr, %value : !spv.ptr<f32, StorageBuffer>
+  %0 = spv.EXT.AtomicFAdd "Device" "Acquire|Release" %ptr, %value : !spv.ptr<f32, StorageBuffer>
   return %0 : f32
 }

mlir/test/Dialect/SPIRV/IR/cooperative-matrix-ops.mlir

 // RUN: mlir-opt -allow-unregistered-dialect -split-input-file -verify-diagnostics %s | FileCheck %s
 
 // CHECK-LABEL: @cooperative_matrix_load
 spv.func @cooperative_matrix_load(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %b : i1) "None" {
-  // CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup>
-  %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup>
+  // CHECK: {{%.*}} = spv.NV.CooperativeMatrixLoad {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup>
+  %0 = spv.NV.CooperativeMatrixLoad %ptr, %stride, %b : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup>
   spv.Return
 }
 
 // -----
 // CHECK-LABEL: @cooperative_matrix_load_memaccess
 spv.func @cooperative_matrix_load_memaccess(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %b : i1) "None" {
-  // CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
-  %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
+  // CHECK: {{%.*}} = spv.NV.CooperativeMatrixLoad {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
+  %0 = spv.NV.CooperativeMatrixLoad %ptr, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
   spv.Return
 }
 
 // CHECK-LABEL: @cooperative_matrix_load_diff_ptr_type
 spv.func @cooperative_matrix_load_diff_ptr_type(%ptr : !spv.ptr<vector<4xi32>, StorageBuffer>, %stride : i32, %b : i1) "None" {
-  // CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<vector<4xi32>, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
-  %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b ["Volatile"] : !spv.ptr<vector<4xi32>, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
+  // CHECK: {{%.*}} = spv.NV.CooperativeMatrixLoad {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<vector<4xi32>, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
+  %0 = spv.NV.CooperativeMatrixLoad %ptr, %stride, %b ["Volatile"] : !spv.ptr<vector<4xi32>, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
   spv.Return
 }
 
 // CHECK-LABEL: @cooperative_matrix_store
 spv.func @cooperative_matrix_store(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %m : !spv.coopmatrix<8x16xi32, Workgroup>, %b : i1) "None" {
-  // CHECK: spv.CooperativeMatrixStoreNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Workgroup>
-  spv.CooperativeMatrixStoreNV %ptr, %m, %stride, %b : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Workgroup>
+  // CHECK: spv.NV.CooperativeMatrixStore {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Workgroup>
+  spv.NV.CooperativeMatrixStore %ptr, %m, %stride, %b : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Workgroup>
   spv.Return
 }
 
 // CHECK-LABEL: @cooperative_matrix_store_memaccess
 spv.func @cooperative_matrix_store_memaccess(%ptr : !spv.ptr<i32, StorageBuffer>, %m : !spv.coopmatrix<8x16xi32, Subgroup>, %stride : i32, %b : i1) "None" {
-  // CHECK: spv.CooperativeMatrixStoreNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup>
-  spv.CooperativeMatrixStoreNV %ptr, %m, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup>
+  // CHECK: spv.NV.CooperativeMatrixStore {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup>
+  spv.NV.CooperativeMatrixStore %ptr, %m, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup>
   spv.Return
 }
 
 // CHECK-LABEL: @cooperative_matrix_length
 spv.func @cooperative_matrix_length() -> i32 "None" {
-  // CHECK: {{%.*}} = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<8x16xi32, Subgroup>
-  %0 = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<8x16xi32, Subgroup>
+  // CHECK: {{%.*}} = spv.NV.CooperativeMatrixLength : !spv.coopmatrix<8x16xi32, Subgroup>
+  %0 = spv.NV.CooperativeMatrixLength : !spv.coopmatrix<8x16xi32, Subgroup>
   spv.ReturnValue %0 : i32
 }
 
 // CHECK-LABEL: @cooperative_matrix_muladd
 spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x32xi8, Subgroup>, %b : !spv.coopmatrix<32x8xi8, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" {
-  // CHECK: {{%.*}} = spv.CooperativeMatrixMulAddNV {{%.*}}, {{%.*}}, {{%.*}}  : !spv.coopmatrix<8x32xi8, Subgroup>, !spv.coopmatrix<32x8xi8, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
-  %r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x32xi8, Subgroup>, !spv.coopmatrix<32x8xi8, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
+  // CHECK: {{%.*}} = spv.NV.CooperativeMatrixMulAdd {{%.*}}, {{%.*}}, {{%.*}}  : !spv.coopmatrix<8x32xi8, Subgroup>, !spv.coopmatrix<32x8xi8, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
+  %r = spv.NV.CooperativeMatrixMulAdd %a, %b, %c : !spv.coopmatrix<8x32xi8, Subgroup>, !spv.coopmatrix<32x8xi8, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
   spv.Return
 }
 
 // CHECK-LABEL: @cooperative_matrix_add
 spv.func @cooperative_matrix_add(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" {
   // CHECK: {{%.*}} = spv.IAdd {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup>
   %r = spv.IAdd %a, %b : !spv.coopmatrix<8x16xi32, Subgroup>
   spv.Return
spv.func @cooperative_matrix_access_chain(%a : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>) -> !spv.ptr<f32, Function> "None" {
   // CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}] : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>, i32
   %1 = spv.AccessChain %a[%0] : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>, i32
   spv.ReturnValue %1 : !spv.ptr<f32, Function>
 }
 
 // -----
 
 spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<16x16xi32, Subgroup>, %b : !spv.coopmatrix<16x8xi32, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" {
-  // expected-error @+1 {{'spv.CooperativeMatrixMulAddNV' op matrix size must match}}
-  %r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<16x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
+  // expected-error @+1 {{'spv.NV.CooperativeMatrixMulAdd' op matrix size must match}}
+  %r = spv.NV.CooperativeMatrixMulAdd %a, %b, %c : !spv.coopmatrix<16x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
   spv.Return
 }
 
 // -----
 
 spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x8xi32, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" {
-  // expected-error @+1 {{'spv.CooperativeMatrixMulAddNV' op matrix size must match}}
-  %r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<8x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
+  // expected-error @+1 {{'spv.NV.CooperativeMatrixMulAdd' op matrix size must match}}
+  %r = spv.NV.CooperativeMatrixMulAdd %a, %b, %c : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<8x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
   spv.Return
 }
 
 // -----
 
 spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<16x8xi32, Workgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" {
-  // expected-error @+1 {{'spv.CooperativeMatrixMulAddNV' op matrix scope must match}}
-  %r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Workgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
+  // expected-error @+1 {{'spv.NV.CooperativeMatrixMulAdd' op matrix scope must match}}
+  %r = spv.NV.CooperativeMatrixMulAdd %a, %b, %c : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Workgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
   spv.Return
 }
 
 // -----
 
 spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<16x8xi32, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" {
   // expected-error @+1 {{matrix element type must match}}
-  %r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x16xf32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
+  %r = spv.NV.CooperativeMatrixMulAdd %a, %b, %c : !spv.coopmatrix<8x16xf32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
   spv.Return
 }
 
 // -----
 
 spv.func @cooperative_matrix_load_memaccess(%ptr : !spv.ptr<!spv.struct<(f32 [0])>, StorageBuffer>, %stride : i32, %b : i1) "None" {
   // expected-error @+1 {{Pointer must point to a scalar or vector type}}
-  %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b : !spv.ptr<!spv.struct<(f32 [0])>, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
+  %0 = spv.NV.CooperativeMatrixLoad %ptr, %stride, %b : !spv.ptr<!spv.struct<(f32 [0])>, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
   spv.Return
 }
 
 // -----
 
 spv.func @cooperative_matrix_load_memaccess(%ptr : !spv.ptr<i32, Function>, %stride : i32, %b : i1) "None" {
   // expected-error @+1 {{Pointer storage class must be Workgroup, StorageBuffer or PhysicalStorageBufferEXT}}
-  %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b : !spv.ptr<i32, Function> as !spv.coopmatrix<8x16xi32, Subgroup>
+  %0 = spv.NV.CooperativeMatrixLoad %ptr, %stride, %b : !spv.ptr<i32, Function> as !spv.coopmatrix<8x16xi32, Subgroup>
   spv.Return
 }

mlir/test/Dialect/SPIRV/IR/group-ops.mlir

 // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
-// spv.SubgroupBallotKHR
+// spv.KHR.SubgroupBallot
 //===----------------------------------------------------------------------===//
 
 func.func @subgroup_ballot(%predicate: i1) -> vector<4xi32> {
-  // CHECK: %{{.*}} = spv.SubgroupBallotKHR %{{.*}} : vector<4xi32>
-  %0 = spv.SubgroupBallotKHR %predicate: vector<4xi32>
+  // CHECK: %{{.*}} = spv.KHR.SubgroupBallot %{{.*}} : vector<4xi32>
+  %0 = spv.KHR.SubgroupBallot %predicate: vector<4xi32>
   return %0: vector<4xi32>
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // spv.GroupBroadcast
 //===----------------------------------------------------------------------===//
func.func @group_broadcast_negative_locid_vec4(%value: f32, %localid: vector<4xi32> ) -> f32 {
   // expected-error @+1 {{localid is a vector and can be with only  2 or 3 components, actual number is 4}}
   %0 = spv.GroupBroadcast <Subgroup> %value, %localid : f32, vector<4xi32>
   return %0: f32
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.SubgroupBallotKHR
+// spv.KHR.SubgroupBallot
 //===----------------------------------------------------------------------===//
 
 func.func @subgroup_ballot(%predicate: i1) -> vector<4xi32> {
-  %0 = spv.SubgroupBallotKHR %predicate: vector<4xi32>
+  %0 = spv.KHR.SubgroupBallot %predicate: vector<4xi32>
   return %0: vector<4xi32>
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.SubgroupBlockReadINTEL
+// spv.INTEL.SubgroupBlockRead
 //===----------------------------------------------------------------------===//
 
 func.func @subgroup_block_read_intel(%ptr : !spv.ptr<i32, StorageBuffer>) -> i32 {
-  // CHECK: spv.SubgroupBlockReadINTEL %{{.*}} : i32
-  %0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : i32
+  // CHECK: spv.INTEL.SubgroupBlockRead %{{.*}} : i32
+  %0 = spv.INTEL.SubgroupBlockRead "StorageBuffer" %ptr : i32
   return %0: i32
 }
 
 // -----
 
 func.func @subgroup_block_read_intel_vector(%ptr : !spv.ptr<i32, StorageBuffer>) -> vector<3xi32> {
-  // CHECK: spv.SubgroupBlockReadINTEL %{{.*}} : vector<3xi32>
-  %0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : vector<3xi32>
+  // CHECK: spv.INTEL.SubgroupBlockRead %{{.*}} : vector<3xi32>
+  %0 = spv.INTEL.SubgroupBlockRead "StorageBuffer" %ptr : vector<3xi32>
   return %0: vector<3xi32>
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.SubgroupBlockWriteINTEL
+// spv.INTEL.SubgroupBlockWrite
 //===----------------------------------------------------------------------===//
 
 func.func @subgroup_block_write_intel(%ptr : !spv.ptr<i32, StorageBuffer>, %value: i32) -> () {
-  // CHECK: spv.SubgroupBlockWriteINTEL %{{.*}}, %{{.*}} : i32
-  spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : i32
+  // CHECK: spv.INTEL.SubgroupBlockWrite %{{.*}}, %{{.*}} : i32
+  spv.INTEL.SubgroupBlockWrite "StorageBuffer" %ptr, %value : i32
   return
 }
 
 // -----
 
 func.func @subgroup_block_write_intel_vector(%ptr : !spv.ptr<i32, StorageBuffer>, %value: vector<3xi32>) -> () {
-  // CHECK: spv.SubgroupBlockWriteINTEL %{{.*}}, %{{.*}} : vector<3xi32>
-  spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : vector<3xi32>
+  // CHECK: spv.INTEL.SubgroupBlockWrite %{{.*}}, %{{.*}} : vector<3xi32>
+  spv.INTEL.SubgroupBlockWrite "StorageBuffer" %ptr, %value : vector<3xi32>
   return
 }

mlir/test/Dialect/SPIRV/IR/joint-matrix-ops.mlir

 // RUN: mlir-opt -allow-unregistered-dialect -split-input-file -verify-diagnostics %s | FileCheck %s
 
 // CHECK-LABEL: @joint_matrix_load
 spv.func @joint_matrix_load(%ptr : !spv.ptr<i32, Workgroup>, %stride : i32) "None" {
-  // CHECK: {{%.*}} = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> {{%.*}}, {{%.*}} : (!spv.ptr<i32, Workgroup>, i32) -> !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>
-  %0 = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> %ptr, %stride : (!spv.ptr<i32, Workgroup>, i32) -> !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>
+  // CHECK: {{%.*}} = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> {{%.*}}, {{%.*}} : (!spv.ptr<i32, Workgroup>, i32) -> !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>
+  %0 = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> %ptr, %stride : (!spv.ptr<i32, Workgroup>, i32) -> !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>
   spv.Return
 }
 
 // -----
 // CHECK-LABEL: @joint_matrix_load_memaccess
 spv.func @joint_matrix_load_memaccess(%ptr : !spv.ptr<i32, CrossWorkgroup>, %stride : i32) "None" {
-  // CHECK: {{%.*}} = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> {{%.*}}, {{%.*}} {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, CrossWorkgroup>, i32) -> !spv.jointmatrix<8x16xi32, ColumnMajor, Subgroup>
-  %0 = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> %ptr, %stride {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, CrossWorkgroup>, i32) -> !spv.jointmatrix<8x16xi32, ColumnMajor, Subgroup>
+  // CHECK: {{%.*}} = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> {{%.*}}, {{%.*}} {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, CrossWorkgroup>, i32) -> !spv.jointmatrix<8x16xi32, ColumnMajor, Subgroup>
+  %0 = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> %ptr, %stride {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, CrossWorkgroup>, i32) -> !spv.jointmatrix<8x16xi32, ColumnMajor, Subgroup>
   spv.Return
 }
 
 // CHECK-LABEL: @joint_matrix_load_diff_ptr_type
 spv.func @joint_matrix_load_diff_ptr_type(%ptr : !spv.ptr<vector<4xi32>, Workgroup>, %stride : i32) "None" {
-  // CHECK: {{%.*}} = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> {{%.*}}, {{%.*}} {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<vector<4xi32>, Workgroup>, i32) -> !spv.jointmatrix<8x16xi32, RowMajor, Workgroup>
-  %0 = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> %ptr, %stride {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<vector<4xi32>, Workgroup>, i32) -> !spv.jointmatrix<8x16xi32, RowMajor, Workgroup>
+  // CHECK: {{%.*}} = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> {{%.*}}, {{%.*}} {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<vector<4xi32>, Workgroup>, i32) -> !spv.jointmatrix<8x16xi32, RowMajor, Workgroup>
+  %0 = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> %ptr, %stride {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<vector<4xi32>, Workgroup>, i32) -> !spv.jointmatrix<8x16xi32, RowMajor, Workgroup>
   spv.Return
 }
 
 // CHECK-LABEL: @joint_matrix_store
 spv.func @joint_matrix_store(%ptr : !spv.ptr<i32, Workgroup>, %stride : i32, %m : !spv.jointmatrix<8x16xi32, RowMajor, Workgroup>) "None" {
-  // CHECK: spv.JointMatrixStoreINTEL <Subgroup> <RowMajor> {{%.*}}, {{%.*}}, {{%.*}} : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<8x16xi32, RowMajor, Workgroup>, i32)
-  spv.JointMatrixStoreINTEL <Subgroup> <RowMajor> %ptr, %m, %stride : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<8x16xi32, RowMajor, Workgroup>, i32)
+  // CHECK: spv.INTEL.JointMatrixStore <Subgroup> <RowMajor> {{%.*}}, {{%.*}}, {{%.*}} : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<8x16xi32, RowMajor, Workgroup>, i32)
+  spv.INTEL.JointMatrixStore <Subgroup> <RowMajor> %ptr, %m, %stride : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<8x16xi32, RowMajor, Workgroup>, i32)
   spv.Return
 }
 
 // CHECK-LABEL: @joint_matrix_store_memaccess
 spv.func @joint_matrix_store_memaccess(%ptr : !spv.ptr<i32, Workgroup>, %m : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, %stride : i32) "None" {
-  // CHECK: spv.JointMatrixStoreINTEL <Subgroup> <ColumnMajor> {{%.*}}, {{%.*}}, {{%.*}} {Volatile} : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, i32)
-  spv.JointMatrixStoreINTEL <Subgroup> <ColumnMajor> %ptr, %m, %stride {Volatile} : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, i32)
+  // CHECK: spv.INTEL.JointMatrixStore <Subgroup> <ColumnMajor> {{%.*}}, {{%.*}}, {{%.*}} {Volatile} : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, i32)
+  spv.INTEL.JointMatrixStore <Subgroup> <ColumnMajor> %ptr, %m, %stride {Volatile} : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, i32)
   spv.Return
 }
 
 // CHECK-LABEL: @joint_matrix_length
 spv.func @joint_matrix_length() -> i32 "None" {
-  // CHECK: {{%.*}} = spv.JointMatrixWorkItemLengthINTEL : !spv.jointmatrix<8x16xi32, PackedB, Subgroup>
-  %0 = spv.JointMatrixWorkItemLengthINTEL : !spv.jointmatrix<8x16xi32, PackedB, Subgroup>
+  // CHECK: {{%.*}} = spv.INTEL.JointMatrixWorkItemLength : !spv.jointmatrix<8x16xi32, PackedB, Subgroup>
+  %0 = spv.INTEL.JointMatrixWorkItemLength : !spv.jointmatrix<8x16xi32, PackedB, Subgroup>
   spv.ReturnValue %0 : i32
 }
 
 // CHECK-LABEL: @joint_matrix_muladd
 spv.func @joint_matrix_muladd(%a : !spv.jointmatrix<8x32xi8, RowMajor, Subgroup>, %b : !spv.jointmatrix<32x8xi8, ColumnMajor, Subgroup>, %c : !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>) "None" {
-  // CHECK: {{%.*}} = spv.JointMatrixMadINTEL <Subgroup> {{%.*}}, {{%.*}}, {{%.*}}  : !spv.jointmatrix<8x32xi8, RowMajor, Subgroup>, !spv.jointmatrix<32x8xi8, ColumnMajor, Subgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
-  %r = spv.JointMatrixMadINTEL <Subgroup> %a, %b, %c : !spv.jointmatrix<8x32xi8, RowMajor, Subgroup>, !spv.jointmatrix<32x8xi8, ColumnMajor, Subgroup> -> !spv.jointmatrix<8x8xi32,  RowMajor, Subgroup>
+  // CHECK: {{%.*}} = spv.INTEL.JointMatrixMad <Subgroup> {{%.*}}, {{%.*}}, {{%.*}}  : !spv.jointmatrix<8x32xi8, RowMajor, Subgroup>, !spv.jointmatrix<32x8xi8, ColumnMajor, Subgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
+  %r = spv.INTEL.JointMatrixMad <Subgroup> %a, %b, %c : !spv.jointmatrix<8x32xi8, RowMajor, Subgroup>, !spv.jointmatrix<32x8xi8, ColumnMajor, Subgroup> -> !spv.jointmatrix<8x8xi32,  RowMajor, Subgroup>
   spv.Return
 }
 
 // -----
 
 spv.func @joint_matrix_muladd(%a : !spv.jointmatrix<16x16xi32, RowMajor, Subgroup>, %b : !spv.jointmatrix<16x8xi32, RowMajor, Subgroup>, %c : !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>) "None" {
-  // expected-error @+1 {{'spv.JointMatrixMadINTEL' op matrix size must match}}
-  %r = spv.JointMatrixMadINTEL <Subgroup> %a, %b, %c : !spv.jointmatrix<16x16xi32, RowMajor, Subgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Subgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
+  // expected-error @+1 {{'spv.INTEL.JointMatrixMad' op matrix size must match}}
+  %r = spv.INTEL.JointMatrixMad <Subgroup> %a, %b, %c : !spv.jointmatrix<16x16xi32, RowMajor, Subgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Subgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
   spv.Return
 }
 
 // -----
 
 spv.func @joint_matrix_muladd(%a : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, %b : !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>, %c : !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>) "None" {
-  // expected-error @+1 {{'spv.JointMatrixMadINTEL' op matrix size must match}}
-  %r = spv.JointMatrixMadINTEL <Subgroup> %a, %b, %c : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, !spv.jointmatrix<8x8xi32, RowMajor, Subgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
+  // expected-error @+1 {{'spv.INTEL.JointMatrixMad' op matrix size must match}}
+  %r = spv.INTEL.JointMatrixMad <Subgroup> %a, %b, %c : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, !spv.jointmatrix<8x8xi32, RowMajor, Subgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
   spv.Return
 }
 
 // -----
 
 spv.func @joint_matrix_muladd(%a : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, %b : !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>, %c : !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>) "None" {
-  // expected-error @+1 {{'spv.JointMatrixMadINTEL' op matrix scope must match}}
-  %r = spv.JointMatrixMadINTEL <Subgroup> %a, %b, %c : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Workgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
+  // expected-error @+1 {{'spv.INTEL.JointMatrixMad' op matrix scope must match}}
+  %r = spv.INTEL.JointMatrixMad <Subgroup> %a, %b, %c : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Workgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
   spv.Return
 }
 
 // -----
 
 spv.func @joint_matrix_muladd(%a : !spv.jointmatrix<8x16xf32, RowMajor, Subgroup>, %b : !spv.jointmatrix<16x8xi32, RowMajor, Subgroup>, %c : !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>) "None" {
   // expected-error @+1 {{matrix element type must match}}
-  %r = spv.JointMatrixMadINTEL <Subgroup> %a, %b, %c : !spv.jointmatrix<8x16xf32, RowMajor, Subgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Subgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
+  %r = spv.INTEL.JointMatrixMad <Subgroup> %a, %b, %c : !spv.jointmatrix<8x16xf32, RowMajor, Subgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Subgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
   spv.Return
 }
 
 // -----
 
 spv.func @joint_matrix_load_memaccess(%ptr : !spv.ptr<!spv.struct<(f32 [0])>, Workgroup>, %stride : i32) "None" {
   // expected-error @+1 {{Pointer must point to a scalar or vector type}}
-  %0 = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> %ptr, %stride : (!spv.ptr<!spv.struct<(f32 [0])>, Workgroup>, i32)-> !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>
+  %0 = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> %ptr, %stride : (!spv.ptr<!spv.struct<(f32 [0])>, Workgroup>, i32)-> !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>
   spv.Return
 }
 
 // -----
 
 spv.func @joint_matrix_load_memaccess(%ptr : !spv.ptr<i32, Function>, %stride : i32) "None" {
   // expected-error @+1 {{Pointer storage class must be Workgroup or CrossWorkgroup}}
-  %0 = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> %ptr, %stride : (!spv.ptr<i32, Function>, i32) -> !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>
+  %0 = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> %ptr, %stride : (!spv.ptr<i32, Function>, i32) -> !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>
   spv.Return
 }

mlir/test/Dialect/SPIRV/IR/misc-ops.mlir

func.func @undef() -> () {
   // expected-error @+1{{expected ':'}}
   %0 = spv.Undef
   spv.Return
 }
 
 // -----
 
 func.func @assume_true(%arg : i1) -> () {
-  // CHECK: spv.AssumeTrueKHR %{{.*}}
-  spv.AssumeTrueKHR %arg
+  // CHECK: spv.KHR.AssumeTrue %{{.*}}
+  spv.KHR.AssumeTrue %arg
   spv.Return
 }
 
 // -----
 
 func.func @assume_true(%arg : f32) -> () {
   // expected-error @+2{{use of value '%arg' expects different type than prior uses: 'i1' vs 'f32'}}
   // expected-note @-2 {{prior use here}}
-  spv.AssumeTrueKHR %arg
+  spv.KHR.AssumeTrue %arg
   spv.Return
 }

mlir/test/Dialect/SPIRV/IR/target-env.mlir

 // whose value, if containing AtomicCounterMemory bit, additionally requires
 // AtomicStorage capability.
 
 // spv.BitReverse is available in all SPIR-V versions under Shader capability.
 
 // spv.GroupNonUniformBallot is available starting from SPIR-V 1.3 under
 // GroupNonUniform capability.
 
-// spv.SubgroupBallotKHR is available under in all SPIR-V versions under
+// spv.KHR.SubgroupBallot is available under in all SPIR-V versions under
 // SubgroupBallotKHR capability and SPV_KHR_shader_ballot extension.
 
 // The GeometryPointSize capability implies the Geometry capability, which
 // implies the Shader capability.
 
 // PhysicalStorageBuffer64 addressing model is available via extension
 // SPV_EXT_physical_storage_buffer or SPV_KHR_physical_storage_buffer;
 // both extensions are incorporated into SPIR-V 1.5.

 //===----------------------------------------------------------------------===//
 // Extension
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @subgroup_ballot_suitable_extension
 func.func @subgroup_ballot_suitable_extension(%predicate: i1) -> vector<4xi32> attributes {
   spv.target_env = #spv.target_env<#spv.vce<v1.4, [SubgroupBallotKHR], [SPV_KHR_shader_ballot]>, #spv.resource_limits<>>
 } {
-  // CHECK: spv.SubgroupBallotKHR
+  // CHECK: spv.KHR.SubgroupBallot
   %0 = "test.convert_to_subgroup_ballot_op"(%predicate): (i1) -> (vector<4xi32>)
   return %0: vector<4xi32>
 }
 
 // CHECK-LABEL: @subgroup_ballot_missing_extension
 func.func @subgroup_ballot_missing_extension(%predicate: i1) -> vector<4xi32> attributes {
   spv.target_env = #spv.target_env<#spv.vce<v1.4, [SubgroupBallotKHR], []>, #spv.resource_limits<>>
 } {

mlir/test/Dialect/SPIRV/Transforms/vce-deduction.mlir

spv.module Logical GLSL450 attributes {
   }
 }
 
 //===----------------------------------------------------------------------===//
 // Extension
 //===----------------------------------------------------------------------===//
 
 // Test deducing minimal extensions.
-// spv.SubgroupBallotKHR requires the SPV_KHR_shader_ballot extension.
+// spv.KHR.SubgroupBallot requires the SPV_KHR_shader_ballot extension.
 
 // CHECK: requires #spv.vce<v1.0, [SubgroupBallotKHR, Shader], [SPV_KHR_shader_ballot]>
 spv.module Logical GLSL450 attributes {
   spv.target_env = #spv.target_env<
     #spv.vce<v1.0, [Shader, SubgroupBallotKHR],
              [SPV_KHR_shader_ballot, SPV_KHR_shader_clock, SPV_KHR_variable_pointers]>, #spv.resource_limits<>>
 } {
   spv.func @subgroup_ballot(%predicate : i1) -> vector<4xi32> "None" {
-    %0 = spv.SubgroupBallotKHR %predicate: vector<4xi32>
+    %0 = spv.KHR.SubgroupBallot %predicate: vector<4xi32>
     spv.ReturnValue %0: vector<4xi32>
   }
 }
 
 // Test deducing implied extension.
 // Vulkan memory model requires SPV_KHR_vulkan_memory_model, which is enabled
 // implicitly by v1.5.
 

mlir/test/Target/SPIRV/atomic-ops.mlir

spv.func @test_int_atomics(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 "None" {
     %12 = spv.AtomicCompareExchange "Workgroup" "Release" "Acquire" %ptr, %value, %comparator: !spv.ptr<i32, Workgroup>
     // CHECK: spv.AtomicExchange "Workgroup" "Release" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup>
     %13 = spv.AtomicExchange "Workgroup" "Release" %ptr, %value: !spv.ptr<i32, Workgroup>
     spv.ReturnValue %0: i32
   }
 
   // CHECK-LABEL: @test_float_atomics
   spv.func @test_float_atomics(%ptr: !spv.ptr<f32, Workgroup>, %value: f32) -> f32 "None" {
-    // CHECK: spv.AtomicFAddEXT "Workgroup" "Acquire" %{{.*}}, %{{.*}} : !spv.ptr<f32, Workgroup>
-    %0 = spv.AtomicFAddEXT "Workgroup" "Acquire" %ptr, %value : !spv.ptr<f32, Workgroup>
+    // CHECK: spv.EXT.AtomicFAdd "Workgroup" "Acquire" %{{.*}}, %{{.*}} : !spv.ptr<f32, Workgroup>
+    %0 = spv.EXT.AtomicFAdd "Workgroup" "Acquire" %ptr, %value : !spv.ptr<f32, Workgroup>
     spv.ReturnValue %0: f32
   }
 }

mlir/test/Target/SPIRV/cooperative-matrix-ops.mlir

 // RUN: mlir-translate -test-spirv-roundtrip -split-input-file %s | FileCheck %s
 
 spv.module Logical GLSL450 requires #spv.vce<v1.0, [CooperativeMatrixNV], [SPV_NV_cooperative_matrix]> {
   // CHECK-LABEL: @cooperative_matrix_load
   spv.func @cooperative_matrix_load(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %b : i1) "None" {
-    // CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup>
-    %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup>
+    // CHECK: {{%.*}} = spv.NV.CooperativeMatrixLoad {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup>
+    %0 = spv.NV.CooperativeMatrixLoad %ptr, %stride, %b : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup>
     spv.Return
   }
 
   // CHECK-LABEL: @cooperative_matrix_load_memaccess
   spv.func @cooperative_matrix_load_memaccess(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %b : i1) "None" {
-    // CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
-    %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
+    // CHECK: {{%.*}} = spv.NV.CooperativeMatrixLoad {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
+    %0 = spv.NV.CooperativeMatrixLoad %ptr, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
     spv.Return
   }
 
   // CHECK-LABEL: @cooperative_matrix_store
   spv.func @cooperative_matrix_store(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %m : !spv.coopmatrix<16x8xi32, Workgroup>, %b : i1) "None" {
-    // CHECK: spv.CooperativeMatrixStoreNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<16x8xi32, Workgroup>
-    spv.CooperativeMatrixStoreNV %ptr, %m, %stride, %b : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<16x8xi32, Workgroup>
+    // CHECK: spv.NV.CooperativeMatrixStore {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<16x8xi32, Workgroup>
+    spv.NV.CooperativeMatrixStore %ptr, %m, %stride, %b : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<16x8xi32, Workgroup>
     spv.Return
   }
 
   // CHECK-LABEL: @cooperative_matrix_store_memaccess
   spv.func @cooperative_matrix_store_memaccess(%ptr : !spv.ptr<i32, StorageBuffer>, %m : !spv.coopmatrix<8x16xi32, Subgroup>, %stride : i32, %b : i1) "None" {
-    // CHECK: spv.CooperativeMatrixStoreNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup>
-    spv.CooperativeMatrixStoreNV %ptr, %m, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup>
+    // CHECK: spv.NV.CooperativeMatrixStore {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup>
+    spv.NV.CooperativeMatrixStore %ptr, %m, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup>
     spv.Return
   }
 
   // CHECK-LABEL: @cooperative_matrix_length
   spv.func @cooperative_matrix_length() -> i32 "None" {
-    // CHECK: {{%.*}} = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<8x16xi32, Subgroup>
-    %0 = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<8x16xi32, Subgroup>
+    // CHECK: {{%.*}} = spv.NV.CooperativeMatrixLength : !spv.coopmatrix<8x16xi32, Subgroup>
+    %0 = spv.NV.CooperativeMatrixLength : !spv.coopmatrix<8x16xi32, Subgroup>
     spv.ReturnValue %0 : i32
   }
 
   // CHECK-LABEL: @cooperative_matrix_muladd
   spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<16x8xi32, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" {
-    // CHECK: {{%.*}} = spv.CooperativeMatrixMulAddNV {{%.*}}, {{%.*}}, {{%.*}}  : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
-    %r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
+    // CHECK: {{%.*}} = spv.NV.CooperativeMatrixMulAdd {{%.*}}, {{%.*}}, {{%.*}}  : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
+    %r = spv.NV.CooperativeMatrixMulAdd %a, %b, %c : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
     spv.Return
   }
 
   // CHECK-LABEL: @cooperative_matrix_add
   spv.func @cooperative_matrix_add(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" {
     // CHECK: {{%.*}} = spv.IAdd {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup>
     %r = spv.IAdd %a, %b : !spv.coopmatrix<8x16xi32, Subgroup>
     spv.Return

mlir/test/Target/SPIRV/group-ops.mlir

 // RUN: mlir-translate -test-spirv-roundtrip -split-input-file %s | FileCheck %s
 
 spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
   // CHECK-LABEL: @subgroup_ballot
   spv.func @subgroup_ballot(%predicate: i1) -> vector<4xi32> "None" {
-    // CHECK: %{{.*}} = spv.SubgroupBallotKHR %{{.*}}: vector<4xi32>
-    %0 = spv.SubgroupBallotKHR %predicate: vector<4xi32>
+    // CHECK: %{{.*}} = spv.KHR.SubgroupBallot %{{.*}}: vector<4xi32>
+    %0 = spv.KHR.SubgroupBallot %predicate: vector<4xi32>
     spv.ReturnValue %0: vector<4xi32>
   }
   // CHECK-LABEL: @group_broadcast_1
   spv.func @group_broadcast_1(%value: f32, %localid: i32 ) -> f32 "None" {
     // CHECK: spv.GroupBroadcast <Workgroup> %{{.*}}, %{{.*}} : f32, i32
     %0 = spv.GroupBroadcast <Workgroup> %value, %localid : f32, i32
     spv.ReturnValue %0: f32
   }
   // CHECK-LABEL: @group_broadcast_2
   spv.func @group_broadcast_2(%value: f32, %localid: vector<3xi32> ) -> f32 "None" {
     // CHECK: spv.GroupBroadcast <Workgroup> %{{.*}}, %{{.*}} : f32, vector<3xi32>
     %0 = spv.GroupBroadcast <Workgroup> %value, %localid : f32, vector<3xi32>
     spv.ReturnValue %0: f32
   }
   // CHECK-LABEL: @subgroup_block_read_intel
   spv.func @subgroup_block_read_intel(%ptr : !spv.ptr<i32, StorageBuffer>) -> i32 "None" {
-    // CHECK: spv.SubgroupBlockReadINTEL %{{.*}} : i32
-    %0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : i32
+    // CHECK: spv.INTEL.SubgroupBlockRead %{{.*}} : i32
+    %0 = spv.INTEL.SubgroupBlockRead "StorageBuffer" %ptr : i32
     spv.ReturnValue %0: i32
   }
   // CHECK-LABEL: @subgroup_block_read_intel_vector
   spv.func @subgroup_block_read_intel_vector(%ptr : !spv.ptr<i32, StorageBuffer>) -> vector<3xi32> "None" {
-    // CHECK: spv.SubgroupBlockReadINTEL %{{.*}} : vector<3xi32>
-    %0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : vector<3xi32>
+    // CHECK: spv.INTEL.SubgroupBlockRead %{{.*}} : vector<3xi32>
+    %0 = spv.INTEL.SubgroupBlockRead "StorageBuffer" %ptr : vector<3xi32>
     spv.ReturnValue %0: vector<3xi32>
   }
   // CHECK-LABEL: @subgroup_block_write_intel
   spv.func @subgroup_block_write_intel(%ptr : !spv.ptr<i32, StorageBuffer>, %value: i32) -> () "None" {
-    // CHECK: spv.SubgroupBlockWriteINTEL %{{.*}}, %{{.*}} : i32
-    spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : i32
+    // CHECK: spv.INTEL.SubgroupBlockWrite %{{.*}}, %{{.*}} : i32
+    spv.INTEL.SubgroupBlockWrite "StorageBuffer" %ptr, %value : i32
     spv.Return
   }
   // CHECK-LABEL: @subgroup_block_write_intel_vector
   spv.func @subgroup_block_write_intel_vector(%ptr : !spv.ptr<i32, StorageBuffer>, %value: vector<3xi32>) -> () "None" {
-    // CHECK: spv.SubgroupBlockWriteINTEL %{{.*}}, %{{.*}} : vector<3xi32>
-    spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : vector<3xi32>
+    // CHECK: spv.INTEL.SubgroupBlockWrite %{{.*}}, %{{.*}} : vector<3xi32>
+    spv.INTEL.SubgroupBlockWrite "StorageBuffer" %ptr, %value : vector<3xi32>
     spv.Return
   }
 }

mlir/test/Target/SPIRV/joint-matrix-ops.mlir

 // RUN: mlir-translate -test-spirv-roundtrip -split-input-file %s | FileCheck %s
 
 spv.module Logical GLSL450 requires #spv.vce<v1.0, [JointMatrixINTEL], [SPV_INTEL_joint_matrix]> {
   // CHECK-LABEL: @joint_matrix_load
   spv.func @joint_matrix_load(%ptr : !spv.ptr<i32, Workgroup>, %stride : i32) "None" {
-    // CHECK: {{%.*}} = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> {{%.*}}, {{%.*}} : (!spv.ptr<i32, Workgroup>, i32) -> !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>
-    %0 = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> %ptr, %stride : (!spv.ptr<i32, Workgroup>, i32) -> !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>
+    // CHECK: {{%.*}} = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> {{%.*}}, {{%.*}} : (!spv.ptr<i32, Workgroup>, i32) -> !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>
+    %0 = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> %ptr, %stride : (!spv.ptr<i32, Workgroup>, i32) -> !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>
     spv.Return
   }
 
   // CHECK-LABEL: @joint_matrix_load_memaccess
   spv.func @joint_matrix_load_memaccess(%ptr : !spv.ptr<i32, Workgroup>, %stride : i32) "None" {
-    // CHECK: {{%.*}} = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> {{%.*}}, {{%.*}} {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, Workgroup>, i32) -> !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>
-    %0 = spv.JointMatrixLoadINTEL <Subgroup> <RowMajor> %ptr, %stride {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, Workgroup>, i32) -> !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>
+    // CHECK: {{%.*}} = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> {{%.*}}, {{%.*}} {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, Workgroup>, i32) -> !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>
+    %0 = spv.INTEL.JointMatrixLoad <Subgroup> <RowMajor> %ptr, %stride {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, Workgroup>, i32) -> !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>
     spv.Return
   }
 
   // CHECK-LABEL: @joint_matrix_store
   spv.func @joint_matrix_store(%ptr : !spv.ptr<i32, Workgroup>, %stride : i32, %m : !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>) "None" {
-    // CHECK: spv.JointMatrixStoreINTEL <Subgroup> <RowMajor> {{%.*}}, {{%.*}}, {{%.*}} : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>, i32)
-    spv.JointMatrixStoreINTEL <Subgroup> <RowMajor> %ptr, %m, %stride : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>, i32)
+    // CHECK: spv.INTEL.JointMatrixStore <Subgroup> <RowMajor> {{%.*}}, {{%.*}}, {{%.*}} : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>, i32)
+    spv.INTEL.JointMatrixStore <Subgroup> <RowMajor> %ptr, %m, %stride : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Workgroup>, i32)
     spv.Return
   }
 
   // CHECK-LABEL: @joint_matrix_store_memaccess
   spv.func @joint_matrix_store_memaccess(%ptr : !spv.ptr<i32, Workgroup>, %m : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, %stride : i32) "None" {
-    // CHECK: spv.JointMatrixStoreINTEL <Subgroup> <RowMajor> {{%.*}}, {{%.*}}, {{%.*}} {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, i32)
-    spv.JointMatrixStoreINTEL <Subgroup> <RowMajor> %ptr, %m, %stride {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, i32)
+    // CHECK: spv.INTEL.JointMatrixStore <Subgroup> <RowMajor> {{%.*}}, {{%.*}}, {{%.*}} {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, i32)
+    spv.INTEL.JointMatrixStore <Subgroup> <RowMajor> %ptr, %m, %stride {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, Workgroup>, !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, i32)
     spv.Return
   }
 
   // CHECK-LABEL: @joint_matrix_length
   spv.func @joint_matrix_length() -> i32 "None" {
-    // CHECK: {{%.*}} = spv.JointMatrixWorkItemLengthINTEL : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>
-    %0 = spv.JointMatrixWorkItemLengthINTEL : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>
+    // CHECK: {{%.*}} = spv.INTEL.JointMatrixWorkItemLength : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>
+    %0 = spv.INTEL.JointMatrixWorkItemLength : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>
     spv.ReturnValue %0 : i32
   }
 
   // CHECK-LABEL: @joint_matrix_muladd
   spv.func @joint_matrix_muladd(%a : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, %b : !spv.jointmatrix<16x8xi32, RowMajor, Subgroup>, %c : !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>) "None" {
-    // CHECK: {{%.*}} = spv.JointMatrixMadINTEL <Subgroup> {{%.*}}, {{%.*}}, {{%.*}}  : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Subgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
-    %r = spv.JointMatrixMadINTEL <Subgroup> %a, %b, %c : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Subgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
+    // CHECK: {{%.*}} = spv.INTEL.JointMatrixMad <Subgroup> {{%.*}}, {{%.*}}, {{%.*}}  : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Subgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
+    %r = spv.INTEL.JointMatrixMad <Subgroup> %a, %b, %c : !spv.jointmatrix<8x16xi32, RowMajor, Subgroup>, !spv.jointmatrix<16x8xi32, RowMajor, Subgroup> -> !spv.jointmatrix<8x8xi32, RowMajor, Subgroup>
     spv.Return
   }
 }

mlir/test/lib/Dialect/SPIRV/TestAvailability.cpp

ConvertToModule::matchAndRewrite(Operation *op,
   rewriter.replaceOpWithNewOp<spirv::ModuleOp>(
       op, spirv::AddressingModel::PhysicalStorageBuffer64,
       spirv::MemoryModel::Vulkan);
   return success();
 }
 
 ConvertToSubgroupBallot::ConvertToSubgroupBallot(MLIRContext *context)
     : RewritePattern("test.convert_to_subgroup_ballot_op", 1, context,
-                     {"spv.SubgroupBallotKHR"}) {}
+                     {"spv.KHR.SubgroupBallot"}) {}
 
 LogicalResult
 ConvertToSubgroupBallot::matchAndRewrite(Operation *op,
                                          PatternRewriter &rewriter) const {
   Value predicate = op->getOperand(0);
 
   rewriter.replaceOpWithNewOp<spirv::KHRSubgroupBallotOp>(
       op, op->getResult(0).getType(), predicate);
   return success();
 }
 
 namespace mlir {
 void registerConvertToTargetEnvPass() {
   PassRegistration<ConvertToTargetEnv>();
 }
 } // namespace mlir