[MLIR] Add support for signed / unsigned operands for IntArithmeticOp

[andidr]

Summary

Currently, only signless integer operands are allowed for arithmetic integer operations. This commit additionally allows for explicitly signed and explicitly unsigned integer operands.

Minimal testing on std.addi is provided.

[rriddle]

The same constraint applies as described in https://reviews.llvm.org/D76136.

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

 // tensors thereof.  This operation takes two operands and returns one result,
 // each of these is required to be of the same type.  This type may be an
 // integer scalar type, a vector whose element type is an integer type, or an
 // integer tensor.  The custom assembly form of the operation is as follows
 //
 //     <op>i %0, %1 : i32
 class IntArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
     ArithmeticOp<mnemonic, traits>,
-    Arguments<(ins SignlessIntegerLike:$lhs, SignlessIntegerLike:$rhs)>;
+    Arguments<(ins IntegerLike:$lhs, IntegerLike:$rhs)>;
 
 // Base class for standard arithmetic binary operations on floats, vectors and
 // tensors thereof.  This operation has two operands and returns one result,
 // each of these is required to be of the same type.  This type may be a
 // floating point scalar type, a vector whose element type is a floating point
 // type, or a floating point tensor.  The custom assembly form of the operation
 // is as follows
 //

mlir/include/mlir/IR/OpBase.td

 //===----------------------------------------------------------------------===//
 
 // Type constraint for bool-like types: bools, vectors of bools, tensors of
 // bools.
 def BoolLike : TypeConstraint<Or<[I1.predicate, VectorOf<[I1]>.predicate,
                                   TensorOf<[I1]>.predicate]>,
     "bool-like">;
 
+// Type constraint for integer-like types: integers, indices, vectors of
+// integers, tensors of integers.
+def IntegerLike : TypeConstraint<Or<[
+        AnyInteger.predicate, Index.predicate,
+        VectorOf<[AnyInteger]>.predicate,
+        TensorOf<[AnyInteger]>.predicate]>,
+    "integer-like">;
+
 // Type constraint for signless-integer-like types: signless integers, indices,
 // vectors of signless integers, tensors of signless integers.
 def SignlessIntegerLike : TypeConstraint<Or<[
         AnySignlessInteger.predicate, Index.predicate,
         VectorOf<[AnySignlessInteger]>.predicate,
         TensorOf<[AnySignlessInteger]>.predicate]>,
     "signless-integer-like">;
 

mlir/test/IR/core-ops.mlir

^bb0(%a : f32):
 
   // CHECK: %2 = addf %arg0, %arg0 : f32
   %x = "std.addf"(%a, %a) : (f32,f32) -> (f32)
 
   // CHECK:   return
   return
 }
 
-// CHECK-LABEL: func @standard_instrs(%arg0: tensor<4x4x?xf32>, %arg1: f32, %arg2: i32, %arg3: index, %arg4: i64, %arg5: f16) {
-func @standard_instrs(tensor<4x4x?xf32>, f32, i32, index, i64, f16) {
-^bb42(%t: tensor<4x4x?xf32>, %f: f32, %i: i32, %idx : index, %j: i64, %half: f16):
+// CHECK-LABEL: func @standard_instrs(%arg0: tensor<4x4x?xf32>, %arg1: f32, %arg2: i32, %arg3: index, %arg4: i64, %arg5: f16, %arg6: si32, %arg7: ui32) {
+func @standard_instrs(tensor<4x4x?xf32>, f32, i32, index, i64, f16, si32, ui32) {
+^bb42(%t: tensor<4x4x?xf32>, %f: f32, %i: i32, %idx : index, %j: i64, %half: f16, %si: si32, %ui: ui32):
   // CHECK: %0 = dim %arg0, 2 : tensor<4x4x?xf32>
   %a = "std.dim"(%t){index = 2} : (tensor<4x4x?xf32>) -> index
 
   // CHECK: %1 = dim %arg0, 2 : tensor<4x4x?xf32>
   %a2 = dim %t, 2 : tensor<4x4x?xf32>
 
   // CHECK: %2 = addf %arg1, %arg1 : f32
   %f2 = "std.addf"(%f, %f) : (f32,f32) -> f32
^bb42(%t: tensor<4x4x?xf32>, %f: f32, %i: i32, %idx : index, %j: i64, %half: f16, %si: si32, %ui: ui32):
   %143 = fpext %vcf32 : vector<4xf32> to vector<4xf64>
 
   // CHECK: = fptrunc {{.*}} : vector<4xf32> to vector<4xf16>
   %144 = fptrunc %vcf32 : vector<4xf32> to vector<4xf16>
 
   // CHECK: %{{[0-9]+}} = rsqrt %arg1 : f32
   %145 = rsqrt %f : f32
 
+  // CHECK: %{{[0-9]+}} = addi %arg6, %arg6 : si32
+  %146 = "std.addi"(%si, %si) : (si32,si32) -> si32
+
+  // CHECK: %{{[0-9]+}} = addi %{{[0-9]+}}, %{{[0-9]+}} : si32
+  %147 = addi %146, %146 : si32
+
+  // CHECK: %{{[0-9]+}} = addi %arg7, %arg7 : ui32
+  %148 = "std.addi"(%ui, %ui) : (ui32,ui32) -> ui32
+
+  // CHECK: %{{[0-9]+}} = addi %{{[0-9]+}}, %{{[0-9]+}} : ui32
+  %149 = addi %148, %148 : ui32
+
   return
 }
 
 // CHECK-LABEL: func @affine_apply() {
 func @affine_apply() {
   %i = "std.constant"() {value = 0: index} : () -> index
   %j = "std.constant"() {value = 1: index} : () -> index
 

mlir/test/IR/invalid-ops.mlir

 ^bb0(%a : f32):
   %sf = addf{%a, %a} : f32  // expected-error {{expected attribute name}}
 }
 
 // -----
 
 func @func_with_ops(f32) {
 ^bb0(%a : f32):
-  // expected-error@+1 {{'std.addi' op operand #0 must be signless-integer-like}}
+  // expected-error@+1 {{'std.addi' op operand #0 must be integer-like}}
   %sf = addi %a, %a : f32
 }
 
 // -----
 
 func @func_with_ops(i32) {
 ^bb0(%a : i32):
   %sf = addf %a, %a : i32  // expected-error {{'std.addf' op operand #0 must be floating-point-like}}