[SCEV] Extend isImpliedCondOperandsViaRanges to independent predicates #71110
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
@llvm/pr-subscribers-llvm-transforms Author: Philip Reames (preames) ChangesAs far as I can tell, there's nothing in this code which actually assumes the two predicates in (FoundLHS FoundPred FoundRHS) => (LHS Pred RHS) are the same. Noticed while investigating something else, this is purely an oppurtunistic optimization while I'm looking at the code. Unfortunately, this doesn't solve my original problem. :) Patch is 27.09 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/71110.diff 7 Files Affected:
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
index 2765f1286d8bce5..234c05f48d8edfa 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -1942,7 +1942,9 @@ class ScalarEvolution {
/// true. Utility function used by isImpliedCondOperands. Tries to get
/// cases like "X `sgt` 0 => X - 1 `sgt` -1".
bool isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred, const SCEV *LHS,
- const SCEV *RHS, const SCEV *FoundLHS,
+ const SCEV *RHS,
+ ICmpInst::Predicate FoundPred,
+ const SCEV *FoundLHS,
const SCEV *FoundRHS);
/// Return true if the condition denoted by \p LHS \p Pred \p RHS is implied
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index de24aa986688a1e..476b8cdd0e953d0 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -11753,6 +11753,9 @@ bool ScalarEvolution::isImpliedCondBalancedTypes(
if (isImpliedCondOperands(FoundPred, LHS, RHS, FoundLHS, FoundRHS, CtxI))
return true;
+ if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, FoundPred, FoundLHS, FoundRHS))
+ return true;
+
// Otherwise assume the worst.
return false;
}
@@ -12010,7 +12013,7 @@ bool ScalarEvolution::isImpliedViaMerge(ICmpInst::Predicate Pred,
auto ProvedEasily = [&](const SCEV *S1, const SCEV *S2) {
return isKnownViaNonRecursiveReasoning(Pred, S1, S2) ||
- isImpliedCondOperandsViaRanges(Pred, S1, S2, FoundLHS, FoundRHS) ||
+ isImpliedCondOperandsViaRanges(Pred, S1, S2, Pred, FoundLHS, FoundRHS) ||
isImpliedViaOperations(Pred, S1, S2, FoundLHS, FoundRHS, Depth);
};
@@ -12112,7 +12115,7 @@ bool ScalarEvolution::isImpliedCondOperands(ICmpInst::Predicate Pred,
const SCEV *FoundLHS,
const SCEV *FoundRHS,
const Instruction *CtxI) {
- if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, FoundLHS, FoundRHS))
+ if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, Pred, FoundLHS, FoundRHS))
return true;
if (isImpliedCondOperandsViaNoOverflow(Pred, LHS, RHS, FoundLHS, FoundRHS))
@@ -12464,6 +12467,7 @@ ScalarEvolution::isImpliedCondOperandsHelper(ICmpInst::Predicate Pred,
bool ScalarEvolution::isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred,
const SCEV *LHS,
const SCEV *RHS,
+ ICmpInst::Predicate FoundPred,
const SCEV *FoundLHS,
const SCEV *FoundRHS) {
if (!isa<SCEVConstant>(RHS) || !isa<SCEVConstant>(FoundRHS))
@@ -12478,9 +12482,9 @@ bool ScalarEvolution::isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred,
const APInt &ConstFoundRHS = cast<SCEVConstant>(FoundRHS)->getAPInt();
// `FoundLHSRange` is the range we know `FoundLHS` to be in by virtue of the
- // antecedent "`FoundLHS` `Pred` `FoundRHS`".
+ // antecedent "`FoundLHS` `FoundPred` `FoundRHS`".
ConstantRange FoundLHSRange =
- ConstantRange::makeExactICmpRegion(Pred, ConstFoundRHS);
+ ConstantRange::makeExactICmpRegion(FoundPred, ConstFoundRHS);
// Since `LHS` is `FoundLHS` + `Addend`, we can compute a range for `LHS`:
ConstantRange LHSRange = FoundLHSRange.add(ConstantRange(*Addend));
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll b/llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll
index b238e55bf83eb71..279d4ac581148bd 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll
@@ -63,7 +63,8 @@ define void @ult_infinite_ub() mustprogress {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 2
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
br label %for.body
@@ -88,7 +89,8 @@ define void @ult_129_not_taken() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -111,7 +113,8 @@ define void @ult_129_unknown_start(i8 %start) mustprogress {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -163,7 +166,8 @@ define void @ult_ub1() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 2
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 2
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 3
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 3
;
entry:
br label %for.body
@@ -188,7 +192,8 @@ define void @ult_ub2() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -213,7 +218,8 @@ define void @ult_129_preinc() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 2
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
br label %for.body
@@ -236,7 +242,8 @@ define void @ult_preinc(i8 %step) {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 2
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
%assume = icmp ult i8 128, %step
@@ -313,7 +320,8 @@ define void @slt_wrap() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 63
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 63
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 64
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 64
;
entry:
br label %for.body
@@ -361,7 +369,8 @@ define void @slt_infinite_ub() mustprogress {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -386,7 +395,8 @@ define void @slt_129_not_taken() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -433,7 +443,8 @@ define void @slt_129_unknown_start(i8 %start) mustprogress {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (((127 + (-1 * (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))<nuw><nsw> + (-1 * %start) + (0 smax (-127 + %start)<nsw>)) /u -127) + (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (((127 + (-1 * (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))<nuw><nsw> + (-1 * %start) + (0 smax (-127 + %start)<nsw>)) /u -127) + (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -459,7 +470,8 @@ define void @slt_ub1() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -484,7 +496,8 @@ define void @slt_ub2() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -509,7 +522,8 @@ define void @slt_129_preinc() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 2
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
br label %for.body
@@ -532,7 +546,8 @@ define void @slt_preinc(i8 %step) {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 2
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
%assume = icmp ult i8 128, %step
@@ -601,18 +616,20 @@ declare void @llvm.assume(i1)
define void @step_is_neg_addrec_slt_8(i64 %n) {
; CHECK-LABEL: 'step_is_neg_addrec_slt_8'
; CHECK-NEXT: Determining loop execution counts for: @step_is_neg_addrec_slt_8
-; CHECK-NEXT: Loop %inner: backedge-taken count is (7 /u {0,+,-1}<nuw><nsw><%outer.header>)
+; CHECK-NEXT: Loop %inner: backedge-taken count is (7 /u {0,+,-1}<%outer.header>)
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is 8
-; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is (7 /u {0,+,-1}<nuw><nsw><%outer.header>)
-; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is (7 /u {0,+,-1}<nuw><nsw><%outer.header>)
+; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is (7 /u {0,+,-1}<%outer.header>)
+; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is (7 /u {0,+,-1}<%outer.header>)
; CHECK-NEXT: Predicates:
-; CHECK: Loop %inner: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %inner: Trip multiple is 1
; CHECK-NEXT: Loop %outer.header: backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: constant max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %outer.header: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %outer.header: Trip multiple is 1
;
entry:
br label %outer.header
@@ -648,13 +665,15 @@ define void @step_is_neg_addrec_slt_var(i32 %n) {
; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is ({0,+,1}<nuw><nsw><%outer.header> + ({0,+,-1}<nsw><%outer.header> smax %n))
; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is ({0,+,1}<nuw><nsw><%outer.header> + ({0,+,-1}<nsw><%outer.header> smax %n))
; CHECK-NEXT: Predicates:
-; CHECK: Loop %inner: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %inner: Trip multiple is 1
; CHECK-NEXT: Loop %outer.header: backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: constant max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %outer.header: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %outer.header: Trip multiple is 1
;
entry:
br label %outer.header
@@ -690,13 +709,15 @@ define void @step_is_neg_addrec_unknown_start(i32 %n) {
; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nsw><%outer.header>))
; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nsw><%outer.header>))
; CHECK-NEXT: Predicates:
-; CHECK: Loop %inner: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %inner: Trip multiple is 1
; CHECK-NEXT: Loop %outer.header: backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: constant max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %outer.header: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %outer.header: Trip multiple is 1
;
entry:
br label %outer.header
diff --git a/llvm/test/Transforms/IndVarSimplify/X86/loop-invariant-conditions.ll b/llvm/test/Transforms/IndVarSimplify/X86/loop-invariant-conditions.ll
index 4543ec220dbee2b..24ba862eebc4284 100644
--- a/llvm/test/Transforms/IndVarSimplify/X86/loop-invariant-conditions.ll
+++ b/llvm/test/Transforms/IndVarSimplify/X86/loop-invariant-conditions.ll
@@ -109,8 +109,7 @@ define void @test3(i64 %start) {
; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i64 [[START]], -1
-; CHECK-NEXT: br i1 [[CMP1]], label [[FOR_END]], label [[LOOP]]
+; CHECK-NEXT: br i1 false, label [[FOR_END]], label [[LOOP]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -136,17 +135,15 @@ for.end: ; preds = %if.end, %entry
define void @test3.next(i64 %start) {
; CHECK-LABEL: @test3.next(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = add nsw i64 [[START:%.*]], 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
+; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], 25
; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i64 [[TMP0]], 0
-; CHECK-NEXT: br i1 [[CMP1]], label [[FOR_END]], label [[LOOP]]
+; CHECK-NEXT: br i1 false, label [[FOR_END]], label [[LOOP]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -181,8 +178,7 @@ define void @test4(i64 %start) {
; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp sgt i64 [[START]], -1
-; CHECK-NEXT: br i1 [[CMP1]], label [[LOOP]], label [[FOR_END]]
+; CHECK-NEXT: br i1 true, label [[LOOP]], label [[FOR_END]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -208,17 +204,15 @@ for.end: ; preds = %if.end, %entry
define void @test4.next(i64 %start) {
; CHECK-LABEL: @test4.next(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = add nsw i64 [[START:%.*]], 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
+; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], 25
; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp sgt i64 [[TMP0]], 0
-; CHECK-NEXT: br i1 [[CMP1]], label [[LOOP]], label [[FOR_END]]
+; CHECK-NEXT: br i1 true, label [[LOOP]], label [[FOR_END]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -246,14 +240,12 @@ define void @test5(i64 %start) {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
-; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nuw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT: [[INDVARS_IV_NEXT:%.*]] = add nuw i64 [[START:%.*]], 1
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], 25
-; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
+; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE:%.*]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp ugt i64 [[START]], 100
-; CHECK-NEXT: br i1 [[CMP1]], label [[LOOP]], label [[FOR_END]]
+; CHECK-NEXT: br i1 false, label [[LOOP]], label [[FOR_END]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -279,17 +271,14 @@ for.end: ; preds = %if.end, %entry
define void @test5.next(i64 %start) {
; CHECK-LABEL: @test5.next(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = add nuw i64 [[START:%.*]], 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
-; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nuw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT: [[INDVARS_IV_NEXT:%.*]] = add nuw i64 [[START:%.*]], 1
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], 25
-; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
+; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE:%.*]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp ugt i64 [[TMP0]], 101
-; CHECK-NEXT: br i1 [[CMP1]], label [[LOOP]], label [[FOR_END]]
+; CHECK-NEXT: br i1 false, label [[LOOP]], label [[FOR_END]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -318,14 +307,12 @@ define void @test6(i64 %start) {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
-; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nuw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT: [[INDVARS_IV_NEXT:%.*]] = add nuw i64 [[START:%.*]], 1
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], 25
-; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
+; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE:%.*]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp ult i64 [[START]], 100
-; CHECK-NEXT: br i1 [[CMP1]], label [[FOR_END]], label [[LOOP]]
+; CHECK-NEXT: br i1 true, label [[FOR_END]], label [[LOOP]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -351,17 +338,14 @@ for.end: ; preds = %if.end, %entry
define void @test6.next(i64 %start) {
; CHECK-LABEL: @test6.next(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = add nuw i64 [[START:%.*]], 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:...
[truncated]
|
|
@llvm/pr-subscribers-llvm-analysis Author: Philip Reames (preames) ChangesAs far as I can tell, there's nothing in this code which actually assumes the two predicates in (FoundLHS FoundPred FoundRHS) => (LHS Pred RHS) are the same. Noticed while investigating something else, this is purely an oppurtunistic optimization while I'm looking at the code. Unfortunately, this doesn't solve my original problem. :) Patch is 27.09 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/71110.diff 7 Files Affected:
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
index 2765f1286d8bce5..234c05f48d8edfa 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -1942,7 +1942,9 @@ class ScalarEvolution {
/// true. Utility function used by isImpliedCondOperands. Tries to get
/// cases like "X `sgt` 0 => X - 1 `sgt` -1".
bool isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred, const SCEV *LHS,
- const SCEV *RHS, const SCEV *FoundLHS,
+ const SCEV *RHS,
+ ICmpInst::Predicate FoundPred,
+ const SCEV *FoundLHS,
const SCEV *FoundRHS);
/// Return true if the condition denoted by \p LHS \p Pred \p RHS is implied
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index de24aa986688a1e..476b8cdd0e953d0 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -11753,6 +11753,9 @@ bool ScalarEvolution::isImpliedCondBalancedTypes(
if (isImpliedCondOperands(FoundPred, LHS, RHS, FoundLHS, FoundRHS, CtxI))
return true;
+ if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, FoundPred, FoundLHS, FoundRHS))
+ return true;
+
// Otherwise assume the worst.
return false;
}
@@ -12010,7 +12013,7 @@ bool ScalarEvolution::isImpliedViaMerge(ICmpInst::Predicate Pred,
auto ProvedEasily = [&](const SCEV *S1, const SCEV *S2) {
return isKnownViaNonRecursiveReasoning(Pred, S1, S2) ||
- isImpliedCondOperandsViaRanges(Pred, S1, S2, FoundLHS, FoundRHS) ||
+ isImpliedCondOperandsViaRanges(Pred, S1, S2, Pred, FoundLHS, FoundRHS) ||
isImpliedViaOperations(Pred, S1, S2, FoundLHS, FoundRHS, Depth);
};
@@ -12112,7 +12115,7 @@ bool ScalarEvolution::isImpliedCondOperands(ICmpInst::Predicate Pred,
const SCEV *FoundLHS,
const SCEV *FoundRHS,
const Instruction *CtxI) {
- if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, FoundLHS, FoundRHS))
+ if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, Pred, FoundLHS, FoundRHS))
return true;
if (isImpliedCondOperandsViaNoOverflow(Pred, LHS, RHS, FoundLHS, FoundRHS))
@@ -12464,6 +12467,7 @@ ScalarEvolution::isImpliedCondOperandsHelper(ICmpInst::Predicate Pred,
bool ScalarEvolution::isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred,
const SCEV *LHS,
const SCEV *RHS,
+ ICmpInst::Predicate FoundPred,
const SCEV *FoundLHS,
const SCEV *FoundRHS) {
if (!isa<SCEVConstant>(RHS) || !isa<SCEVConstant>(FoundRHS))
@@ -12478,9 +12482,9 @@ bool ScalarEvolution::isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred,
const APInt &ConstFoundRHS = cast<SCEVConstant>(FoundRHS)->getAPInt();
// `FoundLHSRange` is the range we know `FoundLHS` to be in by virtue of the
- // antecedent "`FoundLHS` `Pred` `FoundRHS`".
+ // antecedent "`FoundLHS` `FoundPred` `FoundRHS`".
ConstantRange FoundLHSRange =
- ConstantRange::makeExactICmpRegion(Pred, ConstFoundRHS);
+ ConstantRange::makeExactICmpRegion(FoundPred, ConstFoundRHS);
// Since `LHS` is `FoundLHS` + `Addend`, we can compute a range for `LHS`:
ConstantRange LHSRange = FoundLHSRange.add(ConstantRange(*Addend));
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll b/llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll
index b238e55bf83eb71..279d4ac581148bd 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll
@@ -63,7 +63,8 @@ define void @ult_infinite_ub() mustprogress {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 2
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
br label %for.body
@@ -88,7 +89,8 @@ define void @ult_129_not_taken() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -111,7 +113,8 @@ define void @ult_129_unknown_start(i8 %start) mustprogress {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -163,7 +166,8 @@ define void @ult_ub1() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 2
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 2
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 3
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 3
;
entry:
br label %for.body
@@ -188,7 +192,8 @@ define void @ult_ub2() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -213,7 +218,8 @@ define void @ult_129_preinc() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 2
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
br label %for.body
@@ -236,7 +242,8 @@ define void @ult_preinc(i8 %step) {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 2
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
%assume = icmp ult i8 128, %step
@@ -313,7 +320,8 @@ define void @slt_wrap() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 63
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 63
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 64
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 64
;
entry:
br label %for.body
@@ -361,7 +369,8 @@ define void @slt_infinite_ub() mustprogress {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -386,7 +395,8 @@ define void @slt_129_not_taken() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -433,7 +443,8 @@ define void @slt_129_unknown_start(i8 %start) mustprogress {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (((127 + (-1 * (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))<nuw><nsw> + (-1 * %start) + (0 smax (-127 + %start)<nsw>)) /u -127) + (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (((127 + (-1 * (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))<nuw><nsw> + (-1 * %start) + (0 smax (-127 + %start)<nsw>)) /u -127) + (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -459,7 +470,8 @@ define void @slt_ub1() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -484,7 +496,8 @@ define void @slt_ub2() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -509,7 +522,8 @@ define void @slt_129_preinc() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 2
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
br label %for.body
@@ -532,7 +546,8 @@ define void @slt_preinc(i8 %step) {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
-; CHECK: Loop %for.body: Trip multiple is 2
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
%assume = icmp ult i8 128, %step
@@ -601,18 +616,20 @@ declare void @llvm.assume(i1)
define void @step_is_neg_addrec_slt_8(i64 %n) {
; CHECK-LABEL: 'step_is_neg_addrec_slt_8'
; CHECK-NEXT: Determining loop execution counts for: @step_is_neg_addrec_slt_8
-; CHECK-NEXT: Loop %inner: backedge-taken count is (7 /u {0,+,-1}<nuw><nsw><%outer.header>)
+; CHECK-NEXT: Loop %inner: backedge-taken count is (7 /u {0,+,-1}<%outer.header>)
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is 8
-; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is (7 /u {0,+,-1}<nuw><nsw><%outer.header>)
-; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is (7 /u {0,+,-1}<nuw><nsw><%outer.header>)
+; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is (7 /u {0,+,-1}<%outer.header>)
+; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is (7 /u {0,+,-1}<%outer.header>)
; CHECK-NEXT: Predicates:
-; CHECK: Loop %inner: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %inner: Trip multiple is 1
; CHECK-NEXT: Loop %outer.header: backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: constant max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %outer.header: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %outer.header: Trip multiple is 1
;
entry:
br label %outer.header
@@ -648,13 +665,15 @@ define void @step_is_neg_addrec_slt_var(i32 %n) {
; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is ({0,+,1}<nuw><nsw><%outer.header> + ({0,+,-1}<nsw><%outer.header> smax %n))
; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is ({0,+,1}<nuw><nsw><%outer.header> + ({0,+,-1}<nsw><%outer.header> smax %n))
; CHECK-NEXT: Predicates:
-; CHECK: Loop %inner: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %inner: Trip multiple is 1
; CHECK-NEXT: Loop %outer.header: backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: constant max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %outer.header: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %outer.header: Trip multiple is 1
;
entry:
br label %outer.header
@@ -690,13 +709,15 @@ define void @step_is_neg_addrec_unknown_start(i32 %n) {
; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nsw><%outer.header>))
; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nsw><%outer.header>))
; CHECK-NEXT: Predicates:
-; CHECK: Loop %inner: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %inner: Trip multiple is 1
; CHECK-NEXT: Loop %outer.header: backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: constant max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
-; CHECK: Loop %outer.header: Trip multiple is 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Loop %outer.header: Trip multiple is 1
;
entry:
br label %outer.header
diff --git a/llvm/test/Transforms/IndVarSimplify/X86/loop-invariant-conditions.ll b/llvm/test/Transforms/IndVarSimplify/X86/loop-invariant-conditions.ll
index 4543ec220dbee2b..24ba862eebc4284 100644
--- a/llvm/test/Transforms/IndVarSimplify/X86/loop-invariant-conditions.ll
+++ b/llvm/test/Transforms/IndVarSimplify/X86/loop-invariant-conditions.ll
@@ -109,8 +109,7 @@ define void @test3(i64 %start) {
; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i64 [[START]], -1
-; CHECK-NEXT: br i1 [[CMP1]], label [[FOR_END]], label [[LOOP]]
+; CHECK-NEXT: br i1 false, label [[FOR_END]], label [[LOOP]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -136,17 +135,15 @@ for.end: ; preds = %if.end, %entry
define void @test3.next(i64 %start) {
; CHECK-LABEL: @test3.next(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = add nsw i64 [[START:%.*]], 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
+; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], 25
; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i64 [[TMP0]], 0
-; CHECK-NEXT: br i1 [[CMP1]], label [[FOR_END]], label [[LOOP]]
+; CHECK-NEXT: br i1 false, label [[FOR_END]], label [[LOOP]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -181,8 +178,7 @@ define void @test4(i64 %start) {
; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp sgt i64 [[START]], -1
-; CHECK-NEXT: br i1 [[CMP1]], label [[LOOP]], label [[FOR_END]]
+; CHECK-NEXT: br i1 true, label [[LOOP]], label [[FOR_END]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -208,17 +204,15 @@ for.end: ; preds = %if.end, %entry
define void @test4.next(i64 %start) {
; CHECK-LABEL: @test4.next(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = add nsw i64 [[START:%.*]], 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
+; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 1
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], 25
; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp sgt i64 [[TMP0]], 0
-; CHECK-NEXT: br i1 [[CMP1]], label [[LOOP]], label [[FOR_END]]
+; CHECK-NEXT: br i1 true, label [[LOOP]], label [[FOR_END]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -246,14 +240,12 @@ define void @test5(i64 %start) {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
-; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nuw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT: [[INDVARS_IV_NEXT:%.*]] = add nuw i64 [[START:%.*]], 1
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], 25
-; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
+; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE:%.*]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp ugt i64 [[START]], 100
-; CHECK-NEXT: br i1 [[CMP1]], label [[LOOP]], label [[FOR_END]]
+; CHECK-NEXT: br i1 false, label [[LOOP]], label [[FOR_END]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -279,17 +271,14 @@ for.end: ; preds = %if.end, %entry
define void @test5.next(i64 %start) {
; CHECK-LABEL: @test5.next(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = add nuw i64 [[START:%.*]], 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
-; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nuw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT: [[INDVARS_IV_NEXT:%.*]] = add nuw i64 [[START:%.*]], 1
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], 25
-; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
+; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE:%.*]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp ugt i64 [[TMP0]], 101
-; CHECK-NEXT: br i1 [[CMP1]], label [[LOOP]], label [[FOR_END]]
+; CHECK-NEXT: br i1 false, label [[LOOP]], label [[FOR_END]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -318,14 +307,12 @@ define void @test6(i64 %start) {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
-; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nuw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT: [[INDVARS_IV_NEXT:%.*]] = add nuw i64 [[START:%.*]], 1
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], 25
-; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE]], label [[FOR_END:%.*]]
+; CHECK-NEXT: br i1 [[CMP]], label [[BACKEDGE:%.*]], label [[FOR_END:%.*]]
; CHECK: backedge:
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[CMP1:%.*]] = icmp ult i64 [[START]], 100
-; CHECK-NEXT: br i1 [[CMP1]], label [[FOR_END]], label [[LOOP]]
+; CHECK-NEXT: br i1 true, label [[FOR_END]], label [[LOOP]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
@@ -351,17 +338,14 @@ for.end: ; preds = %if.end, %entry
define void @test6.next(i64 %start) {
; CHECK-LABEL: @test6.next(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[TMP0:%.*]] = add nuw i64 [[START:%.*]], 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:...
[truncated]
|
You can test this locally with the following command:git-clang-format --diff 015c06ade023362ba7410e06618dea407fa07e5f af6a9d6da8337e1c6b0e933d8191f521f6ffc485 -- llvm/include/llvm/Analysis/ScalarEvolution.h llvm/lib/Analysis/ScalarEvolution.cppView the diff from clang-format here.diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index a8b22e18a..62f36ebeb 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -11753,7 +11753,8 @@ bool ScalarEvolution::isImpliedCondBalancedTypes(
if (isImpliedCondOperands(FoundPred, LHS, RHS, FoundLHS, FoundRHS, CtxI))
return true;
- if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, FoundPred, FoundLHS, FoundRHS))
+ if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, FoundPred, FoundLHS,
+ FoundRHS))
return true;
// Otherwise assume the worst.
@@ -12013,7 +12014,8 @@ bool ScalarEvolution::isImpliedViaMerge(ICmpInst::Predicate Pred,
auto ProvedEasily = [&](const SCEV *S1, const SCEV *S2) {
return isKnownViaNonRecursiveReasoning(Pred, S1, S2) ||
- isImpliedCondOperandsViaRanges(Pred, S1, S2, Pred, FoundLHS, FoundRHS) ||
+ isImpliedCondOperandsViaRanges(Pred, S1, S2, Pred, FoundLHS,
+ FoundRHS) ||
isImpliedViaOperations(Pred, S1, S2, FoundLHS, FoundRHS, Depth);
};
@@ -12464,12 +12466,9 @@ ScalarEvolution::isImpliedCondOperandsHelper(ICmpInst::Predicate Pred,
return false;
}
-bool ScalarEvolution::isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred,
- const SCEV *LHS,
- const SCEV *RHS,
- ICmpInst::Predicate FoundPred,
- const SCEV *FoundLHS,
- const SCEV *FoundRHS) {
+bool ScalarEvolution::isImpliedCondOperandsViaRanges(
+ ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS,
+ ICmpInst::Predicate FoundPred, const SCEV *FoundLHS, const SCEV *FoundRHS) {
if (!isa<SCEVConstant>(RHS) || !isa<SCEVConstant>(FoundRHS))
// The restriction on `FoundRHS` be lifted easily -- it exists only to
// reduce the compile time impact of this optimization.
|
As far as I can tell, there's nothing in this code which actually assumes the two predicates in (FoundLHS FoundPred FoundRHS) => (LHS Pred RHS) are the same. Noticed while investigating something else, this is purely an oppurtunistic optimization while I'm looking at the code. Unfortunately, this doesn't solve my original problem. :)
preames
force-pushed
the
pr-scev-constant-ranges-two-predicates
branch
from
e160505
to
af6a9d6
Compare
|
@nikic Can you take a second look at the test changes? There's a couple which are worth comment. When rebasing to eliminate the white space, I discovered I'd missed updating a couple originally. test/Analysis/ScalarEvolution/trip-count-negative-stride.ll -- This looks mildly concerning on the surface, but I think it's safe to ignore. The entire loop nest is immediate UB, and the inner loop expression simplifies to 7 /u 0. (We're missing that simplification.) test/CodeGen/BPF/loop-exit-cond.ll - I'm clearly breaking the intention of the test here. However, looking at the commit that introduced this, the patch made a cost model change and asserted that disabled LFTR. That was never true to begin with beyond one very narrow test case, so I don't feel bad effectively reverting that behavior. I'm honestly tempted just to delete the test. |
Yeah, this is fine.
I think it's okay to land this, but we should let BPF maintainers know that this broke, so they can find a new solution (cc @yonghong-song). I agree that the cost model change doesn't really prevent LFTR, and just happened to work in that specific case. This seems like something that may be hard to undo in the backend, so I might be open to have a TTI hook to disable LFTR -- it's kind of part of the canonical form, but also not really, because we can only actually form it rarely and it's TTI driven anyway. (Though more generally, I have some doubts that performing LFTR to replace inequality exit conditions with equality exit conditions is really a useful transform in the first place.) |
This was referenced Nov 8, 2023
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
As far as I can tell, there's nothing in this code which actually assumes the two predicates in (FoundLHS FoundPred FoundRHS) => (LHS Pred RHS) are the same.
Noticed while investigating something else, this is purely an oppurtunistic optimization while I'm looking at the code. Unfortunately, this doesn't solve my original problem. :)