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

[ergawy]

Summary

This commit adds a new trait that can be attached to ops that have
signed semantics.

[ergawy]

I couldn't find any place that filters on signed ops. If there is any such place please let me know.

[antiagainst]

In D94896#2504223, @ergawy wrote:

I couldn't find any place that filters on signed ops. If there is any such place please let me know.

There isn't a place using it right now.

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 SignedOp : NativeOpTrait<"spirv::SignedOp">;
+
 def UsableInSpecConstantOp : NativeOpTrait<"spirv::UsableInSpecConstantOp">;
 
 //===----------------------------------------------------------------------===//
 // SPIR-V opcode specification
 //===----------------------------------------------------------------------===//
 
 class SPV_OpCode<string name, int val> {
   // Name used as reference to retrieve the opcode

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

def SPV_BitFieldInsertOp : SPV_Op<"BitFieldInsert",
 
   let assemblyFormat = [{
     operands attr-dict `:` type($base) `,` type($offset) `,` type($count)
   }];
 }
 
 // -----
 
-def SPV_BitFieldSExtractOp : SPV_BitFieldExtractOp<"BitFieldSExtract", []> {
+def SPV_BitFieldSExtractOp : SPV_BitFieldExtractOp<"BitFieldSExtract",
+                                                   [SignedOp]> {
   let summary = "Extract a bit field from an object, with sign extension.";
 
   let description = [{
      Results are computed per component.
 
     Result Type must be a scalar or vector of integer type.
 
      The type of Base must be the same as Result Type.

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

let description = [{
     ```
   }];
 
   let verifier = [{ return verifyCastOp(this->getOperation(), false, true); }];
 }
 
 // -----
 
-def SPV_ConvertSToFOp : SPV_CastOp<"ConvertSToF", SPV_Float, SPV_Integer, []> {
+def SPV_ConvertSToFOp : SPV_CastOp<"ConvertSToF",
+                                   SPV_Float,
+                                   SPV_Integer,
+                                   [SignedOp]> {
   let summary = [{
     Convert value numerically from signed integer to floating point.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
 
     Signed Value must be a scalar or vector of integer type.  It must have
let description = [{
     ```
   }];
 
   let verifier = [{ return verifyCastOp(this->getOperation(), false); }];
 }
 
 // -----
 
-def SPV_SConvertOp : SPV_CastOp<"SConvert", SPV_Integer, SPV_Integer, [UsableInSpecConstantOp]> {
+def SPV_SConvertOp : SPV_CastOp<"SConvert",
+                                SPV_Integer,
+                                SPV_Integer,
+                                [UsableInSpecConstantOp, SignedOp]> {
   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

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

def SPV_LogicalOrOp : SPV_LogicalBinaryOp<"LogicalOr",
 
   let hasFolder = 1;
 }
 
 // -----
 
 def SPV_SGreaterThanOp : SPV_LogicalBinaryOp<"SGreaterThan",
                                              SPV_Integer,
-                                             [UsableInSpecConstantOp]> {
+                                             [UsableInSpecConstantOp, SignedOp]> {
   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 = [{
     ```
   }];
 }
 
 // -----
 
 def SPV_SGreaterThanEqualOp : SPV_LogicalBinaryOp<"SGreaterThanEqual",
                                                   SPV_Integer,
-                                                  [UsableInSpecConstantOp]> {
+                                                  [UsableInSpecConstantOp,
+                                                   SignedOp]> {
   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 = [{
     ```
   }];
 }
 
 // -----
 
 def SPV_SLessThanOp : SPV_LogicalBinaryOp<"SLessThan",
                                           SPV_Integer,
-                                          [UsableInSpecConstantOp]> {
+                                          [UsableInSpecConstantOp, SignedOp]> {
   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 = [{
     ```
   }];
 }
 
 // -----
 
 def SPV_SLessThanEqualOp : SPV_LogicalBinaryOp<"SLessThanEqual",
                                                SPV_Integer,
-                                               [UsableInSpecConstantOp]> {
+                                               [UsableInSpecConstantOp,
+                                                SignedOp]> {
   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.
 

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

let description = [{
     %1 = spv.GroupNonUniformIMul "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
 }
 
 // -----
 
 def SPV_GroupNonUniformSMaxOp :
-    SPV_GroupNonUniformArithmeticOp<"GroupNonUniformSMax", SPV_Integer, []> {
+    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 = [{
     Result Type  must be a scalar or vector of integer type.
 
let description = [{
     %1 = spv.GroupNonUniformSMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
 }
 
 // -----
 
 def SPV_GroupNonUniformSMinOp :
-    SPV_GroupNonUniformArithmeticOp<"GroupNonUniformSMin", SPV_Integer, []> {
+    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 = [{
     Result Type  must be a scalar or vector of integer type.
 

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

 
 namespace mlir {
 namespace OpTrait {
 namespace spirv {
 
 template <typename ConcreteType>
 class UnsignedOp : public TraitBase<ConcreteType, UnsignedOp> {};
 
+template <typename ConcreteType>
+class SignedOp : public TraitBase<ConcreteType, SignedOp> {};
+
 /// 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_