[llvm] r347289 - Recommit "[LoopSimplifyCFG] Teach LoopSimplifyCFG to constant-fold branches and switches"

Maxim Kazantsev via llvm-commits llvm-commits at lists.llvm.org
Thu Nov 22 23:59:49 PST 2018


Hi Mikael,

I've just merged https://reviews.llvm.org/rL347484, could you please check if it helps?

--Max

-----Original Message-----
From: Mikael Holmén <mikael.holmen at ericsson.com> 
Sent: Friday, November 23, 2018 2:42 PM
To: Maxim Kazantsev <max.kazantsev at azul.com>
Cc: llvm-commits at lists.llvm.org
Subject: Re: [llvm] r347289 - Recommit "[LoopSimplifyCFG] Teach LoopSimplifyCFG to constant-fold branches and switches"

Hi Max,

With this commit the following starts crashing:

  opt -o /dev/null bbi-21357.ll -loop-simplifycfg -loop-deletion

I get:

opt: ../lib/Transforms/Scalar/LoopDeletion.cpp:138: LoopDeletionResult deleteLoopIfDead(llvm::Loop *, llvm::DominatorTree &, llvm::ScalarEvolution &, llvm::LoopInfo &): Assertion
`L->isLCSSAForm(DT) && "Expected LCSSA!"' failed.
Stack dump:
0.      Program arguments: build-all/bin/opt -o /dev/null bbi-21357.ll 
-loop-simplifycfg -loop-deletion
1.      Running pass 'Function Pass Manager' on module 'bbi-21357.ll'.
2.      Running pass 'Loop Pass Manager' on function '@f1'
3.      Running pass 'Delete dead loops' on basic block '%bb1'
#0 0x00000000021e8eb4 PrintStackTraceSignalHandler(void*)
(build-all/bin/opt+0x21e8eb4)
#1 0x00000000021e6fe0 llvm::sys::RunSignalHandlers()
(build-all/bin/opt+0x21e6fe0)
#2 0x00000000021e9218 SignalHandler(int) (build-all/bin/opt+0x21e9218)
#3 0x00007f6880ec6330 __restore_rt
(/lib/x86_64-linux-gnu/libpthread.so.0+0x10330)
#4 0x00007f687fab5c37 gsignal
/build/eglibc-ripdx6/eglibc-2.19/signal/../nptl/sysdeps/unix/sysv/linux/raise.c:56:0
#5 0x00007f687fab9028 abort
/build/eglibc-ripdx6/eglibc-2.19/stdlib/abort.c:91:0
#6 0x00007f687faaebf6 __assert_fail_base
/build/eglibc-ripdx6/eglibc-2.19/assert/assert.c:92:0
#7 0x00007f687faaeca2 (/lib/x86_64-linux-gnu/libc.so.6+0x2fca2)
#8 0x0000000001ffa3a4 deleteLoopIfDead(llvm::Loop*, llvm::DominatorTree&, llvm::ScalarEvolution&, llvm::LoopInfo&)
(build-all/bin/opt+0x1ffa3a4)
#9 0x0000000001ffa8b6 (anonymous
namespace)::LoopDeletionLegacyPass::runOnLoop(llvm::Loop*,
llvm::LPPassManager&) (build-all/bin/opt+0x1ffa8b6)
#10 0x000000000167a58c
llvm::LPPassManager::runOnFunction(llvm::Function&)
(build-all/bin/opt+0x167a58c)
#11 0x0000000001c0797d
llvm::FPPassManager::runOnFunction(llvm::Function&)
(build-all/bin/opt+0x1c0797d)
#12 0x0000000001c07c38 llvm::FPPassManager::runOnModule(llvm::Module&)
(build-all/bin/opt+0x1c07c38)
#13 0x0000000001c0809a llvm::legacy::PassManagerImpl::run(llvm::Module&)
(build-all/bin/opt+0x1c0809a)
#14 0x000000000077b08b main (build-all/bin/opt+0x77b08b)
#15 0x00007f687faa0f45 __libc_start_main
/build/eglibc-ripdx6/eglibc-2.19/csu/libc-start.c:321:0
#16 0x00000000007605fd _start (build-all/bin/opt+0x7605fd)

I've seen a couple of other failures too recently, e.g.

  PHINode should have one entry for each predecessor of its parent basic block!

and also

opt: ../lib/Transforms/Scalar/IndVarSimplify.cpp:2585: bool (anonymous namespace)::IndVarSimplify::run(llvm::Loop *): Assertion `L->isRecursivelyLCSSAForm(*DT, *LI) && "LCSSA required to run indvars!"' failed."

but I haven't reduced and really verified they are due to this commit yet.

/Mikael

On 11/20/18 6:43 AM, Max Kazantsev via llvm-commits wrote:
> Author: mkazantsev
> Date: Mon Nov 19 21:43:32 2018
> New Revision: 347289
> 
> URL: http://llvm.org/viewvc/llvm-project?rev=347289&view=rev
> Log:
> Recommit "[LoopSimplifyCFG] Teach LoopSimplifyCFG to constant-fold branches and switches"
> 
> The initial version of patch lacked Phi nodes updates in destinations 
> of removed edges. This version contains this update and tests on this situation.
> 
> Differential Revision: https://reviews.llvm.org/D54021
> 
> 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/L
> oopSimplifyCFG.cpp?rev=347289&r1=347288&r2=347289&view=diff
> ======================================================================
> ========
> --- llvm/trunk/lib/Transforms/Scalar/LoopSimplifyCFG.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/LoopSimplifyCFG.cpp Mon Nov 19 
> +++ 21:43:32 2018
> @@ -41,6 +41,318 @@ 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);
> +          Succ->removePredecessor(BB);
> +        }
> +
> +      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 +385,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/LoopSim
> plifyCFG/constant-fold-branch.ll?rev=347289&r1=347288&r2=347289&view=d
> iff 
> ======================================================================
> ========
> --- llvm/trunk/test/Transforms/LoopSimplifyCFG/constant-fold-branch.ll 
> (original)
> +++ llvm/trunk/test/Transforms/LoopSimplifyCFG/constant-fold-branch.ll 
> +++ Mon Nov 19 21:43:32 2018
> @@ -1,10 +1,58 @@
>   ; 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
> +; REQUIRES: asserts
> +; 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_branch_loop_phis: 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 live_block_test_switch_loop_phis: 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 +755,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]]
> @@ -744,6 +792,54 @@ exit:
>     ret i32 %i.inc
>   }
>   
> +; Check that when the block is not actually dead, we don't remove it. 
> +Version ; with Phi node.
> +define i32 @live_block_test_branch_loop_phis(i1 %c, i32 %end) { ; 
> +CHECK-LABEL: @live_block_test_branch_loop_phis(
> +; CHECK-NEXT:  preheader:
> +; CHECK-NEXT:    br label [[HEADER:%.*]]
> +; CHECK:       header:
> +; CHECK-NEXT:    [[I:%.*]] = phi i32 [ 0, [[PREHEADER:%.*]] ], [ [[I_INC:%.*]], [[BACKEDGE:%.*]] ]
> +; CHECK-NEXT:    br i1 [[C:%.*]], label [[CHECK:%.*]], label [[LIVE:%.*]]
> +; CHECK:       check:
> +; CHECK-NEXT:    br label [[BACKEDGE]]
> +; CHECK:       live:
> +; CHECK-NEXT:    [[I_2:%.*]] = add i32 [[I]], 1
> +; CHECK-NEXT:    br label [[BACKEDGE]]
> +; CHECK:       backedge:
> +; CHECK-NEXT:    [[I_1:%.*]] = phi i32 [ [[I]], [[CHECK]] ], [ [[I_2]], [[LIVE]] ]
> +; CHECK-NEXT:    [[I_INC]] = add i32 [[I_1]], 1
> +; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[I_INC]], [[END:%.*]]
> +; CHECK-NEXT:    br i1 [[CMP]], label [[HEADER]], label [[EXIT:%.*]]
> +; CHECK:       exit:
> +; CHECK-NEXT:    [[I_INC_LCSSA:%.*]] = phi i32 [ [[I_INC]], [[BACKEDGE]] ]
> +; CHECK-NEXT:    ret i32 [[I_INC_LCSSA]]
> +;
> +preheader:
> +  br label %header
> +
> +header:
> +  %i = phi i32 [0, %preheader], [%i.inc, %backedge]
> +  br i1 %c, label %check, label %live
> +
> +check:
> +  br i1 true, label %backedge, label %live
> +
> +live:
> +  %phi = phi i32 [ 1, %header ], [ -1, %check ]
> +  %i.2 = add i32 %i, %phi
> +  br label %backedge
> +
> +backedge:
> +  %i.1 = phi i32 [%i, %check], [%i.2, %live]
> +  %i.inc = add i32 %i.1, 1
> +  %cmp = icmp slt i32 %i.inc, %end
> +  br i1 %cmp, label %header, label %exit
> +
> +exit:
> +  ret i32 %i.inc
> +}
> +
>   define i32 @live_block_test_switch_loop(i1 %c, i32 %end) {
>   ; CHECK-LABEL: @live_block_test_switch_loop(
>   ; CHECK-NEXT:  preheader:
> @@ -752,11 +848,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]]
> @@ -786,6 +878,54 @@ live:
>     br label %backedge
>   
>   backedge:
> +  %i.1 = phi i32 [%i, %check], [%i.2, %live]  %i.inc = add i32 %i.1, 
> + 1  %cmp = icmp slt i32 %i.inc, %end  br i1 %cmp, label %header, 
> + label %exit
> +
> +exit:
> +  ret i32 %i.inc
> +}
> +
> +define i32 @live_block_test_switch_loop_phis(i1 %c, i32 %end) { ; 
> +CHECK-LABEL: @live_block_test_switch_loop_phis(
> +; CHECK-NEXT:  preheader:
> +; CHECK-NEXT:    br label [[HEADER:%.*]]
> +; CHECK:       header:
> +; CHECK-NEXT:    [[I:%.*]] = phi i32 [ 0, [[PREHEADER:%.*]] ], [ [[I_INC:%.*]], [[BACKEDGE:%.*]] ]
> +; CHECK-NEXT:    br i1 [[C:%.*]], label [[CHECK:%.*]], label [[LIVE:%.*]]
> +; CHECK:       check:
> +; CHECK-NEXT:    br label [[BACKEDGE]]
> +; CHECK:       live:
> +; CHECK-NEXT:    [[I_2:%.*]] = add i32 [[I]], 1
> +; CHECK-NEXT:    br label [[BACKEDGE]]
> +; CHECK:       backedge:
> +; CHECK-NEXT:    [[I_1:%.*]] = phi i32 [ [[I]], [[CHECK]] ], [ [[I_2]], [[LIVE]] ]
> +; CHECK-NEXT:    [[I_INC]] = add i32 [[I_1]], 1
> +; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[I_INC]], [[END:%.*]]
> +; CHECK-NEXT:    br i1 [[CMP]], label [[HEADER]], label [[EXIT:%.*]]
> +; CHECK:       exit:
> +; CHECK-NEXT:    [[I_INC_LCSSA:%.*]] = phi i32 [ [[I_INC]], [[BACKEDGE]] ]
> +; CHECK-NEXT:    ret i32 [[I_INC_LCSSA]]
> +;
> +preheader:
> +  br label %header
> +
> +header:
> +  %i = phi i32 [0, %preheader], [%i.inc, %backedge]
> +  br i1 %c, label %check, label %live
> +
> +check:
> +  switch i32 1, label %live [i32 0, label %live
> +  i32 1, label %backedge
> +  i32 2, label %live]
> +
> +live:
> +  %phi = phi i32 [ 1, %header ], [ -1, %check ], [ -1, %check ], [ 
> +-1, %check ]
> +  %i.2 = add i32 %i, %phi
> +  br label %backedge
> +
> +backedge:
>     %i.1 = phi i32 [%i, %check], [%i.2, %live]
>     %i.inc = add i32 %i.1, 1
>     %cmp = icmp slt i32 %i.inc, %end
> 
> 
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
> 


More information about the llvm-commits mailing list