From: Chris Lattner Date: Mon, 8 Apr 2002 22:03:57 +0000 (+0000) Subject: s/Method/Function X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=b7653df0853f06112b741be09f1b7ae5a6aa6fde;p=oota-llvm.git s/Method/Function git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2180 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/CodeGen/RegClass.h b/include/llvm/CodeGen/RegClass.h index 1e5f5513725..3db72b73639 100644 --- a/include/llvm/CodeGen/RegClass.h +++ b/include/llvm/CodeGen/RegClass.h @@ -36,7 +36,7 @@ typedef std::vector 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/include/llvm/Support/InstVisitor.h b/include/llvm/Support/InstVisitor.h index f56847ae3e7..c379cc17439 100644 --- a/include/llvm/Support/InstVisitor.h +++ b/include/llvm/Support/InstVisitor.h @@ -68,7 +68,7 @@ struct InstVisitor { // Define visitors for modules, methods and basic blocks... // void visit(Module *M) { visit(M->begin(), M->end()); } - void visit(Method *M) { visit(M->begin(), M->end()); } + void visit(Function *F) { visit(F->begin(), F->end()); } void visit(BasicBlock *BB) { visit(BB->begin(), BB->end()); } // visit - Finally, code to visit an instruction... diff --git a/include/llvm/iTerminators.h b/include/llvm/iTerminators.h index 8feeac5e917..790b0e2b111 100644 --- a/include/llvm/iTerminators.h +++ b/include/llvm/iTerminators.h @@ -208,8 +208,8 @@ public: inline const Function *getCalledFunction() const { return dyn_cast(Operands[0].get()); } - inline Method *getCalledFunction() { - return dyn_cast(Operands[0].get()); + inline Function *getCalledFunction() { + return dyn_cast(Operands[0].get()); } // getCalledValue - Get a pointer to a method that is invoked by this inst. diff --git a/lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp b/lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp index 45f7b9dec09..a0b410ec250 100644 --- a/lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp +++ b/lib/Analysis/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 BBI = po_begin(M), BBE = po_end(M); + for(po_iterator 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 BBI = po_begin(M); BBI != po_end(M) ; ++BBI) { + for (po_iterator 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/Analysis/LoopInfo.cpp b/lib/Analysis/LoopInfo.cpp index 344e3a446bf..cd7768f1823 100644 --- a/lib/Analysis/LoopInfo.cpp +++ b/lib/Analysis/LoopInfo.cpp @@ -26,7 +26,7 @@ bool cfg::Loop::contains(const BasicBlock *BB) const { //===----------------------------------------------------------------------===// // cfg::LoopInfo implementation // -bool cfg::LoopInfo::runOnMethod(Method *M) { +bool cfg::LoopInfo::runOnMethod(Function *F) { BBMap.clear(); // Reset internal state of analysis TopLevelLoops.clear(); Calculate(getAnalysis()); // Update diff --git a/lib/CodeGen/InstrSched/InstrScheduling.cpp b/lib/CodeGen/InstrSched/InstrScheduling.cpp index 31eca3903b1..69813c744e5 100644 --- a/lib/CodeGen/InstrSched/InstrScheduling.cpp +++ b/lib/CodeGen/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/CodeGen/InstrSched/SchedPriorities.cpp b/lib/CodeGen/InstrSched/SchedPriorities.cpp index 810692f7ba0..02e50c0cc79 100644 --- a/lib/CodeGen/InstrSched/SchedPriorities.cpp +++ b/lib/CodeGen/InstrSched/SchedPriorities.cpp @@ -25,7 +25,7 @@ #include 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/CodeGen/RegAlloc/PhyRegAlloc.h b/lib/CodeGen/RegAlloc/PhyRegAlloc.h index ce922985871..a38197191b1 100644 --- a/lib/CodeGen/RegAlloc/PhyRegAlloc.h +++ b/lib/CodeGen/RegAlloc/PhyRegAlloc.h @@ -62,7 +62,7 @@ typedef std::hash_map 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 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/CodeGen/RegAlloc/RegClass.h b/lib/CodeGen/RegAlloc/RegClass.h index 1e5f5513725..3db72b73639 100644 --- a/lib/CodeGen/RegAlloc/RegClass.h +++ b/lib/CodeGen/RegAlloc/RegClass.h @@ -36,7 +36,7 @@ typedef std::vector 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/InstrSched/InstrScheduling.cpp b/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp index 31eca3903b1..69813c744e5 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 810692f7ba0..02e50c0cc79 100644 --- a/lib/Target/SparcV9/InstrSched/SchedPriorities.cpp +++ b/lib/Target/SparcV9/InstrSched/SchedPriorities.cpp @@ -25,7 +25,7 @@ #include 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 45f7b9dec09..a0b410ec250 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 BBI = po_begin(M), BBE = po_end(M); + for(po_iterator 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 BBI = po_begin(M); BBI != po_end(M) ; ++BBI) { + for (po_iterator 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 ce922985871..a38197191b1 100644 --- a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h +++ b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h @@ -62,7 +62,7 @@ typedef std::hash_map 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 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 1e5f5513725..3db72b73639 100644 --- a/lib/Target/SparcV9/RegAlloc/RegClass.h +++ b/lib/Target/SparcV9/RegAlloc/RegClass.h @@ -36,7 +36,7 @@ typedef std::vector 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 7f836c7a20f..8dd894664b1 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& 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& 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& 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& 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 8ec23991083..caf96f88c02 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 09b44f5f2e5..cb6d100d398 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); diff --git a/lib/VMCore/BasicBlock.cpp b/lib/VMCore/BasicBlock.cpp index 7c910918c64..e126d702b40 100644 --- a/lib/VMCore/BasicBlock.cpp +++ b/lib/VMCore/BasicBlock.cpp @@ -1,6 +1,6 @@ //===-- BasicBlock.cpp - Implement BasicBlock related functions --*- C++ -*--=// // -// This file implements the Method class for the VMCore library. +// This file implements the BasicBlock class for the VMCore library. // //===----------------------------------------------------------------------===// @@ -15,9 +15,9 @@ // Instantiate Templates - This ugliness is the price we have to pay // for having a ValueHolderImpl.h file seperate from ValueHolder.h! :( // -template class ValueHolder; +template class ValueHolder; -BasicBlock::BasicBlock(const std::string &name, Method *Parent) +BasicBlock::BasicBlock(const std::string &name, Function *Parent) : Value(Type::LabelTy, Value::BasicBlockVal, name), InstList(this, 0), machineInstrVec(new MachineCodeForBasicBlock) { if (Parent) @@ -32,7 +32,7 @@ BasicBlock::~BasicBlock() { // Specialize setName to take care of symbol table majik void BasicBlock::setName(const std::string &name, SymbolTable *ST) { - Method *P; + Function *P; assert((ST == 0 || (!getParent() || ST == getParent()->getSymbolTable())) && "Invalid symtab argument!"); if ((P = getParent()) && hasName()) P->getSymbolTable()->remove(this); @@ -40,7 +40,7 @@ void BasicBlock::setName(const std::string &name, SymbolTable *ST) { if (P && hasName()) P->getSymbolTable()->insert(this); } -void BasicBlock::setParent(Method *parent) { +void BasicBlock::setParent(Function *parent) { if (getParent() && hasName()) getParent()->getSymbolTable()->remove(this); diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index f99b5ab5aa3..77a362903c1 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -194,7 +194,7 @@ namespace { // Anonymous namespace for class verifySymbolTable(M->getSymbolTable()); return false; } - bool runOnMethod(Method *M) { verifyMethod(M); return false; } + bool runOnMethod(Function *F) { verifyMethod(F); return false; } }; }