[llvm] 412eb07 - [indvars] Use fact loop must exit to canonicalize to unsigned conditions
Philip Reames via llvm-commits
llvm-commits at lists.llvm.org
Fri Oct 22 10:32:01 PDT 2021
Author: Philip Reames
Date: 2021-10-22T10:31:36-07:00
New Revision: 412eb07edd4e83afeb1e727e91213e2cbd771f29
URL: https://github.com/llvm/llvm-project/commit/412eb07edd4e83afeb1e727e91213e2cbd771f29
DIFF: https://github.com/llvm/llvm-project/commit/412eb07edd4e83afeb1e727e91213e2cbd771f29.diff
LOG: [indvars] Use fact loop must exit to canonicalize to unsigned conditions
The logic in this patch is that if we find a comparison which would be unsigned except for when the loop is infinite, and we can prove that an infinite loop must be ill defined, we can still make the predicate unsigned.
The eventual goal (combined with a follow on patch) is to use the fact the loop exits to remove the zext (see tests) entirely.
A couple of points worth noting:
* We loose the ability to prove the loop unreachable by committing to the must exit interpretation. If instead, we later proved that rhs was definitely outside the range required for finiteness, we could have killed the loop entirely. (We don't currently implement this transform, but could in theory, do so.)
* simplifyAndExtend has a very limited list of users it walks. In particular, in the examples is stops at the zext and never visits the icmp. (Because we can't fold the zext to an addrec yet in SCEV.) Being willing to visit when we haven't simplified regresses multiple tests (seemingly because of less optimal results when computing trip counts). D112170 explores fixing that, but - at least so far - appears to be too expensive compile time wise.
Differential Revision: https://reviews.llvm.org/D111836
Added:
Modified:
llvm/include/llvm/Analysis/ScalarEvolution.h
llvm/lib/Transforms/Scalar/IndVarSimplify.cpp
llvm/test/Transforms/IndVarSimplify/finite-exit-comparisons.ll
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
index 79e8634775ed..b2f2acbb6f4c 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -1162,6 +1162,18 @@ class ScalarEvolution {
/// Try to apply information from loop guards for \p L to \p Expr.
const SCEV *applyLoopGuards(const SCEV *Expr, const Loop *L);
+ /// Return true if the loop has no abnormal exits. That is, if the loop
+ /// is not infinite, it must exit through an explicit edge in the CFG.
+ /// (As opposed to either a) throwing out of the function or b) entering a
+ /// well defined infinite loop in some callee.)
+ bool loopHasNoAbnormalExits(const Loop *L) {
+ return getLoopProperties(L).HasNoAbnormalExits;
+ }
+
+ /// Return true if this loop is finite by assumption. That is,
+ /// to be infinite, it must also be undefined.
+ bool loopIsFiniteByAssumption(const Loop *L);
+
private:
/// A CallbackVH to arrange for ScalarEvolution to be notified whenever a
/// Value is deleted.
@@ -1482,14 +1494,6 @@ class ScalarEvolution {
return getLoopProperties(L).HasNoSideEffects;
}
- bool loopHasNoAbnormalExits(const Loop *L) {
- return getLoopProperties(L).HasNoAbnormalExits;
- }
-
- /// Return true if this loop is finite by assumption. That is,
- /// to be infinite, it must also be undefined.
- bool loopIsFiniteByAssumption(const Loop *L);
-
/// Compute a LoopDisposition value.
LoopDisposition computeLoopDisposition(const SCEV *S, const Loop *L);
diff --git a/llvm/lib/Transforms/Scalar/IndVarSimplify.cpp b/llvm/lib/Transforms/Scalar/IndVarSimplify.cpp
index 57253abb1be5..4f18f6199b1b 100644
--- a/llvm/lib/Transforms/Scalar/IndVarSimplify.cpp
+++ b/llvm/lib/Transforms/Scalar/IndVarSimplify.cpp
@@ -1435,8 +1435,9 @@ bool IndVarSimplify::canonicalizeExitCondition(Loop *L) {
auto *LHS = ICmp->getOperand(0);
auto *RHS = ICmp->getOperand(1);
- // Avoid computing SCEVs in the loop to avoid poisoning cache with
- // sub-optimal results.
+ // For the range reasoning, avoid computing SCEVs in the loop to avoid
+ // poisoning cache with sub-optimal results. For the must-execute case,
+ // this is a neccessary precondition for correctness.
if (!L->isLoopInvariant(RHS))
continue;
@@ -1450,13 +1451,36 @@ bool IndVarSimplify::canonicalizeExitCondition(Loop *L) {
const unsigned OuterBitWidth = DL.getTypeSizeInBits(RHS->getType());
auto FullCR = ConstantRange::getFull(InnerBitWidth);
FullCR = FullCR.zeroExtend(OuterBitWidth);
- if (!FullCR.contains(SE->getUnsignedRange(SE->getSCEV(RHS))))
+ if (FullCR.contains(SE->getUnsignedRange(SE->getSCEV(RHS)))) {
+ // We have now matched icmp signed-cond zext(X), zext(Y'), and can thus
+ // replace the signed condition with the unsigned version.
+ ICmp->setPredicate(ICmp->getUnsignedPredicate());
+ Changed = true;
+ // Note: No SCEV invalidation needed. We've changed the predicate, but
+ // have not changed exit counts, or the values produced by the compare.
continue;
+ }
- // We have now matched icmp signed-cond zext(X), zext(Y'), and can thus
- // replace the signed condition with the unsigned version.
- ICmp->setPredicate(ICmp->getUnsignedPredicate());
- Changed = true;
+ // If we have a loop which would be undefined if infinite, and it has at
+ // most one possible dynamic exit, then we can conclude that exit must
+ // be taken. If that exit must be taken, and we know the LHS can only
+ // take values in the positive domain, then we can conclude RHS must
+ // also be in that same range, and replace a signed compare with an
+ // unsigned one.
+ // If the exit might not be taken in a well defined program.
+ if (ExitingBlocks.size() == 1 && SE->loopHasNoAbnormalExits(L) &&
+ SE->loopIsFiniteByAssumption(L)) {
+ // We have now matched icmp signed-cond zext(X), zext(Y'), and can thus
+ // replace the signed condition with the unsigned version.
+ ICmp->setPredicate(ICmp->getUnsignedPredicate());
+ Changed = true;
+
+ // Given we've changed exit counts, notify SCEV.
+ // Some nested loops may share same folded exit basic block,
+ // thus we need to notify top most loop.
+ SE->forgetTopmostLoop(L);
+ continue;
+ }
}
return Changed;
}
@@ -1842,10 +1866,9 @@ bool IndVarSimplify::run(Loop *L) {
// Eliminate redundant IV cycles.
NumElimIV += Rewriter.replaceCongruentIVs(L, DT, DeadInsts);
- if (canonicalizeExitCondition(L))
- // We've changed the predicate, but have not changed exit counts, or the
- // values which can flow through any SCEV. i.e, no invalidation needed.
- Changed = true;
+ // Try to convert exit conditions to unsigned
+ // Note: Handles invalidation internally if needed.
+ Changed |= canonicalizeExitCondition(L);
// Try to eliminate loop exits based on analyzeable exit counts
if (optimizeLoopExits(L, Rewriter)) {
diff --git a/llvm/test/Transforms/IndVarSimplify/finite-exit-comparisons.ll b/llvm/test/Transforms/IndVarSimplify/finite-exit-comparisons.ll
index e9192f34f068..ad7126647fb5 100644
--- a/llvm/test/Transforms/IndVarSimplify/finite-exit-comparisons.ll
+++ b/llvm/test/Transforms/IndVarSimplify/finite-exit-comparisons.ll
@@ -105,7 +105,7 @@ define void @slt_non_constant_rhs(i16 %n) mustprogress {
; CHECK-NEXT: [[IV:%.*]] = phi i8 [ [[IV_NEXT:%.*]], [[FOR_BODY]] ], [ 0, [[ENTRY:%.*]] ]
; CHECK-NEXT: [[IV_NEXT]] = add i8 [[IV]], 1
; CHECK-NEXT: [[ZEXT:%.*]] = zext i8 [[IV_NEXT]] to i16
-; CHECK-NEXT: [[CMP:%.*]] = icmp slt i16 [[ZEXT]], [[N:%.*]]
+; CHECK-NEXT: [[CMP:%.*]] = icmp ult i16 [[ZEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
; CHECK: for.end:
; CHECK-NEXT: ret void
@@ -391,7 +391,7 @@ define void @sgt_non_constant_rhs(i16 %n) mustprogress {
; CHECK-NEXT: [[IV:%.*]] = phi i8 [ [[IV_NEXT:%.*]], [[FOR_BODY]] ], [ 0, [[ENTRY:%.*]] ]
; CHECK-NEXT: [[IV_NEXT]] = add i8 [[IV]], 1
; CHECK-NEXT: [[ZEXT:%.*]] = zext i8 [[IV_NEXT]] to i16
-; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i16 [[ZEXT]], [[N:%.*]]
+; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i16 [[ZEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
; CHECK: for.end:
; CHECK-NEXT: ret void
@@ -445,7 +445,7 @@ define void @sle_non_constant_rhs(i16 %n) mustprogress {
; CHECK-NEXT: [[IV:%.*]] = phi i8 [ [[IV_NEXT:%.*]], [[FOR_BODY]] ], [ 0, [[ENTRY:%.*]] ]
; CHECK-NEXT: [[IV_NEXT]] = add i8 [[IV]], 1
; CHECK-NEXT: [[ZEXT:%.*]] = zext i8 [[IV_NEXT]] to i16
-; CHECK-NEXT: [[CMP:%.*]] = icmp sle i16 [[ZEXT]], [[N:%.*]]
+; CHECK-NEXT: [[CMP:%.*]] = icmp ule i16 [[ZEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
; CHECK: for.end:
; CHECK-NEXT: ret void
@@ -499,7 +499,7 @@ define void @sge_non_constant_rhs(i16 %n) mustprogress {
; CHECK-NEXT: [[IV:%.*]] = phi i8 [ [[IV_NEXT:%.*]], [[FOR_BODY]] ], [ 0, [[ENTRY:%.*]] ]
; CHECK-NEXT: [[IV_NEXT]] = add i8 [[IV]], 1
; CHECK-NEXT: [[ZEXT:%.*]] = zext i8 [[IV_NEXT]] to i16
-; CHECK-NEXT: [[CMP:%.*]] = icmp sge i16 [[ZEXT]], [[N:%.*]]
+; CHECK-NEXT: [[CMP:%.*]] = icmp uge i16 [[ZEXT]], [[N:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
; CHECK: for.end:
; CHECK-NEXT: ret void
More information about the llvm-commits
mailing list