s/Method/Function

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

8 files changed, 35 insertions, 37 deletions

diff --git a/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp b/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp
index 31eca39..69813c7 100644
--- a/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp
+++ b/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp
@@ -1504,13 +1504,13 @@ namespace {
       Destroyed.push_back(MethodLiveVarInfo::ID);
     }
     
-    bool runOnMethod(Method *M);
+    bool runOnMethod(Function *F);
   };
 } // end anonymous namespace
 
 
 bool
-InstructionSchedulingWithSSA::runOnMethod(Method *M)
+InstructionSchedulingWithSSA::runOnMethod(Function *M)
 {
   if (SchedDebugLevel == Sched_Disable)
     return false;
diff --git a/lib/Target/SparcV9/InstrSched/SchedPriorities.cpp b/lib/Target/SparcV9/InstrSched/SchedPriorities.cpp
index 810692f..02e50c0 100644
--- a/lib/Target/SparcV9/InstrSched/SchedPriorities.cpp
+++ b/lib/Target/SparcV9/InstrSched/SchedPriorities.cpp
@@ -25,7 +25,7 @@
 #include <iostream>
 using std::cerr;
 
-SchedPriorities::SchedPriorities(const Method *method, const SchedGraph *G,
+SchedPriorities::SchedPriorities(const Function *, const SchedGraph *G,
                                  MethodLiveVarInfo &LVI)
   : curTime(0), graph(G), methodLiveVarInfo(LVI),
     nodeDelayVec(G->getNumNodes(), INVALID_LATENCY), // make errors obvious
diff --git a/lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp b/lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp
index 45f7b9d..a0b410e 100644
--- a/lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp
+++ b/lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp
@@ -1,4 +1,4 @@
-//===-- MethodLiveVarInfo.cpp - Live Variable Analysis for a Method -------===//
+//===-- MethodLiveVarInfo.cpp - Live Variable Analysis for a Function -----===//
 //
 // This is the interface to method level live variable information that is
 // provided by live variable analysis.
@@ -42,7 +42,7 @@ const ValueSet &MethodLiveVarInfo::getInSetOfBB(const BasicBlock *BB) const {
 // Performs live var analysis for a method
 //-----------------------------------------------------------------------------
 
-bool MethodLiveVarInfo::runOnMethod(Method *Meth) {
+bool MethodLiveVarInfo::runOnMethod(Function *Meth) {
   M = Meth;
   if (DEBUG_LV) std::cerr << "Analysing live variables ...\n";
 
@@ -62,10 +62,10 @@ bool MethodLiveVarInfo::runOnMethod(Method *Meth) {
 // constructs BBLiveVars and init Def and In sets
 //-----------------------------------------------------------------------------
 
-void MethodLiveVarInfo::constructBBs(const Method *M) {
+void MethodLiveVarInfo::constructBBs(const Function *M) {
   unsigned int POId = 0;                // Reverse Depth-first Order ID
   
-  for(po_iterator<const Method*> BBI = po_begin(M), BBE = po_end(M);
+  for(po_iterator<const Function*> BBI = po_begin(M), BBE = po_end(M);
       BBI != BBE; ++BBI, ++POId) { 
     const BasicBlock *BB = *BBI;        // get the current BB 
 
@@ -83,7 +83,7 @@ void MethodLiveVarInfo::constructBBs(const Method *M) {
   // However, LV info is not correct for those blocks (they are not
   // analyzed)
   //
-  for (Method::const_iterator BBRI = M->begin(), BBRE = M->end();
+  for (Function::const_iterator BBRI = M->begin(), BBRE = M->end();
        BBRI != BBRE; ++BBRI, ++POId)
     if (!BBLiveVar::GetFromBB(*BBRI))                 // Not yet processed?
       BBLiveVar::CreateOnBB(*BBRI, POId);
@@ -94,11 +94,11 @@ void MethodLiveVarInfo::constructBBs(const Method *M) {
 // do one backward pass over the CFG (for iterative analysis)
 //-----------------------------------------------------------------------------
 
-bool MethodLiveVarInfo::doSingleBackwardPass(const Method *M, unsigned int iter) {
+bool MethodLiveVarInfo::doSingleBackwardPass(const Function *M, unsigned int iter) {
   if (DEBUG_LV) std::cerr << "\n After Backward Pass " << iter << "...\n";
 
   bool NeedAnotherIteration = false;
-  for (po_iterator<const Method*> BBI = po_begin(M); BBI != po_end(M) ; ++BBI) {
+  for (po_iterator<const Function*> BBI = po_begin(M); BBI != po_end(M) ; ++BBI) {
     BBLiveVar *LVBB = BBLiveVar::GetFromBB(*BBI);
     assert(LVBB && "BasicBlock information not set for block!");
 
@@ -123,7 +123,7 @@ bool MethodLiveVarInfo::doSingleBackwardPass(const Method *M, unsigned int iter)
 void MethodLiveVarInfo::releaseMemory() {
   // First remove all BBLiveVar annotations created in constructBBs().
   if (M)
-    for (Method::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
+    for (Function::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
       BBLiveVar::RemoveFromBB(*I);
   M = 0;
 
diff --git a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h
index ce92298..a381971 100644
--- a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h
+++ b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h
@@ -62,7 +62,7 @@ typedef std::hash_map<const MachineInstr *, AddedInstrns *> AddedInstrMapType;
 //----------------------------------------------------------------------------
 // class PhyRegAlloc:
 // Main class the register allocator. Call allocateRegisters() to allocate
-// registers for a Method.
+// registers for a Function.
 //----------------------------------------------------------------------------
 
 
@@ -70,7 +70,7 @@ class PhyRegAlloc: public NonCopyable {
 
   std::vector<RegClass *> RegClassList; // vector of register classes
   const TargetMachine &TM;              // target machine
-  const Method* Meth;                   // name of the method we work on
+  const Function *Meth;                 // name of the function we work on
   MachineCodeForMethod &mcInfo;         // descriptor for method's native code
   MethodLiveVarInfo *const LVI;         // LV information for this method 
                                         // (already computed for BBs) 
@@ -85,7 +85,7 @@ class PhyRegAlloc: public NonCopyable {
                                         // currently not used
 
 public:
-  PhyRegAlloc(Method *M, const TargetMachine& TM, MethodLiveVarInfo *Lvi,
+  PhyRegAlloc(Function *F, const TargetMachine& TM, MethodLiveVarInfo *Lvi,
               cfg::LoopInfo *LoopDepthCalc);
   ~PhyRegAlloc();
 
diff --git a/lib/Target/SparcV9/RegAlloc/RegClass.h b/lib/Target/SparcV9/RegAlloc/RegClass.h
index 1e5f551..3db72b7 100644
--- a/lib/Target/SparcV9/RegAlloc/RegClass.h
+++ b/lib/Target/SparcV9/RegAlloc/RegClass.h
@@ -36,7 +36,7 @@ typedef std::vector<unsigned> ReservedColorListType;
 //
 //-----------------------------------------------------------------------------
 class RegClass {
-  const Method *const Meth;             // Method we are working on
+  const Function *const Meth;           // Function we are working on
   const MachineRegClassInfo *const MRC; // corresponding MRC
   const unsigned RegClassID;            // my int ID
 
@@ -47,7 +47,7 @@ class RegClass {
   const ReservedColorListType *const ReservedColorList;
   //
   // for passing registers that are pre-allocated and cannot be used by the
-  // register allocator for this method.
+  // register allocator for this function.
   
   bool *IsColorUsedArr;
   //
@@ -69,14 +69,13 @@ class RegClass {
 
  public:
 
-  RegClass(const Method *const M, 
-	   const MachineRegClassInfo *const MRC, 
-	   const ReservedColorListType *const RCL = NULL);
+  RegClass(const Function *M,
+	   const MachineRegClassInfo *MRC,
+	   const ReservedColorListType *RCL = 0);
 
-  ~RegClass() { delete[] IsColorUsedArr; };
+  ~RegClass() { delete[] IsColorUsedArr; }
 
-  inline void createInterferenceGraph() 
-    { IG.createGraph(); }
+  inline void createInterferenceGraph() { IG.createGraph(); }
 
   inline InterferenceGraph &getIG() { return IG; }
 
diff --git a/lib/Target/SparcV9/SparcV9Internals.h b/lib/Target/SparcV9/SparcV9Internals.h
index 7f836c7..8dd8946 100644
--- a/lib/Target/SparcV9/SparcV9Internals.h
+++ b/lib/Target/SparcV9/SparcV9Internals.h
@@ -126,7 +126,7 @@ public:
   // returned in `minstrVec'.  Any temporary registers (TmpInstruction)
   // created are returned in `tempVec'.
   // 
-  virtual void  CreateCodeToLoadConst(Method* method,
+  virtual void  CreateCodeToLoadConst(Function* method,
                                       Value* val,
                                       Instruction* dest,
                                       std::vector<MachineInstr*>& minstrVec,
@@ -139,7 +139,7 @@ public:
   // The generated instructions are returned in `minstrVec'.
   // Any temp. registers (TmpInstruction) created are returned in `tempVec'.
   // 
-  virtual void  CreateCodeToCopyIntToFloat(Method* method,
+  virtual void  CreateCodeToCopyIntToFloat(Function* method,
                                            Value* val,
                                            Instruction* dest,
                                            std::vector<MachineInstr*>& minstr,
@@ -150,7 +150,7 @@ public:
   // `val' to an integer value `dest' by copying to memory and back.
   // See the previous function for information about return values.
   // 
-  virtual void  CreateCodeToCopyFloatToInt(Method* method,
+  virtual void  CreateCodeToCopyFloatToInt(Function* method,
                                            Value* val,
                                            Instruction* dest,
                                            std::vector<MachineInstr*>& minstr,
@@ -159,7 +159,7 @@ public:
 
  // create copy instruction(s)
   virtual void CreateCopyInstructionsByType(const TargetMachine& target,
-                                            Method* method,
+                                            Function* method,
                                             Value* src,
                                             Instruction* dest,
                                             std::vector<MachineInstr*>& minstr) const;
@@ -353,7 +353,7 @@ public:
   // method args and return values etc.) with specific hardware registers
   // as required. See SparcRegInfo.cpp for the implementation for Sparc.
   //
-  void suggestRegs4MethodArgs(const Method *Meth, 
+  void suggestRegs4MethodArgs(const Function *Meth, 
 			      LiveRangeInfo& LRI) const;
 
   void suggestRegs4CallArgs(const MachineInstr *CallMI, 
@@ -364,7 +364,7 @@ public:
                            LiveRangeInfo& LRI) const;
 
 
-  void colorMethodArgs(const Method *Meth,  LiveRangeInfo &LRI,
+  void colorMethodArgs(const Function *Meth,  LiveRangeInfo &LRI,
 		       AddedInstrns *FirstAI) const;
 
   void colorCallArgs(const MachineInstr *CallMI, LiveRangeInfo &LRI,
diff --git a/lib/Target/SparcV9/SparcV9RegInfo.cpp b/lib/Target/SparcV9/SparcV9RegInfo.cpp
index 8ec2399..caf96f88 100644
--- a/lib/Target/SparcV9/SparcV9RegInfo.cpp
+++ b/lib/Target/SparcV9/SparcV9RegInfo.cpp
@@ -334,14 +334,14 @@ void UltraSparcRegInfo::suggestReg4CallAddr(const MachineInstr * CallMI,
 //  If the arg is passed on stack due to the lack of regs, NOTHING will be
 //  done - it will be colored (or spilled) as a normal live range.
 //---------------------------------------------------------------------------
-void UltraSparcRegInfo::suggestRegs4MethodArgs(const Method *Meth, 
+void UltraSparcRegInfo::suggestRegs4MethodArgs(const Function *Meth, 
 					       LiveRangeInfo& LRI) const 
 {
 
                                                  // get the argument list
-  const Method::ArgumentListType& ArgList = Meth->getArgumentList();           
+  const Function::ArgumentListType& ArgList = Meth->getArgumentList();
                                                  // get an iterator to arg list
-  Method::ArgumentListType::const_iterator ArgIt = ArgList.begin(); 
+  Function::ArgumentListType::const_iterator ArgIt = ArgList.begin(); 
 
   // for each argument
   for( unsigned argNo=0; ArgIt != ArgList.end() ; ++ArgIt, ++argNo) {    
@@ -383,15 +383,14 @@ void UltraSparcRegInfo::suggestRegs4MethodArgs(const Method *Meth,
 // the correct hardware registers if they did not receive the correct
 // (suggested) color through graph coloring.
 //---------------------------------------------------------------------------
-void UltraSparcRegInfo::colorMethodArgs(const Method *Meth, 
+void UltraSparcRegInfo::colorMethodArgs(const Function *Meth, 
 					LiveRangeInfo &LRI,
 					AddedInstrns *FirstAI) const {
 
                                                  // get the argument list
-  const Method::ArgumentListType& ArgList = Meth->getArgumentList();           
+  const Function::ArgumentListType& ArgList = Meth->getArgumentList();
                                                  // get an iterator to arg list
-  Method::ArgumentListType::const_iterator ArgIt = ArgList.begin(); 
-
+  Function::ArgumentListType::const_iterator ArgIt = ArgList.begin(); 
   MachineInstr *AdMI;
 
 
@@ -399,7 +398,7 @@ void UltraSparcRegInfo::colorMethodArgs(const Method *Meth,
   for( unsigned argNo=0; ArgIt != ArgList.end() ; ++ArgIt, ++argNo) {    
 
     // get the LR of arg
-    LiveRange *const LR = LRI.getLiveRangeForValue((const Value *) *ArgIt); 
+    LiveRange *LR = LRI.getLiveRangeForValue(*ArgIt); 
     assert( LR && "No live range found for method arg");
 
 
diff --git a/lib/Target/SparcV9/SparcV9TargetMachine.cpp b/lib/Target/SparcV9/SparcV9TargetMachine.cpp
index 09b44f5..cb6d100 100644
--- a/lib/Target/SparcV9/SparcV9TargetMachine.cpp
+++ b/lib/Target/SparcV9/SparcV9TargetMachine.cpp
@@ -243,7 +243,7 @@ struct FreeMachineCodeForFunction : public MethodPass {
            I != E; ++I)
         MachineCodeForInstruction::get(*I).dropAllReferences();
     
-    for (Method::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI)
+    for (Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI)
       for (BasicBlock::iterator I = (*FI)->begin(), E = (*FI)->end();
            I != E; ++I)
         freeMachineCode(*I);