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.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10302 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Analysis/Dominators.h b/include/llvm/Analysis/Dominators.h
index 4179fe7dc28ab2df3d4dc1402c58a63ae81277df..424280724c10bd26c67e28e3d49ffb0e752bf504 100644 (file)
--- a/include/llvm/Analysis/Dominators.h
+++ b/include/llvm/Analysis/Dominators.h
@@ -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];

diff --git a/lib/VMCore/Dominators.cpp b/lib/VMCore/Dominators.cpp
index b2d4d942d43652b89708845877de50d8a5a1df80..424cc223c5311191f580a0cbc68b9d2a9be616c8 100644 (file)
--- a/lib/VMCore/Dominators.cpp
+++ b/lib/VMCore/Dominators.cpp
@@ -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;
 }