6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-17 21:29:20 +00:00
Code Issues Projects Releases Wiki Activity

Remove DominatorSet usage from LoopSimplify. Patch from Owen Anderson.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@35757 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Nick Lewycky 2007-04-08 01:04:30 +00:00
parent 51bc779096
commit a397ce1cc2
1 changed files with 54 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

143
lib/Transforms/Utils/LoopSimplify.cpp
View File

@ -64,12 +64,10 @@ namespace {
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
// We need loop information to identify the loops...
AU.addRequired<LoopInfo>();
AU.addRequired<DominatorSet>();
AU.addRequired<DominatorTree>();
AU.addRequired<ETForest>();
AU.addPreserved<LoopInfo>();
AU.addPreserved<DominatorSet>();
AU.addPreserved<ImmediateDominators>();
AU.addPreserved<ETForest>();
AU.addPreserved<DominatorTree>();
@ -313,8 +311,9 @@ BasicBlock *LoopSimplify::SplitBlockPredecessors(BasicBlock *BB,
// Can we eliminate this phi node now?
if (Value *V = PN->hasConstantValue(true)) {
if (!isa<Instruction>(V) ||
getAnalysis<DominatorSet>().dominates(cast<Instruction>(V), PN)) {
Instruction *I = dyn_cast<Instruction>(V);
if (!I || (I->getParent() != NewBB &&
getAnalysis<ETForest>().dominates(I, PN))) {
PN->replaceAllUsesWith(V);
if (AA) AA->deleteValue(PN);
BB->getInstList().erase(PN);
@ -542,10 +541,9 @@ Loop *LoopSimplify::SeparateNestedLoop(Loop *L) {
// 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))
if (EF->dominates(Header, *PI))
AddBlockAndPredsToSet(*PI, Header, BlocksInL);
@ -674,8 +672,8 @@ void LoopSimplify::InsertUniqueBackedgeBlock(Loop *L) {
}
/// UpdateDomInfoForRevectoredPreds - This method is used to update the four
/// different kinds of dominator information (dominator sets, immediate
/// dominators, dominator trees, and dominance frontiers) after a new block has
/// different kinds of dominator information (immediate dominators,
/// dominator trees, et-forest and dominance frontiers) after a new block has
/// been added to the CFG.
///
/// This only supports the case when an existing block (known as "NewBBSucc"),
@ -693,33 +691,8 @@ void LoopSimplify::UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB,
++succ_begin(NewBB) == succ_end(NewBB) &&
"NewBB should have a single successor!");
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]);
{
unsigned i, e = PredBlocks.size();
// It is possible for some preds to not be reachable, and thus have empty
// dominator sets (all blocks must dom themselves, so no domset would
// otherwise be empty). If we see any of these, don't intersect with them,
// as that would certainly leave the resultant set empty.
for (i = 1; NewBBDomSet.empty(); ++i) {
assert(i != e && "Didn't find reachable pred?");
NewBBDomSet = DS.getDominators(PredBlocks[i]);
}
// Intersect the rest of the non-empty sets.
for (; i != e; ++i) {
const DominatorSet::DomSetType &PredDS = DS.getDominators(PredBlocks[i]);
if (!PredDS.empty())
set_intersect(NewBBDomSet, PredDS);
}
NewBBDomSet.insert(NewBB); // All blocks dominate themselves.
DS.addBasicBlock(NewBB, NewBBDomSet);
}
ETForest& ETF = getAnalysis<ETForest>();
// 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!
@ -727,14 +700,16 @@ void LoopSimplify::UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB,
bool NewBBDominatesNewBBSucc = true;
{
BasicBlock *OnePred = PredBlocks[0];
unsigned i, e = PredBlocks.size();
for (i = 1; !DS.isReachable(OnePred); ++i) {
unsigned i = 1, e = PredBlocks.size();
for (i = 1; !ETF.dominates(&OnePred->getParent()->getEntryBlock(), OnePred);
++i) {
assert(i != e && "Didn't find reachable pred?");
OnePred = PredBlocks[i];
}
for (; i != e; ++i)
if (PredBlocks[i] != OnePred && DS.isReachable(PredBlocks[i])) {
if (PredBlocks[i] != OnePred &&
ETF.dominates(&PredBlocks[i]->getParent()->getEntryBlock(), OnePred)){
NewBBDominatesNewBBSucc = false;
break;
}
@ -742,7 +717,7 @@ void LoopSimplify::UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB,
if (NewBBDominatesNewBBSucc)
for (pred_iterator PI = pred_begin(NewBBSucc), E = pred_end(NewBBSucc);
PI != E; ++PI)
if (*PI != NewBB && !DS.dominates(NewBBSucc, *PI)) {
if (*PI != NewBB && !ETF.dominates(NewBBSucc, *PI)) {
NewBBDominatesNewBBSucc = false;
break;
}
@ -755,44 +730,31 @@ void LoopSimplify::UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB,
NewBBDominatesNewBBSucc = true;
for (pred_iterator PI = pred_begin(NewBBSucc), E = pred_end(NewBBSucc);
PI != E; ++PI)
if (*PI != NewBB && !DS.dominates(NewBBSucc, *PI)) {
if (*PI != NewBB && !ETF.dominates(NewBBSucc, *PI)) {
NewBBDominatesNewBBSucc = false;
break;
}
}
// If NewBB dominates some blocks, then it will dominate all blocks that
// NewBBSucc does.
if (NewBBDominatesNewBBSucc) {
Function *F = NewBB->getParent();
for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I)
if (DS.dominates(NewBBSucc, I))
DS.addDominator(I, NewBB);
}
// Update immediate dominator information if we have it.
BasicBlock *NewBBIDom = 0;
// Update immediate dominator information if we have it.
if (ImmediateDominators *ID = getAnalysisToUpdate<ImmediateDominators>()) {
// To find the immediate dominator of the new exit node, we trace up the
// immediate dominators of a predecessor until we find a basic block that
// dominates the exit block.
//
BasicBlock *Dom = PredBlocks[0]; // Some random predecessor.
// Find a reachable pred.
for (unsigned i = 1; !DS.isReachable(Dom); ++i) {
assert(i != PredBlocks.size() && "Didn't find reachable pred!");
Dom = PredBlocks[i];
unsigned i = 0;
for (i = 0; i < PredBlocks.size(); ++i)
if (ETF.dominates(&PredBlocks[i]->getParent()->getEntryBlock(), PredBlocks[i])) {
NewBBIDom = PredBlocks[i];
break;
}
assert(i != PredBlocks.size() && "No reachable preds?");
for (i = i + 1; i < PredBlocks.size(); ++i) {
if (ETF.dominates(&PredBlocks[i]->getParent()->getEntryBlock(), PredBlocks[i]))
NewBBIDom = ETF.nearestCommonDominator(NewBBIDom, PredBlocks[i]);
}
while (!NewBBDomSet.count(Dom)) { // Loop until we find a dominator.
assert(Dom != 0 && "No shared dominator found???");
Dom = ID->get(Dom);
}
assert(NewBBIDom && "No immediate dominator found??");
// Set the immediate dominator now...
ID->addNewBlock(NewBB, Dom);
NewBBIDom = Dom; // Reuse this if calculating DominatorTree info...
ID->addNewBlock(NewBB, NewBBIDom);
// 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
@ -805,24 +767,21 @@ void LoopSimplify::UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB,
if (DominatorTree *DT = getAnalysisToUpdate<DominatorTree>()) {
// If we don't have ImmediateDominator info around, calculate the idom as
// above.
DominatorTree::Node *NewBBIDomNode;
if (NewBBIDom) {
NewBBIDomNode = DT->getNode(NewBBIDom);
} else {
// Scan all the pred blocks that were pulled out. Any individual one may
// actually be unreachable, which would mean it doesn't have dom info.
NewBBIDomNode = 0;
for (unsigned i = 0; !NewBBIDomNode; ++i) {
assert(i != PredBlocks.size() && "No reachable preds?");
NewBBIDomNode = DT->getNode(PredBlocks[i]);
if (!NewBBIDom) {
unsigned i = 0;
for (i = 0; i < PredBlocks.size(); ++i)
if (ETF.dominates(&PredBlocks[i]->getParent()->getEntryBlock(), PredBlocks[i])) {
NewBBIDom = PredBlocks[i];
break;
}
assert(i != PredBlocks.size() && "No reachable preds?");
for (i = i + 1; i < PredBlocks.size(); ++i) {
if (ETF.dominates(&PredBlocks[i]->getParent()->getEntryBlock(), PredBlocks[i]))
NewBBIDom = ETF.nearestCommonDominator(NewBBIDom, PredBlocks[i]);
}
while (!NewBBDomSet.count(NewBBIDomNode->getBlock())) {
NewBBIDomNode = NewBBIDomNode->getIDom();
assert(NewBBIDomNode && "No shared dominator found??");
}
NewBBIDom = NewBBIDomNode->getBlock();
assert(NewBBIDom && "No immediate dominator found??");
}
DominatorTree::Node *NewBBIDomNode = DT->getNode(NewBBIDom);
// Create the new dominator tree node... and set the idom of NewBB.
DominatorTree::Node *NewBBNode = DT->createNewNode(NewBB, NewBBIDomNode);
@ -857,7 +816,7 @@ void LoopSimplify::UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB,
bool DominatesPred = false;
for (pred_iterator PI = pred_begin(*SetI), E = pred_end(*SetI);
PI != E; ++PI)
if (DS.dominates(NewBB, *PI))
if (ETF.dominates(NewBB, *PI))
DominatesPred = true;
if (!DominatesPred)
Set.erase(SetI++);
@ -885,8 +844,14 @@ void LoopSimplify::UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB,
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(),
// FIXME: There's probably a better way to do this...
std::vector<BasicBlock*> PredDoms;
for (Function::iterator I = Pred->getParent()->begin(),
E = Pred->getParent()->end(); I != E; ++I)
if (ETF.dominates(&(*I), Pred))
PredDoms.push_back(I);
for (std::vector<BasicBlock*>::const_iterator PDI = PredDoms.begin(),
PDE = PredDoms.end(); PDI != PDE; ++PDI) {
BasicBlock *PredDom = *PDI;
@ -900,12 +865,12 @@ void LoopSimplify::UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB,
// 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)) {
if (PredDom == NewBBSucc || !ETF.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)) {
if (ETF.dominates(PredDom, *PI)) {
ShouldRemove = false;
break;
}