[mlir] Make division unsigned.

[hgreving]

Summary

Uses arith.divui where it is safe to do so.
Adjusts the tests for above.

[hgreving]

This patch is wrong, abandoning.

[hgreving]

Re-opening

mlir/lib/Dialect/SCF/Utils/Utils.cpp

static Value ceilDivPositive(OpBuilder &builder, Location loc, Value dividend,
                              int64_t divisor) {
   assert(divisor > 0 && "expected positive divisor");
   assert(dividend.getType().isIndex() && "expected index-typed value");
 
   Value divisorMinusOneCst =
       builder.create<arith::ConstantIndexOp>(loc, divisor - 1);
   Value divisorCst = builder.create<arith::ConstantIndexOp>(loc, divisor);
   Value sum = builder.create<arith::AddIOp>(loc, dividend, divisorMinusOneCst);
-  return builder.create<arith::DivSIOp>(loc, sum, divisorCst);
+  return builder.create<arith::DivUIOp>(loc, sum, divisorCst);
 }
 
 // Build the IR that performs ceil division of a positive value by another
 // positive value:
 //    ceildiv(a, b) = divis(a + (b - 1), b)
 // where divis is rounding-to-zero division.
 static Value ceilDivPositive(OpBuilder &builder, Location loc, Value dividend,
                              Value divisor) {
   assert(dividend.getType().isIndex() && "expected index-typed value");
 
   Value cstOne = builder.create<arith::ConstantIndexOp>(loc, 1);
   Value divisorMinusOne = builder.create<arith::SubIOp>(loc, divisor, cstOne);
   Value sum = builder.create<arith::AddIOp>(loc, dividend, divisorMinusOne);
-  return builder.create<arith::DivSIOp>(loc, sum, divisor);
+  return builder.create<arith::DivUIOp>(loc, sum, divisor);
 }
 
 /// Helper to replace uses of loop carried values (iter_args) and loop
 /// yield values while promoting single iteration scf.for ops.
 static void replaceIterArgsAndYieldResults(scf::ForOp forOp) {
   // Replace uses of iter arguments with iter operands (initial values).
   auto iterOperands = forOp.getIterOperands();
   auto iterArgs = forOp.getRegionIterArgs();

mlir/test/Dialect/Affine/loop-coalescing.mlir

func.func @unnormalized_loops() {
   %c10 = arith.constant 10 : index
   %c17 = arith.constant 17 : index
 
   // Number of iterations in the outer scf.
   // CHECK: %[[diff_i:.*]] = arith.subi %[[orig_ub_i]], %[[orig_lb_i]]
   // CHECK: %[[c1:.*]] = arith.constant 1
   // CHECK: %[[step_minus_c1:.*]] = arith.subi %[[orig_step_i]], %[[c1]]
   // CHECK: %[[dividend:.*]] = arith.addi %[[diff_i]], %[[step_minus_c1]]
-  // CHECK: %[[numiter_i:.*]] = arith.divsi %[[dividend]], %[[orig_step_i]]
+  // CHECK: %[[numiter_i:.*]] = arith.divui %[[dividend]], %[[orig_step_i]]
 
   // Normalized lower bound and step for the outer scf.
   // CHECK: %[[lb_i:.*]] = arith.constant 0
   // CHECK: %[[step_i:.*]] = arith.constant 1
 
   // Number of iterations in the inner loop, the pattern is the same as above,
   // only capture the final result.
-  // CHECK: %[[numiter_j:.*]] = arith.divsi {{.*}}, %[[orig_step_j]]
+  // CHECK: %[[numiter_j:.*]] = arith.divui {{.*}}, %[[orig_step_j]]
 
   // New bounds of the outer scf.
   // CHECK: %[[range:.*]] = arith.muli %[[numiter_i]], %[[numiter_j]]
   // CHECK: scf.for %[[i:.*]] = %[[lb_i]] to %[[range]] step %[[step_i]]
   scf.for %i = %c5 to %c10 step %c2 {
     // The inner loop has been removed.
     // CHECK-NOT: scf.for
     scf.for %j = %c7 to %c17 step %c3 {

 // CHECK-SAME: %[[orig_step2:[A-Za-z0-9]+]]:
 func.func @parametric(%lb1 : index, %ub1 : index, %step1 : index,
                  %lb2 : index, %ub2 : index, %step2 : index) {
   // Compute the number of iterations for each of the loops and the total
   // number of iterations.
   // CHECK: %[[range1:.*]] = arith.subi %[[orig_ub1]], %[[orig_lb1]]
   // CHECK: %[[orig_step1_minus_1:.*]] = arith.subi %[[orig_step1]], %c1
   // CHECK: %[[dividend1:.*]] = arith.addi %[[range1]], %[[orig_step1_minus_1]]
-  // CHECK: %[[numiter1:.*]] = arith.divsi %[[dividend1]], %[[orig_step1]]
+  // CHECK: %[[numiter1:.*]] = arith.divui %[[dividend1]], %[[orig_step1]]
   // CHECK: %[[range2:.*]] = arith.subi %[[orig_ub2]], %[[orig_lb2]]
   // CHECK: %[[orig_step2_minus_1:.*]] = arith.subi %arg5, %c1
   // CHECK: %[[dividend2:.*]] = arith.addi %[[range2]], %[[orig_step2_minus_1]]
-  // CHECK: %[[numiter2:.*]] = arith.divsi %[[dividend2]], %[[orig_step2]]
+  // CHECK: %[[numiter2:.*]] = arith.divui %[[dividend2]], %[[orig_step2]]
   // CHECK: %[[range:.*]] = arith.muli %[[numiter1]], %[[numiter2]] : index
 
   // Check that the outer loop is updated.
   // CHECK: scf.for %[[i:.*]] = %c0{{.*}} to %[[range]] step %c1
   scf.for %i = %lb1 to %ub1 step %step1 {
     // Check that the inner loop is removed.
     // CHECK-NOT: scf.for
     scf.for %j = %lb2 to %ub2 step %step2 {

mlir/test/Dialect/SCF/loop-unroll.mlir

 //  UNROLL-BY-2-SAME:  %[[STEP:.*2]]: index,
 //  UNROLL-BY-2-SAME:  %[[MEM:.*3]]: memref<?xf32>
 //
 //   UNROLL-BY-2-DAG:  %[[V0:.*]] = arith.subi %[[UB]], %[[LB]] : index
 //   UNROLL-BY-2-DAG:  %[[C1:.*]] = arith.constant 1 : index
 //   UNROLL-BY-2-DAG:  %[[V1:.*]] = arith.subi %[[STEP]], %[[C1]] : index
 //   UNROLL-BY-2-DAG:  %[[V2:.*]] = arith.addi %[[V0]], %[[V1]] : index
 //       Compute trip count in V3.
-//   UNROLL-BY-2-DAG:  %[[V3:.*]] = arith.divsi %[[V2]], %[[STEP]] : index
+//   UNROLL-BY-2-DAG:  %[[V3:.*]] = arith.divui %[[V2]], %[[STEP]] : index
 //       Store unroll factor in C2.
 //   UNROLL-BY-2-DAG:  %[[C2:.*]] = arith.constant 2 : index
 //   UNROLL-BY-2-DAG:  %[[V4:.*]] = arith.remsi %[[V3]], %[[C2]] : index
 //   UNROLL-BY-2-DAG:  %[[V5:.*]] = arith.subi %[[V3]], %[[V4]] : index
 //   UNROLL-BY-2-DAG:  %[[V6:.*]] = arith.muli %[[V5]], %[[STEP]] : index
 //       Compute upper bound of unrolled loop in V7.
 //   UNROLL-BY-2-DAG:  %[[V7:.*]] = arith.addi %[[LB]], %[[V6]] : index
 //       Compute step of unrolled loop in V8.

 //  UNROLL-BY-3-SAME:  %[[STEP:.*2]]: index,
 //  UNROLL-BY-3-SAME:  %[[MEM:.*3]]: memref<?xf32>
 //
 //   UNROLL-BY-3-DAG:  %[[V0:.*]] = arith.subi %[[UB]], %[[LB]] : index
 //   UNROLL-BY-3-DAG:  %[[C1:.*]] = arith.constant 1 : index
 //   UNROLL-BY-3-DAG:  %[[V1:.*]] = arith.subi %[[STEP]], %[[C1]] : index
 //   UNROLL-BY-3-DAG:  %[[V2:.*]] = arith.addi %[[V0]], %[[V1]] : index
 //       Compute trip count in V3.
-//   UNROLL-BY-3-DAG:  %[[V3:.*]] = arith.divsi %[[V2]], %[[STEP]] : index
+//   UNROLL-BY-3-DAG:  %[[V3:.*]] = arith.divui %[[V2]], %[[STEP]] : index
 //       Store unroll factor in C3.
 //   UNROLL-BY-3-DAG:  %[[C3:.*]] = arith.constant 3 : index
 //   UNROLL-BY-3-DAG:  %[[V4:.*]] = arith.remsi %[[V3]], %[[C3]] : index
 //   UNROLL-BY-3-DAG:  %[[V5:.*]] = arith.subi %[[V3]], %[[V4]] : index
 //   UNROLL-BY-3-DAG:  %[[V6:.*]] = arith.muli %[[V5]], %[[STEP]] : index
 //       Compute upper bound of unrolled loop in V7.
 //   UNROLL-BY-3-DAG:  %[[V7:.*]] = arith.addi %[[LB]], %[[V6]] : index
 //       Compute step of unrolled loop in V8.

 //   CLEANUP-UNROLL-BY-5-DAG:  %[[C3:.*]] = arith.constant 3 : index
 //   CLEANUP-UNROLL-BY-5-NEXT: %[[V0:.*]] = affine.apply {{.*}}
 //   CLEANUP-UNROLL-BY-5-NEXT: memref.store %{{.*}}, %[[MEM]][%[[V0]]] : memref<?xf32>
 //   CLEANUP-UNROLL-BY-5-NEXT: %[[V1:.*]] = affine.apply {{.*}}
 //   CLEANUP-UNROLL-BY-5-NEXT: memref.store %{{.*}}, %[[MEM]][%[[V1]]] : memref<?xf32>
 //   CLEANUP-UNROLL-BY-5-NEXT: %[[V2:.*]] = affine.apply {{.*}}
 //   CLEANUP-UNROLL-BY-5-NEXT: memref.store %{{.*}}, %[[MEM]][%[[V2]]] : memref<?xf32>
 //   CLEANUP-UNROLL-BY-5-NEXT: return
 No newline at end of file

mlir/test/Transforms/parametric-tiling.mlir

 // RUN: mlir-opt -test-extract-fixed-outer-loops='test-outer-loop-sizes=7' %s | FileCheck %s --check-prefixes=COMMON,TILE_7
 // RUN: mlir-opt -test-extract-fixed-outer-loops='test-outer-loop-sizes=7,4' %s | FileCheck %s --check-prefixes=COMMON,TILE_74
 
 // COMMON-LABEL: @rectangular
 func.func @rectangular(%arg0: memref<?x?xf32>) {
   %c2 = arith.constant 2 : index
   %c44 = arith.constant 44 : index
   %c1 = arith.constant 1 : index
   // Range of the original loop:
   //   (upper - lower + step - 1) / step
   // where step is known to be %c1.
   // COMMON:      %[[diff:.*]] = arith.subi %c44, %c2
   // COMMON:      %[[adjustment:.*]] = arith.subi %c1, %c1_{{.*}}
   // COMMON-NEXT: %[[diff_adj:.*]] = arith.addi %[[diff]], %[[adjustment]]
-  // COMMON-NEXT: %[[range:.*]] = arith.divsi %[[diff_adj]], %c1
+  // COMMON-NEXT: %[[range:.*]] = arith.divui %[[diff_adj]], %c1
 
   // Ceildiv to get the parametric tile size.
   // COMMON:       %[[sum:.*]] = arith.addi %[[range]], %c6
-  // COMMON-NEXT:  %[[size:.*]] = arith.divsi %[[sum]], %c7
+  // COMMON-NEXT:  %[[size:.*]] = arith.divui %[[sum]], %c7
   // New outer step (original is %c1).
   // COMMON-NEXT:      %[[step:.*]] = arith.muli %c1, %[[size]]
 
   // Range of the second original loop
   //   (upper - lower + step - 1) / step
   // where step is known to be %c2.
   // TILE_74:      %[[diff2:.*]] = arith.subi %c44, %c1
   // TILE_74:      %[[adjustment2:.*]] = arith.subi %c2, %c1_{{.*}}
   // TILE_74-NEXT: %[[diff2_adj:.*]] = arith.addi %[[diff2]], %[[adjustment2]]
-  // TILE_74-NEXT: %[[range2:.*]] = arith.divsi %[[diff2_adj]], %c2
+  // TILE_74-NEXT: %[[range2:.*]] = arith.divui %[[diff2_adj]], %c2
 
   // Ceildiv to get the parametric tile size for the second original scf.
   // TILE_74:      %[[sum2:.*]] = arith.addi %[[range2]], %c3
-  // TILE_74-NEXT: %[[size2:.*]] = arith.divsi %[[sum2]], %c4
+  // TILE_74-NEXT: %[[size2:.*]] = arith.divui %[[sum2]], %c4
   // New inner step (original is %c2).
   // TILE_74-NEXT:     %[[step2:.*]] = arith.muli %c2, %[[size2]]
 
   // Updated outer loop(s) use new steps.
   // COMMON: scf.for %[[i:.*]] = %c2 to %c44 step %[[step]]
   // TILE_74:scf.for %[[j:.*]] = %c1 to %c44 step %[[step2]]
  scf.for %i = %c2 to %c44 step %c1 {
     // Upper bound for the inner loop min(%i + %step, %c44).
func.func @triangular(%arg0: memref<?x?xf32>) {
   %c44 = arith.constant 44 : index
   %c1 = arith.constant 1 : index
   // Range of the original outer loop:
   //   (upper - lower + step - 1) / step
   // where step is known to be %c1.
   // COMMON:      %[[diff:.*]] = arith.subi %c44, %c2
   // COMMON:      %[[adjustment:.*]] = arith.subi %c1, %c1_{{.*}}
   // COMMON-NEXT: %[[diff_adj:.*]] = arith.addi %[[diff]], %[[adjustment]]
-  // COMMON-NEXT: %[[range:.*]] = arith.divsi %[[diff_adj]], %c1
+  // COMMON-NEXT: %[[range:.*]] = arith.divui %[[diff_adj]], %c1
 
   // Ceildiv to get the parametric tile size.
   // COMMON:       %[[sum:.*]] = arith.addi %[[range]], %c6
-  // COMMON-NEXT:  %[[size:.*]] = arith.divsi %[[sum]], %c7
+  // COMMON-NEXT:  %[[size:.*]] = arith.divui %[[sum]], %c7
   // New outer step (original is %c1).
   // COMMON-NEXT:  %[[step:.*]] = arith.muli %c1, %[[size]]
 
   // Constant adjustment for inner loop has been hoisted out.
   // TILE_74:      %[[adjustment2:.*]] = arith.subi %c2, %c1_{{.*}}
 
   // New outer scf.
   // COMMON: scf.for %[[i:.*]] = %c2 to %c44 step %[[step]]
 
   // Range of the original inner loop
   //   (upper - lower + step - 1) / step
   // where step is known to be %c2.
   // TILE_74:      %[[diff2:.*]] = arith.subi %[[i]], %c1
   // TILE_74-NEXT: %[[diff2_adj:.*]] = arith.addi %[[diff2]], %[[adjustment2]]
-  // TILE_74-NEXT: %[[range2:.*]] = arith.divsi %[[diff2_adj]], %c2
+  // TILE_74-NEXT: %[[range2:.*]] = arith.divui %[[diff2_adj]], %c2
 
   // Ceildiv to get the parametric tile size for the second original scf.
   // TILE_74:      %[[sum2:.*]] = arith.addi %[[range2]], %c3
-  // TILE_74-NEXT: %[[size2:.*]] = arith.divsi %[[sum2]], %c4
+  // TILE_74-NEXT: %[[size2:.*]] = arith.divui %[[sum2]], %c4
   // New inner step (original is %c2).
   // TILE_74-NEXT:     %[[step2:.*]] = arith.muli %c2, %[[size2]]
 
   // New inner scf.
   // TILE_74:scf.for %[[j:.*]] = %c1 to %[[i]] step %[[step2]]
  scf.for %i = %c2 to %c44 step %c1 {
     // Upper bound for the inner loop min(%i + %step, %c44).
     // COMMON:      %[[stepped:.*]] = arith.addi %[[i]], %[[step]]