MLIR: add ceil/floor divide in Standard Dialect

[AlexEichenberger]

Summary

Added support for ceil/floor divide in the standard dialect. It works with signed integers with pos/neg nominator and/or denominator. The formula used as as follows:

c
floorDiv(n, m) {
  x = (m<0) ? 1 : -1
  return (n*m<0) ? - ((-n+x) / m) -1 : n / m

ceilDiv(n, m) {
  x = (m > 0) ? -1 : 1
  return (n*m>0) ? ((n+x) / m) + 1 : - (-n / m)

and was extensively tested before implementation. Note that there are two selects, and the first ones test whether the denominator is postive/negative. This test would go away in affine ceil/floor since the denominator is known to be negative. Since we do not have (I believe) the ability to indicate a non-negative signed integer at this time, the lowering of ceil/floor for affine functions are left in place, as it uses the more efficient technique with only 1 select per operation.

This patch added the constant folding, the canonicalization for div by 1, and lowering to LLVM. There are literal tests for each of these phases, and I added a more exhaustive integration test that verifies the correct results of divide by + or - 10 for integers from -20 to +20.

[ftynse]

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

2849

This does not match the actual opcode

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

3290 ↗

(On Diff #299136)

Please use auto when it improves readability, e.g. when the type is obvious from the RHS because of the cast/template or it would be too long to spell out.

[aartbik]

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

2839

Isn't the "leading bit as sign" a bit too much detail in this comment.
Doesn't it suffice to say that it treats the inputs as signed entities?

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

3065

Just curious, did you make these (and below) column width changes on purpose
or did your editor clean these up automatically? :-)

[silvas]

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

3279 ↗

(On Diff #299136)

Can we instead have patterns that lower this to other std ops? That seems more reusable. Is there anything LLVM-specific here? Much as we have the lib/Dialect/Shape/Transforms/ShapeToShapeLowering.cpp that breaks down shape.num_elements into more primitive shape dialect ops, I think we can do the same here.

you can easily populate such patterns into the std-to-llvm conversion using a function analogous to populateShapeRewritePatterns

[AlexEichenberger]

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

3279 ↗

(On Diff #299136)

@silvas That makes a lot of sense. I wanted to go this direction but was not sure if introducing a new pass would be too intrusive. Technically, since I translate std -> std in order to implement the ceil and floor, that is technically the right approach. Will transform the code to go that route, using the populateShapeRewritePatterns as a model.

[AlexEichenberger]

Followed the suggestion to include the handling of ceil and floor (generic version supporting arbitrary pos/neg nominator/denominator) as a separate std to std pass. I also removed "auto" where easily substituted by the actual type, fixed the description of the ops as requested, and fixed a couple of other suggestions.

[AlexEichenberger]

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

2839

I adjusted the prior definition of div; it is now simplified a bit, agreed it was a bit fussy.

2849

Thanks, fixed that

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

3290 ↗

(On Diff #299136)

replaced by the actual types in the new version.

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

3065

Using VS Code, hope its ok. If not, I can revert the changes manually.

[silvas]

mlir/lib/Dialect/StandardOps/Transforms/StdToStdLowering.cpp

1 ↗

(On Diff #301379)

comment out of date

9 ↗

(On Diff #301379)

comment out of date

15 ↗

(On Diff #301379)

can you trim down this list of includes?

37 ↗

(On Diff #301379)

nit: remove blank line

80 ↗

(On Diff #301379)

nit: remove blank line.

136 ↗

(On Diff #301379)

mlir:: shouldn't be needed.

[silvas]

Thanks for factoring out the std-to-std! That part looks good! (consider my drive-by comment addressed :) )

[AlexEichenberger]

@silvas Will push an update with fixes for your comment. One thing I do not know and input would be appreciated. Should this pass be added in the "mlir driver"? If so, can you recommend where the pass should be added. Thanks

[silvas]

In D89726#2360204, @AlexEichenberger wrote:

@silvas Will push an update with fixes for your comment. One thing I do not know and input would be appreciated. Should this pass be added in the "mlir driver"? If so, can you recommend where the pass should be added. Thanks

There is currently no "mlir driver" (in the sense of "clang driver" that sets up all the needed passes). I'm in the process of trying to add a concept of a "reference backend" to MLIR upstream which would be a great place to include this pass.

[AlexEichenberger]

removed redundant includes and mlir:: qualifier, corrected the comments copied over (sorry)

[ftynse]

mlir/include/mlir/Dialect/StandardOps/Transforms/Passes.td

25

I'd use a more descriptive name. What about std-expand-divs? (both "std-to-std" and "lowering" sound out of place in the general pass list)

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

3512

This actually fits into 80 cols... Your editor seems to be using 78. Let's please avoid spurious stylistic changes for places that don't contradict our current style guide.

mlir/lib/Dialect/StandardOps/Transforms/StdToStdLowering.cpp

55 ↗

(On Diff #301419)

This can overflow on relatively small numbers... Let's just use logic operations instead:
%nneg = cmpi "lt" %n, 0
%mneg = cmpi "lt" %m, 0
%resneg = xor %nneg, %mneg

mlir/test/Transforms/constant-fold.mlir

438

Please don't check irrelevant pieces of the IR. Here, -NEXT does not look necessary, neither does the check for values being returned from the function (return is only necessary to prevent DCE).

[AlexEichenberger]

responded to comments, including the removal of the n*m>0 test that may overflow by a logical equivalent using n and m compares only.

[AlexEichenberger]

mlir/include/mlir/Dialect/StandardOps/Transforms/Passes.td

25

@ftynse Context: my original implementation had this inside the std-to-llvm lowering, and then @silvas recommended to do a separate pass taking Shape to Shape as an example. The generic name anticipates that there may be additional ops that would use a std to std lowering scheme.

Given that background, if you still want the more specific name, I have no problems doing so.

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

3065

Reverted all changes to comments

3512

Thanks for the explanation. Did revert all these spurious changes.

mlir/lib/Dialect/StandardOps/Transforms/StdToStdLowering.cpp

55 ↗

(On Diff #301419)

Implemented your changes, had to be a bit careful to properly handle the cases where n is zero. Tested the changes systematically to make sure the code is equivalent.

Thanks for this good suggestion.

9 ↗

(On Diff #301379)

updated both out of date comments

15 ↗

(On Diff #301379)

Good catch, did prune the list.

136 ↗

(On Diff #301379)

thanks, removed

mlir/test/Transforms/constant-fold.mlir

438

removed the check on the return, here and other places I had the same pattern.

[ftynse]

mlir/include/mlir/Dialect/StandardOps/Transforms/Passes.td

25

Shape-to-shape is more of an outlier than a rule. I didn't catch its name when it was introduced, I would have pushed back :) We usually reserve X-to-Y pass names for conversions between dialect X and dialect Y. The main goal of a pass is thus sufficiently described by the pass name. We have passes that consume and produce the same dialect and use descriptive names for those. Imagine if we had -scf-to-scf or -affine-to-affine that does all the transformations respective passes currently do (tiling, fusion, permutation, unrolling) based on some additional options? We also managed to survive without "standard-to-standard" transformations for over 2 years, so I don't think provisioning a name for some future transformations that fall into that category is necessary. Even if we did, it is not guaranteed that somebody will always need all of the transformations that would be eventually included in such a pass.

Bottomline, please use a more descriptive name :)

[AlexEichenberger]

mlir/include/mlir/Dialect/StandardOps/Transforms/Passes.td

25

That make perfect sense. Will change ASAP.

[AlexEichenberger]

implemented the requested changes, including the pass name change from -std-to-std-lowering to -std-expand-divs.

[AlexEichenberger]

renamed pattern rewriter function to match the StdExpandDivs theme.

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

let description = [{
     // Tensor element-wise integer division.
     %x = divis %y, %z : tensor<4x?xi8>
     ```
   }];
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
+// SignedFloorDivIOp
+//===----------------------------------------------------------------------===//
+
+def SignedFloorDivIOp : IntArithmeticOp<"floordivi_signed"> {
+  let summary = "signed floor integer division operation";
+  let description = [{
+    Syntax:
+
+    ```
+    operation ::= ssa-id `=` `floordivi_signed` ssa-use `,` ssa-use `:` type
+    ```
+
+    Signed integer division. Rounds towards negative infinity, i.e. `5 / -2 = -3`.
+
+    Note: the semantics of division by zero or signed division overflow (minimum
+    value divided by -1) is TBD; do NOT assume any specific behavior.
+
+    Example:
+
+    ```mlir
+    // Scalar signed integer division.
+    %a = floordivi_signed %b, %c : i64
+
+    ```
+  }];
+  let hasFolder = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// SignedCeilDivIOp
+//===----------------------------------------------------------------------===//
+
+def SignedCeilDivIOp : IntArithmeticOp<"ceildivi_signed"> {
+  let summary = "signed ceil integer division operation";
+  let description = [{
+    Syntax:
+
+    ```
+    operation ::= ssa-id `=` `ceildivi_signed` ssa-use `,` ssa-use `:` type
+    ```
+
+    Signed integer division. Rounds towards positive infinity, i.e. `7 / -2 = -3`.
+
+    Note: the semantics of division by zero or signed division overflow (minimum
+    value divided by -1) is TBD; do NOT assume any specific behavior.
+
+    Example:
+
+    ```mlir
+    // Scalar signed integer division.
+    %a = ceildivi_signed %b, %c : i64
+    ```
+  }];
+  let hasFolder = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // SignedRemIOp
 //===----------------------------------------------------------------------===//
 
 def SignedRemIOp : IntArithmeticOp<"remi_signed"> {
   let summary = "signed integer division remainder operation";
   let description = [{
     Syntax:
 

mlir/include/mlir/Dialect/StandardOps/Transforms/Passes.h

void populateStdBufferizePatterns(MLIRContext *context,
                                   OwningRewritePatternList &patterns);
 
 /// Creates an instance of std bufferization pass.
 std::unique_ptr<Pass> createStdBufferizePass();
 
 /// Creates an instance of func bufferization pass.
 std::unique_ptr<Pass> createFuncBufferizePass();
 
+/// Creates an instance of the StdExpandDivs pass that legalizes Std
+/// dialect Divs to be convertible to StaLLVMndard. For example,
+/// `std.ceildivi_signed` get transformed to a number of std operations,
+/// which can be lowered to LLVM.
+std::unique_ptr<Pass> createStdExpandDivsPass();
+
+/// Collects a set of patterns to rewrite ops within the Std dialect.
+void populateStdExpandDivsRewritePatterns(MLIRContext *context,
+                                        OwningRewritePatternList &patterns);
+
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/StandardOps/Transforms/Passes.h.inc"
 
 } // end namespace mlir
 
 #endif // MLIR_DIALECT_STANDARD_TRANSFORMS_PASSES_H_

mlir/include/mlir/Dialect/StandardOps/Transforms/Passes.td

 }
 
 def StdBufferize : FunctionPass<"std-bufferize"> {
   let summary = "Bufferize the std dialect";
   let constructor = "mlir::createStdBufferizePass()";
   let dependentDialects = ["scf::SCFDialect"];
 }
 
+def StdExpandDivs : FunctionPass<"std-expand-divs"> {
+  let summary = "Legalize div std dialect operations to be convertible to LLVM.";
+  let constructor = "mlir::createStdExpandDivsPass()";
+}
+
 def FuncBufferize : Pass<"func-bufferize", "ModuleOp"> {
   let summary = "Bufferize func/call/return ops";
   let description = [{
     A finalizing bufferize pass that bufferizes std.func and std.call ops.
 
     Because this pass updates std.func ops, it must be a module pass. It is
     useful to keep this pass separate from other bufferizations so that the
     other ones can be run at function-level in parallel.

mlir/integration_test/Dialect/Standard/CPU/test-ceil-floor-pos-neg.mlir

+// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -std-expand-divs -convert-vector-to-llvm | \
+// RUN: mlir-cpu-runner -e entry -entry-point-result=void  \
+// RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
+// RUN: FileCheck %s
+
+func @transfer_read_2d(%A : memref<40xi32>, %base1: index) {
+  %i42 = constant -42: i32
+  %f = vector.transfer_read %A[%base1], %i42
+      {permutation_map = affine_map<(d0) -> (d0)>} :
+    memref<40xi32>, vector<40xi32>
+  vector.print %f: vector<40xi32>
+  return
+}
+
+func @entry() {
+  %c0 = constant 0: index
+  %c20 = constant 20: i32
+  %c10 = constant 10: i32
+  %cmin10 = constant -10: i32
+  %A = alloc() : memref<40xi32>
+
+  // print numerator
+  affine.for %i = 0 to 40  {
+    %ii = index_cast %i: index to i32
+    %ii30 = subi %ii, %c20 : i32
+    store %ii30, %A[%i] : memref<40xi32>
+  }
+  call @transfer_read_2d(%A, %c0) : (memref<40xi32>, index) -> ()
+
+  // test with ceil(*, 10)
+  affine.for %i = 0 to 40  {
+    %ii = index_cast %i: index to i32
+    %ii30 = subi %ii, %c20 : i32
+    %val = ceildivi_signed %ii30, %c10 : i32
+    store %val, %A[%i] : memref<40xi32>
+  }
+  call @transfer_read_2d(%A, %c0) : (memref<40xi32>, index) -> ()
+
+    // test with floor(*, 10)
+  affine.for %i = 0 to 40  {
+    %ii = index_cast %i: index to i32
+    %ii30 = subi %ii, %c20 : i32
+    %val = floordivi_signed %ii30, %c10 : i32
+    store %val, %A[%i] : memref<40xi32>
+  }
+  call @transfer_read_2d(%A, %c0) : (memref<40xi32>, index) -> ()
+
+
+  // test with ceil(*, -10)
+  affine.for %i = 0 to 40  {
+    %ii = index_cast %i: index to i32
+    %ii30 = subi %ii, %c20 : i32
+    %val = ceildivi_signed %ii30, %cmin10 : i32
+    store %val, %A[%i] : memref<40xi32>
+  }
+  call @transfer_read_2d(%A, %c0) : (memref<40xi32>, index) -> ()
+
+  // test with floor(*, -10)
+  affine.for %i = 0 to 40  {
+    %ii = index_cast %i: index to i32
+    %ii30 = subi %ii, %c20 : i32
+    %val = floordivi_signed %ii30, %cmin10 : i32
+    store %val, %A[%i] : memref<40xi32>
+  }
+  call @transfer_read_2d(%A, %c0) : (memref<40xi32>, index) -> ()
+
+  return
+}
+
+// List below is aligned for easy manual check
+// legend: num, ceil(num, 10), floor(num, 10), ceil(num, -10), floor(num, -10)
+//  ( -20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 )
+//  (  -2,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2 )
+//  (  -2,  -2,  -2,  -2,  -2,  -2,  -2,  -2,  -2,  -2,  -1, -1,  -1,-1, -1, -1, -1, -1, -1, -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1 )
+//  (   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   1,  1,   1, 1,  1,  1,  1,  1,  1,  1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 )
+//  (   2,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,  0,   0, 0,  0,  0,  0,  0,  0,  0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -2, -2, -2, -2, -2, -2, -2, -2 )
+
+// CHECK:( -20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 )
+// CHECK:( -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2 )
+// CHECK:( -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 )
+// CHECK:( 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 )
+// CHECK:( 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -2, -2, -2, -2, -2, -2, -2, -2 )
 No newline at end of file

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
     if (rhs.getSplatValue<IntegerAttr>().getValue() == 1)
       return lhs();
   }
 
   return overflowOrDiv0 ? Attribute() : result;
 }
 
 //===----------------------------------------------------------------------===//
+// SignedFloorDivIOp
+//===----------------------------------------------------------------------===//
+
+static APInt signedCeilNonnegInputs(APInt a, APInt b, bool &overflow) {
+  // Returns (a-1)/b + 1
+  APInt one(a.getBitWidth(), 1, true); // Signed value 1.
+  APInt val = a.ssub_ov(one, overflow).sdiv_ov(b, overflow);
+  return val.sadd_ov(one, overflow);
+}
+
+OpFoldResult SignedFloorDivIOp::fold(ArrayRef<Attribute> operands) {
+  assert(operands.size() == 2 && "binary operation takes two operands");
+
+  // Don't fold if it would overflow or if it requires a division by zero.
+  bool overflowOrDiv0 = false;
+  auto result = constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, APInt b) {
+    if (overflowOrDiv0 || !b) {
+      overflowOrDiv0 = true;
+      return a;
+    }
+    unsigned bits = a.getBitWidth();
+    APInt zero = APInt::getNullValue(bits);
+    if (a.sge(zero) && b.sgt(zero)) {
+      // Both positive (or a is zero), return a / b.
+      return a.sdiv_ov(b, overflowOrDiv0);
+    } else if (a.sle(zero) && b.slt(zero)) {
+      // Both negative (or a is zero), return -a / -b.
+      APInt posA = zero.ssub_ov(a, overflowOrDiv0);
+      APInt posB = zero.ssub_ov(b, overflowOrDiv0);
+      return posA.sdiv_ov(posB, overflowOrDiv0);
+    } else if (a.slt(zero) && b.sgt(zero)) {
+      // A is negative, b is positive, return - ceil(-a, b).
+      APInt posA = zero.ssub_ov(a, overflowOrDiv0);
+      APInt ceil = signedCeilNonnegInputs(posA, b, overflowOrDiv0);
+      return zero.ssub_ov(ceil, overflowOrDiv0);
+    } else {
+      // A is positive, b is negative, return - ceil(a, -b).
+      APInt posB = zero.ssub_ov(b, overflowOrDiv0);
+      APInt ceil = signedCeilNonnegInputs(a, posB, overflowOrDiv0);
+      return zero.ssub_ov(ceil, overflowOrDiv0);
+    }
+  });
+
+  // Fold out floor division by one. Assumes all tensors of all ones are
+  // splats.
+  if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
+    if (rhs.getValue() == 1)
+      return lhs();
+  } else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {
+    if (rhs.getSplatValue<IntegerAttr>().getValue() == 1)
+      return lhs();
+  }
+
+  return overflowOrDiv0 ? Attribute() : result;
+}
+
+//===----------------------------------------------------------------------===//
+// SignedCeilDivIOp
+//===----------------------------------------------------------------------===//
+
+OpFoldResult SignedCeilDivIOp::fold(ArrayRef<Attribute> operands) {
+  assert(operands.size() == 2 && "binary operation takes two operands");
+
+  // Don't fold if it would overflow or if it requires a division by zero.
+  bool overflowOrDiv0 = false;
+  auto result = constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, APInt b) {
+    if (overflowOrDiv0 || !b) {
+      overflowOrDiv0 = true;
+      return a;
+    }
+    unsigned bits = a.getBitWidth();
+    APInt zero = APInt::getNullValue(bits);
+    if (a.sgt(zero) && b.sgt(zero)) {
+      // Both positive, return ceil(a, b).
+      return signedCeilNonnegInputs(a, b, overflowOrDiv0);
+    } else if (a.slt(zero) && b.slt(zero)) {
+      // Both negative, return ceil(-a, -b).
+      APInt posA = zero.ssub_ov(a, overflowOrDiv0);
+      APInt posB = zero.ssub_ov(b, overflowOrDiv0);
+      return signedCeilNonnegInputs(posA, posB, overflowOrDiv0);
+    } else if (a.slt(zero) && b.sgt(zero)) {
+      // A is negative, b is positive, return - ( -a / b).
+      APInt posA = zero.ssub_ov(a, overflowOrDiv0);
+      APInt div = posA.sdiv_ov(b, overflowOrDiv0);
+      return zero.ssub_ov(div, overflowOrDiv0);
+    } else {
+      // A is positive (or zero), b is negative, return - (a / -b).
+      APInt posB = zero.ssub_ov(b, overflowOrDiv0);
+      APInt div = a.sdiv_ov(posB, overflowOrDiv0);
+      return zero.ssub_ov(div, overflowOrDiv0);
+    }
+  });
+
+  // Fold out floor division by one. Assumes all tensors of all ones are
+  // splats.
+  if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
+    if (rhs.getValue() == 1)
+      return lhs();
+  } else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {
+    if (rhs.getSplatValue<IntegerAttr>().getValue() == 1)
+      return lhs();
+  }
+
+  return overflowOrDiv0 ? Attribute() : result;
+}
+
+//===----------------------------------------------------------------------===//
 // SignedRemIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult SignedRemIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "remi_signed takes two operands");
 
   auto rhs = operands.back().dyn_cast_or_null<IntegerAttr>();
   if (!rhs)
OpFoldResult SplatOp::fold(ArrayRef<Attribute> operands) {
   auto constOperand = operands.front();
   if (!constOperand || !constOperand.isa<IntegerAttr, FloatAttr>())
     return {};
 
   auto shapedType = getType().cast<ShapedType>();
   assert(shapedType.getElementType() == constOperand.getType() &&
          "incorrect input attribute type for folding");
 
   // SplatElementsAttr::get treats single value for second arg as being a splat.
   return SplatElementsAttr::get(shapedType, {constOperand});
 }
 
 //===----------------------------------------------------------------------===//
 // StoreOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(StoreOp op) {
LogicalResult matchAndRewrite(OpType op,
                                 PatternRewriter &rewriter) const override {
     // No constant operand, just return;
     if (llvm::none_of(op.getOperands(), [](Value operand) {
           return matchPattern(operand, m_ConstantIndex());
         }))
       return failure();
 
     // At least one of offsets/sizes/strides is a new constant.
     // Form the new list of operands and constant attributes from the existing.
     SmallVector<Value, 8> newOffsets(op.offsets());
     SmallVector<int64_t, 8> newStaticOffsets =
         extractFromI64ArrayAttr(op.static_offsets());
     assert(newStaticOffsets.size() == op.getSourceRank());
     canonicalizeSubViewPart(newOffsets, newStaticOffsets,
                             ShapedType::isDynamicStrideOrOffset);
 
     SmallVector<Value, 8> newSizes(op.sizes());

mlir/lib/Dialect/StandardOps/Transforms/CMakeLists.txt

 add_mlir_dialect_library(MLIRStandardOpsTransforms
   Bufferize.cpp
   ExpandAtomic.cpp
   ExpandMemRefReshape.cpp
   ExpandTanh.cpp
   FuncBufferize.cpp
   FuncConversions.cpp
+  StdExpandDivs.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/StandardOps/Transforms
 
   DEPENDS
   MLIRStandardTransformsIncGen
 
   LINK_LIBS PUBLIC
   MLIRIR
   MLIRPass
   MLIRSCF
   MLIRStandard
   MLIRTransforms
   )

mlir/lib/Dialect/StandardOps/Transforms/StdExpandDivs.cpp

+//===- StdExpandDivs.cpp - Code to prepare Std for lowring Divs 0to LLVM  -===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file Std transformations to expand Divs operation to help for the
+// lowering to LLVM. Currently implemented tranformations are Ceil and Floor
+// for Signed Integers.
+//
+//===----------------------------------------------------------------------===//
+
+#include "PassDetail.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/Dialect/StandardOps/Transforms/Passes.h"
+#include "mlir/IR/PatternMatch.h"
+
+using namespace mlir;
+
+namespace {
+
+/// Expands SignedCeilDivIOP (n, m) into
+///   1) x = (m > 0) ? -1 : 1
+///   2) (n*m>0) ? ((n+x) / m) + 1 : - (-n / m)
+struct SignedCeilDivIOpConverter : public OpRewritePattern<SignedCeilDivIOp> {
+public:
+  using OpRewritePattern::OpRewritePattern;
+  LogicalResult matchAndRewrite(SignedCeilDivIOp op,
+                                PatternRewriter &rewriter) const final {
+    Location loc = op.getLoc();
+    SignedCeilDivIOp signedCeilDivIOp = cast<SignedCeilDivIOp>(op);
+    Type type = signedCeilDivIOp.getType();
+    Value a = signedCeilDivIOp.lhs();
+    Value b = signedCeilDivIOp.rhs();
+    Value plusOne =
+        rewriter.create<ConstantOp>(loc, rewriter.getIntegerAttr(type, 1));
+    Value zero =
+        rewriter.create<ConstantOp>(loc, rewriter.getIntegerAttr(type, 0));
+    Value minusOne =
+        rewriter.create<ConstantOp>(loc, rewriter.getIntegerAttr(type, -1));
+    // Compute x = (b>0) ? -1 : 1.
+    Value compare = rewriter.create<CmpIOp>(loc, CmpIPredicate::sgt, b, zero);
+    Value x = rewriter.create<SelectOp>(loc, compare, minusOne, plusOne);
+    // Compute positive res: 1 + ((x+a)/b).
+    Value xPlusA = rewriter.create<AddIOp>(loc, x, a);
+    Value xPlusADivB = rewriter.create<SignedDivIOp>(loc, xPlusA, b);
+    Value posRes = rewriter.create<AddIOp>(loc, plusOne, xPlusADivB);
+    // Compute negative res: - ((-a)/b).
+    Value minusA = rewriter.create<SubIOp>(loc, zero, a);
+    Value minusADivB = rewriter.create<SignedDivIOp>(loc, minusA, b);
+    Value negRes = rewriter.create<SubIOp>(loc, zero, minusADivB);
+    // Result is (a*b>0) ? pos result : neg result.
+    // Note, we want to avoid using a*b because of possible overflow.
+    // The case that matters are a>0, a==0, a<0, b>0 and b<0. We do
+    // not particuliarly care if a*b<0 is true or false when b is zero
+    // as this will result in an illegal divide. So `a*b<0` can be reformulated
+    // as `(a<0 && b<0) || (a>0 && b>0)' or `(a<0 && b<0) || (a>0 && b>=0)'.
+    // We pick the first expression here.
+    Value aNeg = rewriter.create<CmpIOp>(loc, CmpIPredicate::slt, a, zero);
+    Value aPos = rewriter.create<CmpIOp>(loc, CmpIPredicate::sgt, a, zero);
+    Value bNeg = rewriter.create<CmpIOp>(loc, CmpIPredicate::slt, b, zero);
+    Value bPos = rewriter.create<CmpIOp>(loc, CmpIPredicate::sgt, b, zero);
+    Value firstTerm = rewriter.create<AndOp>(loc, aNeg, bNeg);
+    Value secondTerm = rewriter.create<AndOp>(loc, aPos, bPos);
+    Value compareRes = rewriter.create<OrOp>(loc, firstTerm, secondTerm);
+    Value res = rewriter.create<SelectOp>(loc, compareRes, posRes, negRes);
+    // Perform substitution and return success.
+    rewriter.replaceOp(op, {res});
+    return success();
+  }
+};
+
+/// Expands SignedFloorDivIOP (n, m) into
+///   1)  x = (m<0) ? 1 : -1
+///   2)  return (n*m<0) ? - ((-n+x) / m) -1 : n / m
+struct SignedFloorDivIOpConverter : public OpRewritePattern<SignedFloorDivIOp> {
+public:
+  using OpRewritePattern::OpRewritePattern;
+  LogicalResult matchAndRewrite(SignedFloorDivIOp op,
+                                PatternRewriter &rewriter) const final {
+    Location loc = op.getLoc();
+    SignedFloorDivIOp signedFloorDivIOp = cast<SignedFloorDivIOp>(op);
+    Type type = signedFloorDivIOp.getType();
+    Value a = signedFloorDivIOp.lhs();
+    Value b = signedFloorDivIOp.rhs();
+    Value plusOne =
+        rewriter.create<ConstantOp>(loc, rewriter.getIntegerAttr(type, 1));
+    Value zero =
+        rewriter.create<ConstantOp>(loc, rewriter.getIntegerAttr(type, 0));
+    Value minusOne =
+        rewriter.create<ConstantOp>(loc, rewriter.getIntegerAttr(type, -1));
+    // Compute x = (b<0) ? 1 : -1.
+    Value compare = rewriter.create<CmpIOp>(loc, CmpIPredicate::slt, b, zero);
+    Value x = rewriter.create<SelectOp>(loc, compare, plusOne, minusOne);
+    // Compute negative res: -1 - ((x-a)/b).
+    Value xMinusA = rewriter.create<SubIOp>(loc, x, a);
+    Value xMinusADivB = rewriter.create<SignedDivIOp>(loc, xMinusA, b);
+    Value negRes = rewriter.create<SubIOp>(loc, minusOne, xMinusADivB);
+    // Compute positive res: a/b.
+    Value posRes = rewriter.create<SignedDivIOp>(loc, a, b);
+    // Result is (a*b<0) ? negative result : positive result.
+    // Note, we want to avoid using a*b because of possible overflow.
+    // The case that matters are a>0, a==0, a<0, b>0 and b<0. We do
+    // not particuliarly care if a*b<0 is true or false when b is zero
+    // as this will result in an illegal divide. So `a*b<0` can be reformulated
+    // as `(a>0 && b<0) || (a>0 && b<0)' or `(a>0 && b<0) || (a>0 && b<=0)'.
+    // We pick the first expression here.
+    Value aNeg = rewriter.create<CmpIOp>(loc, CmpIPredicate::slt, a, zero);
+    Value aPos = rewriter.create<CmpIOp>(loc, CmpIPredicate::sgt, a, zero);
+    Value bNeg = rewriter.create<CmpIOp>(loc, CmpIPredicate::slt, b, zero);
+    Value bPos = rewriter.create<CmpIOp>(loc, CmpIPredicate::sgt, b, zero);
+    Value firstTerm = rewriter.create<AndOp>(loc, aNeg, bPos);
+    Value secondTerm = rewriter.create<AndOp>(loc, aPos, bNeg);
+    Value compareRes = rewriter.create<OrOp>(loc, firstTerm, secondTerm);
+    Value res = rewriter.create<SelectOp>(loc, compareRes, negRes, posRes);
+    // Perform substitution and return success.
+    rewriter.replaceOp(op, {res});
+    return success();
+  }
+};
+
+} // namespace
+
+namespace {
+struct StdExpandDivs : public StdExpandDivsBase<StdExpandDivs> {
+  void runOnFunction() override;
+};
+} // namespace
+
+void StdExpandDivs::runOnFunction() {
+  MLIRContext &ctx = getContext();
+
+  OwningRewritePatternList patterns;
+  populateStdExpandDivsRewritePatterns(&ctx, patterns);
+
+  ConversionTarget target(getContext());
+  target.addLegalDialect<StandardOpsDialect>();
+  target.addIllegalOp<SignedCeilDivIOp>();
+  target.addIllegalOp<SignedFloorDivIOp>();
+  if (failed(
+          applyPartialConversion(getFunction(), target, std::move(patterns))))
+    signalPassFailure();
+}
+
+void mlir::populateStdExpandDivsRewritePatterns(
+    MLIRContext *context, OwningRewritePatternList &patterns) {
+  patterns.insert<SignedCeilDivIOpConverter, SignedFloorDivIOpConverter>(
+      context);
+}
+
+std::unique_ptr<Pass> mlir::createStdExpandDivsPass() {
+  return std::make_unique<StdExpandDivs>();
+}

mlir/test/Dialect/Standard/std-expand-divs.mlir

+// RUN: mlir-opt -std-expand-divs %s -split-input-file | FileCheck %s
+
+// Test floor divide with signed integer
+// CHECK-LABEL:       func @floordivi
+// CHECK-SAME:     ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> i32 {
+func @floordivi(%arg0: i32, %arg1: i32) -> (i32) {
+  %res = floordivi_signed %arg0, %arg1 : i32
+  return %res : i32
+// CHECK:           [[ONE:%.+]] = constant 1 : i32
+// CHECK:           [[ZERO:%.+]] = constant 0 : i32
+// CHECK:           [[MIN1:%.+]] = constant -1 : i32
+// CHECK:           [[CMP1:%.+]] = cmpi "slt", [[ARG1]], [[ZERO]] : i32
+// CHECK:           [[X:%.+]] = select [[CMP1]], [[ONE]], [[MIN1]] : i32
+// CHECK:           [[TRUE1:%.+]] = subi [[X]], [[ARG0]] : i32
+// CHECK:           [[TRUE2:%.+]] = divi_signed [[TRUE1]], [[ARG1]] : i32
+// CHECK:           [[TRUE3:%.+]] = subi [[MIN1]], [[TRUE2]] : i32
+// CHECK:           [[FALSE:%.+]] = divi_signed [[ARG0]], [[ARG1]] : i32
+// CHECK:           [[NNEG:%.+]] = cmpi "slt", [[ARG0]], [[ZERO]] : i32
+// CHECK:           [[NPOS:%.+]] = cmpi "sgt", [[ARG0]], [[ZERO]] : i32
+// CHECK:           [[MNEG:%.+]] = cmpi "slt", [[ARG1]], [[ZERO]] : i32
+// CHECK:           [[MPOS:%.+]] = cmpi "sgt", [[ARG1]], [[ZERO]] : i32
+// CHECK:           [[TERM1:%.+]] = and [[NNEG]], [[MPOS]] : i1
+// CHECK:           [[TERM2:%.+]] = and [[NPOS]], [[MNEG]] : i1
+// CHECK:           [[CMP2:%.+]] = or [[TERM1]], [[TERM2]] : i1
+// CHECK:           [[RES:%.+]] = select [[CMP2]], [[TRUE3]], [[FALSE]] : i32
+}
+
+// -----
+
+// Test ceil divide with signed integer
+// CHECK-LABEL:       func @ceildivi
+// CHECK-SAME:     ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> i32 {
+func @ceildivi(%arg0: i32, %arg1: i32) -> (i32) {
+  %res = ceildivi_signed %arg0, %arg1 : i32
+  return %res : i32
+
+// CHECK:           [[ONE:%.+]] = constant 1 : i32
+// CHECK:           [[ZERO:%.+]] = constant 0 : i32
+// CHECK:           [[MINONE:%.+]] = constant -1 : i32
+// CHECK:           [[CMP1:%.+]] = cmpi "sgt", [[ARG1]], [[ZERO]] : i32
+// CHECK:           [[X:%.+]] = select [[CMP1]], [[MINONE]], [[ONE]] : i32
+// CHECK:           [[TRUE1:%.+]] = addi [[X]], [[ARG0]] : i32
+// CHECK:           [[TRUE2:%.+]] = divi_signed [[TRUE1]], [[ARG1]] : i32
+// CHECK:           [[TRUE3:%.+]] = addi [[ONE]], [[TRUE2]] : i32
+// CHECK:           [[FALSE1:%.+]] = subi [[ZERO]], [[ARG0]] : i32
+// CHECK:           [[FALSE2:%.+]] = divi_signed [[FALSE1]], [[ARG1]] : i32
+// CHECK:           [[FALSE3:%.+]] = subi [[ZERO]], [[FALSE2]] : i32
+// CHECK:           [[NNEG:%.+]] = cmpi "slt", [[ARG0]], [[ZERO]] : i32
+// CHECK:           [[NPOS:%.+]] = cmpi "sgt", [[ARG0]], [[ZERO]] : i32
+// CHECK:           [[MNEG:%.+]] = cmpi "slt", [[ARG1]], [[ZERO]] : i32
+// CHECK:           [[MPOS:%.+]] = cmpi "sgt", [[ARG1]], [[ZERO]] : i32
+// CHECK:           [[TERM1:%.+]] = and [[NNEG]], [[MNEG]] : i1
+// CHECK:           [[TERM2:%.+]] = and [[NPOS]], [[MPOS]] : i1
+// CHECK:           [[CMP2:%.+]] = or [[TERM1]], [[TERM2]] : i1
+// CHECK:           [[RES:%.+]] = select [[CMP2]], [[TRUE3]], [[FALSE3]] : i32
+}

mlir/test/IR/core-ops.mlir

^bb42(%t: tensor<4x4x?xf32>, %f: f32, %i: i32, %idx : index, %j: i64, %half: f16):
   %164 = floorf %f : f32
 
   // CHECK: %{{[0-9]+}} = floorf %cst_8 : vector<4xf32>
   %165 = floorf %vcf32 : vector<4xf32>
 
   // CHECK: %{{[0-9]+}} = floorf %arg0 : tensor<4x4x?xf32>
   %166 = floorf %t : tensor<4x4x?xf32>
 
+  // CHECK: %{{[0-9]+}} = floordivi_signed %arg2, %arg2 : i32
+  %167 = floordivi_signed %i, %i : i32
+
+  // CHECK: %{{[0-9]+}} = floordivi_signed %arg3, %arg3 : index
+  %168 = floordivi_signed %idx, %idx : index
+
+  // CHECK: %{{[0-9]+}} = floordivi_signed %cst_5, %cst_5 : vector<42xi32>
+  %169 = floordivi_signed %vci32, %vci32 : vector<42 x i32>
+
+  // CHECK: %{{[0-9]+}} = floordivi_signed %cst_4, %cst_4 : tensor<42xi32>
+  %170 = floordivi_signed %tci32, %tci32 : tensor<42 x i32>
+
+  // CHECK: %{{[0-9]+}} = ceildivi_signed %arg2, %arg2 : i32
+  %171 = ceildivi_signed %i, %i : i32
+
+  // CHECK: %{{[0-9]+}} = ceildivi_signed %arg3, %arg3 : index
+  %172 = ceildivi_signed %idx, %idx : index
+
+  // CHECK: %{{[0-9]+}} = ceildivi_signed %cst_5, %cst_5 : vector<42xi32>
+  %173 = ceildivi_signed %vci32, %vci32 : vector<42 x i32>
+
+  // CHECK: %{{[0-9]+}} = ceildivi_signed %cst_4, %cst_4 : tensor<42xi32>
+  %174 = ceildivi_signed %tci32, %tci32 : tensor<42 x i32>
+
   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/Transforms/canonicalize.mlir

func @tensor_divi_unsigned_by_one(%arg0: tensor<4x5xi32>) -> tensor<4x5xi32> {
   %c1 = constant dense<1> : tensor<4x5xi32>
   %res = divi_unsigned %arg0, %c1 : tensor<4x5xi32>
   // CHECK: return %[[ARG]]
   return %res : tensor<4x5xi32>
 }
 
 // -----
 
+// CHECK-LABEL: func @floordivi_signed_by_one
+// CHECK-SAME: %[[ARG:[a-zA-Z0-9]+]]
+func @floordivi_signed_by_one(%arg0: i32) -> (i32) {
+  %c1 = constant 1 : i32
+  %res = floordivi_signed %arg0, %c1 : i32
+  // CHECK: return %[[ARG]]
+  return %res : i32
+}
+
+// CHECK-LABEL: func @tensor_floordivi_signed_by_one
+// CHECK-SAME: %[[ARG:[a-zA-Z0-9]+]]
+func @tensor_floordivi_signed_by_one(%arg0: tensor<4x5xi32>) -> tensor<4x5xi32> {
+  %c1 = constant dense<1> : tensor<4x5xi32>
+  %res = floordivi_signed %arg0, %c1 : tensor<4x5xi32>
+  // CHECK: return %[[ARG]]
+  return %res : tensor<4x5xi32>
+}
+
+// -----
+
+// CHECK-LABEL: func @ceildivi_signed_by_one
+// CHECK-SAME: %[[ARG:[a-zA-Z0-9]+]]
+func @ceildivi_signed_by_one(%arg0: i32) -> (i32) {
+  %c1 = constant 1 : i32
+  %res = ceildivi_signed %arg0, %c1 : i32
+  // CHECK: return %[[ARG]]
+  return %res : i32
+}
+
+// CHECK-LABEL: func @tensor_ceildivi_signed_by_one
+// CHECK-SAME: %[[ARG:[a-zA-Z0-9]+]]
+func @tensor_ceildivi_signed_by_one(%arg0: tensor<4x5xi32>) -> tensor<4x5xi32> {
+  %c1 = constant dense<1> : tensor<4x5xi32>
+  %res = ceildivi_signed %arg0, %c1 : tensor<4x5xi32>
+  // CHECK: return %[[ARG]]
+  return %res : tensor<4x5xi32>
+}
+
+// -----
+
 // CHECK-LABEL: func @memref_cast_folding_subview
 func @memref_cast_folding_subview(%arg0: memref<4x5xf32>, %i: index) -> (memref<?x?xf32, offset:? , strides: [?, ?]>) {
   %0 = memref_cast %arg0 : memref<4x5xf32> to memref<?x?xf32>
   // CHECK-NEXT: subview %{{.*}}: memref<4x5xf32>
   %1 = subview %0[%i, %i][%i, %i][%i, %i]: memref<?x?xf32> to memref<?x?xf32, offset:? , strides: [?, ?]>
   // CHECK-NEXT: return %{{.*}}
   return %1: memref<?x?xf32, offset:? , strides: [?, ?]>
 }

mlir/test/Transforms/constant-fold.mlir

func @divi_unsigned_splat_tensor() -> (tensor<4xi32>, tensor<4xi32>, tensor<4xi32>) {
   %5 = divi_unsigned %0, %z : tensor<4xi32>
 
   // CHECK-NEXT: return [[C3]], [[C0]], [[XZ]]
   return %2, %4, %5 : tensor<4xi32>, tensor<4xi32>, tensor<4xi32>
 }
 
 // -----
 
+// CHECK-LABEL: func @simple_floordivi_signed
+func @simple_floordivi_signed() -> (i32, i32, i32, i32, i32) {
+  // CHECK-DAG: [[C0:%.+]] = constant 0
+  %z = constant 0 : i32
+  // CHECK-DAG: [[C6:%.+]] = constant 7
+  %0 = constant 7 : i32
+  %1 = constant 2 : i32
+
+  // floor(7, 2) = 3
+  // CHECK-NEXT: [[C3:%.+]] = constant 3 : i32
+  %2 = floordivi_signed %0, %1 : i32
+
+  %3 = constant -2 : i32
+
+  // floor(7, -2) = -4
+  // CHECK-NEXT: [[CM3:%.+]] = constant -4 : i32
+  %4 = floordivi_signed %0, %3 : i32
+
+  %5 = constant -9 : i32
+
+  // floor(-9, 2) = -5
+  // CHECK-NEXT: [[CM4:%.+]] = constant -5 : i32
+  %6 = floordivi_signed %5, %1 : i32
+
+  %7 = constant -13 : i32
+
+  // floor(-13, -2) = 6
+  // CHECK-NEXT: [[CM5:%.+]] = constant 6 : i32
+  %8 = floordivi_signed %7, %3 : i32
+
+  // CHECK-NEXT: [[XZ:%.+]] = floordivi_signed [[C6]], [[C0]]
+  %9 = floordivi_signed %0, %z : i32
+
+  return %2, %4, %6, %8, %9 : i32, i32, i32, i32, i32
+}
+
+// -----
+
+// CHECK-LABEL: func @simple_ceildivi_signed
+func @simple_ceildivi_signed() -> (i32, i32, i32, i32, i32) {
+  // CHECK-DAG: [[C0:%.+]] = constant 0
+  %z = constant 0 : i32
+  // CHECK-DAG: [[C6:%.+]] = constant 7
+  %0 = constant 7 : i32
+  %1 = constant 2 : i32
+
+  // ceil(7, 2) = 4
+  // CHECK-NEXT: [[C3:%.+]] = constant 4 : i32
+  %2 = ceildivi_signed %0, %1 : i32
+
+  %3 = constant -2 : i32
+
+  // ceil(7, -2) = -3
+  // CHECK-NEXT: [[CM3:%.+]] = constant -3 : i32
+  %4 = ceildivi_signed %0, %3 : i32
+
+  %5 = constant -9 : i32
+
+  // ceil(-9, 2) = -4
+  // CHECK-NEXT: [[CM4:%.+]] = constant -4 : i32
+  %6 = ceildivi_signed %5, %1 : i32
+
+  %7 = constant -15 : i32
+
+  // ceil(-15, -2) = 8
+  // CHECK-NEXT: [[CM5:%.+]] = constant 8 : i32
+  %8 = ceildivi_signed %7, %3 : i32
+
+  // CHECK-NEXT: [[XZ:%.+]] = ceildivi_signed [[C6]], [[C0]]
+  %9 = ceildivi_signed %0, %z : i32
+
+  return %2, %4, %6, %8, %9 : i32, i32, i32, i32, i32
+}
+
+// -----
+
 // CHECK-LABEL: func @simple_remi_signed
 func @simple_remi_signed(%a : i32) -> (i32, i32, i32) {
   %0 = constant 5 : i32
   %1 = constant 2 : i32
   %2 = constant 1 : i32
   %3 = constant -2 : i32
 
   // CHECK-NEXT:[[C1:%.+]] = constant 1 : i32