[MLIR][SPIRV] Add `UsableInSpecConstantOp` trait.

[ergawy]

Summary

Instead of checking explicitly checking for whether an op is usalbe
inside a SpecConstantOperationOP, this commit adds a new trait to
filter such ops.

[antiagainst]

Awesome!

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

let description = [{
     %4 = spv.FRemOp %0, %1 : f32
     %5 = spv.FRemOp %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
-def SPV_IAddOp : SPV_ArithmeticBinaryOp<"IAdd", SPV_Integer, [Commutative]> {
+def SPV_IAddOp : SPV_ArithmeticBinaryOp<"IAdd",
+                                        SPV_Integer,
+                                        [Commutative, UsableInSpecConstantOp]> {
   let summary = "Integer addition of Operand 1 and Operand 2.";
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same number of components as Result
     Type. They must have the same component width as Result Type.
let description = [{
     ```
   }];
 
   let hasFolder = 1;
 }
 
 // -----
 
-def SPV_IMulOp : SPV_ArithmeticBinaryOp<"IMul", SPV_Integer, [Commutative]> {
+def SPV_IMulOp : SPV_ArithmeticBinaryOp<"IMul",
+                                        SPV_Integer,
+                                        [Commutative, UsableInSpecConstantOp]> {
   let summary = "Integer multiplication of Operand 1 and Operand 2.";
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same number of components as Result
     Type. They must have the same component width as Result Type.
let description = [{
     ```
   }];
 
   let hasFolder = 1;
 }
 
 // -----
 
-def SPV_ISubOp : SPV_ArithmeticBinaryOp<"ISub", SPV_Integer, []> {
+def SPV_ISubOp : SPV_ArithmeticBinaryOp<"ISub",
+                                        SPV_Integer,
+                                        [UsableInSpecConstantOp]> {
   let summary = "Integer subtraction of Operand 2 from Operand 1.";
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same number of components as Result
     Type. They must have the same component width as Result Type.
let description = [{
     ```
   }];
 
   let hasFolder = 1;
 }
 
 // -----
 
-def SPV_SDivOp : SPV_ArithmeticBinaryOp<"SDiv", SPV_Integer, []> {
+def SPV_SDivOp : SPV_ArithmeticBinaryOp<"SDiv",
+                                        SPV_Integer,
+                                        [UsableInSpecConstantOp]> {
   let summary = "Signed-integer division of Operand 1 divided by Operand 2.";
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same number of components as Result
     Type. They must have the same component width as Result Type.
let description = [{
     %5 = spv.SDiv %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
-def SPV_SModOp : SPV_ArithmeticBinaryOp<"SMod", SPV_Integer, []> {
+def SPV_SModOp : SPV_ArithmeticBinaryOp<"SMod",
+                                        SPV_Integer,
+                                        [UsableInSpecConstantOp]> {
   let summary = [{
     Signed remainder operation for the remainder whose sign matches the sign
     of Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
let description = [{
     %5 = spv.SMod %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
-def SPV_SNegateOp : SPV_ArithmeticUnaryOp<"SNegate", SPV_Integer, []> {
+def SPV_SNegateOp : SPV_ArithmeticUnaryOp<"SNegate",
+                                          SPV_Integer,
+                                          [UsableInSpecConstantOp]> {
   let summary = "Signed-integer subtract of Operand from zero.";
 
   let description = [{
     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
     have the same number of components as Result Type.  The component width
     must equal the component width in Result Type.
 
      Results are computed per component.
 
     <!-- End of AutoGen section -->
 
     #### Example:
 
     ```mlir
     %1 = spv.SNegate %0 : i32
     %3 = spv.SNegate %2 : vector<4xi32>
     ```
   }];
 }
 
 // -----
 
-def SPV_SRemOp : SPV_ArithmeticBinaryOp<"SRem", SPV_Integer, []> {
+def SPV_SRemOp : SPV_ArithmeticBinaryOp<"SRem",
+                                        SPV_Integer,
+                                        [UsableInSpecConstantOp]> {
   let summary = [{
     Signed remainder operation for the remainder whose sign matches the sign
     of Operand 1.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
let description = [{
     %5 = spv.SRem %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
-def SPV_UDivOp : SPV_ArithmeticBinaryOp<"UDiv", SPV_Integer, [UnsignedOp]> {
+def SPV_UDivOp : SPV_ArithmeticBinaryOp<"UDiv",
+                                        SPV_Integer,
+                                        [UnsignedOp, UsableInSpecConstantOp]> {
   let summary = "Unsigned-integer division of Operand 1 divided by Operand 2.";
 
   let description = [{
     Result Type must be a scalar or vector of integer type, whose Signedness
     operand is 0.
 
      The types of Operand 1 and Operand 2 both must be the same as Result
     Type.
let description = [{
     %5 = spv.UDiv %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
-def SPV_UModOp : SPV_ArithmeticBinaryOp<"UMod", SPV_Integer, [UnsignedOp]> {
+def SPV_UModOp : SPV_ArithmeticBinaryOp<"UMod",
+                                        SPV_Integer,
+                                        [UnsignedOp, UsableInSpecConstantOp]> {
   let summary = "Unsigned modulo operation of Operand 1 modulo Operand 2.";
 
   let description = [{
     Result Type must be a scalar or vector of integer type, whose Signedness
     operand is 0.
 
      The types of Operand 1 and Operand 2 both must be the same as Result
     Type.

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

 
 // Check that an op can only be used within the scope of a module-like op.
 def InModuleScope : PredOpTrait<
   "op must appear in a module-like op's block",
   CPred<"isDirectInModuleLikeOp($_op.getParentOp())">>;
 
 def UnsignedOp : NativeOpTrait<"spirv::UnsignedOp">;
 
+def UsableInSpecConstantOp : NativeOpTrait<"spirv::UsableInSpecConstantOp">;
+
 //===----------------------------------------------------------------------===//
 // SPIR-V opcode specification
 //===----------------------------------------------------------------------===//
 
 class SPV_OpCode<string name, int val> {
   // Name used as reference to retrieve the opcode
   string opname = name;
 

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

let availability = [
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
     Capability<[SPV_C_Shader]>
   ];
 }
 
 // -----
 
-def SPV_BitwiseAndOp : SPV_BitBinaryOp<"BitwiseAnd", [Commutative]> {
+def SPV_BitwiseAndOp : SPV_BitBinaryOp<"BitwiseAnd",
+                                       [Commutative, UsableInSpecConstantOp]> {
   let summary = [{
     Result is 1 if both Operand 1 and Operand 2 are 1. Result is 0 if either
     Operand 1 or Operand 2 are 0.
   }];
 
   let description = [{
      Results are computed per component, and within each component, per bit.
 
let availability = [
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
     Capability<[]>
   ];
 }
 
 // -----
 
-def SPV_BitwiseOrOp : SPV_BitBinaryOp<"BitwiseOr", [Commutative]> {
+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
     Operand 1 and Operand 2 are 0.
   }];
 
   let description = [{
      Results are computed per component, and within each component, per bit.
 
let availability = [
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
     Capability<[]>
   ];
 }
 
 // -----
 
-def SPV_BitwiseXorOp : SPV_BitBinaryOp<"BitwiseXor", [Commutative]> {
+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
     if Operand 1 and Operand 2 have the same value.
   }];
 
   let description = [{
      Results are computed per component, and within each component, per bit.
 
let availability = [
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
     Capability<[]>
   ];
 }
 
 // -----
 
-def SPV_ShiftLeftLogicalOp : SPV_ShiftOp<"ShiftLeftLogical", []> {
+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.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
let availability = [
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
     Capability<[]>
   ];
 }
 
 // -----
 
-def SPV_ShiftRightArithmeticOp : SPV_ShiftOp<"ShiftRightArithmetic", []> {
+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.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
let availability = [
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
     Capability<[]>
   ];
 }
 
 // -----
 
-def SPV_ShiftRightLogicalOp : SPV_ShiftOp<"ShiftRightLogical", []> {
+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.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
let availability = [
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
     Capability<[]>
   ];
 }
 
 // -----
 
-def SPV_NotOp : SPV_BitUnaryOp<"Not", []> {
+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

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

let description = [{
     ```
   }];
 
   let verifier = [{ return verifyCastOp(this->getOperation(), false, true); }];
 }
 
 // -----
 
-def SPV_FConvertOp : SPV_CastOp<"FConvert", SPV_Float, SPV_Float, []> {
+def SPV_FConvertOp : SPV_CastOp<"FConvert",
+                                SPV_Float,
+                                SPV_Float,
+                                [UsableInSpecConstantOp]> {
   let summary = [{
     Convert value numerically from one floating-point width to another
     width.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
 
let description = [{
     ```
   }];
 
   let verifier = [{ return verifyCastOp(this->getOperation(), false); }];
 }
 
 // -----
 
-def SPV_SConvertOp : SPV_CastOp<"SConvert", SPV_Integer, SPV_Integer, []> {
+def SPV_SConvertOp : SPV_CastOp<"SConvert", SPV_Integer, SPV_Integer, [UsableInSpecConstantOp]> {
   let summary = [{
     Convert signed width.  This is either a truncate or a sign extend.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
     Signed Value must be a scalar or vector of integer type.  It must have
def SPV_SConvertOp : SPV_CastOp<"SConvert", SPV_Integer, SPV_Integer, [UsableInSpecConstantOp]> {
   let verifier = [{ return verifyCastOp(this->getOperation(), false); }];
 }
 
 // -----
 
 def SPV_UConvertOp : SPV_CastOp<"UConvert",
                                 SPV_Integer,
                                 SPV_Integer,
-                                [UnsignedOp]> {
+                                [UnsignedOp, UsableInSpecConstantOp]> {
   let summary = [{
     Convert unsigned width. This is either a truncate or a zero extend.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of integer type, whose Signedness
     operand is 0.
 

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

def SPV_CompositeConstructOp : SPV_Op<"CompositeConstruct", [NoSideEffect]> {
 
   let results = (outs
     SPV_Composite:$result
   );
 }
 
 // -----
 
-def SPV_CompositeExtractOp : SPV_Op<"CompositeExtract", [NoSideEffect]> {
+def SPV_CompositeExtractOp : SPV_Op<"CompositeExtract",
+                                    [NoSideEffect, UsableInSpecConstantOp]> {
   let summary = "Extract a part of a composite object.";
 
   let description = [{
     Result Type must be the type of object selected by the last provided
     index.  The instruction result is the extracted object.
 
     Composite is the composite to extract from.
 
let builders = [
     OpBuilderDAG<(ins "Value":$composite, "ArrayRef<int32_t>":$indices)>
   ];
 
   let hasFolder = 1;
 }
 
 // -----
 
-def SPV_CompositeInsertOp : SPV_Op<"CompositeInsert", [NoSideEffect]> {
+def SPV_CompositeInsertOp : SPV_Op<"CompositeInsert",
+                                   [NoSideEffect, UsableInSpecConstantOp]> {
   let summary = [{
     Make a copy of a composite object, while modifying one part of it.
   }];
 
   let description = [{
     Result Type must be the same type as Composite.
 
     Object is the object to use as the modified part.

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

let description = [{
     %4 = spv.FUnordNotEqual %0, %1 : f32
     %5 = spv.FUnordNotEqual %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
-def SPV_IEqualOp : SPV_LogicalBinaryOp<"IEqual", SPV_Integer, [Commutative]> {
+def SPV_IEqualOp : SPV_LogicalBinaryOp<"IEqual",
+                                       SPV_Integer,
+                                       [Commutative, UsableInSpecConstantOp]> {
   let summary = "Integer comparison for equality.";
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same component width, and they must
     have the same number of components as Result Type.
let description = [{
     %5 = spv.IEqual %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
-def SPV_INotEqualOp : SPV_LogicalBinaryOp<"INotEqual", SPV_Integer, [Commutative]> {
+def SPV_INotEqualOp : SPV_LogicalBinaryOp<"INotEqual",
+                                          SPV_Integer,
+                                          [Commutative, UsableInSpecConstantOp]> {
   let summary = "Integer comparison for inequality.";
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same component width, and they must
     have the same number of components as Result Type.
let description = [{
     %5 = spv.INotEqual %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
-def SPV_LogicalAndOp : SPV_LogicalBinaryOp<"LogicalAnd", SPV_Bool, [Commutative]> {
+def SPV_LogicalAndOp : SPV_LogicalBinaryOp<"LogicalAnd",
+                                           SPV_Bool,
+                                           [Commutative,
+                                            UsableInSpecConstantOp]> {
   let summary = [{
     Result is true if both Operand 1 and Operand 2 are true. Result is false
     if either Operand 1 or Operand 2 are false.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
let description = [{
     ```
   }];
 
   let hasFolder = 1;
 }
 
 // -----
 
-def SPV_LogicalEqualOp : SPV_LogicalBinaryOp<"LogicalEqual", SPV_Bool, [Commutative]> {
+def SPV_LogicalEqualOp : SPV_LogicalBinaryOp<"LogicalEqual",
+                                             SPV_Bool,
+                                             [Commutative,
+                                              UsableInSpecConstantOp]> {
   let summary = [{
     Result is true if Operand 1 and Operand 2 have the same value. Result is
     false if Operand 1 and Operand 2 have different values.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
let description = [{
     %2 = spv.LogicalEqual %0, %1 : i1
     %2 = spv.LogicalEqual %0, %1 : vector<4xi1>
     ```
   }];
 }
 
 // -----
 
-def SPV_LogicalNotOp : SPV_LogicalUnaryOp<"LogicalNot", SPV_Bool, []> {
+def SPV_LogicalNotOp : SPV_LogicalUnaryOp<"LogicalNot",
+                                          SPV_Bool,
+                                          [UsableInSpecConstantOp]> {
   let summary = [{
     Result is true if Operand is false.  Result is false if Operand is true.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand must be the same as Result Type.
let description = [{
     ```
   }];
 
   let hasCanonicalizer = 1;
 }
 
 // -----
 
-def SPV_LogicalNotEqualOp : SPV_LogicalBinaryOp<"LogicalNotEqual", SPV_Bool, [Commutative]> {
+def SPV_LogicalNotEqualOp : SPV_LogicalBinaryOp<"LogicalNotEqual",
+                                                SPV_Bool,
+                                                [Commutative,
+                                                 UsableInSpecConstantOp]> {
   let summary = [{
     Result is true if Operand 1 and Operand 2 have different values. Result
     is false if Operand 1 and Operand 2 have the same value.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
let description = [{
     %2 = spv.LogicalNotEqual %0, %1 : i1
     %2 = spv.LogicalNotEqual %0, %1 : vector<4xi1>
     ```
   }];
 }
 
 // -----
 
-def SPV_LogicalOrOp : SPV_LogicalBinaryOp<"LogicalOr", SPV_Bool, [Commutative]> {
+def SPV_LogicalOrOp : SPV_LogicalBinaryOp<"LogicalOr",
+                                          SPV_Bool,
+                                          [Commutative,
+                                           UsableInSpecConstantOp]> {
   let summary = [{
     Result is true if either Operand 1 or Operand 2 is true. Result is false
     if both Operand 1 and Operand 2 are false.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
let description = [{
     ```
   }];
 
   let hasFolder = 1;
 }
 
 // -----
 
-def SPV_SGreaterThanOp : SPV_LogicalBinaryOp<"SGreaterThan", SPV_Integer, []> {
+def SPV_SGreaterThanOp : SPV_LogicalBinaryOp<"SGreaterThan",
+                                             SPV_Integer,
+                                             [UsableInSpecConstantOp]> {
   let summary = [{
     Signed-integer comparison if Operand 1 is greater than  Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
let description = [{
     %5 = spv.SGreaterThan %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
-def SPV_SGreaterThanEqualOp : SPV_LogicalBinaryOp<"SGreaterThanEqual", SPV_Integer, []> {
+def SPV_SGreaterThanEqualOp : SPV_LogicalBinaryOp<"SGreaterThanEqual",
+                                                  SPV_Integer,
+                                                  [UsableInSpecConstantOp]> {
   let summary = [{
     Signed-integer comparison if Operand 1 is greater than or equal to
     Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
let description = [{
     %5 = spv.SGreaterThanEqual %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
-def SPV_SLessThanOp : SPV_LogicalBinaryOp<"SLessThan", SPV_Integer, []> {
+def SPV_SLessThanOp : SPV_LogicalBinaryOp<"SLessThan",
+                                          SPV_Integer,
+                                          [UsableInSpecConstantOp]> {
   let summary = [{
     Signed-integer comparison if Operand 1 is less than Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
let description = [{
     %5 = spv.SLessThan %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
-def SPV_SLessThanEqualOp : SPV_LogicalBinaryOp<"SLessThanEqual", SPV_Integer, []> {
+def SPV_SLessThanEqualOp : SPV_LogicalBinaryOp<"SLessThanEqual",
+                                               SPV_Integer,
+                                               [UsableInSpecConstantOp]> {
   let summary = [{
     Signed-integer comparison if Operand 1 is less than or equal to Operand
     2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
let description = [{
 
     ```
   }];
 }
 
 // -----
 
 def SPV_SelectOp : SPV_Op<"Select",
-    [NoSideEffect, AllTypesMatch<["true_value", "false_value", "result"]>]> {
+    [NoSideEffect,
+     AllTypesMatch<["true_value", "false_value", "result"]>,
+     UsableInSpecConstantOp]> {
   let summary = [{
     Select between two objects. Before version 1.4, results are only
     computed per component.
   }];
 
   let description = [{
     Before version 1.4, Result Type must be a pointer, scalar, or vector.
 
let assemblyFormat = [{
     operands attr-dict `:` type($condition) `,` type($result)
   }];
 }
 
 // -----
 
 def SPV_UGreaterThanOp : SPV_LogicalBinaryOp<"UGreaterThan",
                                              SPV_Integer,
-                                             [UnsignedOp]> {
+                                             [UnsignedOp,
+                                              UsableInSpecConstantOp]> {
   let summary = [{
     Unsigned-integer comparison if Operand 1 is greater than  Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
let description = [{
     ```
   }];
 }
 
 // -----
 
 def SPV_UGreaterThanEqualOp : SPV_LogicalBinaryOp<"UGreaterThanEqual",
                                                   SPV_Integer,
-                                                  [UnsignedOp]> {
+                                                  [UnsignedOp,
+                                                   UsableInSpecConstantOp]> {
   let summary = [{
     Unsigned-integer comparison if Operand 1 is greater than or equal to
     Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
let description = [{
     ```
   }];
 }
 
 // -----
 
 def SPV_ULessThanOp : SPV_LogicalBinaryOp<"ULessThan",
                                           SPV_Integer,
-                                          [UnsignedOp]> {
+                                          [UnsignedOp, UsableInSpecConstantOp]> {
   let summary = [{
     Unsigned-integer comparison if Operand 1 is less than Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
let description = [{
     %5 = spv.ULessThan %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
-def SPV_ULessThanEqualOp :
-  SPV_LogicalBinaryOp<"ULessThanEqual", SPV_Integer, [UnsignedOp]> {
+def SPV_ULessThanEqualOp : SPV_LogicalBinaryOp<"ULessThanEqual",
+                                               SPV_Integer,
+                                               [UnsignedOp,
+                                                UsableInSpecConstantOp]> {
   let summary = [{
     Unsigned-integer comparison if Operand 1 is less than or equal to
     Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOpTraits.h

 
 namespace mlir {
 namespace OpTrait {
 namespace spirv {
 
 template <typename ConcreteType>
 class UnsignedOp : public TraitBase<ConcreteType, UnsignedOp> {};
 
+/// A trait to mark ops that can be enclosed/wrapped in a
+/// `SpecConstantOperation` op.
+template <typename ConcreteType>
+class UsableInSpecConstantOp
+    : public TraitBase<ConcreteType, UsableInSpecConstantOp> {};
+
 } // namespace spirv
 } // namespace OpTrait
 } // namespace mlir
 
 #endif // MLIR_DIALECT_SPIRV_IR_SPIRVOPTRAITS_H_

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

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 
 #include "mlir/Dialect/SPIRV/IR/ParserUtils.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOpTraits.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/FunctionImplementation.h"
+#include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/bit.h"
 
 using namespace mlir;
 
 // TODO: generate these strings using ODS.

 static LogicalResult verify(spirv::SpecConstantOperationOp constOp) {
   Block &block = constOp.getRegion().getBlocks().front();
 
   if (block.getOperations().size() != 2)
     return constOp.emitOpError("expected exactly 2 nested ops");
 
   Operation &enclosedOp = block.getOperations().front();
 
-  // TODO Add a `UsableInSpecConstantOp` trait and mark ops from the list below
-  // with it instead.
-  if (!isa<spirv::SConvertOp, spirv::UConvertOp, spirv::FConvertOp,
-           spirv::SNegateOp, spirv::NotOp, spirv::IAddOp, spirv::ISubOp,
-           spirv::IMulOp, spirv::UDivOp, spirv::SDivOp, spirv::UModOp,
-           spirv::SRemOp, spirv::SModOp, spirv::ShiftRightLogicalOp,
-           spirv::ShiftRightArithmeticOp, spirv::ShiftLeftLogicalOp,
-           spirv::BitwiseOrOp, spirv::BitwiseXorOp, spirv::BitwiseAndOp,
-           spirv::CompositeExtractOp, spirv::CompositeInsertOp,
-           spirv::LogicalOrOp, spirv::LogicalAndOp, spirv::LogicalNotOp,
-           spirv::LogicalEqualOp, spirv::LogicalNotEqualOp, spirv::SelectOp,
-           spirv::IEqualOp, spirv::INotEqualOp, spirv::ULessThanOp,
-           spirv::SLessThanOp, spirv::UGreaterThanOp, spirv::SGreaterThanOp,
-           spirv::ULessThanEqualOp, spirv::SLessThanEqualOp,
-           spirv::UGreaterThanEqualOp, spirv::SGreaterThanEqualOp>(enclosedOp))
+  if (!enclosedOp.hasTrait<OpTrait::spirv::UsableInSpecConstantOp>())
     return constOp.emitOpError("invalid enclosed op");
 
   for (auto operand : enclosedOp.getOperands())
     if (!isa<spirv::ConstantOp, spirv::SpecConstantOp,
              spirv::SpecConstantCompositeOp, spirv::SpecConstantOperationOp>(
             operand.getDefiningOp()))
       return constOp.emitOpError(
           "invalid operand, must be defined by a constant operation");