From b8354dd5d80607e361bdcb57a23aba5d7627cca3 Mon Sep 17 00:00:00 2001 From: Jatin Bhateja Date: Wed, 18 Oct 2017 01:36:16 +0000 Subject: [PATCH] [ScalarEvolution] Handling for ICmp occuring in the evolution chain. Summary: If a compare instruction is same or inverse of the compare in the branch of the loop latch, then return a constant evolution node. Currently scope of evaluation is limited to SCEV computation for PHI nodes. This shall facilitate computations of loop exit counts in cases where compare appears in the evolution chain of induction variables. Will fix PR 34538 Reviewers: sanjoy, hfinkel, junryoungju Reviewed By: junryoungju Subscribers: javed.absar, llvm-commits Differential Revision: https://reviews.llvm.org/D38494 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@316054 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/ScalarEvolution.h | 3 ++ lib/Analysis/ScalarEvolution.cpp | 45 ++++++++++++++++++-- lib/Transforms/Scalar/LoopStrengthReduce.cpp | 7 ++- test/Analysis/ScalarEvolution/pr34538.ll | 19 +++++++++ 4 files changed, 69 insertions(+), 5 deletions(-) create mode 100644 test/Analysis/ScalarEvolution/pr34538.ll diff --git a/include/llvm/Analysis/ScalarEvolution.h b/include/llvm/Analysis/ScalarEvolution.h index 3190e7f56cf..af54e536277 100644 --- a/include/llvm/Analysis/ScalarEvolution.h +++ b/include/llvm/Analysis/ScalarEvolution.h @@ -1378,6 +1378,9 @@ private: /// Helper function called from createNodeForPHI. const SCEV *createAddRecFromPHI(PHINode *PN); + /// Evaluate ICmpInst to a constant node for special patterns. + const SCEV *evaluateForICmp(ICmpInst *IC); + /// A helper function for createAddRecFromPHI to handle simple cases. const SCEV *createSimpleAffineAddRec(PHINode *PN, Value *BEValueV, Value *StartValueV); diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp index c69bd601aff..e872e81a5e7 100644 --- a/lib/Analysis/ScalarEvolution.cpp +++ b/lib/Analysis/ScalarEvolution.cpp @@ -4756,11 +4756,26 @@ const SCEV *ScalarEvolution::createAddRecFromPHI(PHINode *PN) { Ops.push_back(Add->getOperand(i)); const SCEV *Accum = getAddExpr(Ops); + bool InvariantF = isLoopInvariant(Accum, L); + + if (!InvariantF && Accum->getSCEVType() == scZeroExtend) { + const SCEV *Op = dyn_cast(Accum)->getOperand(); + const SCEVUnknown *Un = dyn_cast(Op); + if (Un && Un->getValue() && isa(Un->getValue()) && + dyn_cast(Un->getValue())->getOpcode() == + Instruction::ICmp) { + const SCEV *ICmpSC = evaluateForICmp(cast(Un->getValue())); + bool IsConstSC = ICmpSC->getSCEVType() == scConstant; + Accum = + IsConstSC ? getZeroExtendExpr(ICmpSC, Accum->getType()) : Accum; + InvariantF = IsConstSC ? true : false; + } + } + // This is not a valid addrec if the step amount is varying each // loop iteration, but is not itself an addrec in this loop. - if (isLoopInvariant(Accum, L) || - (isa(Accum) && - cast(Accum)->getLoop() == L)) { + if (InvariantF || (isa(Accum) && + cast(Accum)->getLoop() == L)) { SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap; if (auto BO = MatchBinaryOp(BEValueV, DT)) { @@ -6443,6 +6458,30 @@ void ScalarEvolution::forgetLoop(const Loop *L) { } } + +const SCEV *ScalarEvolution::evaluateForICmp(ICmpInst *IC) { + BasicBlock *Latch = nullptr; + const Loop *L = LI.getLoopFor(IC->getParent()); + + // If compare instruction is same or inverse of the compare in the + // branch of the loop latch, then return a constant evolution + // node. This shall facilitate computations of loop exit counts + // in cases where compare appears in the evolution chain of induction + // variables. + if (L && (Latch = L->getLoopLatch())) { + BranchInst *BI = dyn_cast(Latch->getTerminator()); + if (BI && BI->isConditional() && BI->getCondition() == IC) { + if (BI->getSuccessor(0) != L->getHeader()) + return getZero(Type::getInt1Ty(getContext())); + else + return getOne(Type::getInt1Ty(getContext())); + } + } + + return getUnknown(IC); +} + + void ScalarEvolution::forgetValue(Value *V) { Instruction *I = dyn_cast(V); if (!I) return; diff --git a/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/lib/Transforms/Scalar/LoopStrengthReduce.cpp index 6462e3fb856..8551392baa8 100644 --- a/lib/Transforms/Scalar/LoopStrengthReduce.cpp +++ b/lib/Transforms/Scalar/LoopStrengthReduce.cpp @@ -2973,8 +2973,11 @@ void LSRInstance::CollectChains() { // Ignore users that are part of a SCEV expression. This way we only // consider leaf IV Users. This effectively rediscovers a portion of // IVUsers analysis but in program order this time. - if (SE.isSCEVable(I.getType()) && !isa(SE.getSCEV(&I))) - continue; + if (SE.isSCEVable(I.getType())) { + const SCEV *SI = SE.getSCEV(&I); + if (!isa(SI) && !isa(SI)) + continue; + } // Remove this instruction from any NearUsers set it may be in. for (unsigned ChainIdx = 0, NChains = IVChainVec.size(); diff --git a/test/Analysis/ScalarEvolution/pr34538.ll b/test/Analysis/ScalarEvolution/pr34538.ll new file mode 100644 index 00000000000..0aa72c36de4 --- /dev/null +++ b/test/Analysis/ScalarEvolution/pr34538.ll @@ -0,0 +1,19 @@ +; RUN: opt -S -scalar-evolution -loop-deletion -simplifycfg -analyze < %s | FileCheck %s --check-prefix=CHECK-ANALYSIS + +define i32 @foo() local_unnamed_addr #0 { +; CHECK-ANALYSIS: Loop %do.body: backedge-taken count is 10000 +; CHECK-ANALYSIS: Loop %do.body: max backedge-taken count is 10000 +; CHECK-ANALYSIS: Loop %do.body: Predicated backedge-taken count is 10000 +entry: + br label %do.body + +do.body: ; preds = %do.body, %entry + %start.0 = phi i32 [ 0, %entry ], [ %inc.start.0, %do.body ] + %cmp = icmp slt i32 %start.0, 10000 + %inc = zext i1 %cmp to i32 + %inc.start.0 = add nsw i32 %start.0, %inc + br i1 %cmp, label %do.body, label %do.end + +do.end: ; preds = %do.body + ret i32 0 +}