From ed4cd79ffc74e174f028a9d8d9af2fc49d27ca86 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Mon, 13 Oct 2008 03:58:02 +0000 Subject: [PATCH] Disallow the construction of SCEVs with could-not-compute operands. Catch CNCs returned by BinomialCoefficient and don't try to operate with them. This replaces the previous fix for PR2857. llvm-svn: 57431 --- lib/Analysis/ScalarEvolution.cpp | 78 +++----------------------------- 1 file changed, 6 insertions(+), 72 deletions(-) diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp index 473057caf5a..e0750053eb9 100644 --- a/lib/Analysis/ScalarEvolution.cpp +++ b/lib/Analysis/ScalarEvolution.cpp @@ -644,11 +644,12 @@ SCEVHandle SCEVAddRecExpr::evaluateAtIteration(SCEVHandle It, // The computation is correct in the face of overflow provided that the // multiplication is performed _after_ the evaluation of the binomial // coefficient. - SCEVHandle Val = - SE.getMulExpr(getOperand(i), - BinomialCoefficient(It, i, SE, - cast(getType()))); - Result = SE.getAddExpr(Result, Val); + SCEVHandle Coeff = BinomialCoefficient(It, i, SE, + cast(getType())); + if (isa(Coeff)) + return Coeff; + + Result = SE.getAddExpr(Result, SE.getMulExpr(getOperand(i), Coeff)); } return Result; } @@ -676,9 +677,6 @@ SCEVHandle ScalarEvolution::getTruncateExpr(const SCEVHandle &Op, const Type *Ty return getAddRecExpr(Operands, AddRec->getLoop()); } - if (isa(Op)) - return new SCEVCouldNotCompute(); - SCEVTruncateExpr *&Result = (*SCEVTruncates)[std::make_pair(Op, Ty)]; if (Result == 0) Result = new SCEVTruncateExpr(Op, Ty); return Result; @@ -694,9 +692,6 @@ SCEVHandle ScalarEvolution::getZeroExtendExpr(const SCEVHandle &Op, const Type * // operands (often constants). This would allow analysis of something like // this: for (unsigned char X = 0; X < 100; ++X) { int Y = X; } - if (isa(Op)) - return new SCEVCouldNotCompute(); - SCEVZeroExtendExpr *&Result = (*SCEVZeroExtends)[std::make_pair(Op, Ty)]; if (Result == 0) Result = new SCEVZeroExtendExpr(Op, Ty); return Result; @@ -712,9 +707,6 @@ SCEVHandle ScalarEvolution::getSignExtendExpr(const SCEVHandle &Op, const Type * // operands (often constants). This would allow analysis of something like // this: for (signed char X = 0; X < 100; ++X) { int Y = X; } - if (isa(Op)) - return new SCEVCouldNotCompute(); - SCEVSignExtendExpr *&Result = (*SCEVSignExtends)[std::make_pair(Op, Ty)]; if (Result == 0) Result = new SCEVSignExtendExpr(Op, Ty); return Result; @@ -743,10 +735,6 @@ SCEVHandle ScalarEvolution::getAddExpr(std::vector &Ops) { // Sort by complexity, this groups all similar expression types together. GroupByComplexity(Ops); - // Could not compute plus anything equals could not compute. - if (isa(Ops.back())) - return new SCEVCouldNotCompute(); - // If there are any constants, fold them together. unsigned Idx = 0; if (SCEVConstant *LHSC = dyn_cast(Ops[0])) { @@ -972,21 +960,6 @@ SCEVHandle ScalarEvolution::getMulExpr(std::vector &Ops) { // Sort by complexity, this groups all similar expression types together. GroupByComplexity(Ops); - if (isa(Ops.back())) { - // CNC * 0 = 0 - for (unsigned i = 0, e = Ops.size() - 1; i != e; ++i) { - if (Ops[i]->getSCEVType() != scConstant) - break; - - SCEVConstant *SC = cast(Ops[i]); - if (SC->getValue()->isMinValue(false)) - return SC; - } - - // Otherwise, we can't compute it. - return new SCEVCouldNotCompute(); - } - // If there are any constants, fold them together. unsigned Idx = 0; if (SCEVConstant *LHSC = dyn_cast(Ops[0])) { @@ -1152,9 +1125,6 @@ SCEVHandle ScalarEvolution::getUDivExpr(const SCEVHandle &LHS, const SCEVHandle // FIXME: implement folding of (X*4)/4 when we know X*4 doesn't overflow. - if (isa(LHS) || isa(RHS)) - return new SCEVCouldNotCompute(); - SCEVUDivExpr *&Result = (*SCEVUDivs)[std::make_pair(LHS, RHS)]; if (Result == 0) Result = new SCEVUDivExpr(LHS, RHS); return Result; @@ -1202,12 +1172,6 @@ SCEVHandle ScalarEvolution::getAddRecExpr(std::vector &Operands, } } - // Refuse to build an AddRec out of SCEVCouldNotCompute. - for (unsigned i = 0, e = Operands.size(); i != e; ++i) { - if (isa(Operands[i])) - return new SCEVCouldNotCompute(); - } - SCEVAddRecExpr *&Result = (*SCEVAddRecExprs)[std::make_pair(L, std::vector(Operands.begin(), Operands.end()))]; @@ -1230,21 +1194,6 @@ SCEVHandle ScalarEvolution::getSMaxExpr(std::vector Ops) { // Sort by complexity, this groups all similar expression types together. GroupByComplexity(Ops); - if (isa(Ops.back())) { - // CNC smax +inf = +inf. - for (unsigned i = 0, e = Ops.size() - 1; i != e; ++i) { - if (Ops[i]->getSCEVType() != scConstant) - break; - - SCEVConstant *SC = cast(Ops[i]); - if (SC->getValue()->isMaxValue(true)) - return SC; - } - - // Otherwise, we can't compute it. - return new SCEVCouldNotCompute(); - } - // If there are any constants, fold them together. unsigned Idx = 0; if (SCEVConstant *LHSC = dyn_cast(Ops[0])) { @@ -1325,21 +1274,6 @@ SCEVHandle ScalarEvolution::getUMaxExpr(std::vector Ops) { // Sort by complexity, this groups all similar expression types together. GroupByComplexity(Ops); - if (isa(Ops[0])) { - // CNC umax inf = inf. - for (unsigned i = 0, e = Ops.size() - 1; i != e; ++i) { - if (Ops[i]->getSCEVType() != scConstant) - break; - - SCEVConstant *SC = cast(Ops[i]); - if (SC->getValue()->isMaxValue(false)) - return SC; - } - - // Otherwise, we can't compute it. - return new SCEVCouldNotCompute(); - } - // If there are any constants, fold them together. unsigned Idx = 0; if (SCEVConstant *LHSC = dyn_cast(Ops[0])) {