[llvm] 49e928b - [SCEV][NFC] Sink initialization of SymbolicMaxNotTaken from ExitLimit constructor to its callers
Max Kazantsev via llvm-commits
llvm-commits at lists.llvm.org
Wed Dec 7 00:33:15 PST 2022
Author: Max Kazantsev
Date: 2022-12-07T15:33:03+07:00
New Revision: 49e928bee8812829a34730700106377b54f09923
URL: https://github.com/llvm/llvm-project/commit/49e928bee8812829a34730700106377b54f09923
DIFF: https://github.com/llvm/llvm-project/commit/49e928bee8812829a34730700106377b54f09923.diff
LOG: [SCEV][NFC] Sink initialization of SymbolicMaxNotTaken from ExitLimit constructor to its callers
Preserves current behavior (always select Exact if known, otherwise select Constant Max).
This is the final preparation step before letting each particular computation way to decide
how exactly it should be computed. Functional improvement is coming shortly as follow-up.
Differential Revision: https://reviews.llvm.org/D139402
Reviewed By: nikic, fhahn
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 e57a01f5d408..d1097feb751e 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -1335,11 +1335,14 @@ class ScalarEvolution {
/// as arguments and asserts enforce that internally.
/*implicit*/ ExitLimit(const SCEV *E);
- ExitLimit(const SCEV *E, const SCEV *ConstantMaxNotTaken, bool MaxOrZero,
- ArrayRef<const SmallPtrSetImpl<const SCEVPredicate *> *>
- PredSetList = std::nullopt);
-
- ExitLimit(const SCEV *E, const SCEV *ConstantMaxNotTaken, bool MaxOrZero,
+ ExitLimit(
+ const SCEV *E, const SCEV *ConstantMaxNotTaken,
+ const SCEV *SymbolicMaxNotTaken, bool MaxOrZero,
+ ArrayRef<const SmallPtrSetImpl<const SCEVPredicate *> *> PredSetList =
+ std::nullopt);
+
+ ExitLimit(const SCEV *E, const SCEV *ConstantMaxNotTaken,
+ const SCEV *SymbolicMaxNotTaken, bool MaxOrZero,
const SmallPtrSetImpl<const SCEVPredicate *> &PredSet);
/// Test whether this ExitLimit contains any computed information, or
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 25cc7d576c7b..76f0fccab5d0 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -8603,29 +8603,31 @@ bool ScalarEvolution::BackedgeTakenInfo::isConstantMaxOrZero(
}
ScalarEvolution::ExitLimit::ExitLimit(const SCEV *E)
- : ExitLimit(E, E, false, std::nullopt) {}
+ : ExitLimit(E, E, E, false, std::nullopt) {}
ScalarEvolution::ExitLimit::ExitLimit(
- const SCEV *E, const SCEV *ConstantMaxNotTaken, bool MaxOrZero,
+ const SCEV *E, const SCEV *ConstantMaxNotTaken,
+ const SCEV *SymbolicMaxNotTaken, bool MaxOrZero,
ArrayRef<const SmallPtrSetImpl<const SCEVPredicate *> *> PredSetList)
: ExactNotTaken(E), ConstantMaxNotTaken(ConstantMaxNotTaken),
- MaxOrZero(MaxOrZero) {
+ SymbolicMaxNotTaken(SymbolicMaxNotTaken), MaxOrZero(MaxOrZero) {
// If we prove the max count is zero, so is the symbolic bound. This happens
// in practice due to
diff erences in a) how context sensitive we've chosen
// to be and b) how we reason about bounds implied by UB.
- if (ConstantMaxNotTaken->isZero())
- ExactNotTaken = ConstantMaxNotTaken;
-
- // FIXME: For now, SymbolicMaxNotTaken is either exact (if available) or
- // constant max. In the future, we are planning to make it more powerful.
- if (isa<SCEVCouldNotCompute>(ExactNotTaken))
- SymbolicMaxNotTaken = ConstantMaxNotTaken;
- else
- SymbolicMaxNotTaken = ExactNotTaken;
+ if (ConstantMaxNotTaken->isZero()) {
+ this->ExactNotTaken = E = ConstantMaxNotTaken;
+ this->SymbolicMaxNotTaken = SymbolicMaxNotTaken = ConstantMaxNotTaken;
+ }
assert((isa<SCEVCouldNotCompute>(ExactNotTaken) ||
!isa<SCEVCouldNotCompute>(ConstantMaxNotTaken)) &&
- "Exact is not allowed to be less precise than Max");
+ "Exact is not allowed to be less precise than Constant Max");
+ assert((isa<SCEVCouldNotCompute>(ExactNotTaken) ||
+ !isa<SCEVCouldNotCompute>(SymbolicMaxNotTaken)) &&
+ "Exact is not allowed to be less precise than Symbolic Max");
+ assert((isa<SCEVCouldNotCompute>(SymbolicMaxNotTaken) ||
+ !isa<SCEVCouldNotCompute>(ConstantMaxNotTaken)) &&
+ "Symbolic Max is not allowed to be less precise than Constant Max");
assert((isa<SCEVCouldNotCompute>(ConstantMaxNotTaken) ||
isa<SCEVConstant>(ConstantMaxNotTaken)) &&
"No point in having a non-constant max backedge taken count!");
@@ -8640,9 +8642,11 @@ ScalarEvolution::ExitLimit::ExitLimit(
}
ScalarEvolution::ExitLimit::ExitLimit(
- const SCEV *E, const SCEV *ConstantMaxNotTaken, bool MaxOrZero,
+ const SCEV *E, const SCEV *ConstantMaxNotTaken,
+ const SCEV *SymbolicMaxNotTaken, bool MaxOrZero,
const SmallPtrSetImpl<const SCEVPredicate *> &PredSet)
- : ExitLimit(E, ConstantMaxNotTaken, MaxOrZero, { &PredSet }) {}
+ : ExitLimit(E, ConstantMaxNotTaken, SymbolicMaxNotTaken, MaxOrZero,
+ { &PredSet }) {}
/// Allocate memory for BackedgeTakenInfo and copy the not-taken count of each
/// computable exit into a persistent ExitNotTakenInfo array.
@@ -8980,8 +8984,9 @@ ScalarEvolution::computeExitLimitFromCondFromBinOp(
if (isa<SCEVCouldNotCompute>(ConstantMaxBECount) &&
!isa<SCEVCouldNotCompute>(BECount))
ConstantMaxBECount = getConstant(getUnsignedRangeMax(BECount));
-
- return ExitLimit(BECount, ConstantMaxBECount, false,
+ const SCEV *SymbolicMaxBECount =
+ isa<SCEVCouldNotCompute>(BECount) ? ConstantMaxBECount : BECount;
+ return ExitLimit(BECount, ConstantMaxBECount, SymbolicMaxBECount, false,
{ &EL0.Predicates, &EL1.Predicates });
}
@@ -9307,7 +9312,7 @@ ScalarEvolution::ExitLimit ScalarEvolution::computeShiftCompareExitLimit(
unsigned BitWidth = getTypeSizeInBits(RHS->getType());
const SCEV *UpperBound =
getConstant(getEffectiveSCEVType(RHS->getType()), BitWidth);
- return ExitLimit(getCouldNotCompute(), UpperBound, false);
+ return ExitLimit(getCouldNotCompute(), UpperBound, UpperBound, false);
}
return getCouldNotCompute();
@@ -10308,7 +10313,7 @@ ScalarEvolution::howFarToZero(const SCEV *V, const Loop *L, bool ControlsExit,
// should not accept a root of 2.
if (auto S = SolveQuadraticAddRecExact(AddRec, *this)) {
const auto *R = cast<SCEVConstant>(getConstant(*S));
- return ExitLimit(R, R, false, Predicates);
+ return ExitLimit(R, R, R, false, Predicates);
}
return getCouldNotCompute();
}
@@ -10373,7 +10378,8 @@ ScalarEvolution::howFarToZero(const SCEV *V, const Loop *L, bool ControlsExit,
ConstantRange CR = getUnsignedRange(DistancePlusOne);
MaxBECount = APIntOps::umin(MaxBECount, CR.getUnsignedMax() - 1);
}
- return ExitLimit(Distance, getConstant(MaxBECount), false, Predicates);
+ return ExitLimit(Distance, getConstant(MaxBECount), Distance, false,
+ Predicates);
}
// If the condition controls loop exit (the loop exits only if the expression
@@ -10385,12 +10391,15 @@ ScalarEvolution::howFarToZero(const SCEV *V, const Loop *L, bool ControlsExit,
loopHasNoAbnormalExits(AddRec->getLoop())) {
const SCEV *Exact =
getUDivExpr(Distance, CountDown ? getNegativeSCEV(Step) : Step);
- const SCEV *Max = getCouldNotCompute();
+ const SCEV *ConstantMax = getCouldNotCompute();
if (Exact != getCouldNotCompute()) {
APInt MaxInt = getUnsignedRangeMax(applyLoopGuards(Exact, L));
- Max = getConstant(APIntOps::umin(MaxInt, getUnsignedRangeMax(Exact)));
+ ConstantMax =
+ getConstant(APIntOps::umin(MaxInt, getUnsignedRangeMax(Exact)));
}
- return ExitLimit(Exact, Max, false, Predicates);
+ const SCEV *SymbolicMax =
+ isa<SCEVCouldNotCompute>(Exact) ? ConstantMax : Exact;
+ return ExitLimit(Exact, ConstantMax, SymbolicMax, false, Predicates);
}
// Solve the general equation.
@@ -10402,7 +10411,8 @@ ScalarEvolution::howFarToZero(const SCEV *V, const Loop *L, bool ControlsExit,
APInt MaxWithGuards = getUnsignedRangeMax(applyLoopGuards(E, L));
M = getConstant(APIntOps::umin(MaxWithGuards, getUnsignedRangeMax(E)));
}
- return ExitLimit(E, M, false, Predicates);
+ auto *S = isa<SCEVCouldNotCompute>(E) ? M : E;
+ return ExitLimit(E, M, S, false, Predicates);
}
ScalarEvolution::ExitLimit
@@ -12812,7 +12822,7 @@ ScalarEvolution::howManyLessThans(const SCEV *LHS, const SCEV *RHS,
const SCEV *MaxBECount = computeMaxBECountForLT(
Start, Stride, RHS, getTypeSizeInBits(LHS->getType()), IsSigned);
return ExitLimit(getCouldNotCompute() /* ExactNotTaken */, MaxBECount,
- false /*MaxOrZero*/, Predicates);
+ MaxBECount, false /*MaxOrZero*/, Predicates);
}
// We use the expression (max(End,Start)-Start)/Stride to describe the
@@ -12975,27 +12985,30 @@ ScalarEvolution::howManyLessThans(const SCEV *LHS, const SCEV *RHS,
}
}
- const SCEV *MaxBECount;
+ const SCEV *ConstantMaxBECount;
bool MaxOrZero = false;
if (isa<SCEVConstant>(BECount)) {
- MaxBECount = BECount;
+ ConstantMaxBECount = BECount;
} else if (BECountIfBackedgeTaken &&
isa<SCEVConstant>(BECountIfBackedgeTaken)) {
// If we know exactly how many times the backedge will be taken if it's
// taken at least once, then the backedge count will either be that or
// zero.
- MaxBECount = BECountIfBackedgeTaken;
+ ConstantMaxBECount = BECountIfBackedgeTaken;
MaxOrZero = true;
} else {
- MaxBECount = computeMaxBECountForLT(
+ ConstantMaxBECount = computeMaxBECountForLT(
Start, Stride, RHS, getTypeSizeInBits(LHS->getType()), IsSigned);
}
- if (isa<SCEVCouldNotCompute>(MaxBECount) &&
+ if (isa<SCEVCouldNotCompute>(ConstantMaxBECount) &&
!isa<SCEVCouldNotCompute>(BECount))
- MaxBECount = getConstant(getUnsignedRangeMax(BECount));
+ ConstantMaxBECount = getConstant(getUnsignedRangeMax(BECount));
- return ExitLimit(BECount, MaxBECount, MaxOrZero, Predicates);
+ const SCEV *SymbolicMaxBECount =
+ isa<SCEVCouldNotCompute>(BECount) ? ConstantMaxBECount : BECount;
+ return ExitLimit(BECount, ConstantMaxBECount, SymbolicMaxBECount, MaxOrZero,
+ Predicates);
}
ScalarEvolution::ExitLimit
@@ -13083,15 +13096,19 @@ ScalarEvolution::howManyGreaterThans(const SCEV *LHS, const SCEV *RHS,
IsSigned ? APIntOps::smax(getSignedRangeMin(RHS), Limit)
: APIntOps::umax(getUnsignedRangeMin(RHS), Limit);
- const SCEV *MaxBECount = isa<SCEVConstant>(BECount)
- ? BECount
- : getUDivCeilSCEV(getConstant(MaxStart - MinEnd),
- getConstant(MinStride));
+ const SCEV *ConstantMaxBECount =
+ isa<SCEVConstant>(BECount)
+ ? BECount
+ : getUDivCeilSCEV(getConstant(MaxStart - MinEnd),
+ getConstant(MinStride));
- if (isa<SCEVCouldNotCompute>(MaxBECount))
- MaxBECount = BECount;
+ if (isa<SCEVCouldNotCompute>(ConstantMaxBECount))
+ ConstantMaxBECount = BECount;
+ const SCEV *SymbolicMaxBECount =
+ isa<SCEVCouldNotCompute>(BECount) ? ConstantMaxBECount : BECount;
- return ExitLimit(BECount, MaxBECount, false, Predicates);
+ return ExitLimit(BECount, ConstantMaxBECount, SymbolicMaxBECount, false,
+ Predicates);
}
const SCEV *SCEVAddRecExpr::getNumIterationsInRange(const ConstantRange &Range,
More information about the llvm-commits
mailing list