#include "Support/GraphTraits.h"
#include "llvm/Pass.h"
-class Method;
+class Function;
class Module;
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
// 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;
}
// 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.
// 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]);
}
// 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();
// CallGraphNode class definition
//
class CallGraphNode {
- Method *Meth;
+ Function *Meth;
std::vector<CallGraphNode*> CalledMethods;
CallGraphNode(const CallGraphNode &); // Do not implement
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(); }
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) {
}
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 &&
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
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...
DominatorSet(AnalysisID id) : DominatorBase(id == PostDomID) {}
- virtual bool runOnMethod(Method *M);
+ virtual bool runOnMethod(Function *F);
// Accessor interface:
typedef DomSetMapType::const_iterator const_iterator;
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())
DominatorTree(AnalysisID id) : DominatorBase(id == PostDomID) {}
~DominatorTree() { reset(); }
- virtual bool runOnMethod(Method *M) {
+ virtual bool runOnMethod(Function *F) {
reset();
DominatorSet *DS;
if (isPostDominator())
DominanceFrontier(AnalysisID id) : DominatorBase(id == PostDomID) {}
- virtual bool runOnMethod(Method *M) {
+ virtual bool runOnMethod(Function *) {
Frontiers.clear();
DominatorTree *DT;
if (isPostDominator())
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
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
// 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);
// --------- 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();
#endif
// runOnMethod - Pass framework implementation
- virtual bool runOnMethod(Method *M);
+ virtual bool runOnMethod(Function *F);
// getAnalysisUsageInfo - Provide loop info, require dominator set
//
#include <map>
class Value;
class Module;
-class Method;
+class Function;
class MethodArgument;
class BasicBlock;
class Instruction;
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!
// 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:
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.
// verifyMethod - Check a method for errors, useful for use when debugging a
// pass.
-bool verifyMethod(const Method *M);
+bool verifyMethod(const Function *M);
#endif
class Module;
class GlobalVariable;
-class Method;
+class Function;
class BasicBlock;
class Instruction;
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);
// 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);
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) {
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;
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
// 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);
// --------- 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();
class Constant;
class BasicBlock;
-class Method;
+class Function;
class InstrTreeNode;
class InstrForest;
std::hash_set<InstructionNode*> treeRoots;
public:
- /*ctor*/ InstrForest (Method *M);
+ /*ctor*/ InstrForest (Function *F);
/*dtor*/ ~InstrForest ();
inline InstructionNode *getTreeNodeForInstr(Instruction* instr) {
#define LLVM_CODEGEN_INSTR_SELECTION_H
#include "llvm/Instruction.h"
-class Method;
+class Function;
class InstrForest;
class MachineInstr;
class InstructionNode;
// Implemented in machine-specific instruction selection file.
//---------------------------------------------------------------------------
-bool SelectInstructionsForMethod (Method* method,
+bool SelectInstructionsForMethod (Function* function,
TargetMachine &Target);
#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;
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
// 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.
#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;
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
// 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.
std::ostream& operator<< (std::ostream& os, const MachineOperand& mop);
-void PrintMachineInstructions(const Method *method);
+void PrintMachineInstructions(const Function *F);
//**************************************************************************/
#include <map>
class Value;
class BasicBlock;
-class Method;
+class Function;
class Module;
class AnalysisID;
class Pass;
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);
// 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.
// 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);
};
// 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.
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 &);
#include <map>
class Value;
class Module;
-class Method;
+class Function;
class MethodArgument;
class BasicBlock;
class Instruction;
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!
// 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:
class TargetMachine;
class Value;
class Instruction;
-class Method;
+class Function;
//---------------------------------------------------------------------------
// Data types used to define information about a single machine instruction
// 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,
// 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,
// `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,
// create copy instruction(s)
virtual void CreateCopyInstructionsByType(const TargetMachine& target,
- Method* method,
+ Function* method,
Value* src,
Instruction* dest,
std::vector<MachineInstr*>& minstrVec)
class TargetMachine;
class Value;
class Instruction;
-class Method;
+class Function;
//---------------------------------------------------------------------------
// Data types used to define information about a single machine instruction
// 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,
// 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,
// `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,
// create copy instruction(s)
virtual void CreateCopyInstructionsByType(const TargetMachine& target,
- Method* method,
+ Function* method,
Value* src,
Instruction* dest,
std::vector<MachineInstr*>& minstrVec)
class Type;
class Value;
class LiveRangeInfo;
-class Method;
+class Function;
class Instruction;
class LiveRange;
class AddedInstrns;
// 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,
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,
// 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.
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,
//
// 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; }
class Instruction;
class BasicBlock;
class GlobalValue;
-class Method;
+class Function;
+typedef Function Method;
class GlobalVariable;
class Module;
class SymbolTable;
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) {
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;
// 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());
#include "llvm/Analysis/LiveVar/ValueSet.h"
#include "llvm/Annotation.h"
#include <map>
-class Method;
class BasicBlock;
class Value;
LIBRARYNAME = analysis
-DIRS = LiveVar IPA
+DIRS = LiveVar IPA DataStructure
include $(LEVEL)/Makefile.common
#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...
#include <map>
class Value;
class Module;
-class Method;
+class Function;
class MethodArgument;
class BasicBlock;
class Instruction;
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!
// 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:
class Instruction;
class TerminatorInst;
class BasicBlock;
-class Method;
+class Function;
class TargetMachine;
class SchedGraphEdge;
class SchedGraphNode;
private std::hash_map<const BasicBlock*, SchedGraph*>
{
private:
- const Method* method;
+ const Function* method;
public:
typedef std::hash_map<const BasicBlock*, SchedGraph*> map_base;
using map_base::const_iterator;
public:
- /*ctor*/ SchedGraphSet (const Method* _method,
+ /*ctor*/ SchedGraphSet (const Function * function,
const TargetMachine& target);
/*dtor*/ ~SchedGraphSet ();
//
// Graph builder
//
- void buildGraphsForMethod (const Method *method,
+ void buildGraphsForMethod (const Function *F,
const TargetMachine& target);
};
#include <list>
#include <ext/hash_set>
#include <iostream>
-class Method;
+class Function;
class MachineInstr;
class SchedulingManager;
class MethodLiveVarInfo;
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.
-//===-- 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.
class MachineRegInfo;
class TargetMachine;
class Value;
-class Method;
+class Function;
class Instruction;
typedef std::hash_map<const Value*, LiveRange*> LiveRangeMapType;
//----------------------------------------------------------------------------
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
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);
class Instruction;
class TerminatorInst;
class BasicBlock;
-class Method;
+class Function;
class TargetMachine;
class SchedGraphEdge;
class SchedGraphNode;
private std::hash_map<const BasicBlock*, SchedGraph*>
{
private:
- const Method* method;
+ const Function* method;
public:
typedef std::hash_map<const BasicBlock*, SchedGraph*> map_base;
using map_base::const_iterator;
public:
- /*ctor*/ SchedGraphSet (const Method* _method,
+ /*ctor*/ SchedGraphSet (const Function * function,
const TargetMachine& target);
/*dtor*/ ~SchedGraphSet ();
//
// Graph builder
//
- void buildGraphsForMethod (const Method *method,
+ void buildGraphsForMethod (const Function *F,
const TargetMachine& target);
};
#include <list>
#include <ext/hash_set>
#include <iostream>
-class Method;
+class Function;
class MachineInstr;
class SchedulingManager;
class MethodLiveVarInfo;
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.
#include "llvm/Analysis/LiveVar/ValueSet.h"
#include "llvm/Annotation.h"
#include <map>
-class Method;
class BasicBlock;
class Value;
-//===-- 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.
class MachineRegInfo;
class TargetMachine;
class Value;
-class Method;
+class Function;
class Instruction;
typedef std::hash_map<const Value*, LiveRange*> LiveRangeMapType;
//----------------------------------------------------------------------------
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
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);
#include "llvm/iOperators.h"
#include "llvm/iPHINode.h"
-class Method;
using std::vector;
//get the code to be inserted on the edge
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!
}
// 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!");
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();
}
// 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));
}
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;
//===----------------------------------------------------------------------===//
-// 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;
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);
};
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;
}
-// 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);
projects / oota-llvm.git / commitdiff