6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-17 20:29:31 +00:00
Code Issues Projects Releases Wiki Activity

s/Method/Function

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2180 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2002-04-08 22:03:57 +00:00
parent 75cf7cf00d
commit b7653df085
19 changed files with 73 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
include/llvm/CodeGen/RegClass.h
View File

@ -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; }

2
include/llvm/Support/InstVisitor.h
View File

@ -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...

4
include/llvm/iTerminators.h
View File

@ -208,8 +208,8 @@ public:
inline const Function *getCalledFunction() const {
return dyn_cast<Function>(Operands[0].get());
}
inline Method *getCalledFunction() {
return dyn_cast<Method>(Operands[0].get());
inline Function *getCalledFunction() {
return dyn_cast<Function>(Operands[0].get());
}
// getCalledValue - Get a pointer to a method that is invoked by this inst.

16
lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp
View File

@ -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;

2
lib/Analysis/LoopInfo.cpp
View File

@ -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<DominatorSet>()); // Update

4
lib/CodeGen/InstrSched/InstrScheduling.cpp
View File

@ -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;

2
lib/CodeGen/InstrSched/SchedPriorities.cpp
View File

@ -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

6
lib/CodeGen/RegAlloc/PhyRegAlloc.h
View File

@ -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();

15
lib/CodeGen/RegAlloc/RegClass.h
View File

@ -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; }

4
lib/Target/SparcV9/InstrSched/InstrScheduling.cpp
View File

@ -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;

2
lib/Target/SparcV9/InstrSched/SchedPriorities.cpp
View File

@ -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

16
lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp
View File

@ -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;

6
lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h
View File

@ -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();

15
lib/Target/SparcV9/RegAlloc/RegClass.h
View File

@ -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; }

12
lib/Target/SparcV9/SparcV9Internals.h
View File

@ -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,

15
lib/Target/SparcV9/SparcV9RegInfo.cpp
View File

@ -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");

2
lib/Target/SparcV9/SparcV9TargetMachine.cpp
View File

@ -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);

10
lib/VMCore/BasicBlock.cpp
View File

@ -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<Instruction, BasicBlock, Method>;
template class ValueHolder<Instruction, BasicBlock, Function>;
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);

2
lib/VMCore/Verifier.cpp
View File

@ -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; }
};
}