[llvm] [InstCombine] Sink IDiv to Select's arm when another is 1 (PR #203478)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Jun 12 01:09:17 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-transforms
Author: Phoebe Wang (phoebewang)
<details>
<summary>Changes</summary>
And the divisor is not 0. For sdiv, limit divisor to constant to avoid signed overflow concern.
Verified by alive tool: https://alive2.llvm.org/ce/z/ao3ffi
Assisted-by: Claude Sonnet 4.6
---
Full diff: https://github.com/llvm/llvm-project/pull/203478.diff
2 Files Affected:
- (modified) llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp (+33)
- (modified) llvm/test/Transforms/InstCombine/div.ll (+95)
``````````diff
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp b/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
index 17ac09c10f41c..66db296f233c1 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
@@ -1508,6 +1508,39 @@ Instruction *InstCombinerImpl::commonIDivTransforms(BinaryOperator &I) {
}
}
+ // X / (select Cond, 1, Y) --> select Cond, X, (X / Y)
+ // X / (select Cond, Y, 1) --> select Cond, (X / Y), X
+ // Division by 1 is a no-op, so we sink the division into the non-1 arm.
+ // For sdiv, limit Y to constant to avoid signed overflow concern.
+ {
+ Value *Cond, *DivY;
+ const APInt *C;
+ if (match(Op1, m_OneUse(m_Select(m_Value(Cond), m_One(), m_Value(DivY))))) {
+ bool Ok = IsSigned ? (match(DivY, m_APInt(C)) && !C->isZero() &&
+ !C->isAllOnes())
+ : isKnownNonZero(DivY, SQ.getWithInstruction(&I));
+ if (Ok) {
+ Value *Divisor = IsSigned ? ConstantInt::get(Ty, *C) : DivY;
+ Value *NewDiv = Builder.CreateBinOp(I.getOpcode(), Op0, Divisor);
+ if (auto *NewDivInst = dyn_cast<BinaryOperator>(NewDiv))
+ NewDivInst->setIsExact(I.isExact());
+ return createSelectInstWithUnknownProfile(Cond, Op0, NewDiv);
+ }
+ }
+ if (match(Op1, m_OneUse(m_Select(m_Value(Cond), m_Value(DivY), m_One())))) {
+ bool Ok = IsSigned ? (match(DivY, m_APInt(C)) && !C->isZero() &&
+ !C->isAllOnes())
+ : isKnownNonZero(DivY, SQ.getWithInstruction(&I));
+ if (Ok) {
+ Value *Divisor = IsSigned ? ConstantInt::get(Ty, *C) : DivY;
+ Value *NewDiv = Builder.CreateBinOp(I.getOpcode(), Op0, Divisor);
+ if (auto *NewDivInst = dyn_cast<BinaryOperator>(NewDiv))
+ NewDivInst->setIsExact(I.isExact());
+ return createSelectInstWithUnknownProfile(Cond, NewDiv, Op0);
+ }
+ }
+ }
+
// (X * Y) / (X * Z) --> Y / Z (and commuted variants)
if (match(Op0, m_Mul(m_Value(X), m_Value(Y)))) {
auto OB0HasNSW = cast<OverflowingBinaryOperator>(Op0)->hasNoSignedWrap();
diff --git a/llvm/test/Transforms/InstCombine/div.ll b/llvm/test/Transforms/InstCombine/div.ll
index fa8e9c9723e4e..dfc21db864fc7 100644
--- a/llvm/test/Transforms/InstCombine/div.ll
+++ b/llvm/test/Transforms/InstCombine/div.ll
@@ -1869,6 +1869,101 @@ define i32 @udiv_and_shl(i32 %a, i32 %b, i32 %c) {
ret i32 %div
}
+; sdiv X, (select Cond, 1, C) --> select Cond, X, (sdiv X, C)
+
+define i32 @sdiv_select_one_false(i32 %a, i1 %b) {
+; CHECK-LABEL: @sdiv_select_one_false(
+; CHECK-NEXT: [[TMP1:%.*]] = sdiv i32 [[A:%.*]], 2
+; CHECK-NEXT: [[DIV:%.*]] = select i1 [[B:%.*]], i32 [[A]], i32 [[TMP1]]
+; CHECK-NEXT: ret i32 [[DIV]]
+;
+ %sub = select i1 %b, i32 1, i32 2
+ %div = sdiv i32 %a, %sub
+ ret i32 %div
+}
+
+; sdiv X, (select Cond, C, 1) --> select Cond, (sdiv X, C), X
+
+define i32 @sdiv_select_one_true(i32 %a, i1 %b) {
+; CHECK-LABEL: @sdiv_select_one_true(
+; CHECK-NEXT: [[TMP1:%.*]] = sdiv i32 [[A:%.*]], 2
+; CHECK-NEXT: [[DIV:%.*]] = select i1 [[B:%.*]], i32 [[TMP1]], i32 [[A]]
+; CHECK-NEXT: ret i32 [[DIV]]
+;
+ %sub = select i1 %b, i32 2, i32 1
+ %div = sdiv i32 %a, %sub
+ ret i32 %div
+}
+
+; udiv X, (select Cond, 1, C) --> select Cond, X, (udiv X, C)
+
+define i32 @udiv_select_one_false(i32 %a, i1 %b) {
+; CHECK-LABEL: @udiv_select_one_false(
+; CHECK-NEXT: [[TMP1:%.*]] = udiv i32 [[A:%.*]], 3
+; CHECK-NEXT: [[DIV:%.*]] = select i1 [[B:%.*]], i32 [[A]], i32 [[TMP1]]
+; CHECK-NEXT: ret i32 [[DIV]]
+;
+ %sub = select i1 %b, i32 1, i32 3
+ %div = udiv i32 %a, %sub
+ ret i32 %div
+}
+
+; udiv X, (select Cond, 1, Y) --> select Cond, X, (udiv X, Y) for known-non-zero variable
+
+define i32 @udiv_select_one_false_nonnull_var(i32 %a, i1 %b, i32 %y) {
+; CHECK-LABEL: @udiv_select_one_false_nonnull_var(
+; CHECK-NEXT: [[YNZ:%.*]] = add nuw i32 [[Y:%.*]], 1
+; CHECK-NEXT: [[TMP1:%.*]] = udiv i32 [[A:%.*]], [[YNZ]]
+; CHECK-NEXT: [[DIV:%.*]] = select i1 [[B:%.*]], i32 [[A]], i32 [[TMP1]]
+; CHECK-NEXT: ret i32 [[DIV]]
+;
+ %ynz = add nuw i32 %y, 1
+ %sub = select i1 %b, i32 1, i32 %ynz
+ %div = udiv i32 %a, %sub
+ ret i32 %div
+}
+
+; negative test - select has multiple uses, not profitable to duplicate div
+
+define i32 @sdiv_select_one_multiuse(i32 %a, i1 %b) {
+; CHECK-LABEL: @sdiv_select_one_multiuse(
+; CHECK-NEXT: [[SUB:%.*]] = select i1 [[B:%.*]], i32 1, i32 2
+; CHECK-NEXT: call void @use(i32 [[SUB]])
+; CHECK-NEXT: [[DIV:%.*]] = sdiv i32 [[A:%.*]], [[SUB]]
+; CHECK-NEXT: ret i32 [[DIV]]
+;
+ %sub = select i1 %b, i32 1, i32 2
+ call void @use(i32 %sub)
+ %div = sdiv i32 %a, %sub
+ ret i32 %div
+}
+
+; negative test - variable divisor (not a constant), does not apply
+
+define i32 @sdiv_select_one_false_var(i32 %a, i1 %b, i32 %y) {
+; CHECK-LABEL: @sdiv_select_one_false_var(
+; CHECK-NEXT: [[SUB:%.*]] = select i1 [[B:%.*]], i32 1, i32 [[Y:%.*]]
+; CHECK-NEXT: [[DIV:%.*]] = sdiv i32 [[A:%.*]], [[SUB]]
+; CHECK-NEXT: ret i32 [[DIV]]
+;
+ %sub = select i1 %b, i32 1, i32 %y
+ %div = sdiv i32 %a, %sub
+ ret i32 %div
+}
+
+; negative test - divisor is -1: sdiv INT_MIN, -1 is UB, must not hoist
+
+define i32 @sdiv_select_one_false_neg1(i32 %a, i1 %b) {
+; CHECK-LABEL: @sdiv_select_one_false_neg1(
+; CHECK-NEXT: [[SUB:%.*]] = select i1 [[B:%.*]], i32 1, i32 -1
+; CHECK-NEXT: [[DIV:%.*]] = sdiv i32 [[A:%.*]], [[SUB]]
+; CHECK-NEXT: ret i32 [[DIV]]
+;
+ %sub = select i1 %b, i32 1, i32 -1
+ %div = sdiv i32 %a, %sub
+ ret i32 %div
+}
+
!0 = !{!"function_entry_count", i64 1000}
;.
; CHECK: [[META0:![0-9]+]] = !{!"function_entry_count", i64 1000}
``````````
</details>
https://github.com/llvm/llvm-project/pull/203478
More information about the llvm-commits
mailing list