maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

The recalclulate method was a nasty hack that was once used by the -cee pass, 

which never worked itself.  The cee pass still doesn't work, but it doesn't use
this method anymore anyway, so eliminate the method.

llvm-svn: 10302
This commit is contained in:
Chris Lattner 2003-12-07 00:55:32 +00:00
parent 00f5167693
commit d1ea9cd345
2 changed files with 12 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
llvm/include/llvm/Analysis/Dominators.h
View File

@ -252,11 +252,6 @@ struct DominatorSet : public DominatorSetBase {
virtual bool runOnFunction(Function &F);
/// recalculate - This method may be called by external passes that modify the
/// CFG and then need dominator information recalculated. This method is
/// obviously really slow, so it should be avoided if at all possible.
void recalculate();
BasicBlock *getRoot() const {
assert(Roots.size() == 1 && "Should always have entry node!");
return Roots[0];

28
llvm/lib/VMCore/Dominators.cpp
View File

@ -251,20 +251,27 @@ bool DominatorSetBase::dominates(Instruction *A, Instruction *B) const {
}
void DominatorSet::recalculate() {
// runOnFunction - This method calculates the forward dominator sets for the
// specified function.
//
bool DominatorSet::runOnFunction(Function &F) {
BasicBlock *Root = &F.getEntryBlock();
Roots.clear();
Roots.push_back(Root);
assert(pred_begin(Root) == pred_end(Root) &&
"Root node has predecessors in function!");
ImmediateDominators &ID = getAnalysis<ImmediateDominators>();
Doms.clear();
if (Roots.empty()) return;
if (Roots.empty()) return false;
// Root nodes only dominate themselves.
for (unsigned i = 0, e = Roots.size(); i != e; ++i)
Doms[Roots[i]].insert(Roots[i]);
Function *F = Roots.back()->getParent();
// Loop over all of the blocks in the function, calculating dominator sets for
// each function.
for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I)
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
if (BasicBlock *IDom = ID[I]) { // Get idom if block is reachable
DomSetType &DS = Doms[I];
assert(DS.empty() && "Domset already filled in for this block?");
@ -288,18 +295,7 @@ void DominatorSet::recalculate() {
// is important for the case when there is unreachable blocks.
Doms[I];
}
}
// runOnFunction - This method calculates the forward dominator sets for the
// specified function.
//
bool DominatorSet::runOnFunction(Function &F) {
BasicBlock *Root = &F.getEntryBlock();
Roots.clear();
Roots.push_back(Root);
assert(pred_begin(Root) == pred_end(Root) &&
"Root node has predecessors in function!");
recalculate();
return false;
}