Add a fixme so that we don't forget this is broken.

[oota-llvm.git] / lib / Transforms / IPO / GlobalDCE.cpp

diff --git a/lib/Transforms/IPO/GlobalDCE.cpp b/lib/Transforms/IPO/GlobalDCE.cpp
index 24945c02b44b273b5b389184693a95ab79f34731..ae9bd39270717efaf68eb4b173fc726fe73b5e34 100644 (file)
--- a/lib/Transforms/IPO/GlobalDCE.cpp
+++ b/lib/Transforms/IPO/GlobalDCE.cpp
@@ -1,4 +1,4 @@
-//===-- GlobalDCE.cpp - DCE unreachable internal methods ---------*- C++ -*--=//
+//===-- GlobalDCE.cpp - DCE unreachable internal functions ----------------===//
 //
 // This transform is designed to eliminate unreachable internal globals
 //
@@ -6,54 +6,67 @@
 
 #include "llvm/Transforms/IPO/GlobalDCE.h"
 #include "llvm/Analysis/CallGraph.h"
-#include "llvm/Support/DepthFirstIterator.h"
 #include "llvm/Module.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
+#include "llvm/Pass.h"
+#include "Support/DepthFirstIterator.h"
 #include <set>
 
-static bool RemoveUnreachableMethods(Module *M, cfg::CallGraph *CG) {
-  // Create a call graph if one is not already available...
-  cfg::CallGraph &CallGraph = CG ? *CG : *new cfg::CallGraph(M);
-  
-  // Calculate which methods are reachable from the external methods in the call
-  // graph.
+static bool RemoveUnreachableFunctions(Module *M, CallGraph &CallGraph) {
+  // Calculate which functions are reachable from the external functions in the
+  // call graph.
   //
-  set<cfg::CallGraphNode*> ReachableNodes(df_begin(&CallGraph),
-                                         df_end(&CallGraph));
+  std::set<CallGraphNode*> ReachableNodes(df_begin(&CallGraph),
+                                          df_end(&CallGraph));
 
-  // Loop over the methods in the module twice.  The first time is used to drop
-  // references that methods have to each other before they are deleted.  The
-  // second pass removes the methods that need to be removed.
+  // Loop over the functions in the module twice.  The first time is used to
+  // drop references that functions have to each other before they are deleted.
+  // The second pass removes the functions that need to be removed.
   //
-  vector<cfg::CallGraphNode*> MethodsToDelete;   // Track unused methods
+  std::vector<CallGraphNode*> FunctionsToDelete;   // Track unused functions
   for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) {
-    cfg::CallGraphNode *N = CallGraph[*I];
+    CallGraphNode *N = CallGraph[*I];
     if (!ReachableNodes.count(N)) {              // Not reachable??
       (*I)->dropAllReferences();
       N->removeAllCalledMethods();
-      MethodsToDelete.push_back(N);
+      FunctionsToDelete.push_back(N);
     }
   }
 
-  // Nothing to do if no unreachable methods have been found...
-  if (MethodsToDelete.empty()) {
-    // Free the created call graph if it was not passed in
-    if (&CallGraph != CG) delete &CallGraph;
-    return false;
-  }
+  // Nothing to do if no unreachable functions have been found...
+  if (FunctionsToDelete.empty()) return false;
 
-  // Unreachables methods have been found and should have no references to them,
-  // delete them now.
+  // Unreachables functions have been found and should have no references to
+  // them, delete them now.
   //
-  for (vector<cfg::CallGraphNode*>::iterator I = MethodsToDelete.begin(),
-        E = MethodsToDelete.end(); I != E; ++I)
+  for (std::vector<CallGraphNode*>::iterator I = FunctionsToDelete.begin(),
+        E = FunctionsToDelete.end(); I != E; ++I)
     delete CallGraph.removeMethodFromModule(*I);
 
-  // Free the created call graph if it was not passed in
-  if (&CallGraph != CG) delete &CallGraph;
   return true;
 }
 
-bool GlobalDCE::run(Module *M, cfg::CallGraph *CG = 0) {
-  return RemoveUnreachableMethods(M, CG);
+namespace {
+  struct GlobalDCE : public Pass {
+    // run - Do the GlobalDCE pass on the specified module, optionally updating
+    // the specified callgraph to reflect the changes.
+    //
+    bool run(Module *M) {
+      return RemoveUnreachableFunctions(M, getAnalysis<CallGraph>());
+    }
+
+    // getAnalysisUsageInfo - This function works on the call graph of a module.
+    // It is capable of updating the call graph to reflect the new state of the
+    // module.
+    //
+    virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
+                                      Pass::AnalysisSet &Destroyed,
+                                      Pass::AnalysisSet &Provided) {
+      Required.push_back(CallGraph::ID);
+      // FIXME: This should update the callgraph, not destroy it!
+      Destroyed.push_back(CallGraph::ID);
+    }
+  };
 }
+
+Pass *createGlobalDCEPass() { return new GlobalDCE(); }