2003-10-12 21:44:18 +00:00
|
|
|
//===- LoopSimplify.cpp - Loop Canonicalization Pass ----------------------===//
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2002-09-26 16:17:31 +00:00
|
|
|
//
|
2003-10-12 21:43:28 +00:00
|
|
|
// This pass performs several transformations to transform natural loops into a
|
|
|
|
// simpler form, which makes subsequent analyses and transformations simpler and
|
|
|
|
// more effective.
|
2003-02-27 20:27:08 +00:00
|
|
|
//
|
|
|
|
// Loop pre-header insertion guarantees that there is a single, non-critical
|
|
|
|
// entry edge from outside of the loop to the loop header. This simplifies a
|
|
|
|
// number of analyses and transformations, such as LICM.
|
|
|
|
//
|
|
|
|
// Loop exit-block insertion guarantees that all exit blocks from the loop
|
|
|
|
// (blocks which are outside of the loop that have predecessors inside of the
|
2003-12-10 17:20:35 +00:00
|
|
|
// loop) only have predecessors from inside of the loop (and are thus dominated
|
|
|
|
// by the loop header). This simplifies transformations such as store-sinking
|
|
|
|
// that are built into LICM.
|
2003-02-27 20:27:08 +00:00
|
|
|
//
|
2003-10-13 00:37:13 +00:00
|
|
|
// This pass also guarantees that loops will have exactly one backedge.
|
|
|
|
//
|
2003-02-27 20:27:08 +00:00
|
|
|
// Note that the simplifycfg pass will clean up blocks which are split out but
|
2003-10-12 21:43:28 +00:00
|
|
|
// end up being unnecessary, so usage of this pass should not pessimize
|
|
|
|
// generated code.
|
|
|
|
//
|
|
|
|
// This pass obviously modifies the CFG, but updates loop information and
|
|
|
|
// dominator information.
|
2002-09-26 16:17:31 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-12-19 22:17:40 +00:00
|
|
|
#define DEBUG_TYPE "loopsimplify"
|
2002-09-26 16:17:31 +00:00
|
|
|
#include "llvm/Transforms/Scalar.h"
|
2007-10-29 02:30:37 +00:00
|
|
|
#include "llvm/Constants.h"
|
2004-07-29 17:30:56 +00:00
|
|
|
#include "llvm/Instructions.h"
|
2004-03-14 03:59:22 +00:00
|
|
|
#include "llvm/Function.h"
|
|
|
|
#include "llvm/Type.h"
|
2005-03-25 06:37:22 +00:00
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
2003-12-19 06:27:08 +00:00
|
|
|
#include "llvm/Analysis/Dominators.h"
|
|
|
|
#include "llvm/Analysis/LoopInfo.h"
|
2002-09-26 16:17:31 +00:00
|
|
|
#include "llvm/Support/CFG.h"
|
2006-08-27 12:54:02 +00:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/ADT/SetOperations.h"
|
|
|
|
#include "llvm/ADT/SetVector.h"
|
|
|
|
#include "llvm/ADT/Statistic.h"
|
|
|
|
#include "llvm/ADT/DepthFirstIterator.h"
|
2003-12-10 17:20:35 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2006-12-19 22:17:40 +00:00
|
|
|
STATISTIC(NumInserted, "Number of pre-header or exit blocks inserted");
|
|
|
|
STATISTIC(NumNested , "Number of nested loops split out");
|
2002-09-26 16:17:31 +00:00
|
|
|
|
2006-12-19 22:17:40 +00:00
|
|
|
namespace {
|
2006-06-28 23:17:24 +00:00
|
|
|
struct VISIBILITY_HIDDEN LoopSimplify : public FunctionPass {
|
2007-05-06 13:37:16 +00:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2007-05-01 21:15:47 +00:00
|
|
|
LoopSimplify() : FunctionPass((intptr_t)&ID) {}
|
|
|
|
|
2005-03-25 06:37:22 +00:00
|
|
|
// AA - If we have an alias analysis object to update, this is it, otherwise
|
|
|
|
// this is null.
|
|
|
|
AliasAnalysis *AA;
|
2006-02-14 22:34:08 +00:00
|
|
|
LoopInfo *LI;
|
2007-06-21 17:23:45 +00:00
|
|
|
DominatorTree *DT;
|
2002-09-26 16:17:31 +00:00
|
|
|
virtual bool runOnFunction(Function &F);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-09-26 16:17:31 +00:00
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
// We need loop information to identify the loops...
|
|
|
|
AU.addRequired<LoopInfo>();
|
2004-03-13 22:01:26 +00:00
|
|
|
AU.addRequired<DominatorTree>();
|
2002-09-26 16:17:31 +00:00
|
|
|
|
|
|
|
AU.addPreserved<LoopInfo>();
|
|
|
|
AU.addPreserved<DominatorTree>();
|
2003-02-27 20:27:08 +00:00
|
|
|
AU.addPreserved<DominanceFrontier>();
|
2005-08-10 02:07:32 +00:00
|
|
|
AU.addPreservedID(BreakCriticalEdgesID); // No critical edges added.
|
2002-09-26 16:17:31 +00:00
|
|
|
}
|
2007-07-19 18:02:32 +00:00
|
|
|
|
|
|
|
/// verifyAnalysis() - Verify loop nest.
|
|
|
|
void verifyAnalysis() const {
|
|
|
|
#ifndef NDEBUG
|
|
|
|
LoopInfo *NLI = &getAnalysis<LoopInfo>();
|
|
|
|
for (LoopInfo::iterator I = NLI->begin(), E = NLI->end(); I != E; ++I)
|
|
|
|
(*I)->verifyLoop();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2002-09-26 16:17:31 +00:00
|
|
|
private:
|
|
|
|
bool ProcessLoop(Loop *L);
|
2003-02-27 20:27:08 +00:00
|
|
|
BasicBlock *SplitBlockPredecessors(BasicBlock *BB, const char *Suffix,
|
|
|
|
const std::vector<BasicBlock*> &Preds);
|
2004-04-18 22:27:10 +00:00
|
|
|
BasicBlock *RewriteLoopExitBlock(Loop *L, BasicBlock *Exit);
|
2002-09-26 16:17:31 +00:00
|
|
|
void InsertPreheaderForLoop(Loop *L);
|
2004-04-13 05:05:33 +00:00
|
|
|
Loop *SeparateNestedLoop(Loop *L);
|
2003-10-13 00:37:13 +00:00
|
|
|
void InsertUniqueBackedgeBlock(Loop *L);
|
Be far more careful when splitting a loop header, either to form a preheader
or when splitting loops with a common header into multiple loops. In particular
the old code would always insert the preheader before the old loop header. This
is disasterous in cases where the loop hasn't been rotated. For example, it can
produce code like:
.. outside the loop...
jmp LBB1_2 #bb13.outer
LBB1_1: #bb1
movsd 8(%esp,%esi,8), %xmm1
mulsd (%edi), %xmm1
addsd %xmm0, %xmm1
addl $24, %edi
incl %esi
jmp LBB1_3 #bb13
LBB1_2: #bb13.outer
leal (%edx,%eax,8), %edi
pxor %xmm1, %xmm1
xorl %esi, %esi
LBB1_3: #bb13
movapd %xmm1, %xmm0
cmpl $4, %esi
jl LBB1_1 #bb1
Note that the loop body is actually LBB1_1 + LBB1_3, which means that the
loop now contains an uncond branch WITHIN it to jump around the inserted
loop header (LBB1_2). Doh.
This patch changes the preheader insertion code to insert it in the right
spot, producing this code:
... outside the loop, fall into the header ...
LBB1_1: #bb13.outer
leal (%edx,%eax,8), %esi
pxor %xmm0, %xmm0
xorl %edi, %edi
jmp LBB1_3 #bb13
LBB1_2: #bb1
movsd 8(%esp,%edi,8), %xmm0
mulsd (%esi), %xmm0
addsd %xmm1, %xmm0
addl $24, %esi
incl %edi
LBB1_3: #bb13
movapd %xmm0, %xmm1
cmpl $4, %edi
jl LBB1_2 #bb1
Totally crazy, no branch in the loop! :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@30587 91177308-0d34-0410-b5e6-96231b3b80d8
2006-09-23 08:19:21 +00:00
|
|
|
void PlaceSplitBlockCarefully(BasicBlock *NewBB,
|
|
|
|
std::vector<BasicBlock*> &SplitPreds,
|
|
|
|
Loop *L);
|
2002-09-26 16:17:31 +00:00
|
|
|
};
|
|
|
|
|
2007-05-03 01:11:54 +00:00
|
|
|
char LoopSimplify::ID = 0;
|
2006-08-27 22:42:52 +00:00
|
|
|
RegisterPass<LoopSimplify>
|
2003-10-12 21:43:28 +00:00
|
|
|
X("loopsimplify", "Canonicalize natural loops", true);
|
2002-09-26 16:17:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Publically exposed interface to pass...
|
2003-12-10 17:20:35 +00:00
|
|
|
const PassInfo *llvm::LoopSimplifyID = X.getPassInfo();
|
2004-09-20 04:43:15 +00:00
|
|
|
FunctionPass *llvm::createLoopSimplifyPass() { return new LoopSimplify(); }
|
2002-09-26 16:17:31 +00:00
|
|
|
|
|
|
|
/// runOnFunction - Run down all loops in the CFG (recursively, but we could do
|
|
|
|
/// it in any convenient order) inserting preheaders...
|
|
|
|
///
|
2003-10-12 21:43:28 +00:00
|
|
|
bool LoopSimplify::runOnFunction(Function &F) {
|
2002-09-26 16:17:31 +00:00
|
|
|
bool Changed = false;
|
2006-02-14 22:34:08 +00:00
|
|
|
LI = &getAnalysis<LoopInfo>();
|
2005-03-25 06:37:22 +00:00
|
|
|
AA = getAnalysisToUpdate<AliasAnalysis>();
|
2007-06-21 17:23:45 +00:00
|
|
|
DT = &getAnalysis<DominatorTree>();
|
2002-09-26 16:17:31 +00:00
|
|
|
|
2006-08-12 04:51:20 +00:00
|
|
|
// Check to see that no blocks (other than the header) in loops have
|
|
|
|
// predecessors that are not in loops. This is not valid for natural loops,
|
|
|
|
// but can occur if the blocks are unreachable. Since they are unreachable we
|
|
|
|
// can just shamelessly destroy their terminators to make them not branch into
|
|
|
|
// the loop!
|
|
|
|
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
|
|
|
|
// This case can only occur for unreachable blocks. Blocks that are
|
|
|
|
// unreachable can't be in loops, so filter those blocks out.
|
|
|
|
if (LI->getLoopFor(BB)) continue;
|
|
|
|
|
|
|
|
bool BlockUnreachable = false;
|
|
|
|
TerminatorInst *TI = BB->getTerminator();
|
|
|
|
|
|
|
|
// Check to see if any successors of this block are non-loop-header loops
|
|
|
|
// that are not the header.
|
|
|
|
for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i) {
|
|
|
|
// If this successor is not in a loop, BB is clearly ok.
|
|
|
|
Loop *L = LI->getLoopFor(TI->getSuccessor(i));
|
|
|
|
if (!L) continue;
|
|
|
|
|
|
|
|
// If the succ is the loop header, and if L is a top-level loop, then this
|
|
|
|
// is an entrance into a loop through the header, which is also ok.
|
|
|
|
if (L->getHeader() == TI->getSuccessor(i) && L->getParentLoop() == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Otherwise, this is an entrance into a loop from some place invalid.
|
|
|
|
// Either the loop structure is invalid and this is not a natural loop (in
|
|
|
|
// which case the compiler is buggy somewhere else) or BB is unreachable.
|
|
|
|
BlockUnreachable = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this block is ok, check the next one.
|
|
|
|
if (!BlockUnreachable) continue;
|
|
|
|
|
|
|
|
// Otherwise, this block is dead. To clean up the CFG and to allow later
|
|
|
|
// loop transformations to ignore this case, we delete the edges into the
|
|
|
|
// loop by replacing the terminator.
|
|
|
|
|
|
|
|
// Remove PHI entries from the successors.
|
|
|
|
for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i)
|
|
|
|
TI->getSuccessor(i)->removePredecessor(BB);
|
|
|
|
|
2007-10-29 02:30:37 +00:00
|
|
|
// Add a new unreachable instruction before the old terminator.
|
2006-08-12 04:51:20 +00:00
|
|
|
new UnreachableInst(TI);
|
|
|
|
|
|
|
|
// Delete the dead terminator.
|
2007-10-29 02:30:37 +00:00
|
|
|
if (AA) AA->deleteValue(TI);
|
|
|
|
if (!TI->use_empty())
|
|
|
|
TI->replaceAllUsesWith(UndefValue::get(TI->getType()));
|
|
|
|
TI->eraseFromParent();
|
2006-08-12 04:51:20 +00:00
|
|
|
Changed |= true;
|
|
|
|
}
|
|
|
|
|
2006-02-14 22:34:08 +00:00
|
|
|
for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
|
2004-01-08 00:09:44 +00:00
|
|
|
Changed |= ProcessLoop(*I);
|
2002-09-26 16:17:31 +00:00
|
|
|
|
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ProcessLoop - Walk the loop structure in depth first order, ensuring that
|
|
|
|
/// all loops have preheaders.
|
|
|
|
///
|
2003-10-12 21:43:28 +00:00
|
|
|
bool LoopSimplify::ProcessLoop(Loop *L) {
|
2002-09-26 16:17:31 +00:00
|
|
|
bool Changed = false;
|
2006-08-12 05:25:00 +00:00
|
|
|
ReprocessLoop:
|
|
|
|
|
2006-02-14 23:06:02 +00:00
|
|
|
// Canonicalize inner loops before outer loops. Inner loop canonicalization
|
|
|
|
// can provide work for the outer loop to canonicalize.
|
|
|
|
for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
|
|
|
|
Changed |= ProcessLoop(*I);
|
|
|
|
|
2004-03-14 03:59:22 +00:00
|
|
|
assert(L->getBlocks()[0] == L->getHeader() &&
|
|
|
|
"Header isn't first block in loop?");
|
|
|
|
|
2006-08-12 04:51:20 +00:00
|
|
|
// Does the loop already have a preheader? If so, don't insert one.
|
2002-09-26 16:17:31 +00:00
|
|
|
if (L->getLoopPreheader() == 0) {
|
|
|
|
InsertPreheaderForLoop(L);
|
|
|
|
NumInserted++;
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
|
2003-12-10 17:20:35 +00:00
|
|
|
// Next, check to make sure that all exit nodes of the loop only have
|
|
|
|
// predecessors that are inside of the loop. This check guarantees that the
|
|
|
|
// loop preheader/header will dominate the exit blocks. If the exit block has
|
2006-02-12 01:59:10 +00:00
|
|
|
// predecessors from outside of the loop, split the edge now.
|
2007-08-21 00:31:24 +00:00
|
|
|
SmallVector<BasicBlock*, 8> ExitBlocks;
|
2006-02-12 01:59:10 +00:00
|
|
|
L->getExitBlocks(ExitBlocks);
|
2006-02-14 22:34:08 +00:00
|
|
|
|
2006-02-12 01:59:10 +00:00
|
|
|
SetVector<BasicBlock*> ExitBlockSet(ExitBlocks.begin(), ExitBlocks.end());
|
2004-07-15 08:20:22 +00:00
|
|
|
for (SetVector<BasicBlock*>::iterator I = ExitBlockSet.begin(),
|
|
|
|
E = ExitBlockSet.end(); I != E; ++I) {
|
|
|
|
BasicBlock *ExitBlock = *I;
|
2004-07-15 05:36:31 +00:00
|
|
|
for (pred_iterator PI = pred_begin(ExitBlock), PE = pred_end(ExitBlock);
|
|
|
|
PI != PE; ++PI)
|
2006-02-11 02:13:17 +00:00
|
|
|
// Must be exactly this loop: no subloops, parent loops, or non-loop preds
|
|
|
|
// allowed.
|
2006-02-12 01:59:10 +00:00
|
|
|
if (!L->contains(*PI)) {
|
2004-07-15 08:20:22 +00:00
|
|
|
RewriteLoopExitBlock(L, ExitBlock);
|
2004-07-15 05:36:31 +00:00
|
|
|
NumInserted++;
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
2004-07-15 08:20:22 +00:00
|
|
|
}
|
2003-02-27 20:27:08 +00:00
|
|
|
|
2004-04-13 05:05:33 +00:00
|
|
|
// If the header has more than two predecessors at this point (from the
|
|
|
|
// preheader and from multiple backedges), we must adjust the loop.
|
2006-08-12 05:25:00 +00:00
|
|
|
unsigned NumBackedges = L->getNumBackEdges();
|
|
|
|
if (NumBackedges != 1) {
|
|
|
|
// If this is really a nested loop, rip it out into a child loop. Don't do
|
|
|
|
// this for loops with a giant number of backedges, just factor them into a
|
|
|
|
// common backedge instead.
|
|
|
|
if (NumBackedges < 8) {
|
|
|
|
if (Loop *NL = SeparateNestedLoop(L)) {
|
|
|
|
++NumNested;
|
|
|
|
// This is a big restructuring change, reprocess the whole loop.
|
|
|
|
ProcessLoop(NL);
|
|
|
|
Changed = true;
|
|
|
|
// GCC doesn't tail recursion eliminate this.
|
|
|
|
goto ReprocessLoop;
|
|
|
|
}
|
2004-04-13 05:05:33 +00:00
|
|
|
}
|
|
|
|
|
2006-08-12 05:25:00 +00:00
|
|
|
// If we either couldn't, or didn't want to, identify nesting of the loops,
|
|
|
|
// insert a new block that all backedges target, then make it jump to the
|
|
|
|
// loop header.
|
2003-10-13 00:37:13 +00:00
|
|
|
InsertUniqueBackedgeBlock(L);
|
|
|
|
NumInserted++;
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
|
2005-08-10 02:07:32 +00:00
|
|
|
// Scan over the PHI nodes in the loop header. Since they now have only two
|
|
|
|
// incoming values (the loop is canonicalized), we may have simplified the PHI
|
|
|
|
// down to 'X = phi [X, Y]', which should be replaced with 'Y'.
|
|
|
|
PHINode *PN;
|
|
|
|
for (BasicBlock::iterator I = L->getHeader()->begin();
|
|
|
|
(PN = dyn_cast<PHINode>(I++)); )
|
2005-08-10 17:15:20 +00:00
|
|
|
if (Value *V = PN->hasConstantValue()) {
|
2005-08-10 02:07:32 +00:00
|
|
|
PN->replaceAllUsesWith(V);
|
|
|
|
PN->eraseFromParent();
|
|
|
|
}
|
|
|
|
|
2002-09-26 16:17:31 +00:00
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2003-02-27 20:27:08 +00:00
|
|
|
/// SplitBlockPredecessors - Split the specified block into two blocks. We want
|
|
|
|
/// to move the predecessors specified in the Preds list to point to the new
|
|
|
|
/// block, leaving the remaining predecessors pointing to BB. This method
|
|
|
|
/// updates the SSA PHINode's, but no other analyses.
|
2002-09-26 16:17:31 +00:00
|
|
|
///
|
2003-10-12 21:43:28 +00:00
|
|
|
BasicBlock *LoopSimplify::SplitBlockPredecessors(BasicBlock *BB,
|
|
|
|
const char *Suffix,
|
2003-02-27 20:27:08 +00:00
|
|
|
const std::vector<BasicBlock*> &Preds) {
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-02-27 20:27:08 +00:00
|
|
|
// Create new basic block, insert right before the original block...
|
2004-02-04 03:58:28 +00:00
|
|
|
BasicBlock *NewBB = new BasicBlock(BB->getName()+Suffix, BB->getParent(), BB);
|
2002-09-26 16:17:31 +00:00
|
|
|
|
|
|
|
// The preheader first gets an unconditional branch to the loop header...
|
2003-11-21 16:52:05 +00:00
|
|
|
BranchInst *BI = new BranchInst(BB, NewBB);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-02-27 20:27:08 +00:00
|
|
|
// For every PHI node in the block, insert a PHI node into NewBB where the
|
|
|
|
// incoming values from the out of loop edges are moved to NewBB. We have two
|
|
|
|
// possible cases here. If the loop is dead, we just insert dummy entries
|
|
|
|
// into the PHI nodes for the new edge. If the loop is not dead, we move the
|
|
|
|
// incoming edges in BB into new PHI nodes in NewBB.
|
2002-09-26 16:17:31 +00:00
|
|
|
//
|
2003-02-27 20:27:08 +00:00
|
|
|
if (!Preds.empty()) { // Is the loop not obviously dead?
|
2003-12-19 06:27:08 +00:00
|
|
|
// Check to see if the values being merged into the new block need PHI
|
|
|
|
// nodes. If so, insert them.
|
2004-09-28 02:40:37 +00:00
|
|
|
for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(I); ) {
|
|
|
|
PHINode *PN = cast<PHINode>(I);
|
2004-04-13 05:05:33 +00:00
|
|
|
++I;
|
|
|
|
|
2003-12-19 06:27:08 +00:00
|
|
|
// Check to see if all of the values coming in are the same. If so, we
|
|
|
|
// don't need to create a new PHI node.
|
|
|
|
Value *InVal = PN->getIncomingValueForBlock(Preds[0]);
|
|
|
|
for (unsigned i = 1, e = Preds.size(); i != e; ++i)
|
|
|
|
if (InVal != PN->getIncomingValueForBlock(Preds[i])) {
|
|
|
|
InVal = 0;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-12-19 06:27:08 +00:00
|
|
|
// If the values coming into the block are not the same, we need a PHI.
|
|
|
|
if (InVal == 0) {
|
2003-12-09 23:12:55 +00:00
|
|
|
// Create the new PHI node, insert it into NewBB at the end of the block
|
|
|
|
PHINode *NewPHI = new PHINode(PN->getType(), PN->getName()+".ph", BI);
|
2005-03-25 06:37:22 +00:00
|
|
|
if (AA) AA->copyValue(PN, NewPHI);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-12-09 23:12:55 +00:00
|
|
|
// Move all of the edges from blocks outside the loop to the new PHI
|
|
|
|
for (unsigned i = 0, e = Preds.size(); i != e; ++i) {
|
2004-04-13 05:05:33 +00:00
|
|
|
Value *V = PN->removeIncomingValue(Preds[i], false);
|
2003-12-09 23:12:55 +00:00
|
|
|
NewPHI->addIncoming(V, Preds[i]);
|
|
|
|
}
|
2003-12-19 06:27:08 +00:00
|
|
|
InVal = NewPHI;
|
|
|
|
} else {
|
|
|
|
// Remove all of the edges coming into the PHI nodes from outside of the
|
|
|
|
// block.
|
|
|
|
for (unsigned i = 0, e = Preds.size(); i != e; ++i)
|
|
|
|
PN->removeIncomingValue(Preds[i], false);
|
2002-09-26 16:17:31 +00:00
|
|
|
}
|
2003-12-19 06:27:08 +00:00
|
|
|
|
|
|
|
// Add an incoming value to the PHI node in the loop for the preheader
|
|
|
|
// edge.
|
|
|
|
PN->addIncoming(InVal, NewBB);
|
2004-04-13 05:05:33 +00:00
|
|
|
|
|
|
|
// Can we eliminate this phi node now?
|
2005-08-05 00:57:45 +00:00
|
|
|
if (Value *V = PN->hasConstantValue(true)) {
|
2007-04-08 01:04:30 +00:00
|
|
|
Instruction *I = dyn_cast<Instruction>(V);
|
2007-06-08 01:50:32 +00:00
|
|
|
// If I is in NewBB, the Dominator call will fail, because NewBB isn't
|
|
|
|
// registered in DominatorTree yet. Handle this case explicitly.
|
2007-04-08 01:04:30 +00:00
|
|
|
if (!I || (I->getParent() != NewBB &&
|
2007-06-08 01:50:32 +00:00
|
|
|
getAnalysis<DominatorTree>().dominates(I, PN))) {
|
2004-10-17 21:22:38 +00:00
|
|
|
PN->replaceAllUsesWith(V);
|
2005-03-25 06:37:22 +00:00
|
|
|
if (AA) AA->deleteValue(PN);
|
2004-10-17 21:22:38 +00:00
|
|
|
BB->getInstList().erase(PN);
|
|
|
|
}
|
2004-04-13 05:05:33 +00:00
|
|
|
}
|
2002-09-26 16:17:31 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-09-26 16:17:31 +00:00
|
|
|
// Now that the PHI nodes are updated, actually move the edges from
|
2003-02-27 20:27:08 +00:00
|
|
|
// Preds to point to NewBB instead of BB.
|
2002-09-26 16:17:31 +00:00
|
|
|
//
|
2003-02-27 20:27:08 +00:00
|
|
|
for (unsigned i = 0, e = Preds.size(); i != e; ++i) {
|
|
|
|
TerminatorInst *TI = Preds[i]->getTerminator();
|
2002-09-26 16:17:31 +00:00
|
|
|
for (unsigned s = 0, e = TI->getNumSuccessors(); s != e; ++s)
|
2003-02-27 20:27:08 +00:00
|
|
|
if (TI->getSuccessor(s) == BB)
|
2002-09-26 16:17:31 +00:00
|
|
|
TI->setSuccessor(s, NewBB);
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-09-26 16:17:31 +00:00
|
|
|
} else { // Otherwise the loop is dead...
|
2004-09-28 02:40:37 +00:00
|
|
|
for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(I); ++I) {
|
|
|
|
PHINode *PN = cast<PHINode>(I);
|
2002-09-26 16:17:31 +00:00
|
|
|
// Insert dummy values as the incoming value...
|
|
|
|
PN->addIncoming(Constant::getNullValue(PN->getType()), NewBB);
|
2004-09-28 02:40:37 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
}
|
2007-06-21 17:23:45 +00:00
|
|
|
|
2003-02-27 20:27:08 +00:00
|
|
|
return NewBB;
|
|
|
|
}
|
2002-09-26 16:17:31 +00:00
|
|
|
|
2003-02-27 20:27:08 +00:00
|
|
|
/// InsertPreheaderForLoop - Once we discover that a loop doesn't have a
|
|
|
|
/// preheader, this method is called to insert one. This method has two phases:
|
|
|
|
/// preheader insertion and analysis updating.
|
|
|
|
///
|
2003-10-12 21:43:28 +00:00
|
|
|
void LoopSimplify::InsertPreheaderForLoop(Loop *L) {
|
2003-02-27 20:27:08 +00:00
|
|
|
BasicBlock *Header = L->getHeader();
|
|
|
|
|
|
|
|
// Compute the set of predecessors of the loop that are not in the loop.
|
|
|
|
std::vector<BasicBlock*> OutsideBlocks;
|
|
|
|
for (pred_iterator PI = pred_begin(Header), PE = pred_end(Header);
|
|
|
|
PI != PE; ++PI)
|
2006-02-11 02:13:17 +00:00
|
|
|
if (!L->contains(*PI)) // Coming in from outside the loop?
|
|
|
|
OutsideBlocks.push_back(*PI); // Keep track of it...
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2006-09-23 07:40:52 +00:00
|
|
|
// Split out the loop pre-header.
|
2003-02-27 20:27:08 +00:00
|
|
|
BasicBlock *NewBB =
|
|
|
|
SplitBlockPredecessors(Header, ".preheader", OutsideBlocks);
|
2006-09-23 07:40:52 +00:00
|
|
|
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-09-26 16:17:31 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
2003-10-10 17:57:28 +00:00
|
|
|
// Update analysis results now that we have performed the transformation
|
2002-09-26 16:17:31 +00:00
|
|
|
//
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-09-26 16:17:31 +00:00
|
|
|
// We know that we have loop information to update... update it now.
|
|
|
|
if (Loop *Parent = L->getParentLoop())
|
2007-11-27 03:43:35 +00:00
|
|
|
Parent->addBasicBlockToLoop(NewBB, LI->getBase());
|
2003-02-27 22:48:57 +00:00
|
|
|
|
2007-06-21 17:23:45 +00:00
|
|
|
DT->splitBlock(NewBB);
|
|
|
|
if (DominanceFrontier *DF = getAnalysisToUpdate<DominanceFrontier>())
|
|
|
|
DF->splitBlock(NewBB);
|
|
|
|
|
Be far more careful when splitting a loop header, either to form a preheader
or when splitting loops with a common header into multiple loops. In particular
the old code would always insert the preheader before the old loop header. This
is disasterous in cases where the loop hasn't been rotated. For example, it can
produce code like:
.. outside the loop...
jmp LBB1_2 #bb13.outer
LBB1_1: #bb1
movsd 8(%esp,%esi,8), %xmm1
mulsd (%edi), %xmm1
addsd %xmm0, %xmm1
addl $24, %edi
incl %esi
jmp LBB1_3 #bb13
LBB1_2: #bb13.outer
leal (%edx,%eax,8), %edi
pxor %xmm1, %xmm1
xorl %esi, %esi
LBB1_3: #bb13
movapd %xmm1, %xmm0
cmpl $4, %esi
jl LBB1_1 #bb1
Note that the loop body is actually LBB1_1 + LBB1_3, which means that the
loop now contains an uncond branch WITHIN it to jump around the inserted
loop header (LBB1_2). Doh.
This patch changes the preheader insertion code to insert it in the right
spot, producing this code:
... outside the loop, fall into the header ...
LBB1_1: #bb13.outer
leal (%edx,%eax,8), %esi
pxor %xmm0, %xmm0
xorl %edi, %edi
jmp LBB1_3 #bb13
LBB1_2: #bb1
movsd 8(%esp,%edi,8), %xmm0
mulsd (%esi), %xmm0
addsd %xmm1, %xmm0
addl $24, %esi
incl %edi
LBB1_3: #bb13
movapd %xmm0, %xmm1
cmpl $4, %edi
jl LBB1_2 #bb1
Totally crazy, no branch in the loop! :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@30587 91177308-0d34-0410-b5e6-96231b3b80d8
2006-09-23 08:19:21 +00:00
|
|
|
// Make sure that NewBB is put someplace intelligent, which doesn't mess up
|
|
|
|
// code layout too horribly.
|
|
|
|
PlaceSplitBlockCarefully(NewBB, OutsideBlocks, L);
|
2003-02-27 20:27:08 +00:00
|
|
|
}
|
|
|
|
|
2004-04-13 05:05:33 +00:00
|
|
|
/// RewriteLoopExitBlock - Ensure that the loop preheader dominates all exit
|
|
|
|
/// blocks. This method is used to split exit blocks that have predecessors
|
|
|
|
/// outside of the loop.
|
2004-04-18 22:27:10 +00:00
|
|
|
BasicBlock *LoopSimplify::RewriteLoopExitBlock(Loop *L, BasicBlock *Exit) {
|
2003-02-27 20:27:08 +00:00
|
|
|
std::vector<BasicBlock*> LoopBlocks;
|
|
|
|
for (pred_iterator I = pred_begin(Exit), E = pred_end(Exit); I != E; ++I)
|
|
|
|
if (L->contains(*I))
|
|
|
|
LoopBlocks.push_back(*I);
|
|
|
|
|
2003-02-27 22:31:07 +00:00
|
|
|
assert(!LoopBlocks.empty() && "No edges coming in from outside the loop?");
|
|
|
|
BasicBlock *NewBB = SplitBlockPredecessors(Exit, ".loopexit", LoopBlocks);
|
|
|
|
|
2006-02-14 22:34:08 +00:00
|
|
|
// Update Loop Information - we know that the new block will be in whichever
|
|
|
|
// loop the Exit block is in. Note that it may not be in that immediate loop,
|
|
|
|
// if the successor is some other loop header. In that case, we continue
|
|
|
|
// walking up the loop tree to find a loop that contains both the successor
|
|
|
|
// block and the predecessor block.
|
|
|
|
Loop *SuccLoop = LI->getLoopFor(Exit);
|
|
|
|
while (SuccLoop && !SuccLoop->contains(L->getHeader()))
|
|
|
|
SuccLoop = SuccLoop->getParentLoop();
|
|
|
|
if (SuccLoop)
|
2007-11-27 03:43:35 +00:00
|
|
|
SuccLoop->addBasicBlockToLoop(NewBB, LI->getBase());
|
2003-02-28 03:07:54 +00:00
|
|
|
|
2007-06-21 17:23:45 +00:00
|
|
|
// Update Dominator Information
|
|
|
|
DT->splitBlock(NewBB);
|
|
|
|
if (DominanceFrontier *DF = getAnalysisToUpdate<DominanceFrontier>())
|
|
|
|
DF->splitBlock(NewBB);
|
|
|
|
|
2004-04-18 22:27:10 +00:00
|
|
|
return NewBB;
|
2003-10-13 00:37:13 +00:00
|
|
|
}
|
|
|
|
|
2004-04-13 05:05:33 +00:00
|
|
|
/// AddBlockAndPredsToSet - Add the specified block, and all of its
|
|
|
|
/// predecessors, to the specified set, if it's not already in there. Stop
|
|
|
|
/// predecessor traversal when we reach StopBlock.
|
2007-04-20 20:04:37 +00:00
|
|
|
static void AddBlockAndPredsToSet(BasicBlock *InputBB, BasicBlock *StopBlock,
|
2004-04-13 05:05:33 +00:00
|
|
|
std::set<BasicBlock*> &Blocks) {
|
2007-04-20 20:04:37 +00:00
|
|
|
std::vector<BasicBlock *> WorkList;
|
|
|
|
WorkList.push_back(InputBB);
|
|
|
|
do {
|
|
|
|
BasicBlock *BB = WorkList.back(); WorkList.pop_back();
|
|
|
|
if (Blocks.insert(BB).second && BB != StopBlock)
|
|
|
|
// If BB is not already processed and it is not a stop block then
|
|
|
|
// insert its predecessor in the work list
|
|
|
|
for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
|
|
|
|
BasicBlock *WBB = *I;
|
|
|
|
WorkList.push_back(WBB);
|
|
|
|
}
|
|
|
|
} while(!WorkList.empty());
|
2004-04-13 05:05:33 +00:00
|
|
|
}
|
|
|
|
|
2004-04-13 15:21:18 +00:00
|
|
|
/// FindPHIToPartitionLoops - The first part of loop-nestification is to find a
|
|
|
|
/// PHI node that tells us how to partition the loops.
|
2007-06-08 01:50:32 +00:00
|
|
|
static PHINode *FindPHIToPartitionLoops(Loop *L, DominatorTree *DT,
|
2007-04-09 22:54:50 +00:00
|
|
|
AliasAnalysis *AA) {
|
2004-09-28 02:40:37 +00:00
|
|
|
for (BasicBlock::iterator I = L->getHeader()->begin(); isa<PHINode>(I); ) {
|
|
|
|
PHINode *PN = cast<PHINode>(I);
|
2004-04-13 15:21:18 +00:00
|
|
|
++I;
|
2005-08-04 23:24:19 +00:00
|
|
|
if (Value *V = PN->hasConstantValue())
|
2007-06-08 01:50:32 +00:00
|
|
|
if (!isa<Instruction>(V) || DT->dominates(cast<Instruction>(V), PN)) {
|
2004-10-17 21:22:38 +00:00
|
|
|
// This is a degenerate PHI already, don't modify it!
|
|
|
|
PN->replaceAllUsesWith(V);
|
2005-03-25 06:37:22 +00:00
|
|
|
if (AA) AA->deleteValue(PN);
|
2005-03-06 21:35:38 +00:00
|
|
|
PN->eraseFromParent();
|
2004-10-17 21:22:38 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Scan this PHI node looking for a use of the PHI node by itself.
|
|
|
|
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
|
|
|
|
if (PN->getIncomingValue(i) == PN &&
|
|
|
|
L->contains(PN->getIncomingBlock(i)))
|
|
|
|
// We found something tasty to remove.
|
|
|
|
return PN;
|
2004-04-13 15:21:18 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Be far more careful when splitting a loop header, either to form a preheader
or when splitting loops with a common header into multiple loops. In particular
the old code would always insert the preheader before the old loop header. This
is disasterous in cases where the loop hasn't been rotated. For example, it can
produce code like:
.. outside the loop...
jmp LBB1_2 #bb13.outer
LBB1_1: #bb1
movsd 8(%esp,%esi,8), %xmm1
mulsd (%edi), %xmm1
addsd %xmm0, %xmm1
addl $24, %edi
incl %esi
jmp LBB1_3 #bb13
LBB1_2: #bb13.outer
leal (%edx,%eax,8), %edi
pxor %xmm1, %xmm1
xorl %esi, %esi
LBB1_3: #bb13
movapd %xmm1, %xmm0
cmpl $4, %esi
jl LBB1_1 #bb1
Note that the loop body is actually LBB1_1 + LBB1_3, which means that the
loop now contains an uncond branch WITHIN it to jump around the inserted
loop header (LBB1_2). Doh.
This patch changes the preheader insertion code to insert it in the right
spot, producing this code:
... outside the loop, fall into the header ...
LBB1_1: #bb13.outer
leal (%edx,%eax,8), %esi
pxor %xmm0, %xmm0
xorl %edi, %edi
jmp LBB1_3 #bb13
LBB1_2: #bb1
movsd 8(%esp,%edi,8), %xmm0
mulsd (%esi), %xmm0
addsd %xmm1, %xmm0
addl $24, %esi
incl %edi
LBB1_3: #bb13
movapd %xmm0, %xmm1
cmpl $4, %edi
jl LBB1_2 #bb1
Totally crazy, no branch in the loop! :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@30587 91177308-0d34-0410-b5e6-96231b3b80d8
2006-09-23 08:19:21 +00:00
|
|
|
// PlaceSplitBlockCarefully - If the block isn't already, move the new block to
|
|
|
|
// right after some 'outside block' block. This prevents the preheader from
|
|
|
|
// being placed inside the loop body, e.g. when the loop hasn't been rotated.
|
|
|
|
void LoopSimplify::PlaceSplitBlockCarefully(BasicBlock *NewBB,
|
|
|
|
std::vector<BasicBlock*>&SplitPreds,
|
|
|
|
Loop *L) {
|
|
|
|
// Check to see if NewBB is already well placed.
|
|
|
|
Function::iterator BBI = NewBB; --BBI;
|
|
|
|
for (unsigned i = 0, e = SplitPreds.size(); i != e; ++i) {
|
|
|
|
if (&*BBI == SplitPreds[i])
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If it isn't already after an outside block, move it after one. This is
|
|
|
|
// always good as it makes the uncond branch from the outside block into a
|
|
|
|
// fall-through.
|
|
|
|
|
|
|
|
// Figure out *which* outside block to put this after. Prefer an outside
|
|
|
|
// block that neighbors a BB actually in the loop.
|
|
|
|
BasicBlock *FoundBB = 0;
|
|
|
|
for (unsigned i = 0, e = SplitPreds.size(); i != e; ++i) {
|
|
|
|
Function::iterator BBI = SplitPreds[i];
|
|
|
|
if (++BBI != NewBB->getParent()->end() &&
|
|
|
|
L->contains(BBI)) {
|
|
|
|
FoundBB = SplitPreds[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If our heuristic for a *good* bb to place this after doesn't find
|
|
|
|
// anything, just pick something. It's likely better than leaving it within
|
|
|
|
// the loop.
|
|
|
|
if (!FoundBB)
|
|
|
|
FoundBB = SplitPreds[0];
|
|
|
|
NewBB->moveAfter(FoundBB);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-04-13 05:05:33 +00:00
|
|
|
/// SeparateNestedLoop - If this loop has multiple backedges, try to pull one of
|
|
|
|
/// them out into a nested loop. This is important for code that looks like
|
|
|
|
/// this:
|
|
|
|
///
|
|
|
|
/// Loop:
|
|
|
|
/// ...
|
|
|
|
/// br cond, Loop, Next
|
|
|
|
/// ...
|
|
|
|
/// br cond2, Loop, Out
|
|
|
|
///
|
|
|
|
/// To identify this common case, we look at the PHI nodes in the header of the
|
|
|
|
/// loop. PHI nodes with unchanging values on one backedge correspond to values
|
|
|
|
/// that change in the "outer" loop, but not in the "inner" loop.
|
|
|
|
///
|
|
|
|
/// If we are able to separate out a loop, return the new outer loop that was
|
|
|
|
/// created.
|
|
|
|
///
|
|
|
|
Loop *LoopSimplify::SeparateNestedLoop(Loop *L) {
|
2007-06-08 01:50:32 +00:00
|
|
|
PHINode *PN = FindPHIToPartitionLoops(L, DT, AA);
|
2004-04-13 15:21:18 +00:00
|
|
|
if (PN == 0) return 0; // No known way to partition.
|
2004-04-13 05:05:33 +00:00
|
|
|
|
2004-04-13 15:21:18 +00:00
|
|
|
// Pull out all predecessors that have varying values in the loop. This
|
|
|
|
// handles the case when a PHI node has multiple instances of itself as
|
|
|
|
// arguments.
|
2004-04-13 05:05:33 +00:00
|
|
|
std::vector<BasicBlock*> OuterLoopPreds;
|
2004-04-13 15:21:18 +00:00
|
|
|
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
|
|
|
|
if (PN->getIncomingValue(i) != PN ||
|
|
|
|
!L->contains(PN->getIncomingBlock(i)))
|
|
|
|
OuterLoopPreds.push_back(PN->getIncomingBlock(i));
|
2004-04-13 05:05:33 +00:00
|
|
|
|
2004-04-13 16:23:25 +00:00
|
|
|
BasicBlock *Header = L->getHeader();
|
2004-04-13 05:05:33 +00:00
|
|
|
BasicBlock *NewBB = SplitBlockPredecessors(Header, ".outer", OuterLoopPreds);
|
|
|
|
|
2007-06-21 17:23:45 +00:00
|
|
|
// Update dominator information
|
|
|
|
DT->splitBlock(NewBB);
|
|
|
|
if (DominanceFrontier *DF = getAnalysisToUpdate<DominanceFrontier>())
|
|
|
|
DF->splitBlock(NewBB);
|
2004-04-13 05:05:33 +00:00
|
|
|
|
Be far more careful when splitting a loop header, either to form a preheader
or when splitting loops with a common header into multiple loops. In particular
the old code would always insert the preheader before the old loop header. This
is disasterous in cases where the loop hasn't been rotated. For example, it can
produce code like:
.. outside the loop...
jmp LBB1_2 #bb13.outer
LBB1_1: #bb1
movsd 8(%esp,%esi,8), %xmm1
mulsd (%edi), %xmm1
addsd %xmm0, %xmm1
addl $24, %edi
incl %esi
jmp LBB1_3 #bb13
LBB1_2: #bb13.outer
leal (%edx,%eax,8), %edi
pxor %xmm1, %xmm1
xorl %esi, %esi
LBB1_3: #bb13
movapd %xmm1, %xmm0
cmpl $4, %esi
jl LBB1_1 #bb1
Note that the loop body is actually LBB1_1 + LBB1_3, which means that the
loop now contains an uncond branch WITHIN it to jump around the inserted
loop header (LBB1_2). Doh.
This patch changes the preheader insertion code to insert it in the right
spot, producing this code:
... outside the loop, fall into the header ...
LBB1_1: #bb13.outer
leal (%edx,%eax,8), %esi
pxor %xmm0, %xmm0
xorl %edi, %edi
jmp LBB1_3 #bb13
LBB1_2: #bb1
movsd 8(%esp,%edi,8), %xmm0
mulsd (%esi), %xmm0
addsd %xmm1, %xmm0
addl $24, %esi
incl %edi
LBB1_3: #bb13
movapd %xmm0, %xmm1
cmpl $4, %edi
jl LBB1_2 #bb1
Totally crazy, no branch in the loop! :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@30587 91177308-0d34-0410-b5e6-96231b3b80d8
2006-09-23 08:19:21 +00:00
|
|
|
// Make sure that NewBB is put someplace intelligent, which doesn't mess up
|
|
|
|
// code layout too horribly.
|
|
|
|
PlaceSplitBlockCarefully(NewBB, OuterLoopPreds, L);
|
|
|
|
|
2004-04-13 05:05:33 +00:00
|
|
|
// Create the new outer loop.
|
|
|
|
Loop *NewOuter = new Loop();
|
|
|
|
|
|
|
|
// Change the parent loop to use the outer loop as its child now.
|
|
|
|
if (Loop *Parent = L->getParentLoop())
|
|
|
|
Parent->replaceChildLoopWith(L, NewOuter);
|
|
|
|
else
|
2006-02-14 22:34:08 +00:00
|
|
|
LI->changeTopLevelLoop(L, NewOuter);
|
2004-04-13 05:05:33 +00:00
|
|
|
|
|
|
|
// This block is going to be our new header block: add it to this loop and all
|
|
|
|
// parent loops.
|
2007-11-27 03:43:35 +00:00
|
|
|
NewOuter->addBasicBlockToLoop(NewBB, LI->getBase());
|
2004-04-13 05:05:33 +00:00
|
|
|
|
|
|
|
// L is now a subloop of our outer loop.
|
|
|
|
NewOuter->addChildLoop(L);
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = L->getBlocks().size(); i != e; ++i)
|
|
|
|
NewOuter->addBlockEntry(L->getBlocks()[i]);
|
|
|
|
|
|
|
|
// Determine which blocks should stay in L and which should be moved out to
|
|
|
|
// the Outer loop now.
|
|
|
|
std::set<BasicBlock*> BlocksInL;
|
|
|
|
for (pred_iterator PI = pred_begin(Header), E = pred_end(Header); PI!=E; ++PI)
|
2007-06-08 01:50:32 +00:00
|
|
|
if (DT->dominates(Header, *PI))
|
2004-04-13 05:05:33 +00:00
|
|
|
AddBlockAndPredsToSet(*PI, Header, BlocksInL);
|
|
|
|
|
|
|
|
|
|
|
|
// Scan all of the loop children of L, moving them to OuterLoop if they are
|
|
|
|
// not part of the inner loop.
|
2007-06-29 02:53:16 +00:00
|
|
|
const std::vector<Loop*> &SubLoops = L->getSubLoops();
|
|
|
|
for (size_t I = 0; I != SubLoops.size(); )
|
|
|
|
if (BlocksInL.count(SubLoops[I]->getHeader()))
|
2004-04-13 05:05:33 +00:00
|
|
|
++I; // Loop remains in L
|
|
|
|
else
|
2007-06-29 02:53:16 +00:00
|
|
|
NewOuter->addChildLoop(L->removeChildLoop(SubLoops.begin() + I));
|
2004-04-13 05:05:33 +00:00
|
|
|
|
|
|
|
// Now that we know which blocks are in L and which need to be moved to
|
|
|
|
// OuterLoop, move any blocks that need it.
|
|
|
|
for (unsigned i = 0; i != L->getBlocks().size(); ++i) {
|
|
|
|
BasicBlock *BB = L->getBlocks()[i];
|
|
|
|
if (!BlocksInL.count(BB)) {
|
|
|
|
// Move this block to the parent, updating the exit blocks sets
|
|
|
|
L->removeBlockFromLoop(BB);
|
2006-02-14 22:34:08 +00:00
|
|
|
if ((*LI)[BB] == L)
|
|
|
|
LI->changeLoopFor(BB, NewOuter);
|
2004-04-13 05:05:33 +00:00
|
|
|
--i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NewOuter;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2003-10-13 00:37:13 +00:00
|
|
|
/// InsertUniqueBackedgeBlock - This method is called when the specified loop
|
|
|
|
/// has more than one backedge in it. If this occurs, revector all of these
|
|
|
|
/// backedges to target a new basic block and have that block branch to the loop
|
|
|
|
/// header. This ensures that loops have exactly one backedge.
|
|
|
|
///
|
|
|
|
void LoopSimplify::InsertUniqueBackedgeBlock(Loop *L) {
|
|
|
|
assert(L->getNumBackEdges() > 1 && "Must have > 1 backedge!");
|
|
|
|
|
|
|
|
// Get information about the loop
|
|
|
|
BasicBlock *Preheader = L->getLoopPreheader();
|
|
|
|
BasicBlock *Header = L->getHeader();
|
|
|
|
Function *F = Header->getParent();
|
|
|
|
|
|
|
|
// Figure out which basic blocks contain back-edges to the loop header.
|
|
|
|
std::vector<BasicBlock*> BackedgeBlocks;
|
|
|
|
for (pred_iterator I = pred_begin(Header), E = pred_end(Header); I != E; ++I)
|
|
|
|
if (*I != Preheader) BackedgeBlocks.push_back(*I);
|
|
|
|
|
|
|
|
// Create and insert the new backedge block...
|
|
|
|
BasicBlock *BEBlock = new BasicBlock(Header->getName()+".backedge", F);
|
2003-11-21 16:52:05 +00:00
|
|
|
BranchInst *BETerminator = new BranchInst(Header, BEBlock);
|
2003-10-13 00:37:13 +00:00
|
|
|
|
|
|
|
// Move the new backedge block to right after the last backedge block.
|
|
|
|
Function::iterator InsertPos = BackedgeBlocks.back(); ++InsertPos;
|
|
|
|
F->getBasicBlockList().splice(InsertPos, F->getBasicBlockList(), BEBlock);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-10-13 00:37:13 +00:00
|
|
|
// Now that the block has been inserted into the function, create PHI nodes in
|
|
|
|
// the backedge block which correspond to any PHI nodes in the header block.
|
2004-09-28 02:40:37 +00:00
|
|
|
for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) {
|
|
|
|
PHINode *PN = cast<PHINode>(I);
|
2003-10-13 00:37:13 +00:00
|
|
|
PHINode *NewPN = new PHINode(PN->getType(), PN->getName()+".be",
|
|
|
|
BETerminator);
|
2005-01-29 00:39:08 +00:00
|
|
|
NewPN->reserveOperandSpace(BackedgeBlocks.size());
|
2005-03-25 06:37:22 +00:00
|
|
|
if (AA) AA->copyValue(PN, NewPN);
|
2003-10-13 00:37:13 +00:00
|
|
|
|
|
|
|
// Loop over the PHI node, moving all entries except the one for the
|
|
|
|
// preheader over to the new PHI node.
|
|
|
|
unsigned PreheaderIdx = ~0U;
|
|
|
|
bool HasUniqueIncomingValue = true;
|
|
|
|
Value *UniqueValue = 0;
|
|
|
|
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
|
|
|
|
BasicBlock *IBB = PN->getIncomingBlock(i);
|
|
|
|
Value *IV = PN->getIncomingValue(i);
|
|
|
|
if (IBB == Preheader) {
|
|
|
|
PreheaderIdx = i;
|
|
|
|
} else {
|
|
|
|
NewPN->addIncoming(IV, IBB);
|
|
|
|
if (HasUniqueIncomingValue) {
|
|
|
|
if (UniqueValue == 0)
|
|
|
|
UniqueValue = IV;
|
|
|
|
else if (UniqueValue != IV)
|
|
|
|
HasUniqueIncomingValue = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-10-13 00:37:13 +00:00
|
|
|
// Delete all of the incoming values from the old PN except the preheader's
|
|
|
|
assert(PreheaderIdx != ~0U && "PHI has no preheader entry??");
|
|
|
|
if (PreheaderIdx != 0) {
|
|
|
|
PN->setIncomingValue(0, PN->getIncomingValue(PreheaderIdx));
|
|
|
|
PN->setIncomingBlock(0, PN->getIncomingBlock(PreheaderIdx));
|
|
|
|
}
|
2005-01-29 00:39:08 +00:00
|
|
|
// Nuke all entries except the zero'th.
|
|
|
|
for (unsigned i = 0, e = PN->getNumIncomingValues()-1; i != e; ++i)
|
|
|
|
PN->removeIncomingValue(e-i, false);
|
2003-10-13 00:37:13 +00:00
|
|
|
|
|
|
|
// Finally, add the newly constructed PHI node as the entry for the BEBlock.
|
|
|
|
PN->addIncoming(NewPN, BEBlock);
|
|
|
|
|
|
|
|
// As an optimization, if all incoming values in the new PhiNode (which is a
|
|
|
|
// subset of the incoming values of the old PHI node) have the same value,
|
|
|
|
// eliminate the PHI Node.
|
|
|
|
if (HasUniqueIncomingValue) {
|
|
|
|
NewPN->replaceAllUsesWith(UniqueValue);
|
2005-03-25 06:37:22 +00:00
|
|
|
if (AA) AA->deleteValue(NewPN);
|
2003-10-13 00:37:13 +00:00
|
|
|
BEBlock->getInstList().erase(NewPN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now that all of the PHI nodes have been inserted and adjusted, modify the
|
|
|
|
// backedge blocks to just to the BEBlock instead of the header.
|
|
|
|
for (unsigned i = 0, e = BackedgeBlocks.size(); i != e; ++i) {
|
|
|
|
TerminatorInst *TI = BackedgeBlocks[i]->getTerminator();
|
|
|
|
for (unsigned Op = 0, e = TI->getNumSuccessors(); Op != e; ++Op)
|
|
|
|
if (TI->getSuccessor(Op) == Header)
|
|
|
|
TI->setSuccessor(Op, BEBlock);
|
|
|
|
}
|
|
|
|
|
|
|
|
//===--- Update all analyses which we must preserve now -----------------===//
|
|
|
|
|
|
|
|
// Update Loop Information - we know that this block is now in the current
|
|
|
|
// loop and all parent loops.
|
2007-11-27 03:43:35 +00:00
|
|
|
L->addBasicBlockToLoop(BEBlock, LI->getBase());
|
2003-10-13 00:37:13 +00:00
|
|
|
|
2007-06-21 17:23:45 +00:00
|
|
|
// Update dominator information
|
|
|
|
DT->splitBlock(BEBlock);
|
|
|
|
if (DominanceFrontier *DF = getAnalysisToUpdate<DominanceFrontier>())
|
|
|
|
DF->splitBlock(BEBlock);
|
2002-09-26 16:17:31 +00:00
|
|
|
}
|