From d594e6f0345b3e1e4b640a7099596ca613da16d6 Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Sun, 24 May 2009 23:25:42 +0000 Subject: [PATCH] Change ScalarEvolution::getSCEVAtScope to always return the original value in the case where a loop exit value cannot be computed, instead of only in some cases while using SCEVCouldNotCompute in others. This simplifies getSCEVAtScope's callers. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@72375 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/ScalarEvolution.h | 4 ++-- lib/Analysis/ScalarEvolution.cpp | 29 ++++++++--------------------- lib/Transforms/Scalar/IndVarSimplify.cpp | 6 ++---- 3 files changed, 12 insertions(+), 27 deletions(-) diff --git a/include/llvm/Analysis/ScalarEvolution.h b/include/llvm/Analysis/ScalarEvolution.h index 7019516a91a..859cb330bc7 100644 --- a/include/llvm/Analysis/ScalarEvolution.h +++ b/include/llvm/Analysis/ScalarEvolution.h @@ -490,8 +490,8 @@ namespace llvm { /// This method can be used to compute the exit value for a variable defined /// in a loop by querying what the value will hold in the parent loop. /// - /// If this value is not computable at this scope, a SCEVCouldNotCompute - /// object is returned. + /// In the case that a relevant loop exit value cannot be computed, the + /// original value V is returned. SCEVHandle getSCEVAtScope(const SCEV *S, const Loop *L); /// getSCEVAtScope - This is a convenience function which does diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp index 85586a20ebf..6c970e7175d 100644 --- a/lib/Analysis/ScalarEvolution.cpp +++ b/lib/Analysis/ScalarEvolution.cpp @@ -2521,10 +2521,8 @@ ScalarEvolution::ComputeBackedgeTakenCount(const Loop *L) { SCEVHandle RHS = getSCEV(ExitCond->getOperand(1)); // Try to evaluate any dependencies out of the loop. - SCEVHandle Tmp = getSCEVAtScope(LHS, L); - if (!isa(Tmp)) LHS = Tmp; - Tmp = getSCEVAtScope(RHS, L); - if (!isa(Tmp)) RHS = Tmp; + LHS = getSCEVAtScope(LHS, L); + RHS = getSCEVAtScope(RHS, L); // At this point, we would like to compute how many iterations of the // loop the predicate will return true for these inputs. @@ -2680,8 +2678,7 @@ ComputeLoadConstantCompareBackedgeTakenCount(LoadInst *LI, Constant *RHS, // Okay, we know we have a (load (gep GV, 0, X)) comparison with a constant. // Check to see if X is a loop variant variable value now. SCEVHandle Idx = getSCEV(VarIdx); - SCEVHandle Tmp = getSCEVAtScope(Idx, L); - if (!isa(Tmp)) Idx = Tmp; + Idx = getSCEVAtScope(Idx, L); // We can only recognize very limited forms of loop index expressions, in // particular, only affine AddRec's like {C1,+,C2}. @@ -2911,8 +2908,8 @@ ComputeBackedgeTakenCountExhaustively(const Loop *L, Value *Cond, bool ExitWhen) /// This method can be used to compute the exit value for a variable defined /// in a loop by querying what the value will hold in the parent loop. /// -/// If this value is not computable at this scope, a SCEVCouldNotCompute -/// object is returned. +/// In the case that a relevant loop exit value cannot be computed, the +/// original value V is returned. SCEVHandle ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) { // FIXME: this should be turned into a virtual method on SCEV! @@ -3016,7 +3013,6 @@ SCEVHandle ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) { for (unsigned i = 0, e = Comm->getNumOperands(); i != e; ++i) { SCEVHandle OpAtScope = getSCEVAtScope(Comm->getOperand(i), L); if (OpAtScope != Comm->getOperand(i)) { - if (OpAtScope == UnknownValue) return UnknownValue; // Okay, at least one of these operands is loop variant but might be // foldable. Build a new instance of the folded commutative expression. std::vector NewOps(Comm->op_begin(), Comm->op_begin()+i); @@ -3024,7 +3020,6 @@ SCEVHandle ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) { for (++i; i != e; ++i) { OpAtScope = getSCEVAtScope(Comm->getOperand(i), L); - if (OpAtScope == UnknownValue) return UnknownValue; NewOps.push_back(OpAtScope); } if (isa(Comm)) @@ -3044,9 +3039,7 @@ SCEVHandle ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) { if (const SCEVUDivExpr *Div = dyn_cast(V)) { SCEVHandle LHS = getSCEVAtScope(Div->getLHS(), L); - if (LHS == UnknownValue) return LHS; SCEVHandle RHS = getSCEVAtScope(Div->getRHS(), L); - if (RHS == UnknownValue) return RHS; if (LHS == Div->getLHS() && RHS == Div->getRHS()) return Div; // must be loop invariant return getUDivExpr(LHS, RHS); @@ -3059,17 +3052,16 @@ SCEVHandle ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) { // To evaluate this recurrence, we need to know how many times the AddRec // loop iterates. Compute this now. SCEVHandle BackedgeTakenCount = getBackedgeTakenCount(AddRec->getLoop()); - if (BackedgeTakenCount == UnknownValue) return UnknownValue; + if (BackedgeTakenCount == UnknownValue) return AddRec; // Then, evaluate the AddRec. return AddRec->evaluateAtIteration(BackedgeTakenCount, *this); } - return UnknownValue; + return AddRec; } if (const SCEVZeroExtendExpr *Cast = dyn_cast(V)) { SCEVHandle Op = getSCEVAtScope(Cast->getOperand(), L); - if (Op == UnknownValue) return Op; if (Op == Cast->getOperand()) return Cast; // must be loop invariant return getZeroExtendExpr(Op, Cast->getType()); @@ -3077,7 +3069,6 @@ SCEVHandle ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) { if (const SCEVSignExtendExpr *Cast = dyn_cast(V)) { SCEVHandle Op = getSCEVAtScope(Cast->getOperand(), L); - if (Op == UnknownValue) return Op; if (Op == Cast->getOperand()) return Cast; // must be loop invariant return getSignExtendExpr(Op, Cast->getType()); @@ -3085,7 +3076,6 @@ SCEVHandle ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) { if (const SCEVTruncateExpr *Cast = dyn_cast(V)) { SCEVHandle Op = getSCEVAtScope(Cast->getOperand(), L); - if (Op == UnknownValue) return Op; if (Op == Cast->getOperand()) return Cast; // must be loop invariant return getTruncateExpr(Op, Cast->getType()); @@ -3238,8 +3228,6 @@ SCEVHandle ScalarEvolution::HowFarToZero(const SCEV *V, const Loop *L) { // Get the initial value for the loop. SCEVHandle Start = getSCEVAtScope(AddRec->getStart(), L->getParentLoop()); - if (isa(Start)) return UnknownValue; - SCEVHandle Step = getSCEVAtScope(AddRec->getOperand(1), L->getParentLoop()); if (const SCEVConstant *StepC = dyn_cast(Step)) { @@ -3805,14 +3793,13 @@ void ScalarEvolution::print(raw_ostream &OS, const Module* ) const { if (const Loop *L = LI->getLoopFor((*I).getParent())) { OS << "Exits: "; SCEVHandle ExitValue = SE.getSCEVAtScope(&*I, L->getParentLoop()); - if (isa(ExitValue)) { + if (!ExitValue->isLoopInvariant(L)) { OS << "<>"; } else { OS << *ExitValue; } } - OS << "\n"; } diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp index 7300bf47fe7..ca7aa7bd30d 100644 --- a/lib/Transforms/Scalar/IndVarSimplify.cpp +++ b/lib/Transforms/Scalar/IndVarSimplify.cpp @@ -275,10 +275,8 @@ void IndVarSimplify::RewriteLoopExitValues(Loop *L, // Okay, this instruction has a user outside of the current loop // and varies predictably *inside* the loop. Evaluate the value it // contains when the loop exits, if possible. - SCEVHandle SH = SE->getSCEV(Inst); - SCEVHandle ExitValue = SE->getSCEVAtScope(SH, L->getParentLoop()); - if (isa(ExitValue) || - !ExitValue->isLoopInvariant(L)) + SCEVHandle ExitValue = SE->getSCEVAtScope(Inst, L->getParentLoop()); + if (!ExitValue->isLoopInvariant(L)) continue; Changed = true; -- 2.11.0