Rename Method to Function

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

8 files changed, 44 insertions, 43 deletions

diff --git a/include/llvm/Analysis/CallGraph.h b/include/llvm/Analysis/CallGraph.h
index 7f083ad86d..3c8b2c4107 100644
--- a/include/llvm/Analysis/CallGraph.h
+++ b/include/llvm/Analysis/CallGraph.h
@@ -43,7 +43,7 @@
 
 #include "Support/GraphTraits.h"
 #include "llvm/Pass.h"
-class Method;
+class Function;
 class Module;
 class CallGraphNode;
 
@@ -53,7 +53,7 @@ class CallGraphNode;
 class CallGraph : public Pass {
   Module *Mod;              // The module this call graph represents
 
-  typedef std::map<const Method *, CallGraphNode *> MethodMapTy;
+  typedef std::map<const Function *, CallGraphNode *> MethodMapTy;
   MethodMapTy MethodMap;    // Map from a method to its node
 
   // Root is root of the call graph, or the external node if a 'main' function
@@ -77,13 +77,13 @@ public:
 
 
   // Subscripting operators, return the call graph node for the provided method
-  inline const CallGraphNode *operator[](const Method *M) const {
-    const_iterator I = MethodMap.find(M);
+  inline const CallGraphNode *operator[](const Function *F) const {
+    const_iterator I = MethodMap.find(F);
     assert(I != MethodMap.end() && "Method not in callgraph!");
     return I->second;
   }
-  inline CallGraphNode *operator[](const Method *M) {
-    const_iterator I = MethodMap.find(M);
+  inline CallGraphNode *operator[](const Function *F) {
+    const_iterator I = MethodMap.find(F);
     assert(I != MethodMap.end() && "Method not in callgraph!");
     return I->second;
   }
@@ -92,7 +92,7 @@ public:
   // Methods to keep a call graph up to date with a method that has been
   // modified
   //
-  void addMethodToModule(Method *Meth);
+  void addMethodToModule(Function *Meth);
 
 
   // removeMethodFromModule - Unlink the method from this module, returning it.
@@ -101,8 +101,8 @@ public:
   // methods (ie, there are no edges in it's CGN).  The easiest way to do this
   // is to dropAllReferences before calling this.
   //
-  Method *removeMethodFromModule(CallGraphNode *CGN);
-  Method *removeMethodFromModule(Method *Meth) {
+  Function *removeMethodFromModule(CallGraphNode *CGN);
+  Function *removeMethodFromModule(Function *Meth) {
     return removeMethodFromModule((*this)[Meth]);
   }
 
@@ -135,15 +135,15 @@ private:
   // Implementation of CallGraph construction
   //
 
-  // getNodeFor - Return the node for the specified method or create one if it
+  // getNodeFor - Return the node for the specified function or create one if it
   // does not already exist.
   //
-  CallGraphNode *getNodeFor(Method *M);
+  CallGraphNode *getNodeFor(Function *F);
 
-  // addToCallGraph - Add a method to the call graph, and link the node to all
+  // addToCallGraph - Add a function to the call graph, and link the node to all
   // of the methods that it calls.
   //
-  void addToCallGraph(Method *M);
+  void addToCallGraph(Function *F);
 
   // destroy - Release memory for the call graph
   void destroy();
@@ -154,7 +154,7 @@ private:
 // CallGraphNode class definition
 //
 class CallGraphNode {
-  Method *Meth;
+  Function *Meth;
   std::vector<CallGraphNode*> CalledMethods;
 
   CallGraphNode(const CallGraphNode &);           // Do not implement
@@ -167,7 +167,7 @@ public:
   typedef std::vector<CallGraphNode*>::const_iterator const_iterator;
 
   // getMethod - Return the method that this call graph node represents...
-  Method *getMethod() const { return Meth; }
+  Function *getMethod() const { return Meth; }
 
   inline iterator begin() { return CalledMethods.begin(); }
   inline iterator end()   { return CalledMethods.end();   }
@@ -193,7 +193,7 @@ private:                    // Stuff to construct the node, used by CallGraph
   friend class CallGraph;
 
   // CallGraphNode ctor - Create a node for the specified method...
-  inline CallGraphNode(Method *M) : Meth(M) {}
+  inline CallGraphNode(Function *F) : Meth(F) {}
   
   // addCalledMethod add a method to the list of methods called by this one
   void addCalledMethod(CallGraphNode *M) {
diff --git a/include/llvm/Analysis/ConstantsScanner.h b/include/llvm/Analysis/ConstantsScanner.h
index 1a85082002..ca0a80e31e 100644
--- a/include/llvm/Analysis/ConstantsScanner.h
+++ b/include/llvm/Analysis/ConstantsScanner.h
@@ -28,15 +28,15 @@ class constant_iterator
   }
 
 public:
-  inline constant_iterator(const Method *M) : InstI(inst_begin(M)), OpIdx(0) {
+  inline constant_iterator(const Function *F) : InstI(inst_begin(F)), OpIdx(0) {
     // Advance to first constant... if we are not already at constant or end
-    if (InstI != inst_end(M) &&                            // InstI is valid?
+    if (InstI != inst_end(F) &&                            // InstI is valid?
 	(InstI->getNumOperands() == 0 || !isAtConstant())) // Not at constant?
       operator++();
   }
 
-  inline constant_iterator(const Method *M, bool)   // end ctor
-    : InstI(inst_end(M)), OpIdx(0) {
+  inline constant_iterator(const Function *F, bool)   // end ctor
+    : InstI(inst_end(F)), OpIdx(0) {
   }
 
   inline bool operator==(const _Self& x) const { return OpIdx == x.OpIdx && 
@@ -72,12 +72,12 @@ public:
   inline bool atEnd() const { return InstI.atEnd(); }
 };
 
-inline constant_iterator constant_begin(const Method *M) {
-  return constant_iterator(M);
+inline constant_iterator constant_begin(const Function *F) {
+  return constant_iterator(F);
 }
 
-inline constant_iterator constant_end(const Method *M) {
-  return constant_iterator(M, true);
+inline constant_iterator constant_end(const Function *F) {
+  return constant_iterator(F, true);
 }
 
 #endif
diff --git a/include/llvm/Analysis/Dominators.h b/include/llvm/Analysis/Dominators.h
index 6de4e5b9bf..d860ec5504 100644
--- a/include/llvm/Analysis/Dominators.h
+++ b/include/llvm/Analysis/Dominators.h
@@ -55,8 +55,8 @@ public:
 private:
   DomSetMapType Doms;
 
-  void calcForwardDominatorSet(Method *M);
-  void calcPostDominatorSet(Method *M);
+  void calcForwardDominatorSet(Function *F);
+  void calcPostDominatorSet(Function *F);
 public:
   // DominatorSet ctor - Build either the dominator set or the post-dominator
   // set for a method... 
@@ -66,7 +66,7 @@ public:
 
   DominatorSet(AnalysisID id) : DominatorBase(id == PostDomID) {}
 
-  virtual bool runOnMethod(Method *M);
+  virtual bool runOnMethod(Function *F);
 
   // Accessor interface:
   typedef DomSetMapType::const_iterator const_iterator;
@@ -120,7 +120,7 @@ public:
 
   ImmediateDominators(AnalysisID id) : DominatorBase(id == PostDomID) {}
 
-  virtual bool runOnMethod(Method *M) {
+  virtual bool runOnMethod(Function *F) {
     IDoms.clear();     // Reset from the last time we were run...
     DominatorSet *DS;
     if (isPostDominator())
@@ -213,7 +213,7 @@ public:
   DominatorTree(AnalysisID id) : DominatorBase(id == PostDomID) {}
   ~DominatorTree() { reset(); }
 
-  virtual bool runOnMethod(Method *M) {
+  virtual bool runOnMethod(Function *F) {
     reset();
     DominatorSet *DS;
     if (isPostDominator())
@@ -270,7 +270,7 @@ public:
 
   DominanceFrontier(AnalysisID id) : DominatorBase(id == PostDomID) {}
 
-  virtual bool runOnMethod(Method *M) {
+  virtual bool runOnMethod(Function *) {
     Frontiers.clear();
     DominatorTree *DT;
     if (isPostDominator())
diff --git a/include/llvm/Analysis/IntervalPartition.h b/include/llvm/Analysis/IntervalPartition.h
index 16b3c9c457..10f53173bc 100644
--- a/include/llvm/Analysis/IntervalPartition.h
+++ b/include/llvm/Analysis/IntervalPartition.h
@@ -42,7 +42,7 @@ public:
   IntervalPartition(AnalysisID AID) : RootInterval(0) { assert(AID == ID); }
 
   // run - Calculate the interval partition for this method
-  virtual bool runOnMethod(Method *M);
+  virtual bool runOnMethod(Function *F);
 
   // IntervalPartition ctor - Build a reduced interval partition from an
   // existing interval graph.  This takes an additional boolean parameter to
diff --git a/include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h b/include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h
index 8785334572..435f177045 100644
--- a/include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h
+++ b/include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h
@@ -8,7 +8,7 @@
 
    It must be called like:
 
-       MethodLiveVarInfo MLVI( Mehtod *);  // initializes data structures
+       MethodLiveVarInfo MLVI(Function *);  // initializes data structures
        MLVI.analyze();                     // do the actural live variable anal
 
  After the analysis, getInSetOfBB or getOutSetofBB can be called to get 
@@ -86,16 +86,16 @@ class MethodLiveVarInfo : public MethodPass {
   // Machine Instr to LiveVarSet Map for providing LVset AFTER each inst
   std::map<const MachineInstr *, const ValueSet *> MInst2LVSetAI; 
 
-  // Stored Method that the data is computed with respect to
-  const Method *M;
+  // Stored Function that the data is computed with respect to
+  const Function *M;
 
   // --------- private methods -----------------------------------------
 
   // constructs BBLiveVars and init Def and In sets
-  void constructBBs(const Method *M);      
+  void constructBBs(const Function *F);
     
   // do one backward pass over the CFG
-  bool doSingleBackwardPass(const Method *M, unsigned int iter); 
+  bool doSingleBackwardPass(const Function *F, unsigned int iter); 
 
   // calculates live var sets for instructions in a BB
   void calcLiveVarSetsForBB(const BasicBlock *BB);
@@ -108,7 +108,7 @@ public:
   // --------- Implement the MethodPass interface ----------------------
 
   // runOnMethod - Perform analysis, update internal data structures.
-  virtual bool runOnMethod(Method *M);
+  virtual bool runOnMethod(Function *F);
 
   // releaseMemory - After LiveVariable analysis has been used, forget!
   virtual void releaseMemory();
diff --git a/include/llvm/Analysis/LoopInfo.h b/include/llvm/Analysis/LoopInfo.h
index f36550e504..13535bc788 100644
--- a/include/llvm/Analysis/LoopInfo.h
+++ b/include/llvm/Analysis/LoopInfo.h
@@ -101,7 +101,7 @@ public:
 #endif
 
   // runOnMethod - Pass framework implementation
-  virtual bool runOnMethod(Method *M);
+  virtual bool runOnMethod(Function *F);
 
   // getAnalysisUsageInfo - Provide loop info, require dominator set
   //
diff --git a/include/llvm/Analysis/SlotCalculator.h b/include/llvm/Analysis/SlotCalculator.h
index 95282447a5..e8fead76bb 100644
--- a/include/llvm/Analysis/SlotCalculator.h
+++ b/include/llvm/Analysis/SlotCalculator.h
@@ -14,7 +14,7 @@
 #include <map>
 class Value;
 class Module;
-class Method;
+class Function;
 class MethodArgument;
 class BasicBlock;
 class Instruction;
@@ -34,7 +34,8 @@ class SlotCalculator {
 
 public:
   SlotCalculator(const Module *M, bool IgnoreNamed);
-  SlotCalculator(const Method *M, bool IgnoreNamed);// Start out in incorp state
+  // Start out in incorp state
+  SlotCalculator(const Function *M, bool IgnoreNamed);
   inline ~SlotCalculator() {}
   
   // getValSlot returns < 0 on error!
@@ -52,7 +53,7 @@ public:
   // If you'd like to deal with a method, use these two methods to get its data
   // into the SlotCalculator!
   //
-  void incorporateMethod(const Method *M);
+  void incorporateMethod(const Function *F);
   void purgeMethod();
 
 protected:
diff --git a/include/llvm/Analysis/Verifier.h b/include/llvm/Analysis/Verifier.h
index d6f4a93fa4..7a0ab000d8 100644
--- a/include/llvm/Analysis/Verifier.h
+++ b/include/llvm/Analysis/Verifier.h
@@ -15,7 +15,7 @@
 
 class Pass;
 class Module;
-class Method;
+class Function;
 
 // createVerifierPass - Check a module or method for validity.  If errors are
 // detected, error messages corresponding to the problem are printed to stderr.
@@ -29,6 +29,6 @@ bool verifyModule(const Module *M);
 
 // verifyMethod - Check a method for errors, useful for use when debugging a
 // pass.
-bool verifyMethod(const Method *M);
+bool verifyMethod(const Function *M);
 
 #endif