[mlir][spirv] Fix script for availability autogen and refresh ops

[antiagainst]

Summary

Previously we only autogen the availability for ops that are
direct instantiating SPV_Op and expected other subclasses of
SPV_Op to define aggregated availability for all ops. This is
quite error prone and we can miss capabilities for certain ops.
Also it's arguable to have multiple levels of subclasses and try
to deduplicate too much: having the availability directly in the
op can be quite explicit and clear. A few extra lines of
declarative code is fine.

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

let description = [{
 
     #### Example:
 
     ```mlir
     %2 = spv.BitCount %0: i32
     %3 = spv.BitCount %1: vector<4xi32>
     ```
   }];
-
-  let availability = [
-    MinVersion<SPV_V_1_0>,
-    MaxVersion<SPV_V_1_5>,
-    Extension<[]>,
-    Capability<[]>
-  ];
 }
 
 // -----
 
 def SPV_BitFieldInsertOp : SPV_Op<"BitFieldInsert",
     [NoSideEffect, AllTypesMatch<["base", "insert", "result"]>]> {
   let summary = [{
     Make a copy of an object, with a modified bit field that comes from
let description = [{
 
     #### Example:
 
     ```mlir
     %2 = spv.BitwiseAnd %0, %1 : i32
     %2 = spv.BitwiseAnd %0, %1 : vector<4xi32>
     ```
   }];
-
-  let availability = [
-    MinVersion<SPV_V_1_0>,
-    MaxVersion<SPV_V_1_5>,
-    Extension<[]>,
-    Capability<[]>
-  ];
 }
 
 // -----
 
 def SPV_BitwiseOrOp : SPV_BitBinaryOp<"BitwiseOr",
                                       [Commutative, UsableInSpecConstantOp]> {
   let summary = [{
     Result is 1 if either Operand 1 or Operand 2 is 1. Result is 0 if both
let description = [{
 
     #### Example:
 
     ```mlir
     %2 = spv.BitwiseOr %0, %1 : i32
     %2 = spv.BitwiseOr %0, %1 : vector<4xi32>
     ```
   }];
-
-  let availability = [
-    MinVersion<SPV_V_1_0>,
-    MaxVersion<SPV_V_1_5>,
-    Extension<[]>,
-    Capability<[]>
-  ];
 }
 
 // -----
 
 def SPV_BitwiseXorOp : SPV_BitBinaryOp<"BitwiseXor",
                                        [Commutative, UsableInSpecConstantOp]> {
   let summary = [{
     Result is 1 if exactly one of Operand 1 or Operand 2 is 1. Result is 0
let description = [{
 
     #### Example:
 
     ```mlir
     %2 = spv.BitwiseXor %0, %1 : i32
     %2 = spv.BitwiseXor %0, %1 : vector<4xi32>
     ```
   }];
-
-  let availability = [
-    MinVersion<SPV_V_1_0>,
-    MaxVersion<SPV_V_1_5>,
-    Extension<[]>,
-    Capability<[]>
-  ];
 }
 
 // -----
 
 def SPV_ShiftLeftLogicalOp : SPV_ShiftOp<"ShiftLeftLogical",
                                          [UsableInSpecConstantOp]> {
   let summary = [{
     Shift the bits in Base left by the number of bits specified in Shift.
-    The least-significant bits will be zero filled.
+    The least-significant bits are zero filled.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
      The type of each Base and Shift must be a scalar or vector of integer
     type. Base and Shift must have the same number of components.  The
     number of components and bit width of the type of Base must be the same
let description = [{
 
     #### Example:
 
     ```mlir
     %2 = spv.ShiftLeftLogical %0, %1 : i32, i16
     %5 = spv.ShiftLeftLogical %3, %4 : vector<3xi32>, vector<3xi16>
     ```
   }];
-
-  let availability = [
-    MinVersion<SPV_V_1_0>,
-    MaxVersion<SPV_V_1_5>,
-    Extension<[]>,
-    Capability<[]>
-  ];
 }
 
 // -----
 
 def SPV_ShiftRightArithmeticOp : SPV_ShiftOp<"ShiftRightArithmetic",
                                              [UsableInSpecConstantOp]> {
   let summary = [{
     Shift the bits in Base right by the number of bits specified in Shift.
-    The most-significant bits will be filled with the sign bit from Base.
+    The most-significant bits are filled with the sign bit from Base.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
      The type of each Base and Shift must be a scalar or vector of integer
     type. Base and Shift must have the same number of components.  The
     number of components and bit width of the type of Base must be the same
let description = [{
 
     #### Example:
 
     ```mlir
     %2 = spv.ShiftRightArithmetic %0, %1 : i32, i16
     %5 = spv.ShiftRightArithmetic %3, %4 : vector<3xi32>, vector<3xi16>
     ```
   }];
-
-  let availability = [
-    MinVersion<SPV_V_1_0>,
-    MaxVersion<SPV_V_1_5>,
-    Extension<[]>,
-    Capability<[]>
-  ];
 }
 
 // -----
 
 def SPV_ShiftRightLogicalOp : SPV_ShiftOp<"ShiftRightLogical",
                                           [UsableInSpecConstantOp]> {
   let summary = [{
     Shift the bits in Base right by the number of bits specified in Shift.
-    The most-significant bits will be zero filled.
+    The most-significant bits are zero filled.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
      The type of each Base and Shift must be a scalar or vector of integer
     type. Base and Shift must have the same number of components.  The
     number of components and bit width of the type of Base must be the same
let description = [{
 
     #### Example:
 
     ```mlir
     %2 = spv.ShiftRightLogical %0, %1 : i32, i16
     %5 = spv.ShiftRightLogical %3, %4 : vector<3xi32>, vector<3xi16>
     ```
   }];
-
-  let availability = [
-    MinVersion<SPV_V_1_0>,
-    MaxVersion<SPV_V_1_5>,
-    Extension<[]>,
-    Capability<[]>
-  ];
 }
 
 // -----
 
 def SPV_NotOp : SPV_BitUnaryOp<"Not", [UsableInSpecConstantOp]> {
   let summary = "Complement the bits of Operand.";
 
   let description = [{
      Results are computed per component, and within each component, per bit.
 
     Result Type must be a scalar or vector of integer type.
 
-    Operand’s type  must be a scalar or vector of integer type.  It must
+    Operand's type  must be a scalar or vector of integer type.  It must
     have the same number of components as Result Type.  The component width
     must equal the component width in Result Type.
 
     <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                   `vector<` integer-literal `x` integer-type `>`

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

 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // -----
 
 def SPV_CompositeConstructOp : SPV_Op<"CompositeConstruct", [NoSideEffect]> {
   let summary = [{
-    Construct a new composite object from a set of constituent objects that
-    will fully form it.
+    Construct a new composite object from a set of constituent objects.
   }];
 
   let description = [{
     Result Type must be a composite type, whose top-level
     members/elements/components/columns have the same type as the types of
     the operands, with one exception. The exception is that for constructing
     a vector, the operands may also be vectors with the same component type
     as the Result Type component type. When constructing a vector, the total
def SPV_VectorExtractDynamicOp : SPV_Op<"VectorExtractDynamic",
   let arguments = (ins
     SPV_Vector:$vector,
     SPV_Integer:$index
   );
 
   let results = (outs
     SPV_Scalar:$result
   );
-  
   let verifier = [{ return success(); }];
   
   let assemblyFormat = [{
     $vector `[` $index `]` attr-dict `:` type($vector) `,` type($index) 
   }];
-  
 }
 
 // -----
 
 def SPV_VectorInsertDynamicOp : SPV_Op<"VectorInsertDynamic",
         [NoSideEffect,
         TypesMatchWith<"type of 'component' matches element type of 'vector'",
                 "vector", "component",
let arguments = (ins
     SPV_Vector:$vector,
     SPV_Scalar:$component,
     SPV_Integer:$index
   );
 
   let results = (outs
     SPV_Vector:$result
   );
-  
   let verifier = [{ return success(); }];
   
   let assemblyFormat = [{
     $component `,` $vector `[` $index `]` attr-dict `:` type($vector) `,` type($index) 
   }];
 }
 
 // -----
 
 #endif // MLIR_DIALECT_SPIRV_IR_COMPOSITE_OPS

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

 #ifndef MLIR_DIALECT_SPIRV_IR_GROUP_OPS
 #define MLIR_DIALECT_SPIRV_IR_GROUP_OPS
 
 // -----
 
 def SPV_GroupBroadcastOp : SPV_Op<"GroupBroadcast",
   [NoSideEffect, AllTypesMatch<["value", "result"]>]> {
   let summary = [{
-    Return the Value of the invocation identified by the local id LocalId to
-    all invocations in the group.
+    Broadcast the Value of the invocation identified by the local id LocalId
+    to the result of all invocations in the group.
   }];
 
   let description = [{
     All invocations of this module within Execution must reach this point of
     execution.
 
     Behavior is undefined if this instruction is used in control flow that
     is non-uniform within Execution.

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

let description = [{
 
     #### Example:
 
     ```
     %4 = spv.Ordered %0, %1 : f32
     %5 = spv.Ordered %2, %3 : vector<4xf32>
     ```
   }];
+
+  let availability = [
+    MinVersion<SPV_V_1_0>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_Kernel]>
+  ];
 }
 
 // -----
 
 def SPV_SGreaterThanOp : SPV_LogicalBinaryOp<"SGreaterThan",
                                              SPV_Integer,
                                              [UsableInSpecConstantOp, SignedOp]> {
   let summary = [{
let description = [{
 
     #### Example:
 
     ```
     %4 = spv.Unordered %0, %1 : f32
     %5 = spv.Unordered %2, %3 : vector<4xf32>
     ```
   }];
+
+  let availability = [
+    MinVersion<SPV_V_1_0>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_Kernel]>
+  ];
 }
 
 // -----
 
 def SPV_ULessThanEqualOp : SPV_LogicalBinaryOp<"ULessThanEqual",
                                                SPV_Integer,
                                                [UnsignedOp,
                                                 UsableInSpecConstantOp]> {

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

def SPV_MatrixTimesMatrixOp : SPV_Op<"MatrixTimesMatrix", [NoSideEffect]> {
   let arguments = (ins
     SPV_AnyMatrix:$leftmatrix,
     SPV_AnyMatrix:$rightmatrix
   );
 
   let results = (outs
     SPV_AnyMatrix:$result
   );
+
   let assemblyFormat = [{
     operands attr-dict `:` type($leftmatrix) `,` type($rightmatrix) `->` type($result)
   }];
+
   let verifier = [{ return verifyMatrixTimesMatrix(*this); }];
 }
 
 // -----
 
 def SPV_MatrixTimesScalarOp : SPV_Op<"MatrixTimesScalar", [NoSideEffect]> {
   let summary = "Scale a floating-point matrix.";
 

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

 // -----
 
 def SPV_CopyMemoryOp : SPV_Op<"CopyMemory", []> {
   let summary = [{
     Copy from the memory pointed to by Source to the memory pointed to by
     Target. Both operands must be non-void pointers and having the same <id>
     Type operand in their OpTypePointer type declaration.  Matching Storage
     Class is not required.  The amount of memory copied is the size of the
-    type pointed to. The copied type must have a fixed size; i.e., it cannot
-    be, nor include, any OpTypeRuntimeArray types.
+    type pointed to. The copied type must have a fixed size; i.e., it must
+    not be, nor include, any OpTypeRuntimeArray types.
   }];
 
   let description = [{
     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. Before version 1.4, at most one memory operands mask can be
     provided. Starting with version 1.4 two masks can be provided, as
     described in Memory Operands. If no masks or only one mask is present,

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

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_NON_UNIFORM_OPS
 #define MLIR_DIALECT_SPIRV_IR_NON_UNIFORM_OPS
 
 class SPV_GroupNonUniformArithmeticOp<string mnemonic, Type type,
       list<OpTrait> traits = []> : SPV_Op<mnemonic, traits> {
 
-  let availability = [
-    MinVersion<SPV_V_1_3>,
-    MaxVersion<SPV_V_1_5>,
-    Extension<[]>,
-    Capability<[SPV_C_GroupNonUniformArithmetic,
-                SPV_C_GroupNonUniformClustered,
-                SPV_C_GroupNonUniformPartitionedNV]>
-  ];
-
   let arguments = (ins
     SPV_ScopeAttr:$execution_scope,
     SPV_GroupOperationAttr:$group_operation,
     SPV_ScalarOrVectorOf<type>:$value,
     Optional<SPV_Integer>:$cluster_size
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<type>:$result
   );
 
   let parser = [{ return parseGroupNonUniformArithmeticOp(parser, result); }];
   let printer = [{ printGroupNonUniformArithmeticOp(getOperation(), p); }];
   let verifier = [{ return ::verifyGroupNonUniformArithmeticOp(getOperation()); }];
 
 }
 
 // -----
 
 def SPV_GroupNonUniformBallotOp : SPV_Op<"GroupNonUniformBallot", []> {
   let summary = [{
-    Returns a bitfield value combining the Predicate value from all
+    Result is a bitfield value combining the Predicate value from all
     invocations in the group that execute the same dynamic instance of this
     instruction. The bit is set to one if the corresponding invocation is
     active and the Predicate for that invocation evaluated to true;
     otherwise, it is set to zero.
   }];
 
   let description = [{
     Result Type  must be a vector of four components of integer type scalar,
def SPV_GroupNonUniformBallotOp : SPV_Op<"GroupNonUniformBallot", []> {
   }];
 }
 
 // -----
 
 def SPV_GroupNonUniformBroadcastOp : SPV_Op<"GroupNonUniformBroadcast",
   [NoSideEffect, AllTypesMatch<["value", "result"]>]> {
   let summary = [{
-    Return the Value of the invocation identified by the id Id to all active
-    invocations in the group.
+    Result is the Value of the invocation identified by the id Id to all
+    active invocations in the group.
   }];
 
   let description = [{
     Result Type  must be a scalar or vector of floating-point type, integer
     type, or Boolean type.
 
     Execution must be Workgroup or Subgroup Scope.
 
def SPV_GroupNonUniformElectOp : SPV_Op<"GroupNonUniformElect", []> {
 
   let builders = [OpBuilderDAG<(ins "spirv::Scope")>];
 
   let assemblyFormat = "$execution_scope attr-dict `:` type($result)";
 }
 
 // -----
 
-def SPV_GroupNonUniformFAddOp :
-    SPV_GroupNonUniformArithmeticOp<"GroupNonUniformFAdd", SPV_Float, []> {
+def SPV_GroupNonUniformFAddOp : SPV_GroupNonUniformArithmeticOp<"GroupNonUniformFAdd", SPV_Float, []> {
   let summary = [{
     A floating point add group operation of all Value operands contributed
     by active invocations in the group.
   }];
 
   let description = [{
     Result Type  must be a scalar or vector of floating-point type.
 
let description = [{
     ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : f32
     %vector = ... : vector<4xf32>
     %0 = spv.GroupNonUniformFAdd "Workgroup" "Reduce" %scalar : f32
     %1 = spv.GroupNonUniformFAdd "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32>
     ```
   }];
+
+  let availability = [
+    MinVersion<SPV_V_1_3>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformClustered, SPV_C_GroupNonUniformPartitionedNV]>
+  ];
 }
 
 // -----
 
-def SPV_GroupNonUniformFMaxOp :
-    SPV_GroupNonUniformArithmeticOp<"GroupNonUniformFMax", SPV_Float, []> {
+def SPV_GroupNonUniformFMaxOp : SPV_GroupNonUniformArithmeticOp<"GroupNonUniformFMax", SPV_Float, []> {
   let summary = [{
     A floating point maximum group operation of all Value operands
     contributed by active invocations in by group.
   }];
 
   let description = [{
     Result Type  must be a scalar or vector of floating-point type.
 
let description = [{
     ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : f32
     %vector = ... : vector<4xf32>
     %0 = spv.GroupNonUniformFMax "Workgroup" "Reduce" %scalar : f32
     %1 = spv.GroupNonUniformFMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32>
     ```
   }];
+
+  let availability = [
+    MinVersion<SPV_V_1_3>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformClustered, SPV_C_GroupNonUniformPartitionedNV]>
+  ];
 }
 
 // -----
 
-def SPV_GroupNonUniformFMinOp :
-    SPV_GroupNonUniformArithmeticOp<"GroupNonUniformFMin", SPV_Float, []> {
+def SPV_GroupNonUniformFMinOp : SPV_GroupNonUniformArithmeticOp<"GroupNonUniformFMin", SPV_Float, []> {
   let summary = [{
     A floating point minimum group operation of all Value operands
     contributed by active invocations in the group.
   }];
 
   let description = [{
     Result Type  must be a scalar or vector of floating-point type.
 
let description = [{
     ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : f32
     %vector = ... : vector<4xf32>
     %0 = spv.GroupNonUniformFMin "Workgroup" "Reduce" %scalar : f32
     %1 = spv.GroupNonUniformFMin "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32>
     ```
   }];
+
+  let availability = [
+    MinVersion<SPV_V_1_3>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformClustered, SPV_C_GroupNonUniformPartitionedNV]>
+  ];
 }
 
 // -----
 
-def SPV_GroupNonUniformFMulOp :
-    SPV_GroupNonUniformArithmeticOp<"GroupNonUniformFMul", SPV_Float, []> {
+def SPV_GroupNonUniformFMulOp : SPV_GroupNonUniformArithmeticOp<"GroupNonUniformFMul", SPV_Float, []> {
   let summary = [{
     A floating point multiply group operation of all Value operands
     contributed by active invocations in the group.
   }];
 
   let description = [{
     Result Type  must be a scalar or vector of floating-point type.
 
let description = [{
     ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : f32
     %vector = ... : vector<4xf32>
     %0 = spv.GroupNonUniformFMul "Workgroup" "Reduce" %scalar : f32
     %1 = spv.GroupNonUniformFMul "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32>
     ```
   }];
+
+  let availability = [
+    MinVersion<SPV_V_1_3>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformClustered, SPV_C_GroupNonUniformPartitionedNV]>
+  ];
 }
 
 // -----
 
-def SPV_GroupNonUniformIAddOp :
-    SPV_GroupNonUniformArithmeticOp<"GroupNonUniformIAdd", SPV_Integer, []> {
+def SPV_GroupNonUniformIAddOp : SPV_GroupNonUniformArithmeticOp<"GroupNonUniformIAdd", SPV_Integer, []> {
   let summary = [{
     An integer add group operation of all Value operands contributed by
     active invocations in the group.
   }];
 
   let description = [{
     Result Type  must be a scalar or vector of integer type.
 
let description = [{
     ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : i32
     %vector = ... : vector<4xi32>
     %0 = spv.GroupNonUniformIAdd "Workgroup" "Reduce" %scalar : i32
     %1 = spv.GroupNonUniformIAdd "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
+
+  let availability = [
+    MinVersion<SPV_V_1_3>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformClustered, SPV_C_GroupNonUniformPartitionedNV]>
+  ];
 }
 
 // -----
 
-def SPV_GroupNonUniformIMulOp :
-    SPV_GroupNonUniformArithmeticOp<"GroupNonUniformIMul", SPV_Integer, []> {
+def SPV_GroupNonUniformIMulOp : SPV_GroupNonUniformArithmeticOp<"GroupNonUniformIMul", SPV_Integer, []> {
   let summary = [{
     An integer multiply group operation of all Value operands contributed by
     active invocations in the group.
   }];
 
   let description = [{
     Result Type  must be a scalar or vector of integer type.
 
let description = [{
     ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : i32
     %vector = ... : vector<4xi32>
     %0 = spv.GroupNonUniformIMul "Workgroup" "Reduce" %scalar : i32
     %1 = spv.GroupNonUniformIMul "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
+
+  let availability = [
+    MinVersion<SPV_V_1_3>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformClustered, SPV_C_GroupNonUniformPartitionedNV]>
+  ];
 }
 
 // -----
 
-def SPV_GroupNonUniformSMaxOp :
-    SPV_GroupNonUniformArithmeticOp<"GroupNonUniformSMax",
+def SPV_GroupNonUniformSMaxOp : SPV_GroupNonUniformArithmeticOp<"GroupNonUniformSMax",
                                     SPV_Integer,
                                     [SignedOp]> {
   let summary = [{
     A signed integer maximum group operation of all Value operands
     contributed by active invocations in the group.
   }];
 
   let description = [{
let description = [{
     ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : i32
     %vector = ... : vector<4xi32>
     %0 = spv.GroupNonUniformSMax "Workgroup" "Reduce" %scalar : i32
     %1 = spv.GroupNonUniformSMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
+
+  let availability = [
+    MinVersion<SPV_V_1_3>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformClustered, SPV_C_GroupNonUniformPartitionedNV]>
+  ];
 }
 
 // -----
 
-def SPV_GroupNonUniformSMinOp :
-    SPV_GroupNonUniformArithmeticOp<"GroupNonUniformSMin",
+def SPV_GroupNonUniformSMinOp : SPV_GroupNonUniformArithmeticOp<"GroupNonUniformSMin",
                                     SPV_Integer,
                                     [SignedOp]> {
   let summary = [{
     A signed integer minimum group operation of all Value operands
     contributed by active invocations in the group.
   }];
 
   let description = [{
let description = [{
     ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : i32
     %vector = ... : vector<4xi32>
     %0 = spv.GroupNonUniformSMin "Workgroup" "Reduce" %scalar : i32
     %1 = spv.GroupNonUniformSMin "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
+
+  let availability = [
+    MinVersion<SPV_V_1_3>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformClustered, SPV_C_GroupNonUniformPartitionedNV]>
+  ];
 }
 
 // -----
 
-def SPV_GroupNonUniformUMaxOp :
-    SPV_GroupNonUniformArithmeticOp<"GroupNonUniformUMax",
+def SPV_GroupNonUniformUMaxOp : SPV_GroupNonUniformArithmeticOp<"GroupNonUniformUMax",
                                     SPV_Integer,
                                     [UnsignedOp]> {
   let summary = [{
     An unsigned integer maximum group operation of all Value operands
     contributed by active invocations in the group.
   }];
 
   let description = [{
let description = [{
     ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : i32
     %vector = ... : vector<4xi32>
     %0 = spv.GroupNonUniformUMax "Workgroup" "Reduce" %scalar : i32
     %1 = spv.GroupNonUniformUMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
+
+  let availability = [
+    MinVersion<SPV_V_1_3>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformClustered, SPV_C_GroupNonUniformPartitionedNV]>
+  ];
 }
 
 // -----
 
-def SPV_GroupNonUniformUMinOp :
-    SPV_GroupNonUniformArithmeticOp<"GroupNonUniformUMin",
+def SPV_GroupNonUniformUMinOp : SPV_GroupNonUniformArithmeticOp<"GroupNonUniformUMin",
                                     SPV_Integer,
                                     [UnsignedOp]> {
   let summary = [{
     An unsigned integer minimum group operation of all Value operands
     contributed by active invocations in the group.
   }];
 
   let description = [{
let description = [{
     ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : i32
     %vector = ... : vector<4xi32>
     %0 = spv.GroupNonUniformUMin "Workgroup" "Reduce" %scalar : i32
     %1 = spv.GroupNonUniformUMin "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
+
+  let availability = [
+    MinVersion<SPV_V_1_3>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformClustered, SPV_C_GroupNonUniformPartitionedNV]>
+  ];
 }
 
 // -----
 
 #endif // MLIR_DIALECT_SPIRV_IR_NON_UNIFORM_OPS

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

def SPV_SpecConstantOp : SPV_Op<"specConstant", [InModuleScope, Symbol]> {
 
   let results = (outs);
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 }
 
-def SPV_SpecConstantCompositeOp : SPV_Op<"specConstantComposite", [InModuleScope, Symbol]> {
+// -----
+
+def SPV_SpecConstantCompositeOp : SPV_Op<"specConstantComposite", [
+    InModuleScope, Symbol]> {
   let summary = "Declare a new composite specialization constant.";
 
   let description = [{
     This op declares a SPIR-V composite specialization constant. This covers
     the `OpSpecConstantComposite` SPIR-V instruction. Scalar constants are
     covered by `spv.specConstant`.
 
     A constituent of a spec constant composite can be:
def SPV_SpecConstantCompositeOp : SPV_Op<"specConstantComposite", [
 
   let results = (outs);
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 }
 
-def SPV_YieldOp : SPV_Op<"mlir.yield", [
-    HasParent<"SpecConstantOperationOp">, NoSideEffect, Terminator]> {
-  let summary = [{
-    Yields the result computed in `spv.SpecConstantOperation`'s
-    region back to the parent op.
-  }];
-
-  let description = [{
-    This op is a special terminator whose only purpose is to terminate
-    an `spv.SpecConstantOperation`'s enclosed region. It accepts a
-    single operand produced by the preceeding (and only other) instruction
-    in its parent block (see SPV_SpecConstantOperation for further
-    details). This op has no corresponding SPIR-V instruction.
-
-    ```
-    spv.mlir.yield ::= `spv.mlir.yield` ssa-id : spirv-type
-    ```
-
-    #### Example:
-    ```mlir
-    %0 = ... (some op supported by SPIR-V OpSpecConstantOp)
-    spv.mlir.yield %0
-    ```
-  }];
-
-  let arguments = (ins AnyType:$operand);
-
-  let results = (outs);
-
-  let hasOpcode = 0;
-
-  let autogenSerialization = 0;
-
-  let assemblyFormat = "attr-dict $operand `:` type($operand)";
-
-  let verifier = [{ return success(); }];
-}
+// -----
 
 def SPV_SpecConstantOperationOp : SPV_Op<"SpecConstantOperation", [
        NoSideEffect, InFunctionScope,
        SingleBlockImplicitTerminator<"YieldOp">]> {
   let summary = [{
     Declare a new specialization constant that results from doing an operation.
   }];
 
def SPV_SpecConstantOperationOp : SPV_Op<"SpecConstantOperation", [
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 }
 
 // -----
 
+def SPV_YieldOp : SPV_Op<"mlir.yield", [
+    HasParent<"SpecConstantOperationOp">, NoSideEffect, Terminator]> {
+  let summary = [{
+    Yields the result computed in `spv.SpecConstantOperation`'s
+    region back to the parent op.
+  }];
+
+  let description = [{
+    This op is a special terminator whose only purpose is to terminate
+    an `spv.SpecConstantOperation`'s enclosed region. It accepts a
+    single operand produced by the preceeding (and only other) instruction
+    in its parent block (see SPV_SpecConstantOperation for further
+    details). This op has no corresponding SPIR-V instruction.
+
+    ```
+    spv.mlir.yield ::= `spv.mlir.yield` ssa-id : spirv-type
+    ```
+
+    #### Example:
+    ```mlir
+    %0 = ... (some op supported by SPIR-V OpSpecConstantOp)
+    spv.mlir.yield %0
+    ```
+  }];
+
+  let arguments = (ins AnyType:$operand);
+
+  let results = (outs);
+
+  let hasOpcode = 0;
+
+  let autogenSerialization = 0;
+
+  let assemblyFormat = "attr-dict $operand `:` type($operand)";
+
+  let verifier = [{ return success(); }];
+}
+
+// -----
+
 #endif // MLIR_DIALECT_SPIRV_IR_STRUCTURE_OPS

mlir/test/Conversion/StandardToSPIRV/std-ops-to-spirv.mlir

func @shift_vector(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) {
   %0 = shift_left %arg0, %arg1 : vector<4xi32>
   // CHECK: spv.ShiftRightArithmetic
   %1 = shift_right_signed %arg0, %arg1 : vector<4xi32>
   // CHECK: spv.ShiftRightLogical
   %2 = shift_right_unsigned %arg0, %arg1 : vector<4xi32>
   return
 }
 
+} // end module
+
+// -----
+
 //===----------------------------------------------------------------------===//
 // std.cmpf
 //===----------------------------------------------------------------------===//
 
+module attributes {
+  spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, {}>
+} {
+
 // CHECK-LABEL: @cmpf
 func @cmpf(%arg0 : f32, %arg1 : f32) {
   // CHECK: spv.FOrdEqual
   %1 = cmpf oeq, %arg0, %arg1 : f32
   // CHECK: spv.FOrdGreaterThan
   %2 = cmpf ogt, %arg0, %arg1 : f32
   // CHECK: spv.FOrdGreaterThanEqual
   %3 = cmpf oge, %arg0, %arg1 : f32
func @cmpf(%arg0 : f32, %arg1 : f32) {
   // CHECK: spv.FUnordGreaterThanEqual
   %9 = cmpf uge, %arg0, %arg1 : f32
   // CHECK: spv.FUnordLessThan
   %10 = cmpf ult, %arg0, %arg1 : f32
   // CHECK: FUnordLessThanEqual
   %11 = cmpf ule, %arg0, %arg1 : f32
   // CHECK: spv.FUnordNotEqual
   %12 = cmpf une, %arg0, %arg1 : f32
+  return
+}
+
+} // end module
+
+// -----
+
+module attributes {
+  spv.target_env = #spv.target_env<#spv.vce<v1.0, [Kernel], []>, {}>
+} {
+
+// CHECK-LABEL: @cmpf
+func @cmpf(%arg0 : f32, %arg1 : f32) {
   // CHECK: spv.Ordered
-  %13 = cmpf ord, %arg0, %arg1 : f32
+  %0 = cmpf ord, %arg0, %arg1 : f32
   // CHECK: spv.Unordered
-  %14 = cmpf uno, %arg0, %arg1 : f32
+  %1 = cmpf uno, %arg0, %arg1 : f32
   return
 }
 
+} // end module
+
+// -----
+
 //===----------------------------------------------------------------------===//
 // std.cmpi
 //===----------------------------------------------------------------------===//
 
+module attributes {
+  spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, {}>
+} {
+
 // CHECK-LABEL: @cmpi
 func @cmpi(%arg0 : i32, %arg1 : i32) {
   // CHECK: spv.IEqual
   %0 = cmpi eq, %arg0, %arg1 : i32
   // CHECK: spv.INotEqual
   %1 = cmpi ne, %arg0, %arg1 : i32
   // CHECK: spv.SLessThan
   %2 = cmpi slt, %arg0, %arg1 : i32

mlir/utils/spirv/gen_spirv_dialect.py

def get_op_definition(instruction, doc, existing_info, capability_mapping):
   # Wrap text
   text = text.split('\n')
   text = [wrapper.fill(line) for line in text if line]
   text = '\n\n'.join(text)
 
   operands = instruction.get('operands', [])
 
   # Op availability
-  avail = ''
-  # We assume other instruction categories has a base availability spec, so
-  # only add this if this is directly using SPV_Op as the base.
-  if inst_category == 'Op':
-    avail = get_availability_spec(instruction, capability_mapping, True, False)
-    if avail:
-      avail = '\n\n  {0}'.format(avail)
 
   # Set op's result
   results = ''
   if len(operands) > 0 and operands[0]['kind'] == 'IdResultType':
     results = '\n    SPV_Type:$result\n  '
     operands = operands[1:]
   if 'results' in existing_info:
     results = existing_info['results']