6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-08 18:31:23 +00:00
Code Issues Projects Releases Wiki Activity

Refactor code out of PropagatePredecessorsForPHIs, turning it into a pure function with no side-effects

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@22612 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2005-08-03 00:29:26 +00:00
parent d423b8b6ca
commit 3b3efc7797
1 changed files with 36 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
lib/Transforms/Utils/SimplifyCFG.cpp
View File

@ -67,55 +67,25 @@ static void AddPredecessorToBlock(BasicBlock *Succ, BasicBlock *NewPred,
} }
} }
// PropagatePredecessorsForPHIs - This gets "Succ" ready to have the // CanPropagatePredecessorsForPHIs - Return true if we can fold BB, an
// predecessors from "BB". This is a little tricky because "Succ" has PHI // almost-empty BB ending in an unconditional branch to Succ, into succ.
// nodes, which need to have extra slots added to them to hold the merge edges
// from BB's predecessors, and BB itself might have had PHI nodes in it. This
// function returns true (failure) if the Succ BB already has a predecessor that
// is a predecessor of BB and incoming PHI arguments would not be discernible.
// //
// Assumption: Succ is the single successor for BB. // Assumption: Succ is the single successor for BB.
// //
static bool PropagatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ) { static bool CanPropagatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ) {
assert(*succ_begin(BB) == Succ && "Succ is not successor of BB!"); assert(*succ_begin(BB) == Succ && "Succ is not successor of BB!");
if (!isa<PHINode>(Succ->front())) if (!isa<PHINode>(Succ->front()))
return false; // We can make the transformation, no problem. return true; // We can make the transformation, no problem.
// If there is more than one predecessor, and there are PHI nodes in
// the successor, then we need to add incoming edges for the PHI nodes
//
const std::vector<BasicBlock*> BBPreds(pred_begin(BB), pred_end(BB));
// Check to see if one of the predecessors of BB is already a predecessor of // Check to see if one of the predecessors of BB is already a predecessor of
// Succ. If so, we cannot do the transformation if there are any PHI nodes // Succ. If so, we cannot do the transformation if there are any PHI nodes
// with incompatible values coming in from the two edges! // with incompatible values coming in from the two edges!
// //
if (!SafeToMergeTerminators(BB->getTerminator(), Succ->getTerminator())) if (!SafeToMergeTerminators(BB->getTerminator(), Succ->getTerminator()))
return true; // Cannot merge. return false; // Cannot merge.
// Loop over all of the PHI nodes in the successor BB. return true;
for (BasicBlock::iterator I = Succ->begin(); isa<PHINode>(I); ++I) {
PHINode *PN = cast<PHINode>(I);
Value *OldVal = PN->removeIncomingValue(BB, false);
assert(OldVal && "No entry in PHI for Pred BB!");
// If this incoming value is one of the PHI nodes in BB, the new entries in
// the PHI node are the entries from the old PHI.
if (isa<PHINode>(OldVal) && cast<PHINode>(OldVal)->getParent() == BB) {
PHINode *OldValPN = cast<PHINode>(OldVal);
for (unsigned i = 0, e = OldValPN->getNumIncomingValues(); i != e; ++i)
PN->addIncoming(OldValPN->getIncomingValue(i),
OldValPN->getIncomingBlock(i));
} else {
for (std::vector<BasicBlock*>::const_iterator PredI = BBPreds.begin(),
End = BBPreds.end(); PredI != End; ++PredI) {
// Add an incoming value for each of the new incoming values...
PN->addIncoming(OldVal, *PredI);
}
}
}
return false;
} }
/// TryToSimplifyUncondBranchFromEmptyBlock - BB contains an unconditional /// TryToSimplifyUncondBranchFromEmptyBlock - BB contains an unconditional
@ -128,10 +98,39 @@ static bool TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB,
// if this transformation fails (returns true) then we cannot do this // if this transformation fails (returns true) then we cannot do this
// transformation! // transformation!
// //
if (PropagatePredecessorsForPHIs(BB, Succ)) return false; if (!CanPropagatePredecessorsForPHIs(BB, Succ)) return false;
DEBUG(std::cerr << "Killing Trivial BB: \n" << *BB); DEBUG(std::cerr << "Killing Trivial BB: \n" << *BB);
if (isa<PHINode>(Succ->begin())) {
// If there is more than one pred of succ, and there are PHI nodes in
// the successor, then we need to add incoming edges for the PHI nodes
//
const std::vector<BasicBlock*> BBPreds(pred_begin(BB), pred_end(BB));
// Loop over all of the PHI nodes in the successor of BB.
for (BasicBlock::iterator I = Succ->begin(); isa<PHINode>(I); ++I) {
PHINode *PN = cast<PHINode>(I);
Value *OldVal = PN->removeIncomingValue(BB, false);
assert(OldVal && "No entry in PHI for Pred BB!");
// If this incoming value is one of the PHI nodes in BB, the new entries in
// the PHI node are the entries from the old PHI.
if (isa<PHINode>(OldVal) && cast<PHINode>(OldVal)->getParent() == BB) {
PHINode *OldValPN = cast<PHINode>(OldVal);
for (unsigned i = 0, e = OldValPN->getNumIncomingValues(); i != e; ++i)
PN->addIncoming(OldValPN->getIncomingValue(i),
OldValPN->getIncomingBlock(i));
} else {
for (std::vector<BasicBlock*>::const_iterator PredI = BBPreds.begin(),
End = BBPreds.end(); PredI != End; ++PredI) {
// Add an incoming value for each of the new incoming values...
PN->addIncoming(OldVal, *PredI);
}
}
}
}
if (isa<PHINode>(&BB->front())) { if (isa<PHINode>(&BB->front())) {
std::vector<BasicBlock*> std::vector<BasicBlock*>
OldSuccPreds(pred_begin(Succ), pred_end(Succ)); OldSuccPreds(pred_begin(Succ), pred_end(Succ));