RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-25 12:12:47 +01:00
Code Issues Projects Releases Wiki Activity

[SCEV] Favor isKnownViaSimpleReasoning over constant ranges check

Browse Source 
There is a more powerful but still simple function `isKnownViaSimpleReasoning ` that
does constant range check and few more additional checks. We use it some places (e.g.
when proving implications) and in some other places we only check constant ranges.

Currently, indvar simplifier fails to remove the check in following loop:

  int inc = ...;
  for (int i = inc, j = inc - 1; i < 200; ++i, ++j)
    if (i > j) { ... }

This patch replaces all usages of `isKnownPredicateViaConstantRanges` with
`isKnownViaSimpleReasoning` to have smarter proofs. In particular, it fixes the
case above.

Reviewed-By: sanjoy
Differential Revision: https://reviews.llvm.org/D43175

llvm-svn: 325214
This commit is contained in:
Max Kazantsev 2018-02-15 07:09:00 +00:00
parent 4ae6e567eb
commit 43812ac389
2 changed files with 38 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
lib/Analysis/ScalarEvolution.cpp
View File

@ -8693,8 +8693,8 @@ bool ScalarEvolution::isKnownPredicate(ICmpInst::Predicate Pred,
if (isKnownPredicateViaSplitting(Pred, LHS, RHS))
return true;
// Otherwise see what can be done with known constant ranges.
return isKnownPredicateViaConstantRanges(Pred, LHS, RHS);
// Otherwise see what can be done with some simple reasoning.
return isKnownViaSimpleReasoning(Pred, LHS, RHS);
}
bool ScalarEvolution::isMonotonicPredicate(const SCEVAddRecExpr *LHS,
@ -8961,7 +8961,7 @@ ScalarEvolution::isLoopBackedgeGuardedByCond(const Loop *L,
// (interprocedural conditions notwithstanding).
if (!L) return true;
if (isKnownPredicateViaConstantRanges(Pred, LHS, RHS))
if (isKnownViaSimpleReasoning(Pred, LHS, RHS))
return true;
BasicBlock *Latch = L->getLoopLatch();
@ -9072,7 +9072,7 @@ ScalarEvolution::isLoopEntryGuardedByCond(const Loop *L,
assert(isAvailableAtLoopEntry(RHS, L) &&
"RHS is not available at Loop Entry");
if (isKnownPredicateViaConstantRanges(Pred, LHS, RHS))
if (isKnownViaSimpleReasoning(Pred, LHS, RHS))
return true;
// If we cannot prove strict comparison (e.g. a > b), maybe we can prove
@ -9087,9 +9087,9 @@ ScalarEvolution::isLoopEntryGuardedByCond(const Loop *L,
if (ProvingStrictComparison) {
ProvedNonStrictComparison =
isKnownPredicateViaConstantRanges(NonStrictPredicate, LHS, RHS);
isKnownViaSimpleReasoning(NonStrictPredicate, LHS, RHS);
ProvedNonEquality =
isKnownPredicateViaConstantRanges(ICmpInst::ICMP_NE, LHS, RHS);
isKnownViaSimpleReasoning(ICmpInst::ICMP_NE, LHS, RHS);
if (ProvedNonStrictComparison && ProvedNonEquality)
return true;
}

32
test/Transforms/IndVarSimplify/loop-invariant-conditions.ll
View File

@ -355,6 +355,38 @@ exit:
ret void
}
; check that we can prove that a recurrency is greater than another recurrency
; in the same loop, with the same step, and with smaller starting value.
define void @test12(i64* %inc_ptr) {
; CHECK-LABEL: @test12
entry:
%inc = load i64, i64* %inc_ptr, !range !0
%inc.minus.1 = sub i64 %inc, 1
br label %loop
loop:
%iv = phi i64 [ %inc, %entry ], [ %iv.next, %backedge ]
%iv.minus.1 = phi i64 [ %inc.minus.1, %entry ], [ %iv.minus.1.next, %backedge ]
%iv.next = add i64 %iv, 1
%iv.minus.1.next = add i64 %iv.minus.1, 1
%brcond = icmp sgt i64 %iv.next, %iv.minus.1.next
; CHECK: br i1 true, label %if.true, label %if.false
br i1 %brcond, label %if.true, label %if.false
if.true:
br label %backedge
if.false:
br label %backedge
backedge:
%loopcond = icmp slt i64 %iv, 200
br i1 %loopcond, label %loop, label %exit
exit:
ret void
}
!1 = !{i64 -1, i64 100}