[llvm] 0159652 - Revert "Return "[LoopDeletion] Break backedge if we can prove that the loop is exited on 1st iteration" (try 2)"
David Blaikie via llvm-commits
llvm-commits at lists.llvm.org
Wed Jun 2 13:52:45 PDT 2021
Please include some details in the commit message about why a patch is
being reverted (helps folks know if the revert will address any issues
they're seeing and any future work can learn from previous issues)
On Fri, May 28, 2021 at 10:26 AM Stefan Pintilie via llvm-commits <
llvm-commits at lists.llvm.org> wrote:
>
> Author: Stefan Pintilie
> Date: 2021-05-28T12:21:22-05:00
> New Revision: 0159652058ca555b05db6a209fe9cf660c3bf8e6
>
> URL:
> https://github.com/llvm/llvm-project/commit/0159652058ca555b05db6a209fe9cf660c3bf8e6
> DIFF:
> https://github.com/llvm/llvm-project/commit/0159652058ca555b05db6a209fe9cf660c3bf8e6.diff
>
> LOG: Revert "Return "[LoopDeletion] Break backedge if we can prove that
> the loop is exited on 1st iteration" (try 2)"
>
> This reverts commit be1a23203b1de655b8c7dac7549818d975a0cbbf.
>
> Added:
>
>
> Modified:
> llvm/lib/Transforms/Scalar/LoopDeletion.cpp
> llvm/test/Transforms/LoopDeletion/eval_first_iteration.ll
> llvm/test/Transforms/LoopDeletion/zero-btc.ll
>
> Removed:
>
>
>
>
> ################################################################################
> diff --git a/llvm/lib/Transforms/Scalar/LoopDeletion.cpp
> b/llvm/lib/Transforms/Scalar/LoopDeletion.cpp
> index 41be776ec141..fd0e983b6199 100644
> --- a/llvm/lib/Transforms/Scalar/LoopDeletion.cpp
> +++ b/llvm/lib/Transforms/Scalar/LoopDeletion.cpp
> @@ -17,7 +17,6 @@
> #include "llvm/ADT/SmallVector.h"
> #include "llvm/ADT/Statistic.h"
> #include "llvm/Analysis/GlobalsModRef.h"
> -#include "llvm/Analysis/LoopIterator.h"
> #include "llvm/Analysis/LoopPass.h"
> #include "llvm/Analysis/MemorySSA.h"
> #include "llvm/Analysis/OptimizationRemarkEmitter.h"
> @@ -136,168 +135,6 @@ static bool isLoopNeverExecuted(Loop *L) {
> return true;
> }
>
> -static const SCEV *
> -getSCEVOnFirstIteration(Value *V, Loop *L, ScalarEvolution &SE,
> - DenseMap<Value *, const SCEV *> &FirstIterSCEV) {
> - // Fist, check in cache.
> - auto Existing = FirstIterSCEV.find(V);
> - if (Existing != FirstIterSCEV.end())
> - return Existing->second;
> - const SCEV *S = nullptr;
> - // TODO: Once ScalarEvolution supports getValueOnNthIteration for
> anything
> - // else but AddRecs, it's a good use case for it. So far, just consider
> some
> - // simple cases, like arithmetic operations.
> - Value *LHS, *RHS;
> - using namespace PatternMatch;
> - if (match(V, m_Add(m_Value(LHS), m_Value(RHS)))) {
> - const SCEV *LHSS = getSCEVOnFirstIteration(LHS, L, SE, FirstIterSCEV);
> - const SCEV *RHSS = getSCEVOnFirstIteration(RHS, L, SE, FirstIterSCEV);
> - S = SE.getAddExpr(LHSS, RHSS);
> - } else if (match(V, m_Sub(m_Value(LHS), m_Value(RHS)))) {
> - const SCEV *LHSS = getSCEVOnFirstIteration(LHS, L, SE, FirstIterSCEV);
> - const SCEV *RHSS = getSCEVOnFirstIteration(RHS, L, SE, FirstIterSCEV);
> - S = SE.getMinusSCEV(LHSS, RHSS);
> - } else if (match(V, m_Mul(m_Value(LHS), m_Value(RHS)))) {
> - const SCEV *LHSS = getSCEVOnFirstIteration(LHS, L, SE, FirstIterSCEV);
> - const SCEV *RHSS = getSCEVOnFirstIteration(RHS, L, SE, FirstIterSCEV);
> - S = SE.getMulExpr(LHSS, RHSS);
> - } else
> - S = SE.getSCEV(V);
> - assert(S && "Case not handled?");
> - FirstIterSCEV[V] = S;
> - return S;
> -}
> -
> -// Try to prove that one of conditions that dominates the latch must exit
> on 1st
> -// iteration.
> -static bool canProveExitOnFirstIteration(Loop *L, DominatorTree &DT,
> - ScalarEvolution &SE, LoopInfo
> &LI) {
> - BasicBlock *Latch = L->getLoopLatch();
> -
> - if (!Latch)
> - return false;
> -
> - LoopBlocksRPO RPOT(L);
> - RPOT.perform(&LI);
> -
> - BasicBlock *Header = L->getHeader();
> - // Blocks that are reachable on the 1st iteration.
> - SmallPtrSet<BasicBlock *, 4> LiveBlocks;
> - // Edges that are reachable on the 1st iteration.
> - DenseSet<BasicBlockEdge> LiveEdges;
> - LiveBlocks.insert(L->getHeader());
> -
> - auto MarkLiveEdge = [&](BasicBlock *From, BasicBlock *To) {
> - assert(LiveBlocks.count(From) && "Must be live!");
> - LiveBlocks.insert(To);
> - LiveEdges.insert({ From, To });
> - };
> -
> - auto MarkAllSuccessorsLive = [&](BasicBlock *BB) {
> - for (auto *Succ : successors(BB))
> - MarkLiveEdge(BB, Succ);
> - };
> -
> - // Check if there is only one predecessor on 1st iteration. Note that
> because
> - // we iterate in RPOT, we have already visited all its (non-latch)
> - // predecessors.
> - auto GetSolePredecessorOnFirstIteration = [&](BasicBlock *
> BB)->BasicBlock * {
> - if (BB == Header)
> - return L->getLoopPredecessor();
> - BasicBlock *OnlyPred = nullptr;
> - for (auto *Pred : predecessors(BB))
> - if (OnlyPred != Pred && LiveEdges.count({ Pred, BB })) {
> - // 2 live preds.
> - if (OnlyPred)
> - return nullptr;
> - OnlyPred = Pred;
> - }
> -
> - assert(OnlyPred && "No live predecessors?");
> - return OnlyPred;
> - };
> - DenseMap<Value *, const SCEV *> FirstIterSCEV;
> - SmallPtrSet<BasicBlock *, 4> Visited;
> -
> - // Use the following algorithm to prove we never take the latch on the
> 1st
> - // iteration:
> - // 1. Traverse in topological order, so that whenever we visit a block,
> all
> - // its predecessors are already visited.
> - // 2. If we can prove that the block may have only 1 predecessor on the
> 1st
> - // iteration, map all its phis onto input from this predecessor.
> - // 3a. If we can prove which successor of out block is taken on the 1st
> - // iteration, mark this successor live.
> - // 3b. If we cannot prove it, conservatively assume that all successors
> are
> - // live.
> - for (auto *BB : RPOT) {
> - Visited.insert(BB);
> -
> - // This block is not reachable on the 1st iterations.
> - if (!LiveBlocks.count(BB))
> - continue;
> -
> - // Skip inner loops.
> - if (LI.getLoopFor(BB) != L) {
> - MarkAllSuccessorsLive(BB);
> - continue;
> - }
> -
> - // If RPOT exists, we should never visit a block before all of its
> - // predecessors are visited. The only situation when this can be
> broken is
> - // irreducible CFG. Do not deal with such cases.
> - if (BB != Header)
> - for (auto *Pred : predecessors(BB))
> - if (!Visited.count(Pred))
> - return false;
> -
> - // If this block has only one live pred, map its phis onto their
> SCEVs.
> - if (auto *OnlyPred = GetSolePredecessorOnFirstIteration(BB))
> - for (auto &PN : BB->phis()) {
> - if (!SE.isSCEVable(PN.getType()))
> - continue;
> - auto *Incoming = PN.getIncomingValueForBlock(OnlyPred);
> - if (DT.dominates(Incoming, BB->getTerminator())) {
> - const SCEV *IncSCEV =
> - getSCEVOnFirstIteration(Incoming, L, SE, FirstIterSCEV);
> - FirstIterSCEV[&PN] = IncSCEV;
> - }
> - }
> -
> - using namespace PatternMatch;
> - ICmpInst::Predicate Pred;
> - Value *LHS, *RHS;
> - const BasicBlock *IfTrue, *IfFalse;
> - // TODO: Handle switches.
> - if (!match(BB->getTerminator(),
> - m_Br(m_ICmp(Pred, m_Value(LHS), m_Value(RHS)),
> - m_BasicBlock(IfTrue), m_BasicBlock(IfFalse)))) {
> - MarkAllSuccessorsLive(BB);
> - continue;
> - }
> -
> - if (!SE.isSCEVable(LHS->getType())) {
> - MarkAllSuccessorsLive(BB);
> - continue;
> - }
> -
> - // Can we prove constant true or false for this condition?
> - const SCEV *LHSS = getSCEVOnFirstIteration(LHS, L, SE, FirstIterSCEV);
> - const SCEV *RHSS = getSCEVOnFirstIteration(RHS, L, SE, FirstIterSCEV);
> - // TODO: isKnownPredicateAt is more powerful, but it's too compile
> time
> - // consuming. So we avoid using it here.
> - if (SE.isKnownPredicate(Pred, LHSS, RHSS))
> - MarkLiveEdge(BB, BB->getTerminator()->getSuccessor(0));
> - else if (SE.isKnownPredicate(ICmpInst::getInversePredicate(Pred),
> LHSS,
> - RHSS))
> - MarkLiveEdge(BB, BB->getTerminator()->getSuccessor(1));
> - else
> - MarkAllSuccessorsLive(BB);
> - }
> -
> - // We can break the latch if it wasn't live.
> - return !LiveEdges.count({ Latch, Header });
> -}
> -
> /// If we can prove the backedge is untaken, remove it. This destroys the
> /// loop, but leaves the (now trivially loop invariant) control flow and
> /// side effects (if any) in place.
> @@ -311,7 +148,7 @@ breakBackedgeIfNotTaken(Loop *L, DominatorTree &DT,
> ScalarEvolution &SE,
> return LoopDeletionResult::Unmodified;
>
> auto *BTC = SE.getBackedgeTakenCount(L);
> - if (!BTC->isZero() && !canProveExitOnFirstIteration(L, DT, SE, LI))
> + if (!BTC->isZero())
> return LoopDeletionResult::Unmodified;
>
> breakLoopBackedge(L, DT, SE, LI, MSSA);
>
> diff --git a/llvm/test/Transforms/LoopDeletion/eval_first_iteration.ll
> b/llvm/test/Transforms/LoopDeletion/eval_first_iteration.ll
> index bed479e408eb..98dafebe0df0 100644
> --- a/llvm/test/Transforms/LoopDeletion/eval_first_iteration.ll
> +++ b/llvm/test/Transforms/LoopDeletion/eval_first_iteration.ll
> @@ -344,19 +344,17 @@ define i32 @test_ne_const() {
> ; CHECK-NEXT: entry:
> ; CHECK-NEXT: br label [[LOOP:%.*]]
> ; CHECK: loop:
> -; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ]
> +; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [
> [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ]
> ; CHECK-NEXT: [[SUB:%.*]] = sub i32 4, [[SUM]]
> ; CHECK-NEXT: [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
> -; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE:%.*]], label
> [[IF_FALSE:%.*]]
> +; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label
> [[IF_FALSE:%.*]]
> ; CHECK: if.false:
> ; CHECK-NEXT: br label [[BACKEDGE]]
> ; CHECK: backedge:
> ; CHECK-NEXT: [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [
> [[SUB]], [[LOOP]] ]
> -; CHECK-NEXT: [[SUM_NEXT:%.*]] = add i32 [[SUM]], [[MERGE_PHI]]
> +; CHECK-NEXT: [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
> ; CHECK-NEXT: [[LOOP_COND:%.*]] = icmp ne i32 [[SUM_NEXT]], 4
> -; CHECK-NEXT: br i1 [[LOOP_COND]], label
> [[BACKEDGE_LOOP_CRIT_EDGE:%.*]], label [[DONE:%.*]]
> -; CHECK: backedge.loop_crit_edge:
> -; CHECK-NEXT: unreachable
> +; CHECK-NEXT: br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
> ; CHECK: done:
> ; CHECK-NEXT: [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]],
> [[BACKEDGE]] ]
> ; CHECK-NEXT: ret i32 [[SUM_NEXT_LCSSA]]
> @@ -396,19 +394,17 @@ define i32 @test_slt_const() {
> ; CHECK-NEXT: entry:
> ; CHECK-NEXT: br label [[LOOP:%.*]]
> ; CHECK: loop:
> -; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ]
> +; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [
> [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ]
> ; CHECK-NEXT: [[SUB:%.*]] = sub i32 4, [[SUM]]
> ; CHECK-NEXT: [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
> -; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE:%.*]], label
> [[IF_FALSE:%.*]]
> +; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label
> [[IF_FALSE:%.*]]
> ; CHECK: if.false:
> ; CHECK-NEXT: br label [[BACKEDGE]]
> ; CHECK: backedge:
> ; CHECK-NEXT: [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [
> [[SUB]], [[LOOP]] ]
> -; CHECK-NEXT: [[SUM_NEXT:%.*]] = add i32 [[SUM]], [[MERGE_PHI]]
> +; CHECK-NEXT: [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
> ; CHECK-NEXT: [[LOOP_COND:%.*]] = icmp slt i32 [[SUM_NEXT]], 4
> -; CHECK-NEXT: br i1 [[LOOP_COND]], label
> [[BACKEDGE_LOOP_CRIT_EDGE:%.*]], label [[DONE:%.*]]
> -; CHECK: backedge.loop_crit_edge:
> -; CHECK-NEXT: unreachable
> +; CHECK-NEXT: br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
> ; CHECK: done:
> ; CHECK-NEXT: [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]],
> [[BACKEDGE]] ]
> ; CHECK-NEXT: ret i32 [[SUM_NEXT_LCSSA]]
> @@ -448,19 +444,17 @@ define i32 @test_ult_const() {
> ; CHECK-NEXT: entry:
> ; CHECK-NEXT: br label [[LOOP:%.*]]
> ; CHECK: loop:
> -; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ]
> +; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [
> [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ]
> ; CHECK-NEXT: [[SUB:%.*]] = sub i32 4, [[SUM]]
> ; CHECK-NEXT: [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
> -; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE:%.*]], label
> [[IF_FALSE:%.*]]
> +; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label
> [[IF_FALSE:%.*]]
> ; CHECK: if.false:
> ; CHECK-NEXT: br label [[BACKEDGE]]
> ; CHECK: backedge:
> ; CHECK-NEXT: [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [
> [[SUB]], [[LOOP]] ]
> -; CHECK-NEXT: [[SUM_NEXT:%.*]] = add i32 [[SUM]], [[MERGE_PHI]]
> +; CHECK-NEXT: [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
> ; CHECK-NEXT: [[LOOP_COND:%.*]] = icmp ult i32 [[SUM_NEXT]], 4
> -; CHECK-NEXT: br i1 [[LOOP_COND]], label
> [[BACKEDGE_LOOP_CRIT_EDGE:%.*]], label [[DONE:%.*]]
> -; CHECK: backedge.loop_crit_edge:
> -; CHECK-NEXT: unreachable
> +; CHECK-NEXT: br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
> ; CHECK: done:
> ; CHECK-NEXT: [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]],
> [[BACKEDGE]] ]
> ; CHECK-NEXT: ret i32 [[SUM_NEXT_LCSSA]]
> @@ -500,19 +494,17 @@ define i32 @test_sgt_const() {
> ; CHECK-NEXT: entry:
> ; CHECK-NEXT: br label [[LOOP:%.*]]
> ; CHECK: loop:
> -; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ]
> +; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [
> [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ]
> ; CHECK-NEXT: [[SUB:%.*]] = sub i32 4, [[SUM]]
> ; CHECK-NEXT: [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
> -; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE:%.*]], label
> [[IF_FALSE:%.*]]
> +; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label
> [[IF_FALSE:%.*]]
> ; CHECK: if.false:
> ; CHECK-NEXT: br label [[BACKEDGE]]
> ; CHECK: backedge:
> ; CHECK-NEXT: [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [
> [[SUB]], [[LOOP]] ]
> -; CHECK-NEXT: [[SUM_NEXT:%.*]] = add i32 [[SUM]], [[MERGE_PHI]]
> +; CHECK-NEXT: [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
> ; CHECK-NEXT: [[LOOP_COND:%.*]] = icmp sgt i32 [[SUM_NEXT]], 4
> -; CHECK-NEXT: br i1 [[LOOP_COND]], label
> [[BACKEDGE_LOOP_CRIT_EDGE:%.*]], label [[DONE:%.*]]
> -; CHECK: backedge.loop_crit_edge:
> -; CHECK-NEXT: unreachable
> +; CHECK-NEXT: br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
> ; CHECK: done:
> ; CHECK-NEXT: [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]],
> [[BACKEDGE]] ]
> ; CHECK-NEXT: ret i32 [[SUM_NEXT_LCSSA]]
> @@ -552,19 +544,17 @@ define i32 @test_ugt_const() {
> ; CHECK-NEXT: entry:
> ; CHECK-NEXT: br label [[LOOP:%.*]]
> ; CHECK: loop:
> -; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ]
> +; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [
> [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ]
> ; CHECK-NEXT: [[SUB:%.*]] = sub i32 4, [[SUM]]
> ; CHECK-NEXT: [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
> -; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE:%.*]], label
> [[IF_FALSE:%.*]]
> +; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[BACKEDGE]], label
> [[IF_FALSE:%.*]]
> ; CHECK: if.false:
> ; CHECK-NEXT: br label [[BACKEDGE]]
> ; CHECK: backedge:
> ; CHECK-NEXT: [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [
> [[SUB]], [[LOOP]] ]
> -; CHECK-NEXT: [[SUM_NEXT:%.*]] = add i32 [[SUM]], [[MERGE_PHI]]
> +; CHECK-NEXT: [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
> ; CHECK-NEXT: [[LOOP_COND:%.*]] = icmp ugt i32 [[SUM_NEXT]], 4
> -; CHECK-NEXT: br i1 [[LOOP_COND]], label
> [[BACKEDGE_LOOP_CRIT_EDGE:%.*]], label [[DONE:%.*]]
> -; CHECK: backedge.loop_crit_edge:
> -; CHECK-NEXT: unreachable
> +; CHECK-NEXT: br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
> ; CHECK: done:
> ; CHECK-NEXT: [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]],
> [[BACKEDGE]] ]
> ; CHECK-NEXT: ret i32 [[SUM_NEXT_LCSSA]]
> @@ -604,24 +594,22 @@ define i32 @test_multiple_pred_const() {
> ; CHECK-NEXT: entry:
> ; CHECK-NEXT: br label [[LOOP:%.*]]
> ; CHECK: loop:
> -; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ]
> +; CHECK-NEXT: [[SUM:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [
> [[SUM_NEXT:%.*]], [[BACKEDGE:%.*]] ]
> ; CHECK-NEXT: [[SUB:%.*]] = sub i32 4, [[SUM]]
> ; CHECK-NEXT: [[IS_POSITIVE:%.*]] = icmp sgt i32 [[SUB]], 0
> ; CHECK-NEXT: br i1 [[IS_POSITIVE]], label [[IF_TRUE:%.*]], label
> [[IF_FALSE:%.*]]
> ; CHECK: if.true:
> ; CHECK-NEXT: switch i32 4, label [[FAILURE:%.*]] [
> -; CHECK-NEXT: i32 100, label [[BACKEDGE:%.*]]
> +; CHECK-NEXT: i32 100, label [[BACKEDGE]]
> ; CHECK-NEXT: i32 200, label [[BACKEDGE]]
> ; CHECK-NEXT: ]
> ; CHECK: if.false:
> ; CHECK-NEXT: br label [[BACKEDGE]]
> ; CHECK: backedge:
> ; CHECK-NEXT: [[MERGE_PHI:%.*]] = phi i32 [ 0, [[IF_FALSE]] ], [
> [[SUB]], [[IF_TRUE]] ], [ [[SUB]], [[IF_TRUE]] ]
> -; CHECK-NEXT: [[SUM_NEXT:%.*]] = add i32 [[SUM]], [[MERGE_PHI]]
> +; CHECK-NEXT: [[SUM_NEXT]] = add i32 [[SUM]], [[MERGE_PHI]]
> ; CHECK-NEXT: [[LOOP_COND:%.*]] = icmp ne i32 [[SUM_NEXT]], 4
> -; CHECK-NEXT: br i1 [[LOOP_COND]], label
> [[BACKEDGE_LOOP_CRIT_EDGE:%.*]], label [[DONE:%.*]]
> -; CHECK: backedge.loop_crit_edge:
> -; CHECK-NEXT: unreachable
> +; CHECK-NEXT: br i1 [[LOOP_COND]], label [[LOOP]], label [[DONE:%.*]]
> ; CHECK: done:
> ; CHECK-NEXT: [[SUM_NEXT_LCSSA:%.*]] = phi i32 [ [[SUM_NEXT]],
> [[BACKEDGE]] ]
> ; CHECK-NEXT: ret i32 [[SUM_NEXT_LCSSA]]
>
> diff --git a/llvm/test/Transforms/LoopDeletion/zero-btc.ll
> b/llvm/test/Transforms/LoopDeletion/zero-btc.ll
> index 958de0505af7..413b0a877dd4 100644
> --- a/llvm/test/Transforms/LoopDeletion/zero-btc.ll
> +++ b/llvm/test/Transforms/LoopDeletion/zero-btc.ll
> @@ -161,16 +161,14 @@ define void @test_multi_exit3(i1 %cond1) {
> ; CHECK-NEXT: entry:
> ; CHECK-NEXT: br label [[LOOP:%.*]]
> ; CHECK: loop:
> -; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ]
> +; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [
> [[IV_INC:%.*]], [[LATCH:%.*]] ]
> ; CHECK-NEXT: store i32 0, i32* @G, align 4
> -; CHECK-NEXT: br i1 [[COND1:%.*]], label [[LATCH:%.*]], label
> [[EXIT:%.*]]
> +; CHECK-NEXT: br i1 [[COND1:%.*]], label [[LATCH]], label [[EXIT:%.*]]
> ; CHECK: latch:
> ; CHECK-NEXT: store i32 1, i32* @G, align 4
> -; CHECK-NEXT: [[IV_INC:%.*]] = add i32 [[IV]], 1
> +; CHECK-NEXT: [[IV_INC]] = add i32 [[IV]], 1
> ; CHECK-NEXT: [[BE_TAKEN:%.*]] = icmp ne i32 [[IV_INC]], 1
> -; CHECK-NEXT: br i1 [[BE_TAKEN]], label [[LATCH_LOOP_CRIT_EDGE:%.*]],
> label [[EXIT]]
> -; CHECK: latch.loop_crit_edge:
> -; CHECK-NEXT: unreachable
> +; CHECK-NEXT: br i1 [[BE_TAKEN]], label [[LOOP]], label [[EXIT]]
> ; CHECK: exit:
> ; CHECK-NEXT: ret void
> ;
>
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20210602/c3e97496/attachment.html>
More information about the llvm-commits
mailing list