[llvm] ValueTracking: simplify udiv/urem recurrences (PR #108973)
Ramkumar Ramachandra via llvm-commits
llvm-commits at lists.llvm.org
Thu Nov 7 03:38:50 PST 2024
https://github.com/artagnon updated https://github.com/llvm/llvm-project/pull/108973
>From 9498f466b4ad838526b85e9a61d9801420c1bc25 Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <ramkumar.ramachandra at codasip.com>
Date: Mon, 7 Oct 2024 10:39:08 +0100
Subject: [PATCH 1/3] ValueTracking: simplify udiv/urem recurrences
udiv and urem recurrences have the property that the result can never
exceed the start value. Implement a simplification based on this
property.
---
llvm/lib/Analysis/ValueTracking.cpp | 26 ++++++++++++++++++-
.../ValueTracking/recurrence-knownbits.ll | 10 ++-----
2 files changed, 27 insertions(+), 9 deletions(-)
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index ed3fa35c5b8610..e37007507d9a11 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -1542,6 +1542,28 @@ static void computeKnownBitsFromOperator(const Operator *I,
}
break;
}
+
+ case Instruction::UDiv:
+ // For UDiv, the result can never exceed either the numerator, or the
+ // start value, whichever is greater. The case where the PHI is not
+ // the numerator of the UDiv is already handled by other code.
+ if (BO->getOperand(0) != P)
+ break;
+ [[fallthrough]];
+
+ case Instruction::URem: {
+ // For URem, the result can never exceed the start value.
+ SimplifyQuery RecQ = Q.getWithoutCondContext();
+
+ unsigned OpNum = P->getOperand(0) == R ? 0 : 1;
+ Instruction *RInst = P->getIncomingBlock(OpNum)->getTerminator();
+
+ RecQ.CxtI = RInst;
+ computeKnownBits(R, DemandedElts, Known2, Depth + 1, RecQ);
+ Known.Zero.setHighBits(Known2.countMinLeadingZeros());
+ break;
+ }
+
default:
break;
}
@@ -9039,12 +9061,14 @@ bool llvm::matchSimpleRecurrence(const PHINode *P, BinaryOperator *&BO,
switch (Opcode) {
default:
continue;
- // TODO: Expand list -- xor, div, gep, uaddo, etc..
+ // TODO: Expand list -- xor, gep, uadd.sat etc.
case Instruction::LShr:
case Instruction::AShr:
case Instruction::Shl:
case Instruction::Add:
case Instruction::Sub:
+ case Instruction::UDiv:
+ case Instruction::URem:
case Instruction::And:
case Instruction::Or:
case Instruction::Mul:
diff --git a/llvm/test/Analysis/ValueTracking/recurrence-knownbits.ll b/llvm/test/Analysis/ValueTracking/recurrence-knownbits.ll
index 726b52271c6afb..2907266fe26333 100644
--- a/llvm/test/Analysis/ValueTracking/recurrence-knownbits.ll
+++ b/llvm/test/Analysis/ValueTracking/recurrence-knownbits.ll
@@ -86,12 +86,9 @@ define i64 @test_udiv(i1 %c) {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[IV:%.*]] = phi i64 [ 9, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[IV_NEXT]] = udiv i64 [[IV]], 3
; CHECK-NEXT: br i1 [[C:%.*]], label [[EXIT:%.*]], label [[LOOP]]
; CHECK: exit:
-; CHECK-NEXT: [[RES:%.*]] = and i64 [[IV]], 16
-; CHECK-NEXT: ret i64 [[RES]]
+; CHECK-NEXT: ret i64 0
;
entry:
br label %loop
@@ -132,12 +129,9 @@ define i64 @test_urem(i1 %c) {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[IV:%.*]] = phi i64 [ 3, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT: [[IV_NEXT]] = urem i64 9, [[IV]]
; CHECK-NEXT: br i1 [[C:%.*]], label [[EXIT:%.*]], label [[LOOP]]
; CHECK: exit:
-; CHECK-NEXT: [[RES:%.*]] = and i64 [[IV]], 4
-; CHECK-NEXT: ret i64 [[RES]]
+; CHECK-NEXT: ret i64 0
;
entry:
br label %loop
>From 5de646179dd698b697a4714e119a3add78262a1e Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <ramkumar.ramachandra at codasip.com>
Date: Tue, 5 Nov 2024 15:31:04 +0000
Subject: [PATCH 2/3] ValueTracking: integrate udiv/urem with shift code
---
llvm/lib/Analysis/ValueTracking.cpp | 42 +++++++++++------------------
1 file changed, 15 insertions(+), 27 deletions(-)
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index e37007507d9a11..68fd616bd0f6b1 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -1426,16 +1426,23 @@ static void computeKnownBitsFromOperator(const Operator *I,
// this is sufficient to catch some interesting cases.
unsigned Opcode = BO->getOpcode();
- // If this is a shift recurrence, we know the bits being shifted in.
- // We can combine that with information about the start value of the
- // recurrence to conclude facts about the result.
switch (Opcode) {
+ // If this is a shift recurrence, we know the bits being shifted in. We
+ // can combine that with information about the start value of the
+ // recurrence to conclude facts about the result. If this is a udiv
+ // recurrence, we know that the result can never exceed either the
+ // numerator or the start value, whichever is greater.
case Instruction::LShr:
case Instruction::AShr:
- case Instruction::Shl: {
+ case Instruction::Shl:
+ case Instruction::UDiv:
if (BO->getOperand(0) != I)
break;
+ [[fallthrough]];
+ // For a urem recurrence, the result can never exceed the start value. The
+ // start value could either be the numerator or the denominator.
+ case Instruction::URem: {
// We have matched a recurrence of the form:
// %iv = [R, %entry], [%iv.next, %backedge]
// %iv.next = shift_op %iv, L
@@ -1453,8 +1460,10 @@ static void computeKnownBitsFromOperator(const Operator *I,
Known.Zero.setLowBits(Known2.countMinTrailingZeros());
break;
case Instruction::LShr:
- // A lshr recurrence will preserve the leading zeros of the
- // start value
+ case Instruction::UDiv:
+ case Instruction::URem:
+ // lshr, udiv, and urem recurrences will preserve the leading zeros of
+ // the start value.
Known.Zero.setHighBits(Known2.countMinLeadingZeros());
break;
case Instruction::AShr:
@@ -1543,27 +1552,6 @@ static void computeKnownBitsFromOperator(const Operator *I,
break;
}
- case Instruction::UDiv:
- // For UDiv, the result can never exceed either the numerator, or the
- // start value, whichever is greater. The case where the PHI is not
- // the numerator of the UDiv is already handled by other code.
- if (BO->getOperand(0) != P)
- break;
- [[fallthrough]];
-
- case Instruction::URem: {
- // For URem, the result can never exceed the start value.
- SimplifyQuery RecQ = Q.getWithoutCondContext();
-
- unsigned OpNum = P->getOperand(0) == R ? 0 : 1;
- Instruction *RInst = P->getIncomingBlock(OpNum)->getTerminator();
-
- RecQ.CxtI = RInst;
- computeKnownBits(R, DemandedElts, Known2, Depth + 1, RecQ);
- Known.Zero.setHighBits(Known2.countMinLeadingZeros());
- break;
- }
-
default:
break;
}
>From 23acb5ef3aaf043ab44fd2129c576180f3d532d5 Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <ramkumar.ramachandra at codasip.com>
Date: Wed, 6 Nov 2024 10:25:50 +0000
Subject: [PATCH 3/3] ValueTracking: fix nit in comment
---
llvm/lib/Analysis/ValueTracking.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 68fd616bd0f6b1..52d3468fbe9cae 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -1441,7 +1441,7 @@ static void computeKnownBitsFromOperator(const Operator *I,
[[fallthrough]];
// For a urem recurrence, the result can never exceed the start value. The
- // start value could either be the numerator or the denominator.
+ // phi could either be the numerator or the denominator.
case Instruction::URem: {
// We have matched a recurrence of the form:
// %iv = [R, %entry], [%iv.next, %backedge]
More information about the llvm-commits
mailing list