mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-01-31 20:51:52 +01:00
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 llvm-svn: 347289
This commit is contained in:
Max Kazantsev
parent
2251e7272c
commit
66f26fb6eb
@ -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, DominatorTree &DT, LoopInfo &LI,
|
||||
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);
|
||||
|
||||
|
||||
@ -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(i1 %c, i32 %end) {
|
||||
; 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(i1 %c, i32 %end) {
|
||||
; 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]]
|
||||
@ -795,6 +887,54 @@ 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
|
||||
br i1 %cmp, label %header, label %exit
|
||||
|
||||
exit:
|
||||
ret i32 %i.inc
|
||||
}
|
||||
|
||||
; Check that we can remove part of blocks of inner loop while the loop still
|
||||
; preserves, in presence of outer loop.
|
||||
define i32 @partial_sub_loop_test_branch_loop(i32 %end) {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user