[llvm] 2f3dc5f - [SCEV] Rename ControlsExit -> ControlsOnlyExit (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Tue Mar 14 03:05:38 PDT 2023
Author: Nikita Popov
Date: 2023-03-14T11:04:54+01:00
New Revision: 2f3dc5fa8b5ddc6cec944580ec59a66cefdf54e7
URL: https://github.com/llvm/llvm-project/commit/2f3dc5fa8b5ddc6cec944580ec59a66cefdf54e7
DIFF: https://github.com/llvm/llvm-project/commit/2f3dc5fa8b5ddc6cec944580ec59a66cefdf54e7.diff
LOG: [SCEV] Rename ControlsExit -> ControlsOnlyExit (NFC)
As suggested in https://reviews.llvm.org/D145510#4192162.
Added:
Modified:
llvm/include/llvm/Analysis/ScalarEvolution.h
llvm/lib/Analysis/ScalarEvolution.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
index ee7cbe427236..8a25cf9b37c8 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -1133,7 +1133,7 @@ class ScalarEvolution {
/// Compute the number of times the backedge of the specified loop will
/// execute if its exit condition were a conditional branch of ExitCond.
///
- /// \p ControlsExit is true if ExitCond directly controls the only exit
+ /// \p ControlsOnlyExit is true if ExitCond directly controls the only exit
/// branch. In this case, we can assume that the loop exits only if the
/// condition is true and can infer that failing to meet the condition prior
/// to integer wraparound results in undefined behavior.
@@ -1141,7 +1141,7 @@ class ScalarEvolution {
/// If \p AllowPredicates is set, this call will try to use a minimal set of
/// SCEV predicates in order to return an exact answer.
ExitLimit computeExitLimitFromCond(const Loop *L, Value *ExitCond,
- bool ExitIfTrue, bool ControlsExit,
+ bool ExitIfTrue, bool ControlsOnlyExit,
bool AllowPredicates = false);
/// A predicate is said to be monotonically increasing if may go from being
@@ -1769,11 +1769,11 @@ class ScalarEvolution {
// complexity.
class ExitLimitCache {
- // It may look like we need key on the whole (L, ExitIfTrue, ControlsExit,
- // AllowPredicates) tuple, but recursive calls to
+ // It may look like we need key on the whole (L, ExitIfTrue,
+ // ControlsOnlyExit, AllowPredicates) tuple, but recursive calls to
// computeExitLimitFromCondCached from computeExitLimitFromCondImpl only
- // vary the in \c ExitCond and \c ControlsExit parameters. We remember the
- // initial values of the other values to assert our assumption.
+ // vary the in \c ExitCond and \c ControlsOnlyExit parameters. We remember
+ // the initial values of the other values to assert our assumption.
SmallDenseMap<PointerIntPair<Value *, 1>, ExitLimit> TripCountMap;
const Loop *L;
@@ -1785,11 +1785,12 @@ class ScalarEvolution {
: L(L), ExitIfTrue(ExitIfTrue), AllowPredicates(AllowPredicates) {}
std::optional<ExitLimit> find(const Loop *L, Value *ExitCond,
- bool ExitIfTrue, bool ControlsExit,
+ bool ExitIfTrue, bool ControlsOnlyExit,
bool AllowPredicates);
void insert(const Loop *L, Value *ExitCond, bool ExitIfTrue,
- bool ControlsExit, bool AllowPredicates, const ExitLimit &EL);
+ bool ControlsOnlyExit, bool AllowPredicates,
+ const ExitLimit &EL);
};
using ExitLimitCacheTy = ExitLimitCache;
@@ -1797,16 +1798,15 @@ class ScalarEvolution {
ExitLimit computeExitLimitFromCondCached(ExitLimitCacheTy &Cache,
const Loop *L, Value *ExitCond,
bool ExitIfTrue,
- bool ControlsExit,
+ bool ControlsOnlyExit,
bool AllowPredicates);
ExitLimit computeExitLimitFromCondImpl(ExitLimitCacheTy &Cache, const Loop *L,
Value *ExitCond, bool ExitIfTrue,
- bool ControlsExit,
+ bool ControlsOnlyExit,
bool AllowPredicates);
- std::optional<ScalarEvolution::ExitLimit>
- computeExitLimitFromCondFromBinOp(ExitLimitCacheTy &Cache, const Loop *L,
- Value *ExitCond, bool ExitIfTrue,
- bool ControlsExit, bool AllowPredicates);
+ std::optional<ScalarEvolution::ExitLimit> computeExitLimitFromCondFromBinOp(
+ ExitLimitCacheTy &Cache, const Loop *L, Value *ExitCond, bool ExitIfTrue,
+ bool ControlsOnlyExit, bool AllowPredicates);
/// Compute the number of times the backedge of the specified loop will
/// execute if its exit condition were a conditional branch of the ICmpInst
@@ -1871,14 +1871,14 @@ class ScalarEvolution {
///
/// \p isSigned specifies whether the less-than is signed.
///
- /// \p ControlsExit is true when the LHS < RHS condition directly controls
+ /// \p ControlsOnlyExit is true when the LHS < RHS condition directly controls
/// the branch (loops exits only if condition is true). In this case, we can
/// use NoWrapFlags to skip overflow checks.
///
/// If \p AllowPredicates is set, this call will try to use a minimal set of
/// SCEV predicates in order to return an exact answer.
ExitLimit howManyLessThans(const SCEV *LHS, const SCEV *RHS, const Loop *L,
- bool isSigned, bool ControlsExit,
+ bool isSigned, bool ControlsOnlyExit,
bool AllowPredicates = false);
ExitLimit howManyGreaterThans(const SCEV *LHS, const SCEV *RHS, const Loop *L,
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 4f4f040ff334..424ff1c26c68 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -8831,9 +8831,9 @@ ScalarEvolution::computeExitLimit(const Loop *L, BasicBlock *ExitingBlock,
assert(ExitIfTrue == L->contains(BI->getSuccessor(1)) &&
"It should have one successor in loop and one exit block!");
// Proceed to the next level to examine the exit condition expression.
- return computeExitLimitFromCond(
- L, BI->getCondition(), ExitIfTrue,
- /*ControlsExit=*/IsOnlyExit, AllowPredicates);
+ return computeExitLimitFromCond(L, BI->getCondition(), ExitIfTrue,
+ /*ControlsOnlyExit=*/IsOnlyExit,
+ AllowPredicates);
}
if (SwitchInst *SI = dyn_cast<SwitchInst>(Term)) {
@@ -8846,24 +8846,25 @@ ScalarEvolution::computeExitLimit(const Loop *L, BasicBlock *ExitingBlock,
Exit = SBB;
}
assert(Exit && "Exiting block must have at least one exit");
- return computeExitLimitFromSingleExitSwitch(L, SI, Exit,
- /*ControlsExit=*/IsOnlyExit);
+ return computeExitLimitFromSingleExitSwitch(
+ L, SI, Exit,
+ /*ControlsOnlyExit=*/IsOnlyExit);
}
return getCouldNotCompute();
}
ScalarEvolution::ExitLimit ScalarEvolution::computeExitLimitFromCond(
- const Loop *L, Value *ExitCond, bool ExitIfTrue,
- bool ControlsExit, bool AllowPredicates) {
+ const Loop *L, Value *ExitCond, bool ExitIfTrue, bool ControlsOnlyExit,
+ bool AllowPredicates) {
ScalarEvolution::ExitLimitCacheTy Cache(L, ExitIfTrue, AllowPredicates);
return computeExitLimitFromCondCached(Cache, L, ExitCond, ExitIfTrue,
- ControlsExit, AllowPredicates);
+ ControlsOnlyExit, AllowPredicates);
}
std::optional<ScalarEvolution::ExitLimit>
ScalarEvolution::ExitLimitCache::find(const Loop *L, Value *ExitCond,
- bool ExitIfTrue, bool ControlsExit,
+ bool ExitIfTrue, bool ControlsOnlyExit,
bool AllowPredicates) {
(void)this->L;
(void)this->ExitIfTrue;
@@ -8872,7 +8873,7 @@ ScalarEvolution::ExitLimitCache::find(const Loop *L, Value *ExitCond,
assert(this->L == L && this->ExitIfTrue == ExitIfTrue &&
this->AllowPredicates == AllowPredicates &&
"Variance in assumed invariant key components!");
- auto Itr = TripCountMap.find({ExitCond, ControlsExit});
+ auto Itr = TripCountMap.find({ExitCond, ControlsOnlyExit});
if (Itr == TripCountMap.end())
return std::nullopt;
return Itr->second;
@@ -8880,14 +8881,14 @@ ScalarEvolution::ExitLimitCache::find(const Loop *L, Value *ExitCond,
void ScalarEvolution::ExitLimitCache::insert(const Loop *L, Value *ExitCond,
bool ExitIfTrue,
- bool ControlsExit,
+ bool ControlsOnlyExit,
bool AllowPredicates,
const ExitLimit &EL) {
assert(this->L == L && this->ExitIfTrue == ExitIfTrue &&
this->AllowPredicates == AllowPredicates &&
"Variance in assumed invariant key components!");
- auto InsertResult = TripCountMap.insert({{ExitCond, ControlsExit}, EL});
+ auto InsertResult = TripCountMap.insert({{ExitCond, ControlsOnlyExit}, EL});
assert(InsertResult.second && "Expected successful insertion!");
(void)InsertResult;
(void)ExitIfTrue;
@@ -8895,36 +8896,37 @@ void ScalarEvolution::ExitLimitCache::insert(const Loop *L, Value *ExitCond,
ScalarEvolution::ExitLimit ScalarEvolution::computeExitLimitFromCondCached(
ExitLimitCacheTy &Cache, const Loop *L, Value *ExitCond, bool ExitIfTrue,
- bool ControlsExit, bool AllowPredicates) {
+ bool ControlsOnlyExit, bool AllowPredicates) {
- if (auto MaybeEL =
- Cache.find(L, ExitCond, ExitIfTrue, ControlsExit, AllowPredicates))
+ if (auto MaybeEL = Cache.find(L, ExitCond, ExitIfTrue, ControlsOnlyExit,
+ AllowPredicates))
return *MaybeEL;
- ExitLimit EL = computeExitLimitFromCondImpl(Cache, L, ExitCond, ExitIfTrue,
- ControlsExit, AllowPredicates);
- Cache.insert(L, ExitCond, ExitIfTrue, ControlsExit, AllowPredicates, EL);
+ ExitLimit EL = computeExitLimitFromCondImpl(
+ Cache, L, ExitCond, ExitIfTrue, ControlsOnlyExit, AllowPredicates);
+ Cache.insert(L, ExitCond, ExitIfTrue, ControlsOnlyExit, AllowPredicates, EL);
return EL;
}
ScalarEvolution::ExitLimit ScalarEvolution::computeExitLimitFromCondImpl(
ExitLimitCacheTy &Cache, const Loop *L, Value *ExitCond, bool ExitIfTrue,
- bool ControlsExit, bool AllowPredicates) {
+ bool ControlsOnlyExit, bool AllowPredicates) {
// Handle BinOp conditions (And, Or).
if (auto LimitFromBinOp = computeExitLimitFromCondFromBinOp(
- Cache, L, ExitCond, ExitIfTrue, ControlsExit, AllowPredicates))
+ Cache, L, ExitCond, ExitIfTrue, ControlsOnlyExit, AllowPredicates))
return *LimitFromBinOp;
// With an icmp, it may be feasible to compute an exact backedge-taken count.
// Proceed to the next level to examine the icmp.
if (ICmpInst *ExitCondICmp = dyn_cast<ICmpInst>(ExitCond)) {
ExitLimit EL =
- computeExitLimitFromICmp(L, ExitCondICmp, ExitIfTrue, ControlsExit);
+ computeExitLimitFromICmp(L, ExitCondICmp, ExitIfTrue, ControlsOnlyExit);
if (EL.hasFullInfo() || !AllowPredicates)
return EL;
// Try again, but use SCEV predicates this time.
- return computeExitLimitFromICmp(L, ExitCondICmp, ExitIfTrue, ControlsExit,
+ return computeExitLimitFromICmp(L, ExitCondICmp, ExitIfTrue,
+ ControlsOnlyExit,
/*AllowPredicates=*/true);
}
@@ -8960,8 +8962,9 @@ ScalarEvolution::ExitLimit ScalarEvolution::computeExitLimitFromCondImpl(
if (Offset != 0)
LHS = getAddExpr(LHS, getConstant(Offset));
auto EL = computeExitLimitFromICmp(L, Pred, LHS, getConstant(NewRHSC),
- ControlsExit, AllowPredicates);
- if (EL.hasAnyInfo()) return EL;
+ ControlsOnlyExit, AllowPredicates);
+ if (EL.hasAnyInfo())
+ return EL;
}
// If it's not an integer or pointer comparison then compute it the hard way.
@@ -8971,7 +8974,7 @@ ScalarEvolution::ExitLimit ScalarEvolution::computeExitLimitFromCondImpl(
std::optional<ScalarEvolution::ExitLimit>
ScalarEvolution::computeExitLimitFromCondFromBinOp(
ExitLimitCacheTy &Cache, const Loop *L, Value *ExitCond, bool ExitIfTrue,
- bool ControlsExit, bool AllowPredicates) {
+ bool ControlsOnlyExit, bool AllowPredicates) {
// Check if the controlling expression for this loop is an And or Or.
Value *Op0, *Op1;
bool IsAnd = false;
@@ -8986,12 +8989,12 @@ ScalarEvolution::computeExitLimitFromCondFromBinOp(
// br (and Op0 Op1), loop, exit
// br (or Op0 Op1), exit, loop
bool EitherMayExit = IsAnd ^ ExitIfTrue;
- ExitLimit EL0 = computeExitLimitFromCondCached(Cache, L, Op0, ExitIfTrue,
- ControlsExit && !EitherMayExit,
- AllowPredicates);
- ExitLimit EL1 = computeExitLimitFromCondCached(Cache, L, Op1, ExitIfTrue,
- ControlsExit && !EitherMayExit,
- AllowPredicates);
+ ExitLimit EL0 = computeExitLimitFromCondCached(
+ Cache, L, Op0, ExitIfTrue, ControlsOnlyExit && !EitherMayExit,
+ AllowPredicates);
+ ExitLimit EL1 = computeExitLimitFromCondCached(
+ Cache, L, Op1, ExitIfTrue, ControlsOnlyExit && !EitherMayExit,
+ AllowPredicates);
// Be robust against unsimplified IR for the form "op i1 X, NeutralElement"
const Constant *NeutralElement = ConstantInt::get(ExitCond->getType(), IsAnd);
@@ -9049,12 +9052,9 @@ ScalarEvolution::computeExitLimitFromCondFromBinOp(
{ &EL0.Predicates, &EL1.Predicates });
}
-ScalarEvolution::ExitLimit
-ScalarEvolution::computeExitLimitFromICmp(const Loop *L,
- ICmpInst *ExitCond,
- bool ExitIfTrue,
- bool ControlsExit,
- bool AllowPredicates) {
+ScalarEvolution::ExitLimit ScalarEvolution::computeExitLimitFromICmp(
+ const Loop *L, ICmpInst *ExitCond, bool ExitIfTrue, bool ControlsOnlyExit,
+ bool AllowPredicates) {
// If the condition was exit on true, convert the condition to exit on false
ICmpInst::Predicate Pred;
if (!ExitIfTrue)
@@ -9066,9 +9066,10 @@ ScalarEvolution::computeExitLimitFromICmp(const Loop *L,
const SCEV *LHS = getSCEV(ExitCond->getOperand(0));
const SCEV *RHS = getSCEV(ExitCond->getOperand(1));
- ExitLimit EL = computeExitLimitFromICmp(L, Pred, LHS, RHS, ControlsExit,
+ ExitLimit EL = computeExitLimitFromICmp(L, Pred, LHS, RHS, ControlsOnlyExit,
AllowPredicates);
- if (EL.hasAnyInfo()) return EL;
+ if (EL.hasAnyInfo())
+ return EL;
auto *ExhaustiveCount =
computeExitCountExhaustively(L, ExitCond, ExitIfTrue);
@@ -9079,12 +9080,9 @@ ScalarEvolution::computeExitLimitFromICmp(const Loop *L,
return computeShiftCompareExitLimit(ExitCond->getOperand(0),
ExitCond->getOperand(1), L, OriginalPred);
}
-ScalarEvolution::ExitLimit
-ScalarEvolution::computeExitLimitFromICmp(const Loop *L,
- ICmpInst::Predicate Pred,
- const SCEV *LHS, const SCEV *RHS,
- bool ControlsExit,
- bool AllowPredicates) {
+ScalarEvolution::ExitLimit ScalarEvolution::computeExitLimitFromICmp(
+ const Loop *L, ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS,
+ bool ControlsOnlyExit, bool AllowPredicates) {
// Try to evaluate any dependencies out of the loop.
LHS = getSCEVAtScope(LHS, L);
@@ -9098,8 +9096,8 @@ ScalarEvolution::computeExitLimitFromICmp(const Loop *L,
Pred = ICmpInst::getSwappedPredicate(Pred);
}
- bool ControllingFiniteLoop =
- ControlsExit && loopHasNoAbnormalExits(L) && loopIsFiniteByAssumption(L);
+ bool ControllingFiniteLoop = ControlsOnlyExit && loopHasNoAbnormalExits(L) &&
+ loopIsFiniteByAssumption(L);
// Simplify the operands before analyzing them.
(void)SimplifyICmpOperands(Pred, LHS, RHS, /*Depth=*/0);
@@ -9153,9 +9151,10 @@ ScalarEvolution::computeExitLimitFromICmp(const Loop *L,
if (isa<SCEVCouldNotCompute>(RHS))
return RHS;
}
- ExitLimit EL = howFarToZero(getMinusSCEV(LHS, RHS), L, ControlsExit,
+ ExitLimit EL = howFarToZero(getMinusSCEV(LHS, RHS), L, ControlsOnlyExit,
AllowPredicates);
- if (EL.hasAnyInfo()) return EL;
+ if (EL.hasAnyInfo())
+ return EL;
break;
}
case ICmpInst::ICMP_EQ: { // while (X == Y)
@@ -9184,11 +9183,12 @@ ScalarEvolution::computeExitLimitFromICmp(const Loop *L,
RHS = getAddExpr(getOne(RHS->getType()), RHS);
[[fallthrough]];
case ICmpInst::ICMP_SLT:
- case ICmpInst::ICMP_ULT: { // while (X < Y)
+ case ICmpInst::ICMP_ULT: { // while (X < Y)
bool IsSigned = ICmpInst::isSigned(Pred);
- ExitLimit EL = howManyLessThans(LHS, RHS, L, IsSigned, ControlsExit,
+ ExitLimit EL = howManyLessThans(LHS, RHS, L, IsSigned, ControlsOnlyExit,
AllowPredicates);
- if (EL.hasAnyInfo()) return EL;
+ if (EL.hasAnyInfo())
+ return EL;
break;
}
case ICmpInst::ICMP_SGE:
@@ -9201,12 +9201,12 @@ ScalarEvolution::computeExitLimitFromICmp(const Loop *L,
RHS = getAddExpr(getMinusOne(RHS->getType()), RHS);
[[fallthrough]];
case ICmpInst::ICMP_SGT:
- case ICmpInst::ICMP_UGT: { // while (X > Y)
+ case ICmpInst::ICMP_UGT: { // while (X > Y)
bool IsSigned = ICmpInst::isSigned(Pred);
- ExitLimit EL =
- howManyGreaterThans(LHS, RHS, L, IsSigned, ControlsExit,
- AllowPredicates);
- if (EL.hasAnyInfo()) return EL;
+ ExitLimit EL = howManyGreaterThans(LHS, RHS, L, IsSigned, ControlsOnlyExit,
+ AllowPredicates);
+ if (EL.hasAnyInfo())
+ return EL;
break;
}
default:
@@ -9220,7 +9220,7 @@ ScalarEvolution::ExitLimit
ScalarEvolution::computeExitLimitFromSingleExitSwitch(const Loop *L,
SwitchInst *Switch,
BasicBlock *ExitingBlock,
- bool ControlsExit) {
+ bool ControlsOnlyExit) {
assert(!L->contains(ExitingBlock) && "Not an exiting block!");
// Give up if the exit is the default dest of a switch.
@@ -9233,7 +9233,7 @@ ScalarEvolution::computeExitLimitFromSingleExitSwitch(const Loop *L,
const SCEV *RHS = getConstant(Switch->findCaseDest(ExitingBlock));
// while (X != Y) --> while (X-Y != 0)
- ExitLimit EL = howFarToZero(getMinusSCEV(LHS, RHS), L, ControlsExit);
+ ExitLimit EL = howFarToZero(getMinusSCEV(LHS, RHS), L, ControlsOnlyExit);
if (EL.hasAnyInfo())
return EL;
@@ -10392,9 +10392,10 @@ SolveQuadraticAddRecRange(const SCEVAddRecExpr *AddRec,
return TruncIfPossible(MinOptional(SL.first, SU.first), BitWidth);
}
-ScalarEvolution::ExitLimit
-ScalarEvolution::howFarToZero(const SCEV *V, const Loop *L, bool ControlsExit,
- bool AllowPredicates) {
+ScalarEvolution::ExitLimit ScalarEvolution::howFarToZero(const SCEV *V,
+ const Loop *L,
+ bool ControlsOnlyExit,
+ bool AllowPredicates) {
// This is only used for loops with a "x != y" exit test. The exit condition
// is now expressed as a single expression, V = x-y. So the exit test is
@@ -10503,7 +10504,7 @@ ScalarEvolution::howFarToZero(const SCEV *V, const Loop *L, bool ControlsExit,
// compute the backedge count. In this case, the step may not divide the
// distance, but we don't care because if the condition is "missed" the loop
// will have undefined behavior due to wrapping.
- if (ControlsExit && AddRec->hasNoSelfWrap() &&
+ if (ControlsOnlyExit && AddRec->hasNoSelfWrap() &&
loopHasNoAbnormalExits(AddRec->getLoop())) {
const SCEV *Exact =
getUDivExpr(Distance, CountDown ? getNegativeSCEV(Step) : Step);
@@ -12715,7 +12716,7 @@ const SCEV *ScalarEvolution::computeMaxBECountForLT(const SCEV *Start,
ScalarEvolution::ExitLimit
ScalarEvolution::howManyLessThans(const SCEV *LHS, const SCEV *RHS,
const Loop *L, bool IsSigned,
- bool ControlsExit, bool AllowPredicates) {
+ bool ControlsOnlyExit, bool AllowPredicates) {
SmallPtrSet<const SCEVPredicate *, 4> Predicates;
const SCEVAddRecExpr *IV = dyn_cast<SCEVAddRecExpr>(LHS);
@@ -12743,7 +12744,7 @@ ScalarEvolution::howManyLessThans(const SCEV *LHS, const SCEV *RHS,
if (!StrideC || !StrideC->getAPInt().isPowerOf2())
return false;
- if (!ControlsExit || !loopHasNoAbnormalExits(L))
+ if (!ControlsOnlyExit || !loopHasNoAbnormalExits(L))
return false;
return loopIsFiniteByAssumption(L);
@@ -12818,7 +12819,7 @@ ScalarEvolution::howManyLessThans(const SCEV *LHS, const SCEV *RHS,
// implicit/exceptional) which causes the loop to execute before the
// exiting instruction we're analyzing would trigger UB.
auto WrapType = IsSigned ? SCEV::FlagNSW : SCEV::FlagNUW;
- bool NoWrap = ControlsExit && IV->getNoWrapFlags(WrapType);
+ bool NoWrap = ControlsOnlyExit && IV->getNoWrapFlags(WrapType);
ICmpInst::Predicate Cond = IsSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
const SCEV *Stride = IV->getStepRecurrence(*this);
@@ -13138,10 +13139,9 @@ ScalarEvolution::howManyLessThans(const SCEV *LHS, const SCEV *RHS,
Predicates);
}
-ScalarEvolution::ExitLimit
-ScalarEvolution::howManyGreaterThans(const SCEV *LHS, const SCEV *RHS,
- const Loop *L, bool IsSigned,
- bool ControlsExit, bool AllowPredicates) {
+ScalarEvolution::ExitLimit ScalarEvolution::howManyGreaterThans(
+ const SCEV *LHS, const SCEV *RHS, const Loop *L, bool IsSigned,
+ bool ControlsOnlyExit, bool AllowPredicates) {
SmallPtrSet<const SCEVPredicate *, 4> Predicates;
// We handle only IV > Invariant
if (!isLoopInvariant(RHS, L))
@@ -13159,7 +13159,7 @@ ScalarEvolution::howManyGreaterThans(const SCEV *LHS, const SCEV *RHS,
return getCouldNotCompute();
auto WrapType = IsSigned ? SCEV::FlagNSW : SCEV::FlagNUW;
- bool NoWrap = ControlsExit && IV->getNoWrapFlags(WrapType);
+ bool NoWrap = ControlsOnlyExit && IV->getNoWrapFlags(WrapType);
ICmpInst::Predicate Cond = IsSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
const SCEV *Stride = getNegativeSCEV(IV->getStepRecurrence(*this));
More information about the llvm-commits
mailing list