[Mlir-commits] [mlir] [mlir][arith] Fold trivial integer division and remainder (PR #212074)
Victor Perez
llvmlistbot at llvm.org
Sun Jul 26 09:07:07 PDT 2026
https://github.com/victor-eds updated https://github.com/llvm/llvm-project/pull/212074
>From e5e0e140224c85bfd2163ebf25f2e32d41323db0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20P=C3=A9rez=20Carrasco?=
<victor.pc.upm at gmail.com>
Date: Sat, 25 Jul 2026 16:06:43 -0700
Subject: [PATCH] [mlir][arith] Fold trivial integer division and remainder
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Add value-preserving folds mirroring LLVM's InstructionSimplify for the
integer division and remainder ops:
divui/divsi/ceildivui/ceildivsi/floordivsi(0, x) -> 0
divui/divsi/ceildivui/ceildivsi/floordivsi(x, x) -> 1
remui/remsi(0, x) -> 0
remui/remsi(x, x) -> 0
The self and zero-dividend cases are valid refinements because division
or remainder by zero is undefined behaviour; no overflow flags are
required. The folds return a scalar or splat constant and bail out on
shaped types with a dynamic shape.
Folding `x / 0` and `x % 0` to poison is left as a TODO: it would make the
arith dialect depend on the ub dialect to materialize `ub.poison`.
LLVM performs the same simplifications: https://godbolt.org/z/dzTjYjs4e
Verified with Alive2:
| Fold | udiv | sdiv | urem | srem |
| :--- | :---: | :---: | :---: | :---: |
| `x / x -> 1`, `x % x -> 0` | [✓](https://alive2.llvm.org/ce/z/YjZCEA) | [✓](https://alive2.llvm.org/ce/z/BSWQrm) | [✓](https://alive2.llvm.org/ce/z/gx5sRH) | [✓](https://alive2.llvm.org/ce/z/VUYkr4) |
| `0 / x -> 0`, `0 % x -> 0` | [✓](https://alive2.llvm.org/ce/z/keqeCZ) | [✓](https://alive2.llvm.org/ce/z/jyf5wm) | [✓](https://alive2.llvm.org/ce/z/fZa6ND) | [✓](https://alive2.llvm.org/ce/z/fo6ss8) |
Signed-off-by: Víctor Pérez Carrasco <victor.pc.upm at gmail.com>
---
mlir/lib/Dialect/Arith/IR/ArithOps.cpp | 95 +++++++++++++-
.../Conversion/ArithToLLVM/arith-to-llvm.mlir | 24 ++--
.../arith-to-spirv-unsupported.mlir | 4 +-
.../ArithToSPIRV/arith-to-spirv.mlir | 22 ++--
mlir/test/Dialect/Arith/canonicalize.mlir | 119 ++++++++++++++++++
5 files changed, 237 insertions(+), 27 deletions(-)
diff --git a/mlir/lib/Dialect/Arith/IR/ArithOps.cpp b/mlir/lib/Dialect/Arith/IR/ArithOps.cpp
index 674577e5764d8..e260ca02509de 100644
--- a/mlir/lib/Dialect/Arith/IR/ArithOps.cpp
+++ b/mlir/lib/Dialect/Arith/IR/ArithOps.cpp
@@ -178,6 +178,19 @@ static Attribute getBoolAttribute(Type type, bool value) {
return DenseElementsAttr::get(shapedType, boolAttr);
}
+/// Return a scalar or splat integer attribute of `type` (an integer/index type
+/// or a shaped type thereof) holding `value`. Returns a null attribute for
+/// shaped types with a dynamic shape, so callers can bail out of folding.
+static Attribute getIntegerAttrOfType(Type type, int64_t value) {
+ auto scalarAttr = IntegerAttr::get(getElementTypeOrSelf(type), value);
+ ShapedType shapedType = dyn_cast<ShapedType>(type);
+ if (!shapedType)
+ return scalarAttr;
+ if (!shapedType.hasStaticShape())
+ return {};
+ return DenseElementsAttr::get(shapedType, scalarAttr);
+}
+
//===----------------------------------------------------------------------===//
// TableGen'd canonicalization patterns
//===----------------------------------------------------------------------===//
@@ -791,10 +804,22 @@ static Value foldDivMul(Value lhs, Value rhs,
}
OpFoldResult arith::DivUIOp::fold(FoldAdaptor adaptor) {
+ // TODO: divui (x, 0) -> poison. Division by zero is undefined behaviour and
+ // could fold to poison, but that would make the arith dialect depend on the
+ // ub dialect to materialize ub.poison; left out for now.
+
// divui (x, 1) -> x.
if (matchPattern(adaptor.getRhs(), m_One()))
return getLhs();
+ // divui (0, x) -> 0. Division by zero is UB, so refining to 0 is valid.
+ if (matchPattern(adaptor.getLhs(), m_Zero()))
+ return getLhs();
+
+ // divui (x, x) -> 1.
+ if (getLhs() == getRhs())
+ return getIntegerAttrOfType(getType(), 1);
+
// (a * b) / b -> a
if (Value val = foldDivMul(getLhs(), getRhs(), IntegerOverflowFlags::nuw))
return val;
@@ -831,10 +856,22 @@ Speculation::Speculatability arith::DivUIOp::getSpeculatability() {
//===----------------------------------------------------------------------===//
OpFoldResult arith::DivSIOp::fold(FoldAdaptor adaptor) {
+ // TODO: divsi (x, 0) -> poison. Division by zero is undefined behaviour and
+ // could fold to poison, but that would make the arith dialect depend on the
+ // ub dialect to materialize ub.poison; left out for now.
+
// divsi (x, 1) -> x.
if (matchPattern(adaptor.getRhs(), m_One()))
return getLhs();
+ // divsi (0, x) -> 0. Division by zero is UB, so refining to 0 is valid.
+ if (matchPattern(adaptor.getLhs(), m_Zero()))
+ return getLhs();
+
+ // divsi (x, x) -> 1.
+ if (getLhs() == getRhs())
+ return getIntegerAttrOfType(getType(), 1);
+
// (a * b) / b -> a
if (Value val = foldDivMul(getLhs(), getRhs(), IntegerOverflowFlags::nsw))
return val;
@@ -887,10 +924,22 @@ static APInt signedCeilNonnegInputs(const APInt &a, const APInt &b,
//===----------------------------------------------------------------------===//
OpFoldResult arith::CeilDivUIOp::fold(FoldAdaptor adaptor) {
+ // TODO: ceildivui (x, 0) -> poison. Division by zero is undefined behaviour
+ // and could fold to poison, but that would make the arith dialect depend on
+ // the ub dialect to materialize ub.poison; left out for now.
+
// ceildivui (x, 1) -> x.
if (matchPattern(adaptor.getRhs(), m_One()))
return getLhs();
+ // ceildivui (0, x) -> 0. Division by zero is UB, so refining to 0 is valid.
+ if (matchPattern(adaptor.getLhs(), m_Zero()))
+ return getLhs();
+
+ // ceildivui (x, x) -> 1.
+ if (getLhs() == getRhs())
+ return getIntegerAttrOfType(getType(), 1);
+
bool overflowOrDiv0 = false;
auto result = constFoldBinaryOp<IntegerAttr>(
adaptor.getOperands(), [&](APInt a, const APInt &b) {
@@ -917,10 +966,22 @@ Speculation::Speculatability arith::CeilDivUIOp::getSpeculatability() {
//===----------------------------------------------------------------------===//
OpFoldResult arith::CeilDivSIOp::fold(FoldAdaptor adaptor) {
+ // TODO: ceildivsi (x, 0) -> poison. Division by zero is undefined behaviour
+ // and could fold to poison, but that would make the arith dialect depend on
+ // the ub dialect to materialize ub.poison; left out for now.
+
// ceildivsi (x, 1) -> x.
if (matchPattern(adaptor.getRhs(), m_One()))
return getLhs();
+ // ceildivsi (0, x) -> 0. Division by zero is UB, so refining to 0 is valid.
+ if (matchPattern(adaptor.getLhs(), m_Zero()))
+ return getLhs();
+
+ // ceildivsi (x, x) -> 1.
+ if (getLhs() == getRhs())
+ return getIntegerAttrOfType(getType(), 1);
+
// Don't fold if it would overflow or if it requires a division by zero.
// TODO: This hook won't fold operations where a = MININT, because
// negating MININT overflows. This can be improved.
@@ -986,10 +1047,22 @@ Speculation::Speculatability arith::CeilDivSIOp::getSpeculatability() {
//===----------------------------------------------------------------------===//
OpFoldResult arith::FloorDivSIOp::fold(FoldAdaptor adaptor) {
+ // TODO: floordivsi (x, 0) -> poison. Division by zero is undefined behaviour
+ // and could fold to poison, but that would make the arith dialect depend on
+ // the ub dialect to materialize ub.poison; left out for now.
+
// floordivsi (x, 1) -> x.
if (matchPattern(adaptor.getRhs(), m_One()))
return getLhs();
+ // floordivsi (0, x) -> 0. Division by zero is UB, so refining to 0 is valid.
+ if (matchPattern(adaptor.getLhs(), m_Zero()))
+ return getLhs();
+
+ // floordivsi (x, x) -> 1.
+ if (getLhs() == getRhs())
+ return getIntegerAttrOfType(getType(), 1);
+
// Don't fold if it would overflow or if it requires a division by zero.
bool overflowOrDiv = false;
auto result = constFoldBinaryOp<IntegerAttr>(
@@ -1009,9 +1082,18 @@ OpFoldResult arith::FloorDivSIOp::fold(FoldAdaptor adaptor) {
//===----------------------------------------------------------------------===//
OpFoldResult arith::RemUIOp::fold(FoldAdaptor adaptor) {
+ // TODO: remui (x, 0) -> poison. Remainder by zero is undefined behaviour and
+ // could fold to poison, but that would make the arith dialect depend on the
+ // ub dialect to materialize ub.poison; left out for now.
+
// remui (x, 1) -> 0.
if (matchPattern(adaptor.getRhs(), m_One()))
- return Builder(getContext()).getZeroAttr(getType());
+ return getIntegerAttrOfType(getType(), 0);
+
+ // remui (0, x) -> 0 and remui (x, x) -> 0. Division by zero is UB, so
+ // refining to 0 is valid.
+ if (matchPattern(adaptor.getLhs(), m_Zero()) || getLhs() == getRhs())
+ return getIntegerAttrOfType(getType(), 0);
// Don't fold if it would require a division by zero.
bool div0 = false;
@@ -1036,9 +1118,18 @@ Speculation::Speculatability arith::RemUIOp::getSpeculatability() {
//===----------------------------------------------------------------------===//
OpFoldResult arith::RemSIOp::fold(FoldAdaptor adaptor) {
+ // TODO: remsi (x, 0) -> poison. Remainder by zero is undefined behaviour and
+ // could fold to poison, but that would make the arith dialect depend on the
+ // ub dialect to materialize ub.poison; left out for now.
+
// remsi (x, 1) -> 0.
if (matchPattern(adaptor.getRhs(), m_One()))
- return Builder(getContext()).getZeroAttr(getType());
+ return getIntegerAttrOfType(getType(), 0);
+
+ // remsi (0, x) -> 0 and remsi (x, x) -> 0. Division by zero is UB, so
+ // refining to 0 is valid.
+ if (matchPattern(adaptor.getLhs(), m_Zero()) || getLhs() == getRhs())
+ return getIntegerAttrOfType(getType(), 0);
// Don't fold if it would require a division by zero.
bool div0 = false;
diff --git a/mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir b/mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir
index 43f21561e6544..d22677fde774a 100644
--- a/mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir
+++ b/mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir
@@ -11,14 +11,14 @@ func.func @vector_ops(%arg0: vector<4xf32>, %arg1: vector<4xi1>, %arg2: vector<4
%0 = arith.constant dense<42.> : vector<4xf32>
// CHECK-NEXT: %1 = llvm.fadd %arg0, %0 : vector<4xf32>
%1 = arith.addf %arg0, %0 : vector<4xf32>
-// CHECK-NEXT: %2 = llvm.sdiv %arg2, %arg2 : vector<4xi64>
- %3 = arith.divsi %arg2, %arg2 : vector<4xi64>
-// CHECK-NEXT: %3 = llvm.udiv %arg2, %arg2 : vector<4xi64>
- %4 = arith.divui %arg2, %arg2 : vector<4xi64>
-// CHECK-NEXT: %4 = llvm.srem %arg2, %arg2 : vector<4xi64>
- %5 = arith.remsi %arg2, %arg2 : vector<4xi64>
-// CHECK-NEXT: %5 = llvm.urem %arg2, %arg2 : vector<4xi64>
- %6 = arith.remui %arg2, %arg2 : vector<4xi64>
+// CHECK-NEXT: %2 = llvm.sdiv %arg2, %arg3 : vector<4xi64>
+ %3 = arith.divsi %arg2, %arg3 : vector<4xi64>
+// CHECK-NEXT: %3 = llvm.udiv %arg2, %arg3 : vector<4xi64>
+ %4 = arith.divui %arg2, %arg3 : vector<4xi64>
+// CHECK-NEXT: %4 = llvm.srem %arg2, %arg3 : vector<4xi64>
+ %5 = arith.remsi %arg2, %arg3 : vector<4xi64>
+// CHECK-NEXT: %5 = llvm.urem %arg2, %arg3 : vector<4xi64>
+ %6 = arith.remui %arg2, %arg3 : vector<4xi64>
// CHECK-NEXT: %6 = llvm.fdiv %arg0, %0 : vector<4xf32>
%7 = arith.divf %arg0, %0 : vector<4xf32>
// CHECK-NEXT: %7 = llvm.frem %arg0, %0 : vector<4xf32>
@@ -780,16 +780,16 @@ func.func @ceildivsi(%arg0 : i64, %arg1 : i64) -> i64 {
}
// CHECK-LABEL: @ceildivui
-// CHECK-SAME: %[[ARG0:.*]]: i32) -> i32
-func.func @ceildivui(%arg0 : i32) -> i32 {
+// CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32) -> i32
+func.func @ceildivui(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK: %[[CST0:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[CMP0:.*]] = llvm.icmp "eq" %[[ARG0]], %[[CST0]] : i32
// CHECK: %[[CST1:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[SUB0:.*]] = llvm.sub %[[ARG0]], %[[CST1]] : i32
-// CHECK: %[[DIV0:.*]] = llvm.udiv %[[SUB0]], %[[ARG0]] : i32
+// CHECK: %[[DIV0:.*]] = llvm.udiv %[[SUB0]], %[[ARG1]] : i32
// CHECK: %[[ADD0:.*]] = llvm.add %[[DIV0]], %[[CST1]] : i32
// CHECK: %[[SEL0:.*]] = llvm.select %[[CMP0]], %[[CST0]], %[[ADD0]] : i1, i32
- %0 = arith.ceildivui %arg0, %arg0 : i32
+ %0 = arith.ceildivui %arg0, %arg1 : i32
return %0: i32
}
diff --git a/mlir/test/Conversion/ArithToSPIRV/arith-to-spirv-unsupported.mlir b/mlir/test/Conversion/ArithToSPIRV/arith-to-spirv-unsupported.mlir
index 92b587d5ed1e4..9ecebb502630c 100644
--- a/mlir/test/Conversion/ArithToSPIRV/arith-to-spirv-unsupported.mlir
+++ b/mlir/test/Conversion/ArithToSPIRV/arith-to-spirv-unsupported.mlir
@@ -53,10 +53,10 @@ func.func @unsupported_2x2elem_vector(%arg0: vector<2x2xi32>) {
// -----
-func.func @int_vector4_invalid(%arg0: vector<2xi16>) {
+func.func @int_vector4_invalid(%arg0: vector<2xi16>, %arg1: vector<2xi16>) {
// expected-error @+2 {{failed to legalize operation 'arith.divui'}}
// expected-error @+1 {{bitwidth emulation is not implemented yet on unsigned op}}
- %0 = arith.divui %arg0, %arg0: vector<2xi16>
+ %0 = arith.divui %arg0, %arg1: vector<2xi16>
return
}
diff --git a/mlir/test/Conversion/ArithToSPIRV/arith-to-spirv.mlir b/mlir/test/Conversion/ArithToSPIRV/arith-to-spirv.mlir
index 5c9966055b540..4cef06992727b 100644
--- a/mlir/test/Conversion/ArithToSPIRV/arith-to-spirv.mlir
+++ b/mlir/test/Conversion/ArithToSPIRV/arith-to-spirv.mlir
@@ -198,18 +198,18 @@ func.func @float32_binary_scalar(%lhs: f32, %rhs: f32) {
// Check int vector types.
// CHECK-LABEL: @int_vector234
-func.func @int_vector234(%arg0: vector<2xi8>, %arg1: vector<4xi64>) {
+func.func @int_vector234(%arg0: vector<2xi8>, %arg1: vector<2xi8>, %arg2: vector<4xi64>, %arg3: vector<4xi64>) {
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<2xi8>
- %0 = arith.divsi %arg0, %arg0: vector<2xi8>
+ %0 = arith.divsi %arg0, %arg1: vector<2xi8>
// CHECK: spirv.UDiv %{{.*}}, %{{.*}}: vector<4xi64>
- %1 = arith.divui %arg1, %arg1: vector<4xi64>
+ %1 = arith.divui %arg2, %arg3: vector<4xi64>
return
}
// CHECK-LABEL: @index_vector
-func.func @index_vector(%arg0: vector<4xindex>) {
+func.func @index_vector(%arg0: vector<4xindex>, %arg1: vector<4xindex>) {
// CHECK: spirv.UMod %{{.*}}, %{{.*}}: vector<4xi32>
- %0 = arith.remui %arg0, %arg0: vector<4xindex>
+ %0 = arith.remui %arg0, %arg1: vector<4xindex>
return
}
@@ -1522,11 +1522,11 @@ func.func @float32_maxnumf_scalar(%arg0 : vector<2xf32>, %arg1 : vector<2xf32>)
// Check int vector types.
// CHECK-LABEL: @int_vector234
-func.func @int_vector234(%arg0: vector<2xi8>, %arg1: vector<4xi64>) {
+func.func @int_vector234(%arg0: vector<2xi8>, %arg1: vector<2xi8>, %arg2: vector<4xi64>, %arg3: vector<4xi64>) {
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<2xi8>
- %0 = arith.divsi %arg0, %arg0: vector<2xi8>
+ %0 = arith.divsi %arg0, %arg1: vector<2xi8>
// CHECK: spirv.UDiv %{{.*}}, %{{.*}}: vector<4xi64>
- %1 = arith.divui %arg1, %arg1: vector<4xi64>
+ %1 = arith.divui %arg2, %arg3: vector<4xi64>
return
}
@@ -1570,11 +1570,11 @@ module attributes {
} {
// CHECK-LABEL: @int_vector23
-func.func @int_vector23(%arg0: vector<2xi8>, %arg1: vector<3xi16>) {
+func.func @int_vector23(%arg0: vector<2xi8>, %arg1: vector<2xi8>, %arg2: vector<3xi16>, %arg3: vector<3xi16>) {
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<2xi32>
- %0 = arith.divsi %arg0, %arg0: vector<2xi8>
+ %0 = arith.divsi %arg0, %arg1: vector<2xi8>
// CHECK: spirv.SDiv %{{.*}}, %{{.*}}: vector<3xi32>
- %1 = arith.divsi %arg1, %arg1: vector<3xi16>
+ %1 = arith.divsi %arg2, %arg3: vector<3xi16>
return
}
diff --git a/mlir/test/Dialect/Arith/canonicalize.mlir b/mlir/test/Dialect/Arith/canonicalize.mlir
index d11b00e1c1e24..5352f777109de 100644
--- a/mlir/test/Dialect/Arith/canonicalize.mlir
+++ b/mlir/test/Dialect/Arith/canonicalize.mlir
@@ -3187,6 +3187,125 @@ func.func @no_fold_divsi_of_muli(%arg0 : index, %arg1 : index) -> index {
// -----
+// CHECK-LABEL: func @divui_zero_dividend
+// CHECK: %[[C0:.+]] = arith.constant 0 : i32
+// CHECK: return %[[C0]]
+func.func @divui_zero_dividend(%arg0 : i32) -> i32 {
+ %c0 = arith.constant 0 : i32
+ %0 = arith.divui %c0, %arg0 : i32
+ return %0 : i32
+}
+
+// CHECK-LABEL: func @divsi_zero_dividend
+// CHECK: %[[C0:.+]] = arith.constant 0 : i32
+// CHECK: return %[[C0]]
+func.func @divsi_zero_dividend(%arg0 : i32) -> i32 {
+ %c0 = arith.constant 0 : i32
+ %0 = arith.divsi %c0, %arg0 : i32
+ return %0 : i32
+}
+
+// CHECK-LABEL: func @divui_self
+// CHECK: %[[C1:.+]] = arith.constant 1 : i32
+// CHECK: return %[[C1]]
+func.func @divui_self(%arg0 : i32) -> i32 {
+ %0 = arith.divui %arg0, %arg0 : i32
+ return %0 : i32
+}
+
+// CHECK-LABEL: func @divsi_self
+// CHECK: %[[C1:.+]] = arith.constant 1 : i32
+// CHECK: return %[[C1]]
+func.func @divsi_self(%arg0 : i32) -> i32 {
+ %0 = arith.divsi %arg0, %arg0 : i32
+ return %0 : i32
+}
+
+// CHECK-LABEL: func @ceildivui_self
+// CHECK: %[[C1:.+]] = arith.constant 1 : i32
+// CHECK: return %[[C1]]
+func.func @ceildivui_self(%arg0 : i32) -> i32 {
+ %0 = arith.ceildivui %arg0, %arg0 : i32
+ return %0 : i32
+}
+
+// CHECK-LABEL: func @ceildivsi_self
+// CHECK: %[[C1:.+]] = arith.constant 1 : i32
+// CHECK: return %[[C1]]
+func.func @ceildivsi_self(%arg0 : i32) -> i32 {
+ %0 = arith.ceildivsi %arg0, %arg0 : i32
+ return %0 : i32
+}
+
+// CHECK-LABEL: func @floordivsi_self
+// CHECK: %[[C1:.+]] = arith.constant 1 : i32
+// CHECK: return %[[C1]]
+func.func @floordivsi_self(%arg0 : i32) -> i32 {
+ %0 = arith.floordivsi %arg0, %arg0 : i32
+ return %0 : i32
+}
+
+// CHECK-LABEL: func @remui_self_and_zero
+// CHECK: %[[C0:.+]] = arith.constant 0 : i32
+// CHECK: return %[[C0]], %[[C0]]
+func.func @remui_self_and_zero(%arg0 : i32) -> (i32, i32) {
+ %c0 = arith.constant 0 : i32
+ %0 = arith.remui %arg0, %arg0 : i32
+ %1 = arith.remui %c0, %arg0 : i32
+ return %0, %1 : i32, i32
+}
+
+// CHECK-LABEL: func @remsi_self_and_zero
+// CHECK: %[[C0:.+]] = arith.constant 0 : i32
+// CHECK: return %[[C0]], %[[C0]]
+func.func @remsi_self_and_zero(%arg0 : i32) -> (i32, i32) {
+ %c0 = arith.constant 0 : i32
+ %0 = arith.remsi %arg0, %arg0 : i32
+ %1 = arith.remsi %c0, %arg0 : i32
+ return %0, %1 : i32, i32
+}
+
+// CHECK-LABEL: func @divui_self_vector
+// CHECK: %[[C1:.+]] = arith.constant dense<1> : vector<4xi32>
+// CHECK: return %[[C1]]
+func.func @divui_self_vector(%arg0 : vector<4xi32>) -> vector<4xi32> {
+ %0 = arith.divui %arg0, %arg0 : vector<4xi32>
+ return %0 : vector<4xi32>
+}
+
+// CHECK-LABEL: func @ceildivui_ceildivsi_floordivsi_zero_dividend
+// CHECK: %[[C0:.+]] = arith.constant 0 : i32
+// CHECK: return %[[C0]], %[[C0]], %[[C0]]
+func.func @ceildivui_ceildivsi_floordivsi_zero_dividend(%arg0 : i32)
+ -> (i32, i32, i32) {
+ %c0 = arith.constant 0 : i32
+ %0 = arith.ceildivui %c0, %arg0 : i32
+ %1 = arith.ceildivsi %c0, %arg0 : i32
+ %2 = arith.floordivsi %c0, %arg0 : i32
+ return %0, %1, %2 : i32, i32, i32
+}
+
+// Distinct operands must not fold to the self identity.
+// CHECK-LABEL: func @divsi_distinct_no_fold
+// CHECK: arith.divsi
+func.func @divsi_distinct_no_fold(%arg0 : i32, %arg1 : i32) -> i32 {
+ %0 = arith.divsi %arg0, %arg1 : i32
+ return %0 : i32
+}
+
+// A dynamic shape must bail out of the self/zero-dividend constant folds.
+// CHECK-LABEL: func @div_rem_self_dynamic_no_fold
+// CHECK: arith.divui
+// CHECK: arith.remui
+func.func @div_rem_self_dynamic_no_fold(%arg0 : tensor<?xi32>)
+ -> (tensor<?xi32>, tensor<?xi32>) {
+ %0 = arith.divui %arg0, %arg0 : tensor<?xi32>
+ %1 = arith.remui %arg0, %arg0 : tensor<?xi32>
+ return %0, %1 : tensor<?xi32>, tensor<?xi32>
+}
+
+// -----
+
// CHECK-LABEL: @test_cmpf(
func.func @test_cmpf(%arg0 : f32) -> (i1, i1, i1, i1) {
// CHECK-DAG: %[[T:.*]] = arith.constant true
More information about the Mlir-commits
mailing list