Update to unspecified overflow behavior of int mul

* Do not use saturating multiplication
* Emit a warning if overflows occur
* Check the behavior in a test
* Add a test with a small bit width which would overflow if the mul
  wouldn't always result a 32-bit int

Author: TinaAMD

mlir/lib/Dialect/Tosa/Transforms/TosaFoldConstantMul.cpp

@@ -74,23 +74,26 @@ struct TosaFoldConstantMul : public OpRewritePattern<MulOp> {
       assert(isa<IntegerType>(rhsElemType) &&
              isa<IntegerType>(resultElementType));
       auto resultElementWidth = resultElementType.getIntOrFloatBitWidth();
-      assert(resultElementWidth == 32 &&
-             "All integer multiplications in TOSA are specified to result in "
-             "32 bit width");
+      assert(resultElementWidth >= lhsElemType.getIntOrFloatBitWidth() &&
+             "The multiplication is expected to have an at least a big  output "
+             "as input type");
       // TODO: To implement shifts > 0, capture the shift value stored in the
       // mul here
-      auto intMulFun = [&resultElementWidth](const APInt &first,
-                                             const APInt &second) {
-        // TODO the documentation has conflicting definitions for the behavior
-        // of overflows
-        // The sign extend should always be valid as the result type is required
-        // to be i32 and all other integer input types are smaller or equal
-        // to 32.
-        return first.sext(resultElementWidth)
-            .smul_sat(second.sext(resultElementWidth));
+      bool mulOverflowed;
+      auto intMulFun = [&resultElementWidth, &mulOverflowed](
+                           const APInt &first, const APInt &second) {
+        bool didOverflow;
+        auto res = first.sext(resultElementWidth)
+                       .smul_ov(second.sext(resultElementWidth), didOverflow);
+        mulOverflowed |= didOverflow;
+        return res;
       };
       newTensor = applyElementWise<APInt, APInt>(lhsValues, rhsValues,
                                                  resultType, intMulFun);
+      if (mulOverflowed) {
+        mulOp.emitWarning(
+            "Multiplication did overflow. The results are unspecified.");
+      }
     } else {
       assert(isa<FloatType>(lhsElemType) && isa<FloatType>(rhsElemType) &&
              isa<FloatType>(resultType.getElementType()));

mlir/test/Dialect/Tosa/constant-mul-opt.mlir

@@ -73,14 +73,28 @@ func.func @mul_fold_int() -> tensor<4xi32> {
   return %2 : tensor<4xi32>
 }
 
-// -----
-// self-multiplication
+// CHECK-LABEL: @mul_fold_i8
+func.func @mul_fold_i8() -> tensor<4xi32> {
+  // CHECK: [[RES:]] ={{.*}}tosa.const{{.*}}204, -12, 0, 0
+  // CHECK-NOT: tosa.mul
+  // CHECK: return [[RES]]
+  %0 = "tosa.const"() {value =
+                        dense<[-17, 4, -2, 0]> :
+                        tensor<4xi8>
+                      } : () -> tensor<4xi8>
+  %1 = "tosa.const"() {value =
+                        dense<[-12, -3, 0, 5]> :
+                        tensor<4xi8>
+                      } : () -> tensor<4xi8>
+  %2 = "tosa.mul"(%0, %1) {shift = 0 : i32} : (tensor<4xi8>, tensor<4xi8>) -> tensor<4xi32>
+  return %2 : tensor<4xi32>
+}
 
 // CHECK-LABEL: @mul_fold_int_overflow
-// TODO: Change expected behavior if the tosa.mul on i32 should not be
-// saturating. Also add a test with different widths in that case.
 func.func @mul_fold_int_overflow() -> tensor<4xi32> {
-  // CHECK: [[RES:]] ={{.*}}tosa.const{{.*}}2147483647, 2147483647, -2147483648, -2147483648
+  // Don't expect any specific results for the overflowing multiplication, just
+  // that it is folded.
+  // CHECK: [[RES:]] ={{.*}}tosa.const
   // CHECK-NOT: tosa.mul
   // CHECK: return [[RES]]
   %0 = "tosa.const"() {value =
@@ -91,10 +105,14 @@ func.func @mul_fold_int_overflow() -> tensor<4xi32> {
                         dense<[1, 10, 1, 30]> :
                         tensor<4xi32>
                       } : () -> tensor<4xi32>
+  // expected-warning@below {{Multiplication did overflow. The results are unspecified.}}
   %2 = "tosa.mul"(%0, %1) {shift = 0 : i32} : (tensor<4xi32>, tensor<4xi32>) -> tensor<4xi32>
   return %2 : tensor<4xi32>
 }
 
+// -----
+// self-multiplication
+
 // CHECK-LABEL: @mul_fold_equal_args
 func.func @mul_fold_equal_args() -> tensor<3xi32> {
   // CHECK: [[RES:]] ={{.*}}tosa.const{{.*}}289, 16, 0