From 483e14ee0412a98db1fb0121528d8d621ae3dfdb Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sat, 27 Apr 2002 07:27:19 +0000 Subject: [PATCH] s/Method/Function git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2336 91177308-0d34-0410-b5e6-96231b3b80d8 --- .../Analysis/LiveVar/FunctionLiveVarInfo.h | 4 +- include/llvm/CodeGen/FunctionLiveVarInfo.h | 4 +- lib/Analysis/LiveVar/BBLiveVar.cpp | 2 +- lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp | 27 +++---- lib/Analysis/PostDominators.cpp | 6 +- lib/CodeGen/InstrSched/InstrScheduling.cpp | 6 +- lib/CodeGen/InstrSched/SchedPriorities.cpp | 8 +- lib/CodeGen/InstrSched/SchedPriorities.h | 8 +- lib/CodeGen/RegAlloc/PhyRegAlloc.cpp | 8 +- lib/CodeGen/RegAlloc/PhyRegAlloc.h | 10 +-- .../SparcV9/InstrSched/InstrScheduling.cpp | 6 +- .../SparcV9/InstrSched/SchedPriorities.cpp | 8 +- .../SparcV9/InstrSched/SchedPriorities.h | 8 +- lib/Target/SparcV9/LiveVar/BBLiveVar.cpp | 2 +- .../SparcV9/LiveVar/FunctionLiveVarInfo.cpp | 27 +++---- lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp | 8 +- lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h | 10 +-- lib/Target/SparcV9/SparcV9RegInfo.cpp | 2 +- lib/Transforms/IPO/InlineSimple.cpp | 2 +- .../ProfilePaths/ProfilePaths.cpp | 73 +++++++++---------- lib/Transforms/Utils/CloneFunction.cpp | 2 +- .../Utils/UnifyFunctionExitNodes.cpp | 6 +- lib/VMCore/Dominators.cpp | 6 +- tools/opt/opt.cpp | 6 +- 24 files changed, 125 insertions(+), 124 deletions(-) diff --git a/include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h b/include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h index eabae4bddcd..4f7db3fb88f 100644 --- a/include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h +++ b/include/llvm/Analysis/LiveVar/FunctionLiveVarInfo.h @@ -79,7 +79,7 @@ enum LiveVarDebugLevel_t { extern cl::Enum DEBUG_LV; -class MethodLiveVarInfo : public FunctionPass { +class FunctionLiveVarInfo : public FunctionPass { // Machine Instr to LiveVarSet Map for providing LVset BEFORE each inst std::map MInst2LVSetBI; @@ -103,7 +103,7 @@ class MethodLiveVarInfo : public FunctionPass { public: static AnalysisID ID; // We are an analysis, we must have an ID - MethodLiveVarInfo(AnalysisID id = ID) { assert(id == ID); } + FunctionLiveVarInfo(AnalysisID id = ID) { assert(id == ID); } // --------- Implement the FunctionPass interface ---------------------- diff --git a/include/llvm/CodeGen/FunctionLiveVarInfo.h b/include/llvm/CodeGen/FunctionLiveVarInfo.h index eabae4bddcd..4f7db3fb88f 100644 --- a/include/llvm/CodeGen/FunctionLiveVarInfo.h +++ b/include/llvm/CodeGen/FunctionLiveVarInfo.h @@ -79,7 +79,7 @@ enum LiveVarDebugLevel_t { extern cl::Enum DEBUG_LV; -class MethodLiveVarInfo : public FunctionPass { +class FunctionLiveVarInfo : public FunctionPass { // Machine Instr to LiveVarSet Map for providing LVset BEFORE each inst std::map MInst2LVSetBI; @@ -103,7 +103,7 @@ class MethodLiveVarInfo : public FunctionPass { public: static AnalysisID ID; // We are an analysis, we must have an ID - MethodLiveVarInfo(AnalysisID id = ID) { assert(id == ID); } + FunctionLiveVarInfo(AnalysisID id = ID) { assert(id == ID); } // --------- Implement the FunctionPass interface ---------------------- diff --git a/lib/Analysis/LiveVar/BBLiveVar.cpp b/lib/Analysis/LiveVar/BBLiveVar.cpp index 5217bf52a58..958f7d7c662 100644 --- a/lib/Analysis/LiveVar/BBLiveVar.cpp +++ b/lib/Analysis/LiveVar/BBLiveVar.cpp @@ -5,7 +5,7 @@ //===----------------------------------------------------------------------===// #include "BBLiveVar.h" -#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" +#include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" #include "llvm/CodeGen/MachineInstr.h" #include "llvm/BasicBlock.h" #include "llvm/Support/CFG.h" diff --git a/lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp b/lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp index 0518aef3b8c..58d4691b763 100644 --- a/lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp +++ b/lib/Analysis/LiveVar/FunctionLiveVarInfo.cpp @@ -5,7 +5,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" +#include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" #include "BBLiveVar.h" #include "llvm/CodeGen/MachineInstr.h" #include "llvm/BasicBlock.h" @@ -14,7 +14,7 @@ #include "Support/SetOperations.h" #include -AnalysisID MethodLiveVarInfo::ID(AnalysisID::create()); +AnalysisID FunctionLiveVarInfo::ID(AnalysisID::create()); cl::Enum DEBUG_LV("dlivevar", cl::NoFlags, "enable live-variable debugging information", @@ -28,12 +28,12 @@ cl::Enum DEBUG_LV("dlivevar", cl::NoFlags, //----------------------------------------------------------------------------- // gets OutSet of a BB -const ValueSet &MethodLiveVarInfo::getOutSetOfBB(const BasicBlock *BB) const { +const ValueSet &FunctionLiveVarInfo::getOutSetOfBB(const BasicBlock *BB) const { return BBLiveVar::GetFromBB(BB)->getOutSet(); } // gets InSet of a BB -const ValueSet &MethodLiveVarInfo::getInSetOfBB(const BasicBlock *BB) const { +const ValueSet &FunctionLiveVarInfo::getInSetOfBB(const BasicBlock *BB) const { return BBLiveVar::GetFromBB(BB)->getInSet(); } @@ -42,7 +42,7 @@ const ValueSet &MethodLiveVarInfo::getInSetOfBB(const BasicBlock *BB) const { // Performs live var analysis for a function //----------------------------------------------------------------------------- -bool MethodLiveVarInfo::runOnFunction(Function *Meth) { +bool FunctionLiveVarInfo::runOnFunction(Function *Meth) { M = Meth; if (DEBUG_LV) std::cerr << "Analysing live variables ...\n"; @@ -62,7 +62,7 @@ bool MethodLiveVarInfo::runOnFunction(Function *Meth) { // constructs BBLiveVars and init Def and In sets //----------------------------------------------------------------------------- -void MethodLiveVarInfo::constructBBs(const Function *M) { +void FunctionLiveVarInfo::constructBBs(const Function *M) { unsigned int POId = 0; // Reverse Depth-first Order ID for(po_iterator BBI = po_begin(M), BBE = po_end(M); @@ -94,7 +94,8 @@ void MethodLiveVarInfo::constructBBs(const Function *M) { // do one backward pass over the CFG (for iterative analysis) //----------------------------------------------------------------------------- -bool MethodLiveVarInfo::doSingleBackwardPass(const Function *M, unsigned iter) { +bool FunctionLiveVarInfo::doSingleBackwardPass(const Function *M, + unsigned iter) { if (DEBUG_LV) std::cerr << "\n After Backward Pass " << iter << "...\n"; bool NeedAnotherIteration = false; @@ -122,7 +123,7 @@ bool MethodLiveVarInfo::doSingleBackwardPass(const Function *M, unsigned iter) { } -void MethodLiveVarInfo::releaseMemory() { +void FunctionLiveVarInfo::releaseMemory() { // First remove all BBLiveVar annotations created in constructBBs(). if (M) for (Function::const_iterator I = M->begin(), E = M->end(); I != E; ++I) @@ -163,8 +164,8 @@ void MethodLiveVarInfo::releaseMemory() { //----------------------------------------------------------------------------- const ValueSet & -MethodLiveVarInfo::getLiveVarSetBeforeMInst(const MachineInstr *MInst, - const BasicBlock *BB) { +FunctionLiveVarInfo::getLiveVarSetBeforeMInst(const MachineInstr *MInst, + const BasicBlock *BB) { if (const ValueSet *LVSet = MInst2LVSetBI[MInst]) { return *LVSet; // if found, just return the set } else { @@ -178,8 +179,8 @@ MethodLiveVarInfo::getLiveVarSetBeforeMInst(const MachineInstr *MInst, // Gives live variable information after a machine instruction //----------------------------------------------------------------------------- const ValueSet & -MethodLiveVarInfo::getLiveVarSetAfterMInst(const MachineInstr *MI, - const BasicBlock *BB) { +FunctionLiveVarInfo::getLiveVarSetAfterMInst(const MachineInstr *MI, + const BasicBlock *BB) { if (const ValueSet *LVSet = MInst2LVSetAI[MI]) { return *LVSet; // if found, just return the set @@ -227,7 +228,7 @@ static void applyTranferFuncForMInst(ValueSet &LVS, const MachineInstr *MInst) { // variable sets into a the caches (MInst2LVSetAI, MInst2LVSetBI) //----------------------------------------------------------------------------- -void MethodLiveVarInfo::calcLiveVarSetsForBB(const BasicBlock *BB) { +void FunctionLiveVarInfo::calcLiveVarSetsForBB(const BasicBlock *BB) { const MachineCodeForBasicBlock &MIVec = BB->getMachineInstrVec(); if (DEBUG_LV >= LV_DEBUG_Instr) diff --git a/lib/Analysis/PostDominators.cpp b/lib/Analysis/PostDominators.cpp index 387b673f606..cf55ab5c372 100644 --- a/lib/Analysis/PostDominators.cpp +++ b/lib/Analysis/PostDominators.cpp @@ -6,7 +6,7 @@ //===----------------------------------------------------------------------===// #include "llvm/Analysis/Dominators.h" -#include "llvm/Transforms/UnifyMethodExitNodes.h" +#include "llvm/Transforms/UnifyFunctionExitNodes.h" #include "llvm/Function.h" #include "llvm/Support/CFG.h" #include "Support/DepthFirstIterator.h" @@ -85,7 +85,7 @@ void cfg::DominatorSet::calcPostDominatorSet(Function *M) { // that there can be at most one return instruction in the function left. // Get it. // - Root = getAnalysis().getExitNode(); + Root = getAnalysis().getExitNode(); if (Root == 0) { // No exit node for the function? Postdomsets are all empty for (Function::const_iterator MI = M->begin(), ME = M->end(); MI!=ME; ++MI) @@ -136,7 +136,7 @@ void cfg::DominatorSet::getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); if (isPostDominator()) { AU.addProvided(PostDomID); - AU.addRequired(UnifyMethodExitNodes::ID); + AU.addRequired(UnifyFunctionExitNodes::ID); } else { AU.addProvided(ID); } diff --git a/lib/CodeGen/InstrSched/InstrScheduling.cpp b/lib/CodeGen/InstrSched/InstrScheduling.cpp index adc8903541d..4c2a28c7882 100644 --- a/lib/CodeGen/InstrSched/InstrScheduling.cpp +++ b/lib/CodeGen/InstrSched/InstrScheduling.cpp @@ -9,7 +9,7 @@ #include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineCodeForInstruction.h" #include "llvm/CodeGen/MachineCodeForMethod.h" -#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" // FIXME: Remove when AnalysisUsage sets can be symbolic! +#include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" // FIXME: Remove when modularized better #include "llvm/Target/TargetMachine.h" #include "llvm/BasicBlock.h" #include "llvm/Instruction.h" @@ -1487,7 +1487,7 @@ namespace { // getAnalysisUsage - We use LiveVarInfo... virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequired(MethodLiveVarInfo::ID); + AU.addRequired(FunctionLiveVarInfo::ID); } bool runOnFunction(Function *F); @@ -1521,7 +1521,7 @@ InstructionSchedulingWithSSA::runOnFunction(Function *M) cerr << "\n*** TRACE OF INSTRUCTION SCHEDULING OPERATIONS\n\n"; // expensive! - SchedPriorities schedPrio(M, graph,getAnalysis()); + SchedPriorities schedPrio(M, graph,getAnalysis()); SchedulingManager S(target, graph, schedPrio); ChooseInstructionsForDelaySlots(S, bb, graph); // modifies graph diff --git a/lib/CodeGen/InstrSched/SchedPriorities.cpp b/lib/CodeGen/InstrSched/SchedPriorities.cpp index 02e50c0cc79..a4480e88657 100644 --- a/lib/CodeGen/InstrSched/SchedPriorities.cpp +++ b/lib/CodeGen/InstrSched/SchedPriorities.cpp @@ -19,14 +19,14 @@ //**************************************************************************/ #include "SchedPriorities.h" -#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" +#include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" #include "llvm/Support/CFG.h" #include "Support/PostOrderIterator.h" #include using std::cerr; SchedPriorities::SchedPriorities(const Function *, const SchedGraph *G, - MethodLiveVarInfo &LVI) + FunctionLiveVarInfo &LVI) : curTime(0), graph(G), methodLiveVarInfo(LVI), nodeDelayVec(G->getNumNodes(), INVALID_LATENCY), // make errors obvious earliestForNode(G->getNumNodes(), 0), @@ -266,7 +266,7 @@ SchedPriorities::findSetWithMaxDelay(std::vector& mcands, bool -SchedPriorities::instructionHasLastUse(MethodLiveVarInfo& methodLiveVarInfo, +SchedPriorities::instructionHasLastUse(FunctionLiveVarInfo &LVI, const SchedGraphNode* graphNode) { const MachineInstr *MI = graphNode->getMachineInstr(); @@ -278,7 +278,7 @@ SchedPriorities::instructionHasLastUse(MethodLiveVarInfo& methodLiveVarInfo, // else check if instruction is a last use and save it in the hash_map bool hasLastUse = false; const BasicBlock* bb = graphNode->getBB(); - const ValueSet &LVs = methodLiveVarInfo.getLiveVarSetBeforeMInst(MI, bb); + const ValueSet &LVs = LVI.getLiveVarSetBeforeMInst(MI, bb); for (MachineInstr::const_val_op_iterator OI = MI->begin(), OE = MI->end(); OI != OE; ++OI) diff --git a/lib/CodeGen/InstrSched/SchedPriorities.h b/lib/CodeGen/InstrSched/SchedPriorities.h index c76beadcb59..3f087d52249 100644 --- a/lib/CodeGen/InstrSched/SchedPriorities.h +++ b/lib/CodeGen/InstrSched/SchedPriorities.h @@ -31,7 +31,7 @@ class Function; class MachineInstr; class SchedulingManager; -class MethodLiveVarInfo; +class FunctionLiveVarInfo; //--------------------------------------------------------------------------- // Debug option levels for instruction scheduling @@ -127,7 +127,7 @@ private: class SchedPriorities: public NonCopyable { public: SchedPriorities(const Function *F, const SchedGraph *G, - MethodLiveVarInfo &LVI); + FunctionLiveVarInfo &LVI); // This must be called before scheduling begins. @@ -157,7 +157,7 @@ private: private: cycles_t curTime; const SchedGraph* graph; - MethodLiveVarInfo &methodLiveVarInfo; + FunctionLiveVarInfo &methodLiveVarInfo; std::hash_map lastUseMap; std::vector nodeDelayVec; std::vector earliestForNode; @@ -180,7 +180,7 @@ private: void initializeReadyHeap (const SchedGraph* graph); - bool instructionHasLastUse (MethodLiveVarInfo& methodLiveVarInfo, + bool instructionHasLastUse (FunctionLiveVarInfo& LVI, const SchedGraphNode* graphNode); // NOTE: The next two return references to the actual vector entries. diff --git a/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp b/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp index c22ede96b33..4f12d697b14 100644 --- a/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp +++ b/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp @@ -14,7 +14,7 @@ #include "llvm/CodeGen/PhyRegAlloc.h" #include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineCodeForMethod.h" -#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" +#include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" #include "llvm/Analysis/LoopInfo.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Target/MachineFrameInfo.h" @@ -50,7 +50,7 @@ namespace { cerr << "\n******************** Function "<< F->getName() << " ********************\n"; - PhyRegAlloc PRA(F, Target, &getAnalysis(), + PhyRegAlloc PRA(F, Target, &getAnalysis(), &getAnalysis()); PRA.allocateRegisters(); @@ -60,7 +60,7 @@ namespace { virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired(cfg::LoopInfo::ID); - AU.addRequired(MethodLiveVarInfo::ID); + AU.addRequired(FunctionLiveVarInfo::ID); } }; } @@ -74,7 +74,7 @@ Pass *getRegisterAllocator(TargetMachine &T) { //---------------------------------------------------------------------------- PhyRegAlloc::PhyRegAlloc(Function *F, const TargetMachine& tm, - MethodLiveVarInfo *Lvi, + FunctionLiveVarInfo *Lvi, cfg::LoopInfo *LDC) : TM(tm), Meth(F), mcInfo(MachineCodeForMethod::get(F)), diff --git a/lib/CodeGen/RegAlloc/PhyRegAlloc.h b/lib/CodeGen/RegAlloc/PhyRegAlloc.h index 5922497f11e..5cc01c67650 100644 --- a/lib/CodeGen/RegAlloc/PhyRegAlloc.h +++ b/lib/CodeGen/RegAlloc/PhyRegAlloc.h @@ -17,13 +17,13 @@ Register allocation must be done as: - MethodLiveVarInfo LVI(*MethodI ); // compute LV info + FunctionLiveVarInfo LVI(*FunctionI ); // compute LV info LVI.analyze(); TargetMachine &target = .... - PhyRegAlloc PRA(*MethodI, target, &LVI); // allocate regs + PhyRegAlloc PRA(*FunctionI, target, &LVI); // allocate regs PRA.allocateRegisters(); */ @@ -35,7 +35,7 @@ #include class MachineCodeForMethod; class MachineRegInfo; -class MethodLiveVarInfo; +class FunctionLiveVarInfo; class MachineInstr; namespace cfg { class LoopInfo; } @@ -70,7 +70,7 @@ class PhyRegAlloc: public NonCopyable { const TargetMachine &TM; // target machine 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 + FunctionLiveVarInfo *const LVI; // LV information for this method // (already computed for BBs) LiveRangeInfo LRI; // LR info (will be computed) const MachineRegInfo &MRI; // Machine Register information @@ -84,7 +84,7 @@ class PhyRegAlloc: public NonCopyable { // currently not used public: - PhyRegAlloc(Function *F, const TargetMachine& TM, MethodLiveVarInfo *Lvi, + PhyRegAlloc(Function *F, const TargetMachine& TM, FunctionLiveVarInfo *Lvi, cfg::LoopInfo *LoopDepthCalc); ~PhyRegAlloc(); diff --git a/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp b/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp index adc8903541d..4c2a28c7882 100644 --- a/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp +++ b/lib/Target/SparcV9/InstrSched/InstrScheduling.cpp @@ -9,7 +9,7 @@ #include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineCodeForInstruction.h" #include "llvm/CodeGen/MachineCodeForMethod.h" -#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" // FIXME: Remove when AnalysisUsage sets can be symbolic! +#include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" // FIXME: Remove when modularized better #include "llvm/Target/TargetMachine.h" #include "llvm/BasicBlock.h" #include "llvm/Instruction.h" @@ -1487,7 +1487,7 @@ namespace { // getAnalysisUsage - We use LiveVarInfo... virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequired(MethodLiveVarInfo::ID); + AU.addRequired(FunctionLiveVarInfo::ID); } bool runOnFunction(Function *F); @@ -1521,7 +1521,7 @@ InstructionSchedulingWithSSA::runOnFunction(Function *M) cerr << "\n*** TRACE OF INSTRUCTION SCHEDULING OPERATIONS\n\n"; // expensive! - SchedPriorities schedPrio(M, graph,getAnalysis()); + SchedPriorities schedPrio(M, graph,getAnalysis()); SchedulingManager S(target, graph, schedPrio); ChooseInstructionsForDelaySlots(S, bb, graph); // modifies graph diff --git a/lib/Target/SparcV9/InstrSched/SchedPriorities.cpp b/lib/Target/SparcV9/InstrSched/SchedPriorities.cpp index 02e50c0cc79..a4480e88657 100644 --- a/lib/Target/SparcV9/InstrSched/SchedPriorities.cpp +++ b/lib/Target/SparcV9/InstrSched/SchedPriorities.cpp @@ -19,14 +19,14 @@ //**************************************************************************/ #include "SchedPriorities.h" -#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" +#include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" #include "llvm/Support/CFG.h" #include "Support/PostOrderIterator.h" #include using std::cerr; SchedPriorities::SchedPriorities(const Function *, const SchedGraph *G, - MethodLiveVarInfo &LVI) + FunctionLiveVarInfo &LVI) : curTime(0), graph(G), methodLiveVarInfo(LVI), nodeDelayVec(G->getNumNodes(), INVALID_LATENCY), // make errors obvious earliestForNode(G->getNumNodes(), 0), @@ -266,7 +266,7 @@ SchedPriorities::findSetWithMaxDelay(std::vector& mcands, bool -SchedPriorities::instructionHasLastUse(MethodLiveVarInfo& methodLiveVarInfo, +SchedPriorities::instructionHasLastUse(FunctionLiveVarInfo &LVI, const SchedGraphNode* graphNode) { const MachineInstr *MI = graphNode->getMachineInstr(); @@ -278,7 +278,7 @@ SchedPriorities::instructionHasLastUse(MethodLiveVarInfo& methodLiveVarInfo, // else check if instruction is a last use and save it in the hash_map bool hasLastUse = false; const BasicBlock* bb = graphNode->getBB(); - const ValueSet &LVs = methodLiveVarInfo.getLiveVarSetBeforeMInst(MI, bb); + const ValueSet &LVs = LVI.getLiveVarSetBeforeMInst(MI, bb); for (MachineInstr::const_val_op_iterator OI = MI->begin(), OE = MI->end(); OI != OE; ++OI) diff --git a/lib/Target/SparcV9/InstrSched/SchedPriorities.h b/lib/Target/SparcV9/InstrSched/SchedPriorities.h index c76beadcb59..3f087d52249 100644 --- a/lib/Target/SparcV9/InstrSched/SchedPriorities.h +++ b/lib/Target/SparcV9/InstrSched/SchedPriorities.h @@ -31,7 +31,7 @@ class Function; class MachineInstr; class SchedulingManager; -class MethodLiveVarInfo; +class FunctionLiveVarInfo; //--------------------------------------------------------------------------- // Debug option levels for instruction scheduling @@ -127,7 +127,7 @@ private: class SchedPriorities: public NonCopyable { public: SchedPriorities(const Function *F, const SchedGraph *G, - MethodLiveVarInfo &LVI); + FunctionLiveVarInfo &LVI); // This must be called before scheduling begins. @@ -157,7 +157,7 @@ private: private: cycles_t curTime; const SchedGraph* graph; - MethodLiveVarInfo &methodLiveVarInfo; + FunctionLiveVarInfo &methodLiveVarInfo; std::hash_map lastUseMap; std::vector nodeDelayVec; std::vector earliestForNode; @@ -180,7 +180,7 @@ private: void initializeReadyHeap (const SchedGraph* graph); - bool instructionHasLastUse (MethodLiveVarInfo& methodLiveVarInfo, + bool instructionHasLastUse (FunctionLiveVarInfo& LVI, const SchedGraphNode* graphNode); // NOTE: The next two return references to the actual vector entries. diff --git a/lib/Target/SparcV9/LiveVar/BBLiveVar.cpp b/lib/Target/SparcV9/LiveVar/BBLiveVar.cpp index 5217bf52a58..958f7d7c662 100644 --- a/lib/Target/SparcV9/LiveVar/BBLiveVar.cpp +++ b/lib/Target/SparcV9/LiveVar/BBLiveVar.cpp @@ -5,7 +5,7 @@ //===----------------------------------------------------------------------===// #include "BBLiveVar.h" -#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" +#include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" #include "llvm/CodeGen/MachineInstr.h" #include "llvm/BasicBlock.h" #include "llvm/Support/CFG.h" diff --git a/lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp b/lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp index 0518aef3b8c..58d4691b763 100644 --- a/lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp +++ b/lib/Target/SparcV9/LiveVar/FunctionLiveVarInfo.cpp @@ -5,7 +5,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" +#include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" #include "BBLiveVar.h" #include "llvm/CodeGen/MachineInstr.h" #include "llvm/BasicBlock.h" @@ -14,7 +14,7 @@ #include "Support/SetOperations.h" #include -AnalysisID MethodLiveVarInfo::ID(AnalysisID::create()); +AnalysisID FunctionLiveVarInfo::ID(AnalysisID::create()); cl::Enum DEBUG_LV("dlivevar", cl::NoFlags, "enable live-variable debugging information", @@ -28,12 +28,12 @@ cl::Enum DEBUG_LV("dlivevar", cl::NoFlags, //----------------------------------------------------------------------------- // gets OutSet of a BB -const ValueSet &MethodLiveVarInfo::getOutSetOfBB(const BasicBlock *BB) const { +const ValueSet &FunctionLiveVarInfo::getOutSetOfBB(const BasicBlock *BB) const { return BBLiveVar::GetFromBB(BB)->getOutSet(); } // gets InSet of a BB -const ValueSet &MethodLiveVarInfo::getInSetOfBB(const BasicBlock *BB) const { +const ValueSet &FunctionLiveVarInfo::getInSetOfBB(const BasicBlock *BB) const { return BBLiveVar::GetFromBB(BB)->getInSet(); } @@ -42,7 +42,7 @@ const ValueSet &MethodLiveVarInfo::getInSetOfBB(const BasicBlock *BB) const { // Performs live var analysis for a function //----------------------------------------------------------------------------- -bool MethodLiveVarInfo::runOnFunction(Function *Meth) { +bool FunctionLiveVarInfo::runOnFunction(Function *Meth) { M = Meth; if (DEBUG_LV) std::cerr << "Analysing live variables ...\n"; @@ -62,7 +62,7 @@ bool MethodLiveVarInfo::runOnFunction(Function *Meth) { // constructs BBLiveVars and init Def and In sets //----------------------------------------------------------------------------- -void MethodLiveVarInfo::constructBBs(const Function *M) { +void FunctionLiveVarInfo::constructBBs(const Function *M) { unsigned int POId = 0; // Reverse Depth-first Order ID for(po_iterator BBI = po_begin(M), BBE = po_end(M); @@ -94,7 +94,8 @@ void MethodLiveVarInfo::constructBBs(const Function *M) { // do one backward pass over the CFG (for iterative analysis) //----------------------------------------------------------------------------- -bool MethodLiveVarInfo::doSingleBackwardPass(const Function *M, unsigned iter) { +bool FunctionLiveVarInfo::doSingleBackwardPass(const Function *M, + unsigned iter) { if (DEBUG_LV) std::cerr << "\n After Backward Pass " << iter << "...\n"; bool NeedAnotherIteration = false; @@ -122,7 +123,7 @@ bool MethodLiveVarInfo::doSingleBackwardPass(const Function *M, unsigned iter) { } -void MethodLiveVarInfo::releaseMemory() { +void FunctionLiveVarInfo::releaseMemory() { // First remove all BBLiveVar annotations created in constructBBs(). if (M) for (Function::const_iterator I = M->begin(), E = M->end(); I != E; ++I) @@ -163,8 +164,8 @@ void MethodLiveVarInfo::releaseMemory() { //----------------------------------------------------------------------------- const ValueSet & -MethodLiveVarInfo::getLiveVarSetBeforeMInst(const MachineInstr *MInst, - const BasicBlock *BB) { +FunctionLiveVarInfo::getLiveVarSetBeforeMInst(const MachineInstr *MInst, + const BasicBlock *BB) { if (const ValueSet *LVSet = MInst2LVSetBI[MInst]) { return *LVSet; // if found, just return the set } else { @@ -178,8 +179,8 @@ MethodLiveVarInfo::getLiveVarSetBeforeMInst(const MachineInstr *MInst, // Gives live variable information after a machine instruction //----------------------------------------------------------------------------- const ValueSet & -MethodLiveVarInfo::getLiveVarSetAfterMInst(const MachineInstr *MI, - const BasicBlock *BB) { +FunctionLiveVarInfo::getLiveVarSetAfterMInst(const MachineInstr *MI, + const BasicBlock *BB) { if (const ValueSet *LVSet = MInst2LVSetAI[MI]) { return *LVSet; // if found, just return the set @@ -227,7 +228,7 @@ static void applyTranferFuncForMInst(ValueSet &LVS, const MachineInstr *MInst) { // variable sets into a the caches (MInst2LVSetAI, MInst2LVSetBI) //----------------------------------------------------------------------------- -void MethodLiveVarInfo::calcLiveVarSetsForBB(const BasicBlock *BB) { +void FunctionLiveVarInfo::calcLiveVarSetsForBB(const BasicBlock *BB) { const MachineCodeForBasicBlock &MIVec = BB->getMachineInstrVec(); if (DEBUG_LV >= LV_DEBUG_Instr) diff --git a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp index c22ede96b33..4f12d697b14 100644 --- a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp +++ b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp @@ -14,7 +14,7 @@ #include "llvm/CodeGen/PhyRegAlloc.h" #include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineCodeForMethod.h" -#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" +#include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" #include "llvm/Analysis/LoopInfo.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Target/MachineFrameInfo.h" @@ -50,7 +50,7 @@ namespace { cerr << "\n******************** Function "<< F->getName() << " ********************\n"; - PhyRegAlloc PRA(F, Target, &getAnalysis(), + PhyRegAlloc PRA(F, Target, &getAnalysis(), &getAnalysis()); PRA.allocateRegisters(); @@ -60,7 +60,7 @@ namespace { virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired(cfg::LoopInfo::ID); - AU.addRequired(MethodLiveVarInfo::ID); + AU.addRequired(FunctionLiveVarInfo::ID); } }; } @@ -74,7 +74,7 @@ Pass *getRegisterAllocator(TargetMachine &T) { //---------------------------------------------------------------------------- PhyRegAlloc::PhyRegAlloc(Function *F, const TargetMachine& tm, - MethodLiveVarInfo *Lvi, + FunctionLiveVarInfo *Lvi, cfg::LoopInfo *LDC) : TM(tm), Meth(F), mcInfo(MachineCodeForMethod::get(F)), diff --git a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h index 5922497f11e..5cc01c67650 100644 --- a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h +++ b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h @@ -17,13 +17,13 @@ Register allocation must be done as: - MethodLiveVarInfo LVI(*MethodI ); // compute LV info + FunctionLiveVarInfo LVI(*FunctionI ); // compute LV info LVI.analyze(); TargetMachine &target = .... - PhyRegAlloc PRA(*MethodI, target, &LVI); // allocate regs + PhyRegAlloc PRA(*FunctionI, target, &LVI); // allocate regs PRA.allocateRegisters(); */ @@ -35,7 +35,7 @@ #include class MachineCodeForMethod; class MachineRegInfo; -class MethodLiveVarInfo; +class FunctionLiveVarInfo; class MachineInstr; namespace cfg { class LoopInfo; } @@ -70,7 +70,7 @@ class PhyRegAlloc: public NonCopyable { const TargetMachine &TM; // target machine 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 + FunctionLiveVarInfo *const LVI; // LV information for this method // (already computed for BBs) LiveRangeInfo LRI; // LR info (will be computed) const MachineRegInfo &MRI; // Machine Register information @@ -84,7 +84,7 @@ class PhyRegAlloc: public NonCopyable { // currently not used public: - PhyRegAlloc(Function *F, const TargetMachine& TM, MethodLiveVarInfo *Lvi, + PhyRegAlloc(Function *F, const TargetMachine& TM, FunctionLiveVarInfo *Lvi, cfg::LoopInfo *LoopDepthCalc); ~PhyRegAlloc(); diff --git a/lib/Target/SparcV9/SparcV9RegInfo.cpp b/lib/Target/SparcV9/SparcV9RegInfo.cpp index ad66a3482cd..ad0dd25685f 100644 --- a/lib/Target/SparcV9/SparcV9RegInfo.cpp +++ b/lib/Target/SparcV9/SparcV9RegInfo.cpp @@ -11,7 +11,7 @@ #include "llvm/CodeGen/MachineCodeForMethod.h" #include "llvm/CodeGen/PhyRegAlloc.h" #include "llvm/CodeGen/MachineInstr.h" -#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" +#include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h" #include "llvm/iTerminators.h" #include "llvm/iOther.h" #include "llvm/Function.h" diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp index fcb1e4fa40e..1581323bea1 100644 --- a/lib/Transforms/IPO/InlineSimple.cpp +++ b/lib/Transforms/IPO/InlineSimple.cpp @@ -18,7 +18,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Transforms/MethodInlining.h" +#include "llvm/Transforms/FunctionInlining.h" #include "llvm/Module.h" #include "llvm/Function.h" #include "llvm/Pass.h" diff --git a/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp b/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp index 860119e2068..b967db64c68 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp +++ b/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp @@ -25,7 +25,7 @@ //===----------------------------------------------------------------------===// #include "llvm/Transforms/Instrumentation/ProfilePaths.h" -#include "llvm/Transforms/UnifyMethodExitNodes.h" +#include "llvm/Transforms/UnifyFunctionExitNodes.h" #include "llvm/Support/CFG.h" #include "llvm/Function.h" #include "llvm/BasicBlock.h" @@ -45,7 +45,7 @@ class ProfilePaths: public FunctionPass { // entry and only one exit node for the function in the CFG of the function // void ProfilePaths::getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequired(UnifyMethodExitNodes::ID); + AU.addRequired(UnifyFunctionExitNodes::ID); } }; @@ -67,20 +67,19 @@ static Node *findBB(std::set &st, BasicBlock *BB){ //Per function pass for inserting counters and trigger code bool ProfilePaths::runOnFunction(Function *M){ - //Transform the cfg s.t. we have just one exit node - BasicBlock *ExitNode = - getAnalysis().getExitNode(); + // Transform the cfg s.t. we have just one exit node + BasicBlock *ExitNode = getAnalysis().getExitNode(); - //iterating over BBs and making graph + // iterating over BBs and making graph std::set nodes; std::set edges; Node *tmp; Node *exitNode, *startNode; - //The nodes must be uniquesly identified: - //That is, no two nodes must hav same BB* + // The nodes must be uniquesly identified: + // That is, no two nodes must hav same BB* - //First enter just nodes: later enter edges + // First enter just nodes: later enter edges for (Function::iterator BB = M->begin(), BE=M->end(); BB != BE; ++BB){ Node *nd=new Node(*BB); nodes.insert(nd); @@ -90,7 +89,7 @@ bool ProfilePaths::runOnFunction(Function *M){ startNode=nd; } - //now do it againto insert edges + // now do it againto insert edges for (Function::iterator BB = M->begin(), BE=M->end(); BB != BE; ++BB){ Node *nd=findBB(nodes, *BB); assert(nd && "No node for this edge!"); @@ -111,39 +110,39 @@ bool ProfilePaths::runOnFunction(Function *M){ BasicBlock *fr=M->front(); - //If only one BB, don't instrument + // If only one BB, don't instrument if (M->getBasicBlocks().size() == 1) { - //The graph is made acyclic: this is done - //by removing back edges for now, and adding them later on + // The graph is made acyclic: this is done + // by removing back edges for now, and adding them later on vector be; g.getBackEdges(be); #ifdef DEBUG_PATH_PROFILES cerr<<"Backedges:"<b is a back edge - //Then we add 2 back edges for it: - //1. from root->b (in vector stDummy) - //and 2. from a->exit (in vector exDummy) + // Now we need to reflect the effect of back edges + // This is done by adding dummy edges + // If a->b is a back edge + // Then we add 2 back edges for it: + // 1. from root->b (in vector stDummy) + // and 2. from a->exit (in vector exDummy) vector stDummy; vector exDummy; addDummyEdges(stDummy, exDummy, g, be); - //Now, every edge in the graph is assigned a weight - //This weight later adds on to assign path - //numbers to different paths in the graph - // All paths for now are acyclic, - //since no back edges in the graph now - //numPaths is the number of acyclic paths in the graph + // Now, every edge in the graph is assigned a weight + // This weight later adds on to assign path + // numbers to different paths in the graph + // All paths for now are acyclic, + // since no back edges in the graph now + // numPaths is the number of acyclic paths in the graph int numPaths=valueAssignmentToEdges(g); - //create instruction allocation r and count - //r is the variable that'll act like an accumulator - //all along the path, we just add edge values to r - //and at the end, r reflects the path number - //count is an array: count[x] would store - //the number of executions of path numbered x + // create instruction allocation r and count + // r is the variable that'll act like an accumulator + // all along the path, we just add edge values to r + // and at the end, r reflects the path number + // count is an array: count[x] would store + // the number of executions of path numbered x Instruction *rVar=new AllocaInst(PointerType::get(Type::IntTy), ConstantUInt::get(Type::UIntTy,1),"R"); @@ -152,14 +151,14 @@ bool ProfilePaths::runOnFunction(Function *M){ AllocaInst(PointerType::get(Type::IntTy), ConstantUInt::get(Type::UIntTy, numPaths), "Count"); - //insert initialization code in first (entry) BB - //this includes initializing r and count + // insert initialization code in first (entry) BB + // this includes initializing r and count insertInTopBB(M->getEntryNode(),numPaths, rVar, countVar); - //now process the graph: get path numbers, - //get increments along different paths, - //and assign "increments" and "updates" (to r and count) - //"optimally". Finally, insert llvm code along various edges + // now process the graph: get path numbers, + // get increments along different paths, + // and assign "increments" and "updates" (to r and count) + // "optimally". Finally, insert llvm code along various edges processGraph(g, rVar, countVar, be, stDummy, exDummy); } diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp index aa627979fb0..808ea48e673 100644 --- a/lib/Transforms/Utils/CloneFunction.cpp +++ b/lib/Transforms/Utils/CloneFunction.cpp @@ -7,7 +7,7 @@ #include "llvm/Instruction.h" #include -// FIXME: This should be merged with MethodInlining +// FIXME: This should be merged with FunctionInlining // RemapInstruction - Convert the instruction operands from referencing the // current values into those specified by ValueMap. diff --git a/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp b/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp index 9a3b52c49cf..0fa87f8e8d2 100644 --- a/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp +++ b/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp @@ -5,7 +5,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Transforms/UnifyMethodExitNodes.h" +#include "llvm/Transforms/UnifyFunctionExitNodes.h" #include "llvm/BasicBlock.h" #include "llvm/Function.h" #include "llvm/iTerminators.h" @@ -13,7 +13,7 @@ #include "llvm/Type.h" using std::vector; -AnalysisID UnifyMethodExitNodes::ID(AnalysisID::create()); +AnalysisID UnifyFunctionExitNodes::ID(AnalysisID::create()); // UnifyAllExitNodes - Unify all exit nodes of the CFG by creating a new @@ -22,7 +22,7 @@ AnalysisID UnifyMethodExitNodes::ID(AnalysisID::create()); // // If there are no return stmts in the Function, a null pointer is returned. // -bool UnifyMethodExitNodes::doit(Function *M, BasicBlock *&ExitNode) { +bool UnifyFunctionExitNodes::doit(Function *M, BasicBlock *&ExitNode) { // Loop over all of the blocks in a function, tracking all of the blocks that // return. // diff --git a/lib/VMCore/Dominators.cpp b/lib/VMCore/Dominators.cpp index 387b673f606..cf55ab5c372 100644 --- a/lib/VMCore/Dominators.cpp +++ b/lib/VMCore/Dominators.cpp @@ -6,7 +6,7 @@ //===----------------------------------------------------------------------===// #include "llvm/Analysis/Dominators.h" -#include "llvm/Transforms/UnifyMethodExitNodes.h" +#include "llvm/Transforms/UnifyFunctionExitNodes.h" #include "llvm/Function.h" #include "llvm/Support/CFG.h" #include "Support/DepthFirstIterator.h" @@ -85,7 +85,7 @@ void cfg::DominatorSet::calcPostDominatorSet(Function *M) { // that there can be at most one return instruction in the function left. // Get it. // - Root = getAnalysis().getExitNode(); + Root = getAnalysis().getExitNode(); if (Root == 0) { // No exit node for the function? Postdomsets are all empty for (Function::const_iterator MI = M->begin(), ME = M->end(); MI!=ME; ++MI) @@ -136,7 +136,7 @@ void cfg::DominatorSet::getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); if (isPostDominator()) { AU.addProvided(PostDomID); - AU.addRequired(UnifyMethodExitNodes::ID); + AU.addRequired(UnifyFunctionExitNodes::ID); } else { AU.addProvided(ID); } diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp index f9ef9edd3cc..2b6f8e32ef3 100644 --- a/tools/opt/opt.cpp +++ b/tools/opt/opt.cpp @@ -12,11 +12,11 @@ #include "llvm/Bytecode/WriteBytecodePass.h" #include "llvm/Assembly/PrintModulePass.h" #include "llvm/Analysis/Verifier.h" -#include "llvm/Transforms/UnifyMethodExitNodes.h" +#include "llvm/Transforms/UnifyFunctionExitNodes.h" #include "llvm/Transforms/ConstantMerge.h" #include "llvm/Transforms/CleanupGCCOutput.h" #include "llvm/Transforms/LevelChange.h" -#include "llvm/Transforms/MethodInlining.h" +#include "llvm/Transforms/FunctionInlining.h" #include "llvm/Transforms/SymbolStripping.h" #include "llvm/Transforms/ChangeAllocations.h" #include "llvm/Transforms/IPO/SimpleStructMutation.h" @@ -77,7 +77,7 @@ struct { { constmerge , createConstantMergePass }, { strip , createSymbolStrippingPass }, { mstrip , createFullSymbolStrippingPass }, - { mergereturn, createUnifyMethodExitNodesPass }, + { mergereturn, createUnifyFunctionExitNodesPass }, { indvars , createIndVarSimplifyPass }, { instcombine, createInstructionCombiningPass },