From 53e751fcba7a5b3bb6eecde18e5590f2051b1453 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Sat, 4 Oct 2008 11:19:07 +0000 Subject: [PATCH] Allow the construction of SCEVs with SCEVCouldNotCompute operands, by implementing folding. Fixes PR2857. llvm-svn: 57049 --- lib/Analysis/ScalarEvolution.cpp | 67 +++++++++++++++++++ .../2008-10-03-CouldNotCompute.ll | 32 +++++++++ 2 files changed, 99 insertions(+) create mode 100644 test/Transforms/IndVarsSimplify/2008-10-03-CouldNotCompute.ll diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp index 51258044691..473057caf5a 100644 --- a/lib/Analysis/ScalarEvolution.cpp +++ b/lib/Analysis/ScalarEvolution.cpp @@ -676,6 +676,9 @@ 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; @@ -691,6 +694,9 @@ 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; @@ -706,6 +712,9 @@ 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; @@ -734,6 +743,10 @@ 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])) { @@ -959,6 +972,21 @@ 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])) { @@ -1124,6 +1152,9 @@ 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; @@ -1171,6 +1202,12 @@ 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()))]; @@ -1193,6 +1230,21 @@ 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])) { @@ -1273,6 +1325,21 @@ 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])) { diff --git a/test/Transforms/IndVarsSimplify/2008-10-03-CouldNotCompute.ll b/test/Transforms/IndVarsSimplify/2008-10-03-CouldNotCompute.ll new file mode 100644 index 00000000000..c78188d4d22 --- /dev/null +++ b/test/Transforms/IndVarsSimplify/2008-10-03-CouldNotCompute.ll @@ -0,0 +1,32 @@ +; RUN: llvm-as < %s | opt -indvars +; PR2857 + +@foo = external global i32 ; [#uses=1] + +define void @test(i32 %n, i32 %arg) { +entry: + br i1 false, label %bb.nph, label %return + +bb.nph: ; preds = %entry + %0 = load i32* @foo, align 4 ; [#uses=1] + %1 = sext i32 %0 to i64 ; [#uses=1] + br label %bb + +bb: ; preds = %bb, %bb.nph + %.in = phi i32 [ %2, %bb ], [ %n, %bb.nph ] ; [#uses=1] + %val.02 = phi i64 [ %5, %bb ], [ 0, %bb.nph ] ; [#uses=2] + %result.01 = phi i64 [ %4, %bb ], [ 0, %bb.nph ] ; [#uses=1] + %2 = add i32 %.in, -1 ; [#uses=2] + %3 = mul i64 %1, %val.02 ; [#uses=1] + %4 = add i64 %3, %result.01 ; [#uses=2] + %5 = add i64 %val.02, 1 ; [#uses=1] + %6 = icmp sgt i32 %2, 0 ; [#uses=1] + br i1 %6, label %bb, label %bb3.bb4_crit_edge + +bb3.bb4_crit_edge: ; preds = %bb + %.lcssa = phi i64 [ %4, %bb ] ; [#uses=0] + ret void + +return: ; preds = %entry + ret void +}