[mlir][spirv] Refactor vendor op definitions

[kuhar]

Summary

Use dedicated vendor op classes/categories. This is so that we can later
change the mnemonics of all vendor ops by changing the base class: SPV_VendorOp.

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

[kuhar]

BTW, I think that the gen_spirv_dialect.py script has gotten complicated enough that we should consider adding some units tests

[antiagainst]

In D133246#3768332, @kuhar wrote:

BTW, I think that the gen_spirv_dialect.py script has gotten complicated enough that we should consider adding some units tests

It's a script for making defining ops semi-automated. It's not used very frequently. I'm not sure it can bring much benefits with thorough testing.

[kuhar]

Closed by https://reviews.llvm.org/rGb8bea837f34534c36fd07477e51b41dd222fb869

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

def SPV_AtomicExchangeOp : SPV_Op<"AtomicExchange", []> {
 
   let results = (outs
     SPV_Numerical:$result
   );
 }
 
 // -----
 
-def SPV_AtomicFAddEXTOp : SPV_Op<"AtomicFAddEXT", []> {
+def SPV_EXTAtomicFAddOp : SPV_ExtVendorOp<"AtomicFAdd", []> {
   let summary = "TBD";
 
   let description = [{
 
 
     <!-- End of AutoGen section -->
 
     Perform the following steps atomically with respect to any other atomic
     accesses within Scope to the same location:
 
     1) load through Pointer to get an Original Value,
 
     2) get a New Value by float addition of Original Value and Value, and
 
     3) store the New Value back through Pointer.
 
-    The instruction’s result is the Original Value.
+    The instruction's result is the Original Value.
 
     Result Type must be a floating-point type scalar.
 
     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.
 

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

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_COOPERATIVE_MATRIX_OPS
 #define MLIR_DIALECT_SPIRV_IR_COOPERATIVE_MATRIX_OPS
 
 // -----
 
-def SPV_CooperativeMatrixLengthNVOp : SPV_Op<"CooperativeMatrixLengthNV",
+def SPV_NVCooperativeMatrixLengthOp : SPV_NvVendorOp<"CooperativeMatrixLength",
   [NoSideEffect]> {
   let summary = "See extension SPV_NV_cooperative_matrix";
 
   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.
def SPV_NVCooperativeMatrixLengthOp : SPV_NvVendorOp<"CooperativeMatrixLength",
   let results = (outs
     SPV_Int32:$result
   );
   let hasVerifier = 0;
 }
 
 // -----
 
-def SPV_CooperativeMatrixLoadNVOp : SPV_Op<"CooperativeMatrixLoadNV", []> {
+def SPV_NVCooperativeMatrixLoadOp : SPV_NvVendorOp<"CooperativeMatrixLoad", []> {
   let summary = "See extension SPV_NV_cooperative_matrix";
 
   let description = [{
     Load a cooperative matrix through a pointer.
 
     Result Type is the type of the loaded object. It must be a cooperative
     matrix type.
 
def SPV_NVCooperativeMatrixLoadOp : SPV_NvVendorOp<"CooperativeMatrixLoad", []> {
 
   let results = (outs
     SPV_AnyCooperativeMatrix:$result
   );
 }
 
 // -----
 
-def SPV_CooperativeMatrixMulAddNVOp : SPV_Op<"CooperativeMatrixMulAddNV",
+def SPV_NVCooperativeMatrixMulAddOp : SPV_NvVendorOp<"CooperativeMatrixMulAdd",
   [NoSideEffect, AllTypesMatch<["c", "result"]>]> {
   let summary = "See extension SPV_NV_cooperative_matrix";
 
   let description = [{
     Linear-algebraic matrix multiply of A by B and then component-wise add C.
     The order of the operations is implementation-dependent. The internal
     precision of floating-point operations is defined by the client API.
     Integer operations are performed at the precision of the Result Type and are
def SPV_NVCooperativeMatrixMulAddOp : SPV_NvVendorOp<"CooperativeMatrixMulAdd",
 
   let results = (outs
     SPV_AnyCooperativeMatrix:$result
   );
 }
 
 // -----
 
-def SPV_CooperativeMatrixStoreNVOp : SPV_Op<"CooperativeMatrixStoreNV", []> {
+def SPV_NVCooperativeMatrixStoreOp : SPV_NvVendorOp<"CooperativeMatrixStore", []> {
   let summary = "See extension SPV_NV_cooperative_matrix";
 
   let description = [{
     Store a cooperative matrix through a pointer.
 
     Pointer is a pointer into an array. Its type must be an OpTypePointer whose
     Type operand is a scalar or vector type. The storage class of Pointer must
     be Workgroup, StorageBuffer, or (if SPV_EXT_physical_storage_buffer is

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

def SPV_GroupBroadcastOp : SPV_Op<"GroupBroadcast",
 
   let assemblyFormat = [{
     $execution_scope operands attr-dict `:` type($value) `,` type($localid)
   }];
 }
 
 // -----
 
-def SPV_SubgroupBallotKHROp : SPV_Op<"SubgroupBallotKHR", []> {
+def SPV_KHRSubgroupBallotOp : SPV_KhrVendorOp<"SubgroupBallot", []> {
   let summary = "See extension SPV_KHR_shader_ballot";
 
   let description = [{
     Computes a bitfield value combining the Predicate value from all invocations
     in the current Subgroup that execute the same dynamic instance of this
     instruction. The bit is set to one if the corresponding invocation is active
     and the predicate is evaluated to true; otherwise, it is set to zero.
 
def SPV_KHRSubgroupBallotOp : SPV_KhrVendorOp<"SubgroupBallot", []> {
 
   let hasVerifier = 0;
 
   let assemblyFormat = "$predicate attr-dict `:` type($result)";
 }
 
 // -----
 
-def SPV_SubgroupBlockReadINTELOp : SPV_Op<"SubgroupBlockReadINTEL", []> {
+def SPV_INTELSubgroupBlockReadOp : SPV_IntelVendorOp<"SubgroupBlockRead", []> {
   let summary = "See extension SPV_INTEL_subgroups";
 
   let description = [{
     Reads one or more components of Result data for each invocation in the
     subgroup from the specified Ptr as a block operation.
 
     The data is read strided, so the first value read is:
     Ptr[ SubgroupLocalInvocationId ]
def SPV_INTELSubgroupBlockReadOp : SPV_IntelVendorOp<"SubgroupBlockRead", []> {
 
   let results = (outs
     SPV_Type:$value
   );
 }
 
 // -----
 
-def SPV_SubgroupBlockWriteINTELOp : SPV_Op<"SubgroupBlockWriteINTEL", []> {
+def SPV_INTELSubgroupBlockWriteOp : SPV_IntelVendorOp<"SubgroupBlockWrite", []> {
   let summary = "See extension SPV_INTEL_subgroups";
 
   let description = [{
     Writes one or more components of Data for each invocation in the subgroup
     from the specified Ptr as a block operation.
 
     The data is written strided, so the first value is written to:
     Ptr[ SubgroupLocalInvocationId ]

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

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_JOINT_MATRIX_OPS
 #define MLIR_DIALECT_SPIRV_IR_JOINT_MATRIX_OPS
 
 // -----
 
-def SPV_JointMatrixWorkItemLengthINTELOp : SPV_Op<"JointMatrixWorkItemLengthINTEL",
+def SPV_INTELJointMatrixWorkItemLengthOp : SPV_IntelVendorOp<"JointMatrixWorkItemLength",
   [NoSideEffect]> {
   let summary = "See extension SPV_INTEL_joint_matrix";
 
   let description = [{
-    Return number of components owned by the current work-item in 
+    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
def SPV_INTELJointMatrixWorkItemLengthOp : SPV_IntelVendorOp<"JointMatrixWorkItemLength",
   let results = (outs
     SPV_Int32:$result
   );
   let hasVerifier = 0;
 }
 
 // -----
 
-def SPV_JointMatrixLoadINTELOp : SPV_Op<"JointMatrixLoadINTEL", []> {
+def SPV_INTELJointMatrixLoadOp : SPV_IntelVendorOp<"JointMatrixLoad", []> {
   let summary = "See extension SPV_INTEL_joint_matrix";
 
   let description = [{
     Load a matrix through a pointer.
 
     Result Type is the type of the loaded matrix. It must be OpTypeJointMatrixINTEL.
 
-    Pointer is the pointer to load through. It specifies start of memory region where 
+    Pointer is the pointer to load through. It specifies start of memory region where
     elements of the matrix are stored and arranged according to Layout.
 
-    Stride is the number of elements in memory between beginnings of successive rows, 
+    Stride is the number of elements in memory between beginnings of successive rows,
     columns (or words) in the result. It must be a scalar integer type.
 
-    Layout indicates how the values loaded from memory are arranged. It must be the 
+    Layout indicates how the values loaded from memory are arranged. It must be the
     result of a constant instruction.
 
-    Scope is syncronization scope for operation on the matrix. It must be the result 
+    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 
+    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 
-         {memory_access = #spv.memory_access<Volatile>} : 
-         (!spv.ptr<i32, CrossWorkgroup>, i32) -> 
+    %0 = spv.JointMatrixLoadINTEL <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)
   }];
 
def SPV_INTELJointMatrixLoadOp : SPV_IntelVendorOp<"JointMatrixLoad", []> {
 
   let results = (outs
     SPV_AnyJointMatrix:$result
   );
 }
 
 // -----
 
-def SPV_JointMatrixMadINTELOp : SPV_Op<"JointMatrixMadINTEL",
+def SPV_INTELJointMatrixMadOp : SPV_IntelVendorOp<"JointMatrixMad",
   [NoSideEffect, AllTypesMatch<["c", "result"]>]> {
   let summary = "See extension SPV_INTEL_joint_matrix";
 
   let description = [{
-    Multiply matrix A by matrix B and add matrix C to the result 
-    of the multiplication: A*B+C. Here A is a M x K matrix, B is 
+    Multiply matrix A by matrix B and add matrix C to the result
+    of the multiplication: A*B+C. Here A is a M x K matrix, B is
     a K x N matrix and C is a M x N matrix.
 
-    Behavior is undefined if sizes of operands do not meet the 
-    conditions above. All operands and the Result Type must be 
+    Behavior is undefined if sizes of operands do not meet the
+    conditions above. All operands and the Result Type must be
     OpTypeJointMatrixINTEL.
 
-    A must be a OpTypeJointMatrixINTEL whose Component Type is a 
-    signed numerical type, Row Count equals to M and Column Count 
+    A must be a OpTypeJointMatrixINTEL whose Component Type is a
+    signed numerical type, Row Count equals to M and Column Count
     equals to K
 
-    B must be a OpTypeJointMatrixINTEL whose Component Type is a 
-    signed numerical type, Row Count equals to K and Column Count 
+    B must be a OpTypeJointMatrixINTEL whose Component Type is a
+    signed numerical type, Row Count equals to K and Column Count
     equals to N
 
-    C and Result Type must be a OpTypeJointMatrixINTEL with Row 
+    C and Result Type must be a OpTypeJointMatrixINTEL with Row
     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 
+    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 : 
-         !spv.jointmatrix<8x32xi8, RowMajor, Subgroup>, 
-         !spv.jointmatrix<32x8xi8, ColumnMajor, Subgroup> 
+    %r = spv.JointMatrixMadINTEL <Subgroup> %a, %b, %c :
+         !spv.jointmatrix<8x32xi8, RowMajor, Subgroup>,
+         !spv.jointmatrix<32x8xi8, ColumnMajor, Subgroup>
          -> !spv.jointmatrix<8x8xi32,  RowMajor, Subgroup>
     ```
 
   }];
 
   let assemblyFormat = [{
     $scope operands attr-dict`:` type($a) `,` type($b) `->` type($c)
   }];
def SPV_INTELJointMatrixMadOp : SPV_IntelVendorOp<"JointMatrixMad",
 
   let results = (outs
     SPV_AnyJointMatrix:$result
   );
 }
 
 // -----
 
-def SPV_JointMatrixStoreINTELOp : SPV_Op<"JointMatrixStoreINTEL", []> {
+def SPV_INTELJointMatrixStoreOp : SPV_IntelVendorOp<"JointMatrixStore", []> {
   let summary = "See extension SPV_INTEL_joint_matrix";
 
   let description = [{
     Store a matrix through a pointer.
 
-    Pointer is the pointer to store through. It specifies 
-    start of memory region where elements of the matrix must 
+    Pointer is the pointer to store through. It specifies
+    start of memory region where elements of the matrix must
     be stored and arranged according to Layout.
 
-    Object is the matrix to store. It must be 
+    Object is the matrix to store. It must be
     OpTypeJointMatrixINTEL.
 
-    Stride is the number of elements in memory between beginnings 
-    of successive rows, columns (or words) of the Object. It must 
+    Stride is the number of elements in memory between beginnings
+    of successive rows, columns (or words) of the Object. It must
     be a scalar integer type.
 
-    Layout indicates how the values stored to memory are arranged. 
+    Layout indicates how the values stored to memory are arranged.
     It must be the result of a constant instruction.
 
-    Scope is syncronization scope for operation on the matrix. 
-    It must be the result of a constant instruction with scalar 
+    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 
+    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 
-    {memory_access = #spv.memory_access<Volatile>} : (!spv.ptr<i32, Workgroup>, 
+    spv.JointMatrixStoreINTEL <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

 
 #ifndef MLIR_DIALECT_SPIRV_IR_MISC_OPS
 #define MLIR_DIALECT_SPIRV_IR_MISC_OPS
 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 
 // -----
 
-def SPV_AssumeTrueKHROp : SPV_Op<"AssumeTrueKHR", []> {
+def SPV_KHRAssumeTrueOp : SPV_KhrVendorOp<"AssumeTrue", []> {
   let summary = "TBD";
 
   let description = [{
 
 
     <!-- End of AutoGen section -->
 
     ```

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

 void spirv::AtomicIAddOp::print(OpAsmPrinter &p) {
   ::printAtomicUpdateOp(*this, p);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.AtomicFAddEXTOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult spirv::AtomicFAddEXTOp::verify() {
+LogicalResult spirv::EXTAtomicFAddOp::verify() {
   return ::verifyAtomicUpdateOp<FloatType>(getOperation());
 }
 
-ParseResult spirv::AtomicFAddEXTOp::parse(OpAsmParser &parser,
+ParseResult spirv::EXTAtomicFAddOp::parse(OpAsmParser &parser,
                                           OperationState &result) {
   return ::parseAtomicUpdateOp(parser, result, true);
 }
-void spirv::AtomicFAddEXTOp::print(OpAsmPrinter &p) {
+void spirv::EXTAtomicFAddOp::print(OpAsmPrinter &p) {
   ::printAtomicUpdateOp(*this, p);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.AtomicIDecrementOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::AtomicIDecrementOp::verify() {
LogicalResult spirv::GroupNonUniformBroadcastOp::verify() {
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.SubgroupBlockReadINTEL
 //===----------------------------------------------------------------------===//
 
-ParseResult spirv::SubgroupBlockReadINTELOp::parse(OpAsmParser &parser,
+ParseResult spirv::INTELSubgroupBlockReadOp::parse(OpAsmParser &parser,
                                                    OperationState &result) {
   // Parse the storage class specification
   spirv::StorageClass storageClass;
   OpAsmParser::UnresolvedOperand ptrInfo;
   Type elementType;
   if (parseEnumStrAttr(storageClass, parser) || parser.parseOperand(ptrInfo) ||
       parser.parseColon() || parser.parseType(elementType)) {
     return failure();
   }
 
   auto ptrType = spirv::PointerType::get(elementType, storageClass);
   if (auto valVecTy = elementType.dyn_cast<VectorType>())
     ptrType = spirv::PointerType::get(valVecTy.getElementType(), storageClass);
 
   if (parser.resolveOperand(ptrInfo, ptrType, result.operands)) {
     return failure();
   }
 
   result.addTypes(elementType);
   return success();
 }
 
-void spirv::SubgroupBlockReadINTELOp::print(OpAsmPrinter &printer) {
+void spirv::INTELSubgroupBlockReadOp::print(OpAsmPrinter &printer) {
   printer << " " << ptr() << " : " << getType();
 }
 
-LogicalResult spirv::SubgroupBlockReadINTELOp::verify() {
+LogicalResult spirv::INTELSubgroupBlockReadOp::verify() {
   if (failed(verifyBlockReadWritePtrAndValTypes(*this, ptr(), value())))
     return failure();
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.SubgroupBlockWriteINTEL
 //===----------------------------------------------------------------------===//
 
-ParseResult spirv::SubgroupBlockWriteINTELOp::parse(OpAsmParser &parser,
+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();
   Type elementType;
   if (parseEnumStrAttr(storageClass, parser) ||
       parser.parseOperandList(operandInfo, 2) || parser.parseColon() ||
       parser.parseType(elementType)) {
     return failure();
   }
 
   auto ptrType = spirv::PointerType::get(elementType, storageClass);
   if (auto valVecTy = elementType.dyn_cast<VectorType>())
     ptrType = spirv::PointerType::get(valVecTy.getElementType(), storageClass);
 
   if (parser.resolveOperands(operandInfo, {ptrType, elementType}, loc,
                              result.operands)) {
     return failure();
   }
   return success();
 }
 
-void spirv::SubgroupBlockWriteINTELOp::print(OpAsmPrinter &printer) {
+void spirv::INTELSubgroupBlockWriteOp::print(OpAsmPrinter &printer) {
   printer << " " << ptr() << ", " << value() << " : " << value().getType();
 }
 
-LogicalResult spirv::SubgroupBlockWriteINTELOp::verify() {
+LogicalResult spirv::INTELSubgroupBlockWriteOp::verify() {
   if (failed(verifyBlockReadWritePtrAndValTypes(*this, ptr(), value())))
     return failure();
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GroupNonUniformElectOp
LogicalResult spirv::VectorShuffleOp::verify() {
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.CooperativeMatrixLoadNV
 //===----------------------------------------------------------------------===//
 
-ParseResult spirv::CooperativeMatrixLoadNVOp::parse(OpAsmParser &parser,
+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;
   Type elementType;
   if (parser.parseOperandList(operandInfo, 3) ||
       parseMemoryAccessAttributes(parser, result) || parser.parseColon() ||
       parser.parseType(ptrType) || parser.parseKeywordType("as", elementType)) {
     return failure();
   }
   if (parser.resolveOperands(operandInfo,
                              {ptrType, strideType, columnMajorType},
                              parser.getNameLoc(), result.operands)) {
     return failure();
   }
 
   result.addTypes(elementType);
   return success();
 }
 
-void spirv::CooperativeMatrixLoadNVOp::print(OpAsmPrinter &printer) {
+void spirv::NVCooperativeMatrixLoadOp::print(OpAsmPrinter &printer) {
   printer << " " << pointer() << ", " << stride() << ", " << columnmajor();
   // Print optional memory access attribute.
   if (auto memAccess = memory_access())
     printer << " [\"" << stringifyMemoryAccess(*memAccess) << "\"]";
   printer << " : " << pointer().getType() << " as " << getType();
 }
 
 static LogicalResult verifyPointerAndCoopMatrixType(Operation *op, Type pointer,
if (storage != spirv::StorageClass::Workgroup &&
       storage != spirv::StorageClass::PhysicalStorageBuffer)
     return op->emitError(
                "Pointer storage class must be Workgroup, StorageBuffer or "
                "PhysicalStorageBufferEXT but provided ")
            << stringifyStorageClass(storage);
   return success();
 }
 
-LogicalResult spirv::CooperativeMatrixLoadNVOp::verify() {
+LogicalResult spirv::NVCooperativeMatrixLoadOp::verify() {
   return verifyPointerAndCoopMatrixType(*this, pointer().getType(),
                                         result().getType());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.CooperativeMatrixStoreNV
 //===----------------------------------------------------------------------===//
 
-ParseResult spirv::CooperativeMatrixStoreNVOp::parse(OpAsmParser &parser,
+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;
   Type elementType;
   if (parser.parseOperandList(operandInfo, 4) ||
       parseMemoryAccessAttributes(parser, result) || parser.parseColon() ||
       parser.parseType(ptrType) || parser.parseComma() ||
       parser.parseType(elementType)) {
     return failure();
   }
   if (parser.resolveOperands(
           operandInfo, {ptrType, elementType, strideType, columnMajorType},
           parser.getNameLoc(), result.operands)) {
     return failure();
   }
 
   return success();
 }
 
-void spirv::CooperativeMatrixStoreNVOp::print(OpAsmPrinter &printer) {
+void spirv::NVCooperativeMatrixStoreOp::print(OpAsmPrinter &printer) {
   printer << " " << pointer() << ", " << object() << ", " << stride() << ", "
           << columnmajor();
   // Print optional memory access attribute.
   if (auto memAccess = memory_access())
     printer << " [\"" << stringifyMemoryAccess(*memAccess) << "\"]";
   printer << " : " << pointer().getType() << ", " << getOperand(1).getType();
 }
 
-LogicalResult spirv::CooperativeMatrixStoreNVOp::verify() {
+LogicalResult spirv::NVCooperativeMatrixStoreOp::verify() {
   return verifyPointerAndCoopMatrixType(*this, pointer().getType(),
                                         object().getType());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.CooperativeMatrixMulAddNV
 //===----------------------------------------------------------------------===//
 
 static LogicalResult
-verifyCoopMatrixMulAdd(spirv::CooperativeMatrixMulAddNVOp op) {
+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>();
   auto typeC = op.c().getType().cast<spirv::CooperativeMatrixNVType>();
   auto typeR = op.result().getType().cast<spirv::CooperativeMatrixNVType>();
   if (typeA.getRows() != typeR.getRows() ||
       typeA.getColumns() != typeB.getRows() ||
       typeB.getColumns() != typeR.getColumns())
     return op.emitOpError("matrix size must match");
   if (typeR.getScope() != typeA.getScope() ||
       typeR.getScope() != typeB.getScope() ||
       typeR.getScope() != typeC.getScope())
     return op.emitOpError("matrix scope must match");
   if (typeA.getElementType() != typeB.getElementType() ||
       typeR.getElementType() != typeC.getElementType())
     return op.emitOpError("matrix element type must match");
   return success();
 }
 
-LogicalResult spirv::CooperativeMatrixMulAddNVOp::verify() {
+LogicalResult spirv::NVCooperativeMatrixMulAddOp::verify() {
   return verifyCoopMatrixMulAdd(*this);
 }
 
 static LogicalResult
 verifyPointerAndJointMatrixType(Operation *op, Type pointer, Type jointMatrix) {
   Type pointeeType = pointer.cast<spirv::PointerType>().getPointeeType();
   if (!pointeeType.isa<spirv::ScalarType>() && !pointeeType.isa<VectorType>())
     return op->emitError(
return op->emitError("Pointer storage class must be Workgroup or "
            << stringifyStorageClass(storage);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.JointMatrixLoadINTEL
 //===----------------------------------------------------------------------===//
 
-LogicalResult spirv::JointMatrixLoadINTELOp::verify() {
+LogicalResult spirv::INTELJointMatrixLoadOp::verify() {
   return verifyPointerAndJointMatrixType(*this, pointer().getType(),
                                          result().getType());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.JointMatrixStoreINTEL
 //===----------------------------------------------------------------------===//
 
-LogicalResult spirv::JointMatrixStoreINTELOp::verify() {
+LogicalResult spirv::INTELJointMatrixStoreOp::verify() {
   return verifyPointerAndJointMatrixType(*this, pointer().getType(),
                                          object().getType());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.JointMatrixMadINTEL
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verifyJointMatrixMad(spirv::JointMatrixMadINTELOp op) {
+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>();
   auto typeR = op.result().getType().cast<spirv::JointMatrixINTELType>();
   if (typeA.getRows() != typeR.getRows() ||
       typeA.getColumns() != typeB.getRows() ||
       typeB.getColumns() != typeR.getColumns())
     return op.emitOpError("matrix size must match");
   if (typeR.getScope() != typeA.getScope() ||
       typeR.getScope() != typeB.getScope() ||
       typeR.getScope() != typeC.getScope())
     return op.emitOpError("matrix scope must match");
   if (typeA.getElementType() != typeB.getElementType() ||
       typeR.getElementType() != typeC.getElementType())
     return op.emitOpError("matrix element type must match");
   return success();
 }
 
-LogicalResult spirv::JointMatrixMadINTELOp::verify() {
+LogicalResult spirv::INTELJointMatrixMadOp::verify() {
   return verifyJointMatrixMad(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.MatrixTimesScalar
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::MatrixTimesScalarOp::verify() {

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

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

mlir/utils/spirv/define_inst.sh

 # ./define_inst.sh SPIRVArithmeticOps.td ArithmeticBinaryOp OpIAdd
 # ./define_inst.sh SPIRVLogicalOps.td LogicalOp OpFOrdEqual
 set -e
 
 file_name=$1
 baseclass=$2
 
 case $baseclass in
-  Op | ArithmeticBinaryOp | ArithmeticUnaryOp | LogicalBinaryOp | LogicalUnaryOp | CastOp | ControlFlowOp | StructureOp | AtomicUpdateOp | AtomicUpdateWithValueOp)
+  Op | ArithmeticBinaryOp | ArithmeticUnaryOp \
+     | LogicalBinaryOp | LogicalUnaryOp \
+     | CastOp | ControlFlowOp | StructureOp \
+     | AtomicUpdateOp | AtomicUpdateWithValueOp \
+     | KhrVendorOp | ExtVendorOp | IntelVendorOp | NvVendorOp )
   ;;
   *)
     echo "Usage : " $0 "<filename> <baseclass> (<opname>)*"
     echo "<filename> is the file name of MLIR SPIR-V op definitions spec"
     echo "<baseclass> must be one of " \
-      "(Op|ArithmeticBinaryOp|ArithmeticUnaryOp|LogicalBinaryOp|LogicalUnaryOp|CastOp|ControlFlowOp|StructureOp|AtomicUpdateOp)"
+      "(Op|ArithmeticBinaryOp|ArithmeticUnaryOp|LogicalBinaryOp|LogicalUnaryOp|CastOp|ControlFlowOp|StructureOp|AtomicUpdateOp|KhrVendorOp|ExtVendorOp|IntelVendorOp|NvVendorOp)"
     exit 1;
   ;;
 esac
 
 shift
 shift
 
 current_file="$(readlink -f "$0")"

mlir/utils/spirv/gen_spirv_dialect.py

Returns:
     - A string containing the TableGen op definition
   """
   if settings.gen_cl_ops:
     fmt_str = ('def SPV_{opname}Op : '
                'SPV_{inst_category}<"{opname_src}", {opcode}, <<Insert result type>> > '
                '{{\n  let summary = {summary};\n\n  let description = '
                '[{{\n{description}}}];{availability}\n')
   else:
-    fmt_str = ('def SPV_{opname_src}Op : '
-               'SPV_{inst_category}<"{opname_src}"{category_args}[{traits}]> '
+    fmt_str = ('def SPV_{vendor_name}{opname_src}Op : '
+               'SPV_{inst_category}<"{opname_src}"{category_args}, [{traits}]> '
                '{{\n  let summary = {summary};\n\n  let description = '
                '[{{\n{description}}}];{availability}\n')
 
+  vendor_name = ''
   inst_category = existing_info.get('inst_category', 'Op')
   if inst_category == 'Op':
     fmt_str +='\n  let arguments = (ins{args});\n\n'\
               '  let results = (outs{results});\n'
+  elif inst_category.endswith('VendorOp'):
+    vendor_name = inst_category.split('VendorOp')[0].upper()
+    assert len(vendor_name) != 0, 'Invalid instruction category'
 
   fmt_str +='{extras}'\
             '}}\n'
 
   opname_src = instruction['opname']
   if opname.startswith('Op'):
     opname_src = opname_src[2:]
+  if len(vendor_name) > 0:
+    assert opname_src.endswith(vendor_name), "op name does not match the instruction category"
+    opname_src = opname_src[:-len(vendor_name)]
 
   category_args = existing_info.get('category_args', '')
 
   if '\n' in doc:
     summary, text = doc.split('\n', 1)
   else:
     summary = doc
     text = ''
   wrapper = textwrap.TextWrapper(
       width=76, initial_indent='    ', subsequent_indent='    ')
 
   # Format summary. If the summary can fit in the same line, we print it out
   # as a "-quoted string; otherwise, wrap the lines using "[{...}]".
-  summary = summary.strip();
+  summary = summary.strip()
   if len(summary) + len('  let summary = "";') <= 80:
     summary = '"{}"'.format(summary)
   else:
     summary = '[{{\n{}\n  }}]'.format(wrapper.fill(summary))
 
   # Wrap text
   text = text.split('\n')
   text = [wrapper.fill(line) for line in text if line]
if description is None:
     description = get_description(text, assembly)
 
   return fmt_str.format(
       opname=opname,
       opname_src=opname_src,
       opcode=instruction['opcode'],
       category_args=category_args,
       inst_category=inst_category,
+      vendor_name=vendor_name,
       traits=existing_info.get('traits', ''),
       summary=summary,
       description=description,
       availability=avail,
       args=arguments,
       results=results,
       extras=existing_info.get('extras', ''))