[Mlir-commits] [mlir] [mlir][arith] Fold trivial integer division and remainder (PR #212074)
Victor Perez
llvmlistbot at llvm.org
Sat Jul 25 16:27:18 PDT 2026
https://github.com/victor-eds created https://github.com/llvm/llvm-project/pull/212074
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
```
Division or remainder by zero is undefined behaviour, so refining the self and zero-dividend cases to a constant is always valid; no overflow flags are required. The folds return a scalar or splat constant and bail out on shaped types with a dynamic shape.
----
Code generated by Claude Code.
>From e219872f40fc5fbc1ed12582365e49ef778627fb 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
Division or remainder by zero is undefined behaviour, so refining the
self and zero-dividend cases to a constant is always valid; no overflow
flags are required. The folds return a scalar or splat constant and bail
out on shaped types with a dynamic shape.
Signed-off-by: Víctor Pérez Carrasco <victor.pc.upm at gmail.com>
---
mlir/lib/Dialect/Arith/IR/ArithOps.cpp | 67 +++++++++++-
mlir/test/Dialect/Arith/canonicalize.mlir | 119 ++++++++++++++++++++++
2 files changed, 184 insertions(+), 2 deletions(-)
diff --git a/mlir/lib/Dialect/Arith/IR/ArithOps.cpp b/mlir/lib/Dialect/Arith/IR/ArithOps.cpp
index 674577e5764d8..d6420c3a222fa 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
//===----------------------------------------------------------------------===//
@@ -795,6 +808,14 @@ OpFoldResult arith::DivUIOp::fold(FoldAdaptor adaptor) {
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;
@@ -835,6 +856,14 @@ OpFoldResult arith::DivSIOp::fold(FoldAdaptor adaptor) {
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;
@@ -891,6 +920,14 @@ OpFoldResult arith::CeilDivUIOp::fold(FoldAdaptor adaptor) {
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) {
@@ -921,6 +958,14 @@ OpFoldResult arith::CeilDivSIOp::fold(FoldAdaptor adaptor) {
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.
@@ -990,6 +1035,14 @@ OpFoldResult arith::FloorDivSIOp::fold(FoldAdaptor adaptor) {
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>(
@@ -1011,7 +1064,12 @@ OpFoldResult arith::FloorDivSIOp::fold(FoldAdaptor adaptor) {
OpFoldResult arith::RemUIOp::fold(FoldAdaptor adaptor) {
// 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;
@@ -1038,7 +1096,12 @@ Speculation::Speculatability arith::RemUIOp::getSpeculatability() {
OpFoldResult arith::RemSIOp::fold(FoldAdaptor adaptor) {
// 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/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