RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-02-16 19:19:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename Method to Function

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1957 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2002-03-23 22:51:58 +00:00
parent bcd8e03138
commit e7506a366e
39 changed files with 162 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
include/llvm/Analysis/CallGraph.h
View File

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

16
include/llvm/Analysis/ConstantsScanner.h
View File

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

12
include/llvm/Analysis/Dominators.h
View File

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

2
include/llvm/Analysis/IntervalPartition.h
View File

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

12
include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h
View File

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

2
include/llvm/Analysis/LoopInfo.h
View File

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

7
include/llvm/Analysis/SlotCalculator.h
View File

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

4
include/llvm/Analysis/Verifier.h
View File

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

12
include/llvm/Assembly/Writer.h
View File

@ -21,7 +21,7 @@
class Module;
class GlobalVariable;
class Method;
class Function;
class BasicBlock;
class Instruction;
class SlotCalculator;
@ -32,7 +32,7 @@ class SlotCalculator;
//
void WriteToAssembly(const Module *Module, std::ostream &o);
void WriteToAssembly(const GlobalVariable *G, std::ostream &o);
void WriteToAssembly(const Method *Method, std::ostream &o);
void WriteToAssembly(const Function *F , std::ostream &o);
void WriteToAssembly(const BasicBlock *BB, std::ostream &o);
void WriteToAssembly(const Instruction *In, std::ostream &o);
void WriteToAssembly(const Constant *V, std::ostream &o);
@ -58,7 +58,7 @@ std::ostream &WriteAsOperand(std::ostream &, const Value *, bool PrintTy = true,
// suffix.
//
void WriteToVCG(const Module *Module, const std::string &Filename);
void WriteToVCG(const Method *Method, const std::string &Filename);
void WriteToVCG(const Function *Func, const std::string &Filename);
@ -74,8 +74,8 @@ inline std::ostream &operator<<(std::ostream &o, const GlobalVariable *G) {
WriteToAssembly(G, o); return o;
}
inline std::ostream &operator<<(std::ostream &o, const Method *M) {
WriteToAssembly(M, o); return o;
inline std::ostream &operator<<(std::ostream &o, const Function *F) {
WriteToAssembly(F, o); return o;
}
inline std::ostream &operator<<(std::ostream &o, const BasicBlock *B) {
@ -103,7 +103,7 @@ inline std::ostream &operator<<(std::ostream &o, const Value *I) {
case Value::MethodArgumentVal: return o << I->getType() << " "<< I->getName();
case Value::InstructionVal:WriteToAssembly(cast<Instruction>(I) , o); break;
case Value::BasicBlockVal: WriteToAssembly(cast<BasicBlock>(I) , o); break;
case Value::MethodVal: WriteToAssembly(cast<Method>(I) , o); break;
case Value::MethodVal: WriteToAssembly(cast<Function>(I) , o); break;
case Value::GlobalVariableVal:
WriteToAssembly(cast<GlobalVariable>(I), o); break;
case Value::ModuleVal: WriteToAssembly(cast<Module>(I) , o); break;

12
include/llvm/CodeGen/FunctionLiveVarInfo.h
View File

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

4
include/llvm/CodeGen/InstrForest.h
View File

@ -31,7 +31,7 @@
class Constant;
class BasicBlock;
class Method;
class Function;
class InstrTreeNode;
class InstrForest;
@ -243,7 +243,7 @@ private:
std::hash_set<InstructionNode*> treeRoots;
public:
/*ctor*/ InstrForest (Method *M);
/*ctor*/ InstrForest (Function *F);
/*dtor*/ ~InstrForest ();
inline InstructionNode *getTreeNodeForInstr(Instruction* instr) {

4
include/llvm/CodeGen/InstrSelection.h
View File

@ -14,7 +14,7 @@
#define LLVM_CODEGEN_INSTR_SELECTION_H
#include "llvm/Instruction.h"
class Method;
class Function;
class InstrForest;
class MachineInstr;
class InstructionNode;
@ -55,7 +55,7 @@ extern bool ThisIsAChainRule (int eruleno);
// Implemented in machine-specific instruction selection file.
//---------------------------------------------------------------------------
bool SelectInstructionsForMethod (Method* method,
bool SelectInstructionsForMethod (Function* function,
TargetMachine &Target);

12
include/llvm/CodeGen/MachineCodeForMethod.h
View File

@ -14,14 +14,14 @@
#include "Support/HashExtras.h"
#include <ext/hash_set>
class Value;
class Method;
class Function;
class Constant;
class Type;
class TargetMachine;
class MachineCodeForMethod : private Annotation {
const Method* method;
const Function* method;
bool compiledAsLeaf;
unsigned staticStackSize;
unsigned automaticVarsSize;
@ -33,7 +33,7 @@ class MachineCodeForMethod : private Annotation {
std::hash_map<const Value*, int> offsets;
public:
/*ctor*/ MachineCodeForMethod(const Method* method,
/*ctor*/ MachineCodeForMethod(const Function* function,
const TargetMachine& target);
// The next two methods are used to construct and to retrieve
@ -43,10 +43,10 @@ public:
// This should not be called before "construct()"
// for a given Method.
//
static MachineCodeForMethod& construct(const Method *method,
static MachineCodeForMethod& construct(const Function *method,
const TargetMachine &target);
static void destruct(const Method *M);
static MachineCodeForMethod& get(const Method* method);
static void destruct(const Function *F);
static MachineCodeForMethod& get(const Function* function);
//
// Accessors for global information about generated code for a method.

12
include/llvm/CodeGen/MachineFunction.h
View File

@ -14,14 +14,14 @@
#include "Support/HashExtras.h"
#include <ext/hash_set>
class Value;
class Method;
class Function;
class Constant;
class Type;
class TargetMachine;
class MachineCodeForMethod : private Annotation {
const Method* method;
const Function* method;
bool compiledAsLeaf;
unsigned staticStackSize;
unsigned automaticVarsSize;
@ -33,7 +33,7 @@ class MachineCodeForMethod : private Annotation {
std::hash_map<const Value*, int> offsets;
public:
/*ctor*/ MachineCodeForMethod(const Method* method,
/*ctor*/ MachineCodeForMethod(const Function* function,
const TargetMachine& target);
// The next two methods are used to construct and to retrieve
@ -43,10 +43,10 @@ public:
// This should not be called before "construct()"
// for a given Method.
//
static MachineCodeForMethod& construct(const Method *method,
static MachineCodeForMethod& construct(const Function *method,
const TargetMachine &target);
static void destruct(const Method *M);
static MachineCodeForMethod& get(const Method* method);
static void destruct(const Function *F);
static MachineCodeForMethod& get(const Function* function);
//
// Accessors for global information about generated code for a method.

2
include/llvm/CodeGen/MachineInstr.h
View File

@ -452,7 +452,7 @@ std::ostream& operator<< (std::ostream& os, const MachineInstr& minstr);
std::ostream& operator<< (std::ostream& os, const MachineOperand& mop);
void PrintMachineInstructions(const Method *method);
void PrintMachineInstructions(const Function *F);
//**************************************************************************/

18
include/llvm/Pass.h
View File

@ -22,7 +22,7 @@
#include <map>
class Value;
class BasicBlock;
class Method;
class Function;
class Module;
class AnalysisID;
class Pass;
@ -105,7 +105,7 @@ protected:
private:
friend class PassManagerT<Module>;
friend class PassManagerT<Method>;
friend class PassManagerT<Function>;
friend class PassManagerT<BasicBlock>;
virtual void addToPassManager(PassManagerT<Module> *PM, AnalysisSet &Req,
AnalysisSet &Destroyed, AnalysisSet &Provided);
@ -129,7 +129,7 @@ struct MethodPass : public Pass {
// runOnMethod - Virtual method overriden by subclasses to do the per-method
// processing of the pass.
//
virtual bool runOnMethod(Method *M) = 0;
virtual bool runOnMethod(Function *M) = 0;
// doFinalization - Virtual method overriden by subclasses to do any post
// processing needed after all passes have run.
@ -143,15 +143,15 @@ struct MethodPass : public Pass {
// run - On a method, we simply initialize, run the method, then finalize.
//
bool run(Method *M);
bool run(Function *M);
private:
friend class PassManagerT<Module>;
friend class PassManagerT<Method>;
friend class PassManagerT<Function>;
friend class PassManagerT<BasicBlock>;
virtual void addToPassManager(PassManagerT<Module> *PM, AnalysisSet &Req,
AnalysisSet &Dest, AnalysisSet &Prov);
virtual void addToPassManager(PassManagerT<Method> *PM,AnalysisSet &Req,
virtual void addToPassManager(PassManagerT<Function> *PM,AnalysisSet &Req,
AnalysisSet &Dest, AnalysisSet &Prov);
};
@ -176,7 +176,7 @@ struct BasicBlockPass : public MethodPass {
// To run this pass on a method, we simply call runOnBasicBlock once for each
// method.
//
virtual bool runOnMethod(Method *BB);
virtual bool runOnMethod(Function *F);
// To run directly on the basic block, we initialize, runOnBasicBlock, then
// finalize.
@ -184,9 +184,9 @@ struct BasicBlockPass : public MethodPass {
bool run(BasicBlock *BB);
private:
friend class PassManagerT<Method>;
friend class PassManagerT<Function>;
friend class PassManagerT<BasicBlock>;
virtual void addToPassManager(PassManagerT<Method> *PM, AnalysisSet &,
virtual void addToPassManager(PassManagerT<Function> *PM, AnalysisSet &,
AnalysisSet &, AnalysisSet &);
virtual void addToPassManager(PassManagerT<BasicBlock> *PM, AnalysisSet &,
AnalysisSet &, AnalysisSet &);

7
include/llvm/SlotCalculator.h
View File

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

10
include/llvm/Target/MachineInstrInfo.h
View File

@ -18,7 +18,7 @@ class MachineInstr;
class TargetMachine;
class Value;
class Instruction;
class Method;
class Function;
//---------------------------------------------------------------------------
// Data types used to define information about a single machine instruction
@ -248,7 +248,7 @@ public:
// The generated instructions are returned in `minstrVec'.
// Any temp. 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,
@ -260,7 +260,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*>& minstVec,
@ -271,7 +271,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*>& minstVec,
@ -281,7 +281,7 @@ public:
// create copy instruction(s)
virtual void CreateCopyInstructionsByType(const TargetMachine& target,
Method* method,
Function* method,
Value* src,
Instruction* dest,
std::vector<MachineInstr*>& minstrVec)

10
include/llvm/Target/TargetInstrInfo.h
View File

@ -18,7 +18,7 @@ class MachineInstr;
class TargetMachine;
class Value;
class Instruction;
class Method;
class Function;
//---------------------------------------------------------------------------
// Data types used to define information about a single machine instruction
@ -248,7 +248,7 @@ public:
// The generated instructions are returned in `minstrVec'.
// Any temp. 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,
@ -260,7 +260,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*>& minstVec,
@ -271,7 +271,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*>& minstVec,
@ -281,7 +281,7 @@ public:
// create copy instruction(s)
virtual void CreateCopyInstructionsByType(const TargetMachine& target,
Method* method,
Function* method,
Value* src,
Instruction* dest,
std::vector<MachineInstr*>& minstrVec)

6
include/llvm/Target/TargetRegInfo.h
View File

@ -17,7 +17,7 @@ class IGNode;
class Type;
class Value;
class LiveRangeInfo;
class Method;
class Function;
class Instruction;
class LiveRange;
class AddedInstrns;
@ -108,7 +108,7 @@ public:
// method args and return values etc.) with specific hardware registers
// as required. See SparcRegInfo.cpp for the implementation for Sparc.
//
virtual void suggestRegs4MethodArgs(const Method *Meth,
virtual void suggestRegs4MethodArgs(const Function *Func,
LiveRangeInfo &LRI) const = 0;
virtual void suggestRegs4CallArgs(const MachineInstr *CallI,
@ -117,7 +117,7 @@ public:
virtual void suggestReg4RetValue(const MachineInstr *RetI,
LiveRangeInfo &LRI) const = 0;
virtual void colorMethodArgs(const Method *Meth, LiveRangeInfo &LRI,
virtual void colorMethodArgs(const Function *Func, LiveRangeInfo &LRI,
AddedInstrns *FirstAI) const = 0;
virtual void colorCallArgs(const MachineInstr *CalI,

2
include/llvm/Transforms/MutateStructTypes.h
View File

@ -88,7 +88,7 @@ private:
// transformMethod - This transforms the instructions of the method to use the
// new types.
//
void transformMethod(Method *M);
void transformMethod(Function *F);
// removeDeadGlobals - This removes the old versions of methods that are no
// longer needed.

4
include/llvm/Transforms/Scalar/InductionVars.h
View File

@ -14,9 +14,9 @@ namespace cfg { class IntervalPartition; }
struct InductionVariableCannonicalize : public MethodPass {
// doInductionVariableCannonicalize - Simplify induction variables in loops
//
static bool doIt(Method *M, cfg::IntervalPartition &IP);
static bool doIt(Function *M, cfg::IntervalPartition &IP);
virtual bool runOnMethod(Method *M);
virtual bool runOnMethod(Function *M);
// getAnalysisUsageInfo - Declare that we need IntervalPartitions
void getAnalysisUsageInfo(Pass::AnalysisSet &Required,

6
include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
View File

@ -23,11 +23,11 @@ public:
//
// If there are no return stmts in the Method, a null pointer is returned.
//
static bool doit(Method *M, BasicBlock *&ExitNode);
static bool doit(Function *F, BasicBlock *&ExitNode);
virtual bool runOnMethod(Method *M) {
return doit(M, ExitNode);
virtual bool runOnMethod(Function *F) {
return doit(F, ExitNode);
}
BasicBlock *getExitNode() const { return ExitNode; }

11
include/llvm/Value.h
View File

@ -23,7 +23,8 @@ class MethodArgument;
class Instruction;
class BasicBlock;
class GlobalValue;
class Method;
class Function;
typedef Function Method;
class GlobalVariable;
class Module;
class SymbolTable;
@ -274,10 +275,10 @@ template <> inline bool isa<BasicBlock, const Value*>(const Value *Val) {
template <> inline bool isa<BasicBlock, Value*>(Value *Val) {
return Val->getValueType() == Value::BasicBlockVal;
}
template <> inline bool isa<Method, const Value*>(const Value *Val) {
template <> inline bool isa<Function, const Value*>(const Value *Val) {
return Val->getValueType() == Value::MethodVal;
}
template <> inline bool isa<Method, Value*>(Value *Val) {
template <> inline bool isa<Function, Value*>(Value *Val) {
return Val->getValueType() == Value::MethodVal;
}
template <> inline bool isa<GlobalVariable, const Value*>(const Value *Val) {
@ -287,10 +288,10 @@ template <> inline bool isa<GlobalVariable, Value*>(Value *Val) {
return Val->getValueType() == Value::GlobalVariableVal;
}
template <> inline bool isa<GlobalValue, const Value*>(const Value *Val) {
return isa<GlobalVariable>(Val) || isa<Method>(Val);
return isa<GlobalVariable>(Val) || isa<Function>(Val);
}
template <> inline bool isa<GlobalValue, Value*>(Value *Val) {
return isa<GlobalVariable>(Val) || isa<Method>(Val);
return isa<GlobalVariable>(Val) || isa<Function>(Val);
}
template <> inline bool isa<Module, const Value*>(const Value *Val) {
return Val->getValueType() == Value::ModuleVal;

4
include/llvm/iTerminators.h
View File

@ -205,8 +205,8 @@ public:
// getCalledMethod - Return the method called, or null if this is an indirect
// method invocation...
//
inline const Method *getCalledMethod() const {
return dyn_cast<Method>(Operands[0].get());
inline const Function *getCalledMethod() const {
return dyn_cast<Function>(Operands[0].get());
}
inline Method *getCalledMethod() {
return dyn_cast<Method>(Operands[0].get());

1
lib/Analysis/LiveVar/BBLiveVar.h
View File

@ -11,7 +11,6 @@
#include "llvm/Analysis/LiveVar/ValueSet.h"
#include "llvm/Annotation.h"
#include <map>
class Method;
class BasicBlock;
class Value;

2
lib/Analysis/Makefile
View File

@ -3,7 +3,7 @@ LEVEL = ../..
LIBRARYNAME = analysis
DIRS = LiveVar IPA
DIRS = LiveVar IPA DataStructure
include $(LEVEL)/Makefile.common

6
lib/Bytecode/Reader/ReaderInternals.h
View File

@ -27,12 +27,6 @@
#define BCR_TRACE(n, X)
#endif
class BasicBlock;
class Method;
class Module;
class Type;
class PointerType;
typedef unsigned char uchar;
struct RawInst { // The raw fields out of the bytecode stream...

7
lib/Bytecode/Writer/SlotCalculator.h
View File

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

8
lib/CodeGen/InstrSched/SchedGraph.h
View File

@ -28,7 +28,7 @@ class Value;
class Instruction;
class TerminatorInst;
class BasicBlock;
class Method;
class Function;
class TargetMachine;
class SchedGraphEdge;
class SchedGraphNode;
@ -339,7 +339,7 @@ class SchedGraphSet :
private std::hash_map<const BasicBlock*, SchedGraph*>
{
private:
const Method* method;
const Function* method;
public:
typedef std::hash_map<const BasicBlock*, SchedGraph*> map_base;
@ -347,7 +347,7 @@ public:
using map_base::const_iterator;
public:
/*ctor*/ SchedGraphSet (const Method* _method,
/*ctor*/ SchedGraphSet (const Function * function,
const TargetMachine& target);
/*dtor*/ ~SchedGraphSet ();
@ -379,7 +379,7 @@ private:
//
// Graph builder
//
void buildGraphsForMethod (const Method *method,
void buildGraphsForMethod (const Function *F,
const TargetMachine& target);
};

5
lib/CodeGen/InstrSched/SchedPriorities.h
View File

@ -28,7 +28,7 @@
#include <list>
#include <ext/hash_set>
#include <iostream>
class Method;
class Function;
class MachineInstr;
class SchedulingManager;
class MethodLiveVarInfo;
@ -125,7 +125,8 @@ private:
class SchedPriorities: public NonCopyable {
public:
SchedPriorities(const Method *M, const SchedGraph *G, MethodLiveVarInfo &LVI);
SchedPriorities(const Function *F, const SchedGraph *G,
MethodLiveVarInfo &LVI);
// This must be called before scheduling begins.

10
lib/CodeGen/RegAlloc/LiveRangeInfo.h
View File

@ -1,4 +1,4 @@
//===-- LiveRangeInfo.h - Track all LiveRanges for a Method ------*- C++ -*-==//
//===-- LiveRangeInfo.h - Track all LiveRanges for a Function ----*- C++ -*-==//
//
// This file contains the class LiveRangeInfo which constructs and keeps
// the LiveRangMap which contains all the live ranges used in a method.
@ -28,7 +28,7 @@ class RegClass;
class MachineRegInfo;
class TargetMachine;
class Value;
class Method;
class Function;
class Instruction;
typedef std::hash_map<const Value*, LiveRange*> LiveRangeMapType;
@ -42,7 +42,7 @@ typedef std::vector<const MachineInstr*> CallRetInstrListType;
//----------------------------------------------------------------------------
class LiveRangeInfo {
const Method *const Meth; // Method for which live range info is held
const Function *const Meth; // Func for which live range info is held
LiveRangeMapType LiveRangeMap; // A map from Value * to LiveRange * to
// record all live ranges in a method
// created by constructLiveRanges
@ -64,11 +64,11 @@ class LiveRangeInfo {
void suggestRegs4CallRets();
const Method* getMethod() { return Meth; }
const Function *getMethod() { return Meth; }
public:
LiveRangeInfo(const Method *M,
LiveRangeInfo(const Function *F,
const TargetMachine& tm,
std::vector<RegClass *> & RCList);

8
lib/Target/SparcV9/InstrSched/SchedGraph.h
View File

@ -28,7 +28,7 @@ class Value;
class Instruction;
class TerminatorInst;
class BasicBlock;
class Method;
class Function;
class TargetMachine;
class SchedGraphEdge;
class SchedGraphNode;
@ -339,7 +339,7 @@ class SchedGraphSet :
private std::hash_map<const BasicBlock*, SchedGraph*>
{
private:
const Method* method;
const Function* method;
public:
typedef std::hash_map<const BasicBlock*, SchedGraph*> map_base;
@ -347,7 +347,7 @@ public:
using map_base::const_iterator;
public:
/*ctor*/ SchedGraphSet (const Method* _method,
/*ctor*/ SchedGraphSet (const Function * function,
const TargetMachine& target);
/*dtor*/ ~SchedGraphSet ();
@ -379,7 +379,7 @@ private:
//
// Graph builder
//
void buildGraphsForMethod (const Method *method,
void buildGraphsForMethod (const Function *F,
const TargetMachine& target);
};

5
lib/Target/SparcV9/InstrSched/SchedPriorities.h
View File

@ -28,7 +28,7 @@
#include <list>
#include <ext/hash_set>
#include <iostream>
class Method;
class Function;
class MachineInstr;
class SchedulingManager;
class MethodLiveVarInfo;
@ -125,7 +125,8 @@ private:
class SchedPriorities: public NonCopyable {
public:
SchedPriorities(const Method *M, const SchedGraph *G, MethodLiveVarInfo &LVI);
SchedPriorities(const Function *F, const SchedGraph *G,
MethodLiveVarInfo &LVI);
// This must be called before scheduling begins.

1
lib/Target/SparcV9/LiveVar/BBLiveVar.h
View File

@ -11,7 +11,6 @@
#include "llvm/Analysis/LiveVar/ValueSet.h"
#include "llvm/Annotation.h"
#include <map>
class Method;
class BasicBlock;
class Value;

10
lib/Target/SparcV9/RegAlloc/LiveRangeInfo.h
View File

@ -1,4 +1,4 @@
//===-- LiveRangeInfo.h - Track all LiveRanges for a Method ------*- C++ -*-==//
//===-- LiveRangeInfo.h - Track all LiveRanges for a Function ----*- C++ -*-==//
//
// This file contains the class LiveRangeInfo which constructs and keeps
// the LiveRangMap which contains all the live ranges used in a method.
@ -28,7 +28,7 @@ class RegClass;
class MachineRegInfo;
class TargetMachine;
class Value;
class Method;
class Function;
class Instruction;
typedef std::hash_map<const Value*, LiveRange*> LiveRangeMapType;
@ -42,7 +42,7 @@ typedef std::vector<const MachineInstr*> CallRetInstrListType;
//----------------------------------------------------------------------------
class LiveRangeInfo {
const Method *const Meth; // Method for which live range info is held
const Function *const Meth; // Func for which live range info is held
LiveRangeMapType LiveRangeMap; // A map from Value * to LiveRange * to
// record all live ranges in a method
// created by constructLiveRanges
@ -64,11 +64,11 @@ class LiveRangeInfo {
void suggestRegs4CallRets();
const Method* getMethod() { return Meth; }
const Function *getMethod() { return Meth; }
public:
LiveRangeInfo(const Method *M,
LiveRangeInfo(const Function *F,
const TargetMachine& tm,
std::vector<RegClass *> & RCList);

1
lib/Transforms/Instrumentation/ProfilePaths/EdgeCode.cpp
View File

@ -16,7 +16,6 @@
#include "llvm/iOperators.h"
#include "llvm/iPHINode.h"
class Method;
using std::vector;
//get the code to be inserted on the edge

15
lib/VMCore/Function.cpp
View File

@ -25,13 +25,14 @@
template class ValueHolder<MethodArgument, Method, Method>;
template class ValueHolder<BasicBlock , Method, Method>;
Method::Method(const MethodType *Ty, bool isInternal, const std::string &name)
Function::Function(const MethodType *Ty, bool isInternal,
const std::string &name)
: GlobalValue(PointerType::get(Ty), Value::MethodVal, isInternal, name),
SymTabValue(this), BasicBlocks(this), ArgumentList(this, this) {
assert(::isa<MethodType>(Ty) && "Method signature must be of method type!");
}
Method::~Method() {
Function::~Function() {
dropAllReferences(); // After this it is safe to delete instructions.
// TODO: Should remove from the end, not the beginning of vector!
@ -45,7 +46,7 @@ Method::~Method() {
}
// Specialize setName to take care of symbol table majik
void Method::setName(const std::string &name, SymbolTable *ST) {
void Function::setName(const std::string &name, SymbolTable *ST) {
Module *P;
assert((ST == 0 || (!getParent() || ST == getParent()->getSymbolTable())) &&
"Invalid symtab argument!");
@ -54,18 +55,18 @@ void Method::setName(const std::string &name, SymbolTable *ST) {
if (P && getName() != "") P->getSymbolTableSure()->insert(this);
}
void Method::setParent(Module *parent) {
void Function::setParent(Module *parent) {
Parent = parent;
// Relink symbol tables together...
setParentSymTab(Parent ? Parent->getSymbolTableSure() : 0);
}
const MethodType *Method::getMethodType() const {
const MethodType *Function::getMethodType() const {
return cast<MethodType>(cast<PointerType>(getType())->getElementType());
}
const Type *Method::getReturnType() const {
const Type *Function::getReturnType() const {
return getMethodType()->getReturnType();
}
@ -77,7 +78,7 @@ const Type *Method::getReturnType() const {
// valid on an object that has "dropped all references", except operator
// delete.
//
void Method::dropAllReferences() {
void Function::dropAllReferences() {
for_each(begin(), end(), std::mem_fun(&BasicBlock::dropAllReferences));
}

24
lib/VMCore/PassManagerT.h
View File

@ -347,7 +347,7 @@ template<> struct PassManagerTraits<BasicBlock> : public BasicBlockPass {
typedef PassClass BatcherClass;
// ParentClass - The type of the parent PassManager...
typedef PassManagerT<Method> ParentClass;
typedef PassManagerT<Function> ParentClass;
// PMType - The type of the passmanager that subclasses this class
typedef PassManagerT<BasicBlock> PMType;
@ -371,12 +371,12 @@ template<> struct PassManagerTraits<BasicBlock> : public BasicBlockPass {
//===----------------------------------------------------------------------===//
// PassManagerTraits<Method> Specialization
// PassManagerTraits<Function> Specialization
//
// This pass manager is used to group together all of the MethodPass's
// into a single unit.
//
template<> struct PassManagerTraits<Method> : public MethodPass {
template<> struct PassManagerTraits<Function> : public MethodPass {
// PassClass - The type of passes tracked by this PassManager
typedef MethodPass PassClass;
@ -390,20 +390,20 @@ template<> struct PassManagerTraits<Method> : public MethodPass {
typedef PassManagerT<Module> ParentClass;
// PMType - The type of the passmanager that subclasses this class
typedef PassManagerT<Method> PMType;
typedef PassManagerT<Function> PMType;
// runPass - Specify how the pass should be run on the UnitType
static bool runPass(PassClass *P, Method *M) {
static bool runPass(PassClass *P, Function *M) {
return P->runOnMethod(M);
}
// getPMName() - Return the name of the unit the PassManager operates on for
// debugging.
const char *getPMName() const { return "Method"; }
const char *getPMName() const { return "Function"; }
// Implement the MethodPass interface...
virtual bool doInitialization(Module *M);
virtual bool runOnMethod(Method *M);
virtual bool runOnMethod(Function *M);
virtual bool doFinalization(Module *M);
};
@ -422,7 +422,7 @@ template<> struct PassManagerTraits<Module> : public Pass {
typedef MethodPass SubPassClass;
// BatcherClass - The type to use for collation of subtypes...
typedef PassManagerT<Method> BatcherClass;
typedef PassManagerT<Function> BatcherClass;
// ParentClass - The type of the parent PassManager...
typedef AnalysisResolver ParentClass;
@ -467,20 +467,20 @@ inline bool PassManagerTraits<BasicBlock>::doFinalization(Module *M) {
}
// PassManagerTraits<Method> Implementations
// PassManagerTraits<Function> Implementations
//
inline bool PassManagerTraits<Method>::doInitialization(Module *M) {
inline bool PassManagerTraits<Function>::doInitialization(Module *M) {
bool Changed = false;
for (unsigned i = 0, e = ((PMType*)this)->Passes.size(); i != e; ++i)
((PMType*)this)->Passes[i]->doInitialization(M);
return Changed;
}
inline bool PassManagerTraits<Method>::runOnMethod(Method *M) {
inline bool PassManagerTraits<Function>::runOnMethod(Function *M) {
return ((PMType*)this)->runOnUnit(M);
}
inline bool PassManagerTraits<Method>::doFinalization(Module *M) {
inline bool PassManagerTraits<Function>::doFinalization(Module *M) {
bool Changed = false;
for (unsigned i = 0, e = ((PMType*)this)->Passes.size(); i != e; ++i)
((PMType*)this)->Passes[i]->doFinalization(M);