[llvm] r347183 - [LoopSimplifyCFG] Teach LoopSimplifyCFG to constant-fold branches and switches
Benjamin Kramer via llvm-commits
llvm-commits at lists.llvm.org
Mon Nov 19 12:05:09 PST 2018
This crashes clang while building libxml. reverted in r347260
$ clang -O3 -fexperimental-new-pass-manager t.i -c -o /dev/null -w
PHINode should have one entry for each predecessor of its parent basic
block!
%h.0 = phi i32 [ 0, %while.body ], [ 1,
%for.body.if.end5.loopexit_crit_edge ], [ 0, %for.cond.preheader ]
in function g
fatal error: error in backend: Broken function found, compilation aborted!
On Mon, Nov 19, 2018 at 6:57 AM Max Kazantsev via llvm-commits <
llvm-commits at lists.llvm.org> wrote:
> Author: mkazantsev
> Date: Sun Nov 18 21:54:38 2018
> New Revision: 347183
>
> URL: http://llvm.org/viewvc/llvm-project?rev=347183&view=rev
> Log:
> [LoopSimplifyCFG] Teach LoopSimplifyCFG to constant-fold branches and
> switches
>
> This patch introduces infrastructure and the simplest case for
> constant-folding
> of branch and switch instructions within loop into unconditional branches.
> It is useful as a cleanup for such passes as loop unswitching that
> sometimes
> produce such branches.
>
> Only the simplest case supported in this patch: after the folding, no block
> should become dead or stop being part of the loop. Support for more
> sophisticated cases will go separately in follow-up patches.
>
> Differential Revision: https://reviews.llvm.org/D54021
> Reviewed By: anna
>
> Modified:
> llvm/trunk/lib/Transforms/Scalar/LoopSimplifyCFG.cpp
> llvm/trunk/test/Transforms/LoopSimplifyCFG/constant-fold-branch.ll
>
> Modified: llvm/trunk/lib/Transforms/Scalar/LoopSimplifyCFG.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/LoopSimplifyCFG.cpp?rev=347183&r1=347182&r2=347183&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/LoopSimplifyCFG.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/LoopSimplifyCFG.cpp Sun Nov 18
> 21:54:38 2018
> @@ -41,6 +41,316 @@ using namespace llvm;
>
> #define DEBUG_TYPE "loop-simplifycfg"
>
> +STATISTIC(NumTerminatorsFolded,
> + "Number of terminators folded to unconditional branches");
> +
> +/// If \p BB is a switch or a conditional branch, but only one of its
> successors
> +/// can be reached from this block in runtime, return this successor.
> Otherwise,
> +/// return nullptr.
> +static BasicBlock *getOnlyLiveSuccessor(BasicBlock *BB) {
> + Instruction *TI = BB->getTerminator();
> + if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
> + if (BI->isUnconditional())
> + return nullptr;
> + if (BI->getSuccessor(0) == BI->getSuccessor(1))
> + return BI->getSuccessor(0);
> + ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
> + if (!Cond)
> + return nullptr;
> + return Cond->isZero() ? BI->getSuccessor(1) : BI->getSuccessor(0);
> + }
> +
> + if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
> + auto *CI = dyn_cast<ConstantInt>(SI->getCondition());
> + if (!CI)
> + return nullptr;
> + for (auto Case : SI->cases())
> + if (Case.getCaseValue() == CI)
> + return Case.getCaseSuccessor();
> + return SI->getDefaultDest();
> + }
> +
> + return nullptr;
> +}
> +
> +/// Helper class that can turn branches and switches with constant
> conditions
> +/// into unconditional branches.
> +class ConstantTerminatorFoldingImpl {
> +private:
> + Loop &L;
> + LoopInfo &LI;
> + DominatorTree &DT;
> +
> + // Whether or not the current loop will still exist after terminator
> constant
> + // folding will be done. In theory, there are two ways how it can
> happen:
> + // 1. Loop's latch(es) become unreachable from loop header;
> + // 2. Loop's header becomes unreachable from method entry.
> + // In practice, the second situation is impossible because we only
> modify the
> + // current loop and its preheader and do not affect preheader's
> reachibility
> + // from any other block. So this variable set to true means that loop's
> latch
> + // has become unreachable from loop header.
> + bool DeleteCurrentLoop = false;
> +
> + // The blocks of the original loop that will still be reachable from
> entry
> + // after the constant folding.
> + SmallPtrSet<BasicBlock *, 8> LiveLoopBlocks;
> + // The blocks of the original loop that will become unreachable from
> entry
> + // after the constant folding.
> + SmallPtrSet<BasicBlock *, 8> DeadLoopBlocks;
> + // The exits of the original loop that will still be reachable from
> entry
> + // after the constant folding.
> + SmallPtrSet<BasicBlock *, 8> LiveExitBlocks;
> + // The exits of the original loop that will become unreachable from
> entry
> + // after the constant folding.
> + SmallPtrSet<BasicBlock *, 8> DeadExitBlocks;
> + // The blocks that will still be a part of the current loop after
> folding.
> + SmallPtrSet<BasicBlock *, 8> BlocksInLoopAfterFolding;
> + // The blocks that have terminators with constant condition that can be
> + // folded. Note: fold candidates should be in L but not in any of its
> + // subloops to avoid complex LI updates.
> + SmallVector<BasicBlock *, 8> FoldCandidates;
> +
> + void dump() const {
> + dbgs() << "Constant terminator folding for loop " << L << "\n";
> + dbgs() << "After terminator constant-folding, the loop will";
> + if (!DeleteCurrentLoop)
> + dbgs() << " not";
> + dbgs() << " be destroyed\n";
> + dbgs() << "Blocks in which we can constant-fold terminator:\n";
> + for (const BasicBlock *BB : FoldCandidates)
> + dbgs() << "\t" << BB->getName() << "\n";
> + auto PrintOutSet = [&](const char *Message,
> + const SmallPtrSetImpl<BasicBlock *> &S) {
> + dbgs() << Message << "\n";
> + for (const BasicBlock *BB : S)
> + dbgs() << "\t" << BB->getName() << "\n";
> + };
> + PrintOutSet("Live blocks from the original loop:", LiveLoopBlocks);
> + PrintOutSet("Dead blocks from the original loop:", DeadLoopBlocks);
> + PrintOutSet("Live exit blocks:", LiveExitBlocks);
> + PrintOutSet("Dead exit blocks:", DeadExitBlocks);
> + if (!DeleteCurrentLoop)
> + PrintOutSet("The following blocks will still be part of the loop:",
> + BlocksInLoopAfterFolding);
> + }
> +
> + /// Fill all information about status of blocks and exits of the
> current loop
> + /// if constant folding of all branches will be done.
> + void analyze() {
> + LoopBlocksDFS DFS(&L);
> + DFS.perform(&LI);
> + assert(DFS.isComplete() && "DFS is expected to be finished");
> +
> + // Collect live and dead loop blocks and exits.
> + SmallPtrSet<BasicBlock *, 8> ExitBlocks;
> + LiveLoopBlocks.insert(L.getHeader());
> + for (auto I = DFS.beginRPO(), E = DFS.endRPO(); I != E; ++I) {
> + BasicBlock *BB = *I;
> +
> + // If a loop block wasn't marked as live so far, then it's dead.
> + if (!LiveLoopBlocks.count(BB)) {
> + DeadLoopBlocks.insert(BB);
> + continue;
> + }
> +
> + BasicBlock *TheOnlySucc = getOnlyLiveSuccessor(BB);
> +
> + // If a block has only one live successor, it's a candidate on
> constant
> + // folding. Only handle blocks from current loop: branches in child
> loops
> + // are skipped because if they can be folded, they should be folded
> during
> + // the processing of child loops.
> + if (TheOnlySucc && LI.getLoopFor(BB) == &L)
> + FoldCandidates.push_back(BB);
> +
> + // Handle successors.
> + auto ProcessSuccessor = [&](BasicBlock *Succ, bool IsLive) {
> + if (!L.contains(Succ)) {
> + if (IsLive)
> + LiveExitBlocks.insert(Succ);
> + ExitBlocks.insert(Succ);
> + } else if (IsLive)
> + LiveLoopBlocks.insert(Succ);
> + };
> + for (BasicBlock *Succ : successors(BB))
> + ProcessSuccessor(Succ, !TheOnlySucc || TheOnlySucc == Succ);
> + }
> +
> + // Sanity check: amount of dead and live loop blocks should match the
> total
> + // number of blocks in loop.
> + assert(L.getNumBlocks() == LiveLoopBlocks.size() +
> DeadLoopBlocks.size() &&
> + "Malformed block sets?");
> +
> + // Now, all exit blocks that are not marked as live are dead.
> + for (auto *ExitBlock : ExitBlocks)
> + if (!LiveExitBlocks.count(ExitBlock))
> + DeadExitBlocks.insert(ExitBlock);
> +
> + // Whether or not the edge From->To will still be present in graph
> after the
> + // folding.
> + auto IsEdgeLive = [&](BasicBlock *From, BasicBlock *To) {
> + if (!LiveLoopBlocks.count(From))
> + return false;
> + BasicBlock *TheOnlySucc = getOnlyLiveSuccessor(From);
> + return !TheOnlySucc || TheOnlySucc == To;
> + };
> +
> + // The loop will not be destroyed if its latch is live.
> + DeleteCurrentLoop = !IsEdgeLive(L.getLoopLatch(), L.getHeader());
> +
> + // If we are going to delete the current loop completely, no extra
> analysis
> + // is needed.
> + if (DeleteCurrentLoop)
> + return;
> +
> + // Otherwise, we should check which blocks will still be a part of the
> + // current loop after the transform.
> + BlocksInLoopAfterFolding.insert(L.getLoopLatch());
> + // If the loop is live, then we should compute what blocks are still
> in
> + // loop after all branch folding has been done. A block is in loop if
> + // it has a live edge to another block that is in the loop; by
> definition,
> + // latch is in the loop.
> + auto BlockIsInLoop = [&](BasicBlock *BB) {
> + return any_of(successors(BB), [&](BasicBlock *Succ) {
> + return BlocksInLoopAfterFolding.count(Succ) && IsEdgeLive(BB,
> Succ);
> + });
> + };
> + for (auto I = DFS.beginPostorder(), E = DFS.endPostorder(); I != E;
> ++I) {
> + BasicBlock *BB = *I;
> + if (BlockIsInLoop(BB))
> + BlocksInLoopAfterFolding.insert(BB);
> + }
> +
> + // Sanity check: header must be in loop.
> + assert(BlocksInLoopAfterFolding.count(L.getHeader()) &&
> + "Header not in loop?");
> + }
> +
> + /// Constant-fold terminators of blocks acculumated in FoldCandidates
> into the
> + /// unconditional branches.
> + void foldTerminators() {
> + DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
> +
> + for (BasicBlock *BB : FoldCandidates) {
> + assert(LI.getLoopFor(BB) == &L && "Should be a loop block!");
> + BasicBlock *TheOnlySucc = getOnlyLiveSuccessor(BB);
> + assert(TheOnlySucc && "Should have one live successor!");
> +
> + LLVM_DEBUG(dbgs() << "Replacing terminator of " << BB->getName()
> + << " with an unconditional branch to the block "
> + << TheOnlySucc->getName() << "\n");
> +
> + SmallPtrSet<BasicBlock *, 2> DeadSuccessors;
> + // Remove all BB's successors except for the live one.
> + for (auto *Succ : successors(BB))
> + if (Succ != TheOnlySucc)
> + DeadSuccessors.insert(Succ);
> +
> + IRBuilder<> Builder(BB->getContext());
> + Instruction *Term = BB->getTerminator();
> + Builder.SetInsertPoint(Term);
> + Builder.CreateBr(TheOnlySucc);
> + Term->eraseFromParent();
> +
> + for (auto *DeadSucc : DeadSuccessors)
> + DTU.deleteEdge(BB, DeadSucc);
> +
> + ++NumTerminatorsFolded;
> + }
> + }
> +
> +public:
> + ConstantTerminatorFoldingImpl(Loop &L, LoopInfo &LI, DominatorTree &DT)
> + : L(L), LI(LI), DT(DT) {}
> + bool run() {
> + assert(L.getLoopLatch() && "Should be single latch!");
> +
> + // Collect all available information about status of blocks after
> constant
> + // folding.
> + analyze();
> +
> + LLVM_DEBUG(dbgs() << "In function " <<
> L.getHeader()->getParent()->getName()
> + << ": ");
> +
> + // Nothing to constant-fold.
> + if (FoldCandidates.empty()) {
> + LLVM_DEBUG(
> + dbgs() << "No constant terminator folding candidates found in
> loop "
> + << L.getHeader()->getName() << "\n");
> + return false;
> + }
> +
> + // TODO: Support deletion of the current loop.
> + if (DeleteCurrentLoop) {
> + LLVM_DEBUG(
> + dbgs()
> + << "Give up constant terminator folding in loop "
> + << L.getHeader()->getName()
> + << ": we don't currently support deletion of the current
> loop.\n");
> + return false;
> + }
> +
> + // TODO: Support deletion of dead loop blocks.
> + if (!DeadLoopBlocks.empty()) {
> + LLVM_DEBUG(dbgs() << "Give up constant terminator folding in loop "
> + << L.getHeader()->getName()
> + << ": we don't currently"
> + " support deletion of dead in-loop blocks.\n");
> + return false;
> + }
> +
> + // TODO: Support dead loop exits.
> + if (!DeadExitBlocks.empty()) {
> + LLVM_DEBUG(dbgs() << "Give up constant terminator folding in loop "
> + << L.getHeader()->getName()
> + << ": we don't currently support dead loop
> exits.\n");
> + return false;
> + }
> +
> + // TODO: Support blocks that are not dead, but also not in loop after
> the
> + // folding.
> + if (BlocksInLoopAfterFolding.size() != L.getNumBlocks()) {
> + LLVM_DEBUG(
> + dbgs() << "Give up constant terminator folding in loop "
> + << L.getHeader()->getName()
> + << ": we don't currently"
> + " support blocks that are not dead, but will stop "
> + "being a part of the loop after constant-folding.\n");
> + return false;
> + }
> +
> + // Dump analysis results.
> + LLVM_DEBUG(dump());
> +
> + LLVM_DEBUG(dbgs() << "Constant-folding " << FoldCandidates.size()
> + << " terminators in loop " <<
> L.getHeader()->getName()
> + << "\n");
> +
> + // Make the actual transforms.
> + foldTerminators();
> +
> +#ifndef NDEBUG
> + // Make sure that we have preserved all data structures after the
> transform.
> + DT.verify();
> + assert(DT.isReachableFromEntry(L.getHeader()));
> + LI.verify(DT);
> +#endif
> +
> + return true;
> + }
> +};
> +
> +/// Turn branches and switches with known constant conditions into
> unconditional
> +/// branches.
> +static bool constantFoldTerminators(Loop &L, DominatorTree &DT, LoopInfo
> &LI) {
> + // To keep things simple, only process loops with single latch. We
> + // canonicalize most loops to this form. We can support multi-latch if
> needed.
> + if (!L.getLoopLatch())
> + return false;
> +
> + ConstantTerminatorFoldingImpl BranchFolder(L, LI, DT);
> + return BranchFolder.run();
> +}
> +
> static bool mergeBlocksIntoPredecessors(Loop &L, DominatorTree &DT,
> LoopInfo &LI, MemorySSAUpdater
> *MSSAU) {
> bool Changed = false;
> @@ -73,6 +383,9 @@ static bool simplifyLoopCFG(Loop &L, Dom
> ScalarEvolution &SE, MemorySSAUpdater *MSSAU)
> {
> bool Changed = false;
>
> + // Constant-fold terminators with known constant conditions.
> + Changed |= constantFoldTerminators(L, DT, LI);
> +
> // Eliminate unconditional branches by merging blocks into their
> predecessors.
> Changed |= mergeBlocksIntoPredecessors(L, DT, LI, MSSAU);
>
>
> Modified:
> llvm/trunk/test/Transforms/LoopSimplifyCFG/constant-fold-branch.ll
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/LoopSimplifyCFG/constant-fold-branch.ll?rev=347183&r1=347182&r2=347183&view=diff
>
> ==============================================================================
> --- llvm/trunk/test/Transforms/LoopSimplifyCFG/constant-fold-branch.ll
> (original)
> +++ llvm/trunk/test/Transforms/LoopSimplifyCFG/constant-fold-branch.ll Sun
> Nov 18 21:54:38 2018
> @@ -1,10 +1,53 @@
> ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
> -; RUN: opt -S -loop-simplifycfg < %s | FileCheck %s
> -; RUN: opt -S -passes='require<domtree>,loop(simplify-cfg)' < %s |
> FileCheck %s
> -; RUN: opt -S -loop-simplifycfg -enable-mssa-loop-dependency=true
> -verify-memoryssa < %s | FileCheck %s
> +; RUN: opt -S -loop-simplifycfg -debug-only=loop-simplifycfg 2>&1 < %s |
> FileCheck %s
> +; RUN: opt -S -passes='require<domtree>,loop(simplify-cfg)'
> -debug-only=loop-simplifycfg 2>&1 < %s | FileCheck %s
> +; RUN: opt -S -loop-simplifycfg -enable-mssa-loop-dependency=true
> -verify-memoryssa -debug-only=loop-simplifycfg 2>&1 < %s | FileCheck %s
>
> target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
>
> +; CHECK-LABEL: In function dead_backedge_test_branch_loop: Give up
> constant terminator folding in loop header: we don't currently support
> blocks that are not dead, but will stop being a part of the loop after
> constant-folding.
> +; CHECK-LABEL: In function dead_backedge_test_switch_loop: Give up
> constant terminator folding in loop header: we don't currently support
> blocks that are not dead, but will stop being a part of the loop after
> constant-folding.
> +; CHECK-LABEL: In function dead_block_test_branch_loop: Give up constant
> terminator folding in loop header: we don't currently support deletion of
> dead in-loop blocks.
> +; CHECK-LABEL: In function dead_block_test_switch_loop: Give up constant
> terminator folding in loop header: we don't currently support deletion of
> dead in-loop blocks.
> +; CHECK-LABEL: In function dead_block_propogate_test_branch_loop: Give up
> constant terminator folding in loop header: we don't currently support
> deletion of dead in-loop blocks.
> +; CHECK-LABEL: In function dead_block_propogate_test_switch_loop: Give up
> constant terminator folding in loop header: we don't currently support
> deletion of dead in-loop blocks.
> +; CHECK-LABEL: In function dead_exit_test_branch_loop: Give up constant
> terminator folding in loop header: we don't currently support dead loop
> exits.
> +; CHECK-LABEL: In function dead_exit_test_switch_loop: Give up constant
> terminator folding in loop header: we don't currently support dead loop
> exits.
> +; CHECK-LABEL: In function dead_loop_test_branch_loop: Give up constant
> terminator folding in loop header: we don't currently support deletion of
> the current loop.
> +; CHECK-LABEL: In function dead_loop_test_switch_loop: Give up constant
> terminator folding in loop header: we don't currently support deletion of
> the current loop.
> +; CHECK-LABEL: In function dead_sub_loop_test_branch_loop: No constant
> terminator folding candidates found in loop dead_loop
> +; CHECK-LABEL: In function dead_sub_loop_test_branch_loop: No constant
> terminator folding candidates found in loop live_loop
> +; CHECK-LABEL: In function dead_sub_loop_test_branch_loop: Give up
> constant terminator folding in loop header: we don't currently support
> deletion of dead in-loop blocks.
> +; CHECK-LABEL: In function dead_sub_loop_test_switch_loop: No constant
> terminator folding candidates found in loop live_loop
> +; CHECK-LABEL: In function dead_sub_loop_test_switch_loop: No constant
> terminator folding candidates found in loop dead_loop
> +; CHECK-LABEL: In function dead_sub_loop_test_switch_loop: Give up
> constant terminator folding in loop header: we don't currently support
> deletion of dead in-loop blocks.
> +; CHECK-LABEL: In function inf_loop_test_branch_loop: Give up constant
> terminator folding in loop header: we don't currently support deletion of
> dead in-loop blocks.
> +; CHECK-LABEL: In function inf_loop_test_switch_loop: Give up constant
> terminator folding in loop header: we don't currently support deletion of
> dead in-loop blocks.
> +; CHECK-LABEL: In function live_block_test_branch_loop: Constant
> terminator folding for loop Loop at depth 1 containing:
> %header<header>,%check,%live,%backedge<latch><exiting>
> +; CHECK: Replacing terminator of check with an unconditional
> branch to the block backedge
> +; CHECK-LABEL: In function live_block_test_switch_loop: Constant
> terminator folding for loop Loop at depth 1 containing:
> %header<header>,%check,%live,%backedge<latch><exiting>
> +; CHECK: Replacing terminator of check with an unconditional
> branch to the block backedge
> +; CHECK-LABEL: In function partial_sub_loop_test_branch_loop: Give up
> constant terminator folding in loop header: we don't currently support
> deletion of dead in-loop blocks.
> +; CHECK-LABEL: In function partial_sub_loop_test_branch_loop: No constant
> terminator folding candidates found in loop outer_header
> +; CHECK-LABEL: In function partial_sub_loop_test_switch_loop: Give up
> constant terminator folding in loop header: we don't currently support
> deletion of dead in-loop blocks.
> +; CHECK-LABEL: In function partial_sub_loop_test_switch_loop: No constant
> terminator folding candidates found in loop outer_header
> +; CHECK-LABEL: In function full_sub_loop_test_branch_loop: Give up
> constant terminator folding in loop header: we don't currently support
> deletion of the current loop.
> +; CHECK-LABEL: In function full_sub_loop_test_branch_loop: No constant
> terminator folding candidates found in loop outer_header
> +; CHECK-LABEL: In function full_sub_loop_test_switch_loop: Give up
> constant terminator folding in loop header: we don't currently support
> deletion of the current loop.
> +; CHECK-LABEL: In function full_sub_loop_test_switch_loop: No constant
> terminator folding candidates found in loop outer_header
> +; CHECK-LABEL: In function full_sub_loop_test_branch_loop_inverse_1: Give
> up constant terminator folding in loop header: we don't currently support
> deletion of the current loop.
> +; CHECK-LABEL: In function full_sub_loop_test_branch_loop_inverse_1: No
> constant terminator folding candidates found in loop outer_header
> +; CHECK-LABEL: In function full_sub_loop_test_switch_loop_inverse_1: Give
> up constant terminator folding in loop header: we don't currently support
> deletion of the current loop.
> +; CHECK-LABEL: In function full_sub_loop_test_switch_loop_inverse_1: No
> constant terminator folding candidates found in loop outer_header
> +; CHECK-LABEL: In function full_sub_loop_test_branch_loop_inverse_2: Give
> up constant terminator folding in loop header: we don't currently support
> dead loop exits.
> +; CHECK-LABEL: In function full_sub_loop_test_branch_loop_inverse_2: No
> constant terminator folding candidates found in loop outer_header
> +; CHECK-LABEL: In function full_sub_loop_test_switch_loop_inverse_2: Give
> up constant terminator folding in loop header: we don't currently support
> dead loop exits.
> +; CHECK-LABEL: In function full_sub_loop_test_switch_loop_inverse_2: No
> constant terminator folding candidates found in loop outer_header
> +; CHECK-LABEL: In function full_sub_loop_test_branch_loop_inverse_3: Give
> up constant terminator folding in loop header: we don't currently support
> deletion of dead in-loop blocks.
> +; CHECK-LABEL: In function full_sub_loop_test_branch_loop_inverse_3: No
> constant terminator folding candidates found in loop outer_header
> +; CHECK-LABEL: In function full_sub_loop_test_switch_loop_inverse_3: Give
> up constant terminator folding in loop header: we don't currently support
> deletion of dead in-loop blocks.
> +; CHECK-LABEL: In function full_sub_loop_test_switch_loop_inverse_3: No
> constant terminator folding candidates found in loop outer_header
> +
> ; Make sure that we can eliminate a provably dead backedge.
> define i32 @dead_backedge_test_branch_loop(i32 %end) {
> ; CHECK-LABEL: @dead_backedge_test_branch_loop(
> @@ -707,7 +750,7 @@ define i32 @live_block_test_branch_loop(
> ; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, [[PREHEADER:%.*]] ], [
> [[I_INC:%.*]], [[BACKEDGE:%.*]] ]
> ; CHECK-NEXT: br i1 [[C:%.*]], label [[CHECK:%.*]], label [[LIVE:%.*]]
> ; CHECK: check:
> -; CHECK-NEXT: br i1 true, label [[BACKEDGE]], label [[LIVE]]
> +; CHECK-NEXT: br label [[BACKEDGE]]
> ; CHECK: live:
> ; CHECK-NEXT: [[I_2:%.*]] = add i32 [[I]], 1
> ; CHECK-NEXT: br label [[BACKEDGE]]
> @@ -752,11 +795,7 @@ define i32 @live_block_test_switch_loop(
> ; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, [[PREHEADER:%.*]] ], [
> [[I_INC:%.*]], [[BACKEDGE:%.*]] ]
> ; CHECK-NEXT: br i1 [[C:%.*]], label [[CHECK:%.*]], label [[LIVE:%.*]]
> ; CHECK: check:
> -; CHECK-NEXT: switch i32 1, label [[LIVE]] [
> -; CHECK-NEXT: i32 0, label [[LIVE]]
> -; CHECK-NEXT: i32 1, label [[BACKEDGE]]
> -; CHECK-NEXT: i32 2, label [[LIVE]]
> -; CHECK-NEXT: ]
> +; CHECK-NEXT: br label [[BACKEDGE]]
> ; CHECK: live:
> ; CHECK-NEXT: [[I_2:%.*]] = add i32 [[I]], 1
> ; CHECK-NEXT: br label [[BACKEDGE]]
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://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/20181119/c5244b15/attachment.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: t.i
Type: application/octet-stream
Size: 233 bytes
Desc: not available
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20181119/c5244b15/attachment.obj>
More information about the llvm-commits
mailing list