//===----------------------------------------------------------------------===//
#include "llvm/Transforms/Scalar.h"
-#include "llvm/Function.h"
+#include "llvm/Constant.h"
#include "llvm/iTerminators.h"
#include "llvm/iPHINode.h"
-#include "llvm/Constant.h"
+#include "llvm/Function.h"
+#include "llvm/Type.h"
#include "llvm/Analysis/Dominators.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Transforms/Utils/Local.h"
#include "Support/SetOperations.h"
#include "Support/Statistic.h"
#include "Support/DepthFirstIterator.h"
namespace {
Statistic<>
NumInserted("loopsimplify", "Number of pre-header or exit blocks inserted");
+ Statistic<>
+ NumNested("loopsimplify", "Number of nested loops split out");
struct LoopSimplify : public FunctionPass {
virtual bool runOnFunction(Function &F);
// We need loop information to identify the loops...
AU.addRequired<LoopInfo>();
AU.addRequired<DominatorSet>();
+ AU.addRequired<DominatorTree>();
AU.addPreserved<LoopInfo>();
AU.addPreserved<DominatorSet>();
bool ProcessLoop(Loop *L);
BasicBlock *SplitBlockPredecessors(BasicBlock *BB, const char *Suffix,
const std::vector<BasicBlock*> &Preds);
- void RewriteLoopExitBlock(Loop *L, BasicBlock *Exit);
+ BasicBlock *RewriteLoopExitBlock(Loop *L, BasicBlock *Exit);
void InsertPreheaderForLoop(Loop *L);
+ Loop *SeparateNestedLoop(Loop *L);
void InsertUniqueBackedgeBlock(Loop *L);
void UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB,
bool LoopSimplify::ProcessLoop(Loop *L) {
bool Changed = false;
+ // Check to see that no blocks (other than the header) in the loop have
+ // predecessors that are not in the loop. 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!
+ assert(L->getBlocks()[0] == L->getHeader() &&
+ "Header isn't first block in loop?");
+ for (unsigned i = 1, e = L->getBlocks().size(); i != e; ++i) {
+ BasicBlock *LoopBB = L->getBlocks()[i];
+ Retry:
+ for (pred_iterator PI = pred_begin(LoopBB), E = pred_end(LoopBB);
+ PI != E; ++PI)
+ if (!L->contains(*PI)) {
+ // This predecessor is not in the loop. Kill its terminator!
+ BasicBlock *DeadBlock = *PI;
+ for (succ_iterator SI = succ_begin(DeadBlock), E = succ_end(DeadBlock);
+ SI != E; ++SI)
+ (*SI)->removePredecessor(DeadBlock); // Remove PHI node entries
+
+ // Delete the dead terminator.
+ DeadBlock->getInstList().pop_back();
+
+ Value *RetVal = 0;
+ if (LoopBB->getParent()->getReturnType() != Type::VoidTy)
+ RetVal = Constant::getNullValue(LoopBB->getParent()->getReturnType());
+ new ReturnInst(RetVal, DeadBlock);
+ goto Retry; // We just invalidated the pred_iterator. Retry.
+ }
+ }
+
// Does the loop already have a preheader? If so, don't modify the loop...
if (L->getLoopPreheader() == 0) {
InsertPreheaderForLoop(L);
// 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
// predecessors from outside of the loop, split the edge now.
- for (unsigned i = 0, e = L->getExitBlocks().size(); i != e; ++i) {
- BasicBlock *ExitBlock = L->getExitBlocks()[i];
+ std::vector<BasicBlock*> ExitBlocks;
+ L->getExitBlocks(ExitBlocks);
+ for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) {
+ BasicBlock *ExitBlock = ExitBlocks[i];
for (pred_iterator PI = pred_begin(ExitBlock), PE = pred_end(ExitBlock);
PI != PE; ++PI)
if (!L->contains(*PI)) {
- RewriteLoopExitBlock(L, ExitBlock);
+ BasicBlock *NewBB = RewriteLoopExitBlock(L, ExitBlock);
+ for (unsigned j = i; j != ExitBlocks.size(); ++j)
+ if (ExitBlocks[j] == ExitBlock)
+ ExitBlocks[j] = NewBB;
+
NumInserted++;
Changed = true;
break;
}
}
- // The preheader may have more than two predecessors at this point (from the
- // preheader and from the backedges). To simplify the loop more, insert an
- // extra back-edge block in the loop so that there is exactly one backedge.
+ // If the header has more than two predecessors at this point (from the
+ // preheader and from multiple backedges), we must adjust the loop.
if (L->getNumBackEdges() != 1) {
+ // If this is really a nested loop, rip it out into a child loop.
+ if (Loop *NL = SeparateNestedLoop(L)) {
+ ++NumNested;
+ // This is a big restructuring change, reprocess the whole loop.
+ ProcessLoop(NL);
+ return true;
+ }
+
InsertUniqueBackedgeBlock(L);
NumInserted++;
Changed = true;
// Check to see if the values being merged into the new block need PHI
// nodes. If so, insert them.
for (BasicBlock::iterator I = BB->begin();
- PHINode *PN = dyn_cast<PHINode>(I); ++I) {
-
+ PHINode *PN = dyn_cast<PHINode>(I); ) {
+ ++I;
+
// 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]);
// Move all of the edges from blocks outside the loop to the new PHI
for (unsigned i = 0, e = Preds.size(); i != e; ++i) {
- Value *V = PN->removeIncomingValue(Preds[i]);
+ Value *V = PN->removeIncomingValue(Preds[i], false);
NewPHI->addIncoming(V, Preds[i]);
}
InVal = NewPHI;
// Add an incoming value to the PHI node in the loop for the preheader
// edge.
PN->addIncoming(InVal, NewBB);
+
+ // Can we eliminate this phi node now?
+ if (Value *V = hasConstantValue(PN)) {
+ PN->replaceAllUsesWith(V);
+ BB->getInstList().erase(PN);
+ }
}
// Now that the PHI nodes are updated, actually move the edges from
return NewBB;
}
-// ChangeExitBlock - This recursive function is used to change any exit blocks
-// that use OldExit to use NewExit instead. This is recursive because children
-// may need to be processed as well.
-//
-static void ChangeExitBlock(Loop *L, BasicBlock *OldExit, BasicBlock *NewExit) {
- if (L->hasExitBlock(OldExit)) {
- L->changeExitBlock(OldExit, NewExit);
- for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
- ChangeExitBlock(*I, OldExit, NewExit);
- }
-}
-
-
/// 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.
ParentLoopsE = getAnalysis<LoopInfo>().end();
}
- // Loop over all sibling loops, performing the substitution (recursively to
- // include child loops)...
- for (; ParentLoops != ParentLoopsE; ++ParentLoops)
- ChangeExitBlock(*ParentLoops, Header, NewBB);
-
DominatorSet &DS = getAnalysis<DominatorSet>(); // Update dominator info
+ DominatorTree &DT = getAnalysis<DominatorTree>();
+
+
+ // Update the dominator tree information.
+ // The immediate dominator of the preheader is the immediate dominator of
+ // the old header.
+ DominatorTree::Node *PHDomTreeNode =
+ DT.createNewNode(NewBB, DT.getNode(Header)->getIDom());
+
+ // Change the header node so that PNHode is the new immediate dominator
+ DT.changeImmediateDominator(DT.getNode(Header), PHDomTreeNode);
+
{
// The blocks that dominate NewBB are the blocks that dominate Header,
// minus Header, plus NewBB.
DominatorSet::DomSetType DomSet = DS.getDominators(Header);
- DomSet.insert(NewBB); // We dominate ourself
DomSet.erase(Header); // Header does not dominate us...
DS.addBasicBlock(NewBB, DomSet);
// The newly created basic block dominates all nodes dominated by Header.
- for (Function::iterator I = Header->getParent()->begin(),
- E = Header->getParent()->end(); I != E; ++I)
- if (DS.dominates(Header, I))
- DS.addDominator(I, NewBB);
+ for (df_iterator<DominatorTree::Node*> DFI = df_begin(PHDomTreeNode),
+ E = df_end(PHDomTreeNode); DFI != E; ++DFI)
+ DS.addDominator((*DFI)->getBlock(), NewBB);
}
// Update immediate dominator information if we have it...
ID->setImmediateDominator(Header, NewBB);
}
- // Update DominatorTree information if it is active.
- if (DominatorTree *DT = getAnalysisToUpdate<DominatorTree>()) {
- // The immediate dominator of the preheader is the immediate dominator of
- // the old header.
- //
- DominatorTree::Node *HeaderNode = DT->getNode(Header);
- DominatorTree::Node *PHNode = DT->createNewNode(NewBB,
- HeaderNode->getIDom());
-
- // Change the header node so that PNHode is the new immediate dominator
- DT->changeImmediateDominator(HeaderNode, PHNode);
- }
-
// Update dominance frontier information...
if (DominanceFrontier *DF = getAnalysisToUpdate<DominanceFrontier>()) {
// The DF(NewBB) is just (DF(Header)-Header), because NewBB dominates
}
}
-void LoopSimplify::RewriteLoopExitBlock(Loop *L, BasicBlock *Exit) {
+/// 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.
+BasicBlock *LoopSimplify::RewriteLoopExitBlock(Loop *L, BasicBlock *Exit) {
DominatorSet &DS = getAnalysis<DominatorSet>();
- assert(std::find(L->getExitBlocks().begin(), L->getExitBlocks().end(), Exit)
- != L->getExitBlocks().end() && "Not a current exit block!");
std::vector<BasicBlock*> LoopBlocks;
for (pred_iterator I = pred_begin(Exit), E = pred_end(Exit); I != E; ++I)
if (Loop *Parent = L->getParentLoop())
Parent->addBasicBlockToLoop(NewBB, getAnalysis<LoopInfo>());
- // Replace any instances of Exit with NewBB in this and any nested loops...
- for (df_iterator<Loop*> I = df_begin(L), E = df_end(L); I != E; ++I)
- if (I->hasExitBlock(Exit))
- I->changeExitBlock(Exit, NewBB); // Update exit block information
-
// Update dominator information (set, immdom, domtree, and domfrontier)
UpdateDomInfoForRevectoredPreds(NewBB, LoopBlocks);
+ return NewBB;
}
+/// 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.
+static void AddBlockAndPredsToSet(BasicBlock *BB, BasicBlock *StopBlock,
+ std::set<BasicBlock*> &Blocks) {
+ if (!Blocks.insert(BB).second) return; // already processed.
+ if (BB == StopBlock) return; // Stop here!
+
+ for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I)
+ AddBlockAndPredsToSet(*I, StopBlock, Blocks);
+}
+
+/// FindPHIToPartitionLoops - The first part of loop-nestification is to find a
+/// PHI node that tells us how to partition the loops.
+static PHINode *FindPHIToPartitionLoops(Loop *L) {
+ for (BasicBlock::iterator I = L->getHeader()->begin();
+ PHINode *PN = dyn_cast<PHINode>(I); ) {
+ ++I;
+ if (Value *V = hasConstantValue(PN)) {
+ // This is a degenerate PHI already, don't modify it!
+ PN->replaceAllUsesWith(V);
+ PN->getParent()->getInstList().erase(PN);
+ } else {
+ // 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;
+ }
+ }
+ return 0;
+}
+
+/// 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) {
+ PHINode *PN = FindPHIToPartitionLoops(L);
+ if (PN == 0) return 0; // No known way to partition.
+
+ // 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.
+ std::vector<BasicBlock*> OuterLoopPreds;
+ 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));
+
+ BasicBlock *Header = L->getHeader();
+ BasicBlock *NewBB = SplitBlockPredecessors(Header, ".outer", OuterLoopPreds);
+
+ // Update dominator information (set, immdom, domtree, and domfrontier)
+ UpdateDomInfoForRevectoredPreds(NewBB, OuterLoopPreds);
+
+ // Create the new outer loop.
+ Loop *NewOuter = new Loop();
+
+ LoopInfo &LI = getAnalysis<LoopInfo>();
+
+ // Change the parent loop to use the outer loop as its child now.
+ if (Loop *Parent = L->getParentLoop())
+ Parent->replaceChildLoopWith(L, NewOuter);
+ else
+ LI.changeTopLevelLoop(L, NewOuter);
+
+ // This block is going to be our new header block: add it to this loop and all
+ // parent loops.
+ NewOuter->addBasicBlockToLoop(NewBB, getAnalysis<LoopInfo>());
+
+ // 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.
+ DominatorSet &DS = getAnalysis<DominatorSet>();
+ std::set<BasicBlock*> BlocksInL;
+ for (pred_iterator PI = pred_begin(Header), E = pred_end(Header); PI!=E; ++PI)
+ if (DS.dominates(Header, *PI))
+ 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.
+ for (Loop::iterator I = L->begin(); I != L->end(); )
+ if (BlocksInL.count((*I)->getHeader()))
+ ++I; // Loop remains in L
+ else
+ NewOuter->addChildLoop(L->removeChildLoop(I));
+
+ // 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);
+ if (LI[BB] == L)
+ LI.changeLoopFor(BB, NewOuter);
+ --i;
+ }
+ }
+
+ return NewOuter;
+}
+
+
+
/// 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
// loop and all parent loops.
L->addBasicBlockToLoop(BEBlock, getAnalysis<LoopInfo>());
- // Replace any instances of Exit with NewBB in this and any nested loops...
- for (df_iterator<Loop*> I = df_begin(L), E = df_end(L); I != E; ++I)
- if (I->hasExitBlock(Header))
- I->changeExitBlock(Header, BEBlock); // Update exit block information
-
// Update dominator information (set, immdom, domtree, and domfrontier)
UpdateDomInfoForRevectoredPreds(BEBlock, BackedgeBlocks);
}
BasicBlock *NewBBSucc = *succ_begin(NewBB);
DominatorSet &DS = getAnalysis<DominatorSet>();
+ // Update dominator information... The blocks that dominate NewBB are the
+ // intersection of the dominators of predecessors, plus the block itself.
+ //
+ DominatorSet::DomSetType NewBBDomSet = DS.getDominators(PredBlocks[0]);
+ for (unsigned i = 1, e = PredBlocks.size(); i != e; ++i)
+ set_intersect(NewBBDomSet, DS.getDominators(PredBlocks[i]));
+ NewBBDomSet.insert(NewBB); // All blocks dominate themselves...
+ DS.addBasicBlock(NewBB, NewBBDomSet);
+
// The newly inserted basic block will dominate existing basic blocks iff the
// PredBlocks dominate all of the non-pred blocks. If all predblocks dominate
// the non-pred blocks, then they all must be the same block!
+ //
bool NewBBDominatesNewBBSucc = true;
{
BasicBlock *OnePred = PredBlocks[0];
if (NewBBDominatesNewBBSucc)
for (pred_iterator PI = pred_begin(NewBBSucc), E = pred_end(NewBBSucc);
PI != E; ++PI)
- if (*PI != NewBB && !DS.dominates(OnePred, *PI)) {
+ if (*PI != NewBB && !DS.dominates(NewBBSucc, *PI)) {
NewBBDominatesNewBBSucc = false;
break;
}
}
- // Update dominator information... The blocks that dominate NewBB are the
- // intersection of the dominators of predecessors, plus the block itself.
- // The newly created basic block does not dominate anything except itself.
- //
- DominatorSet::DomSetType NewBBDomSet = DS.getDominators(PredBlocks[0]);
- for (unsigned i = 1, e = PredBlocks.size(); i != e; ++i)
- set_intersect(NewBBDomSet, DS.getDominators(PredBlocks[i]));
- NewBBDomSet.insert(NewBB); // All blocks dominate themselves...
- DS.addBasicBlock(NewBB, NewBBDomSet);
+ // The other scenario where the new block can dominate its successors are when
+ // all predecessors of NewBBSucc that are not NewBB are dominated by NewBBSucc
+ // already.
+ if (!NewBBDominatesNewBBSucc) {
+ NewBBDominatesNewBBSucc = true;
+ for (pred_iterator PI = pred_begin(NewBBSucc), E = pred_end(NewBBSucc);
+ PI != E; ++PI)
+ if (*PI != NewBB && !DS.dominates(NewBBSucc, *PI)) {
+ NewBBDominatesNewBBSucc = false;
+ break;
+ }
+ }
// If NewBB dominates some blocks, then it will dominate all blocks that
// NewBBSucc does.
// If NewBB strictly dominates other blocks, we need to update their idom's
// now. The only block that need adjustment is the NewBBSucc block, whose
// idom should currently be set to PredBlocks[0].
- if (NewBBDominatesNewBBSucc) {
- assert(ID->get(NewBBSucc) == PredBlocks[0] &&
- "Immediate dominator update code broken!");
+ if (NewBBDominatesNewBBSucc)
ID->setImmediateDominator(NewBBSucc, NewBB);
- }
}
// Update DominatorTree information if it is active.
// dominator of NewBBSucc. Update the dominator tree as appropriate.
if (NewBBDominatesNewBBSucc) {
DominatorTree::Node *NewBBSuccNode = DT->getNode(NewBBSucc);
- assert(NewBBSuccNode->getIDom()->getBlock() == PredBlocks[0] &&
- "Immediate tree update code broken!");
DT->changeImmediateDominator(NewBBSuccNode, NewBBNode);
}
}
// Update dominance frontier information...
if (DominanceFrontier *DF = getAnalysisToUpdate<DominanceFrontier>()) {
- // If NewBB dominates NewBBSucc, then the global dominance frontiers are not
- // changed. DF(NewBB) is now going to be the DF(PredBlocks[0]) without the
- // stuff that the new block does not dominate a predecessor of.
+ // If NewBB dominates NewBBSucc, then DF(NewBB) is now going to be the
+ // DF(PredBlocks[0]) without the stuff that the new block does not dominate
+ // a predecessor of.
if (NewBBDominatesNewBBSucc) {
DominanceFrontier::iterator DFI = DF->find(PredBlocks[0]);
if (DFI != DF->end()) {
DominanceFrontier::DomSetType NewDFSet;
NewDFSet.insert(NewBBSucc);
DF->addBasicBlock(NewBB, NewDFSet);
-
- // Now we must loop over all of the dominance frontiers in the function,
- // replacing occurrences of NewBBSucc with NewBB in some cases. All
- // blocks that dominate a block in PredBlocks and contained NewBBSucc in
- // their dominance frontier must be updated to contain NewBB instead.
- //
- for (unsigned i = 0, e = PredBlocks.size(); i != e; ++i) {
- BasicBlock *Pred = PredBlocks[i];
- // Get all of the dominators of the predecessor...
- const DominatorSet::DomSetType &PredDoms = DS.getDominators(Pred);
- for (DominatorSet::DomSetType::const_iterator PDI = PredDoms.begin(),
- PDE = PredDoms.end(); PDI != PDE; ++PDI) {
- BasicBlock *PredDom = *PDI;
-
- // If the NewBBSucc node is in DF(PredDom), then PredDom didn't
- // dominate NewBBSucc but did dominate a predecessor of it. Now we
- // change this entry to include NewBB in the DF instead of NewBBSucc.
- DominanceFrontier::iterator DFI = DF->find(PredDom);
- assert(DFI != DF->end() && "No dominance frontier for node?");
- if (DFI->second.count(NewBBSucc)) {
- DF->removeFromFrontier(DFI, NewBBSucc);
- DF->addToFrontier(DFI, NewBB);
+ }
+
+ // Now we must loop over all of the dominance frontiers in the function,
+ // replacing occurrences of NewBBSucc with NewBB in some cases. All
+ // blocks that dominate a block in PredBlocks and contained NewBBSucc in
+ // their dominance frontier must be updated to contain NewBB instead.
+ //
+ for (unsigned i = 0, e = PredBlocks.size(); i != e; ++i) {
+ BasicBlock *Pred = PredBlocks[i];
+ // Get all of the dominators of the predecessor...
+ const DominatorSet::DomSetType &PredDoms = DS.getDominators(Pred);
+ for (DominatorSet::DomSetType::const_iterator PDI = PredDoms.begin(),
+ PDE = PredDoms.end(); PDI != PDE; ++PDI) {
+ BasicBlock *PredDom = *PDI;
+
+ // If the NewBBSucc node is in DF(PredDom), then PredDom didn't
+ // dominate NewBBSucc but did dominate a predecessor of it. Now we
+ // change this entry to include NewBB in the DF instead of NewBBSucc.
+ DominanceFrontier::iterator DFI = DF->find(PredDom);
+ assert(DFI != DF->end() && "No dominance frontier for node?");
+ if (DFI->second.count(NewBBSucc)) {
+ // If NewBBSucc should not stay in our dominator frontier, remove it.
+ // We remove it unless there is a predecessor of NewBBSucc that we
+ // dominate, but we don't strictly dominate NewBBSucc.
+ bool ShouldRemove = true;
+ if (PredDom == NewBBSucc || !DS.dominates(PredDom, NewBBSucc)) {
+ // Okay, we know that PredDom does not strictly dominate NewBBSucc.
+ // Check to see if it dominates any predecessors of NewBBSucc.
+ for (pred_iterator PI = pred_begin(NewBBSucc),
+ E = pred_end(NewBBSucc); PI != E; ++PI)
+ if (DS.dominates(PredDom, *PI)) {
+ ShouldRemove = false;
+ break;
+ }
}
+
+ if (ShouldRemove)
+ DF->removeFromFrontier(DFI, NewBBSucc);
+ DF->addToFrontier(DFI, NewBB);
}
}
}
projects / oota-llvm.git / blobdiff