Change references to the Method class to be references to the Function

class.  The Method class is obsolete (renamed) and all references to it
are being converted over to Function.


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

1 files changed, 17 insertions, 17 deletions

diff --git a/lib/Transforms/IPO/GlobalDCE.cpp b/lib/Transforms/IPO/GlobalDCE.cpp
index ea23dbedda..ae9bd39270 100644
--- 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
 //
@@ -7,40 +7,40 @@
 #include "llvm/Transforms/IPO/GlobalDCE.h"
 #include "llvm/Analysis/CallGraph.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, CallGraph &CallGraph) {
-  // 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.
   //
   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.
   //
-  std::vector<CallGraphNode*> MethodsToDelete;   // Track unused methods
+  std::vector<CallGraphNode*> FunctionsToDelete;   // Track unused functions
   for (Module::iterator I = M->begin(), E = M->end(); I != E; ++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()) 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 (std::vector<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);
 
   return true;
@@ -52,7 +52,7 @@ namespace {
     // the specified callgraph to reflect the changes.
     //
     bool run(Module *M) {
-      return RemoveUnreachableMethods(M, getAnalysis<CallGraph>());
+      return RemoveUnreachableFunctions(M, getAnalysis<CallGraph>());
     }
 
     // getAnalysisUsageInfo - This function works on the call graph of a module.