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

s/Method/Function

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2336 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2002-04-27 07:27:19 +00:00
parent 3b743f9fb3
commit 483e14ee04
24 changed files with 125 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -79,7 +79,7 @@ enum LiveVarDebugLevel_t {
extern cl::Enum<LiveVarDebugLevel_t> DEBUG_LV; extern cl::Enum<LiveVarDebugLevel_t> DEBUG_LV;
class MethodLiveVarInfo : public FunctionPass { class FunctionLiveVarInfo : public FunctionPass {
// Machine Instr to LiveVarSet Map for providing LVset BEFORE each inst // Machine Instr to LiveVarSet Map for providing LVset BEFORE each inst
std::map<const MachineInstr *, const ValueSet *> MInst2LVSetBI; std::map<const MachineInstr *, const ValueSet *> MInst2LVSetBI;
@ -103,7 +103,7 @@ class MethodLiveVarInfo : public FunctionPass {
public: public:
static AnalysisID ID; // We are an analysis, we must have an ID 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 ---------------------- // --------- Implement the FunctionPass interface ----------------------

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

@ -79,7 +79,7 @@ enum LiveVarDebugLevel_t {
extern cl::Enum<LiveVarDebugLevel_t> DEBUG_LV; extern cl::Enum<LiveVarDebugLevel_t> DEBUG_LV;
class MethodLiveVarInfo : public FunctionPass { class FunctionLiveVarInfo : public FunctionPass {
// Machine Instr to LiveVarSet Map for providing LVset BEFORE each inst // Machine Instr to LiveVarSet Map for providing LVset BEFORE each inst
std::map<const MachineInstr *, const ValueSet *> MInst2LVSetBI; std::map<const MachineInstr *, const ValueSet *> MInst2LVSetBI;
@ -103,7 +103,7 @@ class MethodLiveVarInfo : public FunctionPass {
public: public:
static AnalysisID ID; // We are an analysis, we must have an ID 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 ---------------------- // --------- Implement the FunctionPass interface ----------------------

2
lib/Analysis/LiveVar/BBLiveVar.cpp
View File

@ -5,7 +5,7 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "BBLiveVar.h" #include "BBLiveVar.h"
#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h"
#include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineInstr.h"
#include "llvm/BasicBlock.h" #include "llvm/BasicBlock.h"
#include "llvm/Support/CFG.h" #include "llvm/Support/CFG.h"

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

@ -5,7 +5,7 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h"
#include "BBLiveVar.h" #include "BBLiveVar.h"
#include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineInstr.h"
#include "llvm/BasicBlock.h" #include "llvm/BasicBlock.h"
@ -14,7 +14,7 @@
#include "Support/SetOperations.h" #include "Support/SetOperations.h"
#include <iostream> #include <iostream>
AnalysisID MethodLiveVarInfo::ID(AnalysisID::create<MethodLiveVarInfo>()); AnalysisID FunctionLiveVarInfo::ID(AnalysisID::create<FunctionLiveVarInfo>());
cl::Enum<LiveVarDebugLevel_t> DEBUG_LV("dlivevar", cl::NoFlags, cl::Enum<LiveVarDebugLevel_t> DEBUG_LV("dlivevar", cl::NoFlags,
"enable live-variable debugging information", "enable live-variable debugging information",
@ -28,12 +28,12 @@ cl::Enum<LiveVarDebugLevel_t> DEBUG_LV("dlivevar", cl::NoFlags,
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// gets OutSet of a BB // 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(); return BBLiveVar::GetFromBB(BB)->getOutSet();
} }
// gets InSet of a BB // 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(); return BBLiveVar::GetFromBB(BB)->getInSet();
} }
@ -42,7 +42,7 @@ const ValueSet &MethodLiveVarInfo::getInSetOfBB(const BasicBlock *BB) const {
// Performs live var analysis for a function // Performs live var analysis for a function
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
bool MethodLiveVarInfo::runOnFunction(Function *Meth) { bool FunctionLiveVarInfo::runOnFunction(Function *Meth) {
M = Meth; M = Meth;
if (DEBUG_LV) std::cerr << "Analysing live variables ...\n"; 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 // 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 unsigned int POId = 0; // Reverse Depth-first Order ID
for(po_iterator<const Function*> BBI = po_begin(M), BBE = po_end(M); for(po_iterator<const Function*> 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) // 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"; if (DEBUG_LV) std::cerr << "\n After Backward Pass " << iter << "...\n";
bool NeedAnotherIteration = false; 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(). // First remove all BBLiveVar annotations created in constructBBs().
if (M) if (M)
for (Function::const_iterator I = M->begin(), E = M->end(); I != E; ++I) for (Function::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
@ -163,7 +164,7 @@ void MethodLiveVarInfo::releaseMemory() {
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
const ValueSet & const ValueSet &
MethodLiveVarInfo::getLiveVarSetBeforeMInst(const MachineInstr *MInst, FunctionLiveVarInfo::getLiveVarSetBeforeMInst(const MachineInstr *MInst,
const BasicBlock *BB) { const BasicBlock *BB) {
if (const ValueSet *LVSet = MInst2LVSetBI[MInst]) { if (const ValueSet *LVSet = MInst2LVSetBI[MInst]) {
return *LVSet; // if found, just return the set return *LVSet; // if found, just return the set
@ -178,7 +179,7 @@ MethodLiveVarInfo::getLiveVarSetBeforeMInst(const MachineInstr *MInst,
// Gives live variable information after a machine instruction // Gives live variable information after a machine instruction
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
const ValueSet & const ValueSet &
MethodLiveVarInfo::getLiveVarSetAfterMInst(const MachineInstr *MI, FunctionLiveVarInfo::getLiveVarSetAfterMInst(const MachineInstr *MI,
const BasicBlock *BB) { const BasicBlock *BB) {
if (const ValueSet *LVSet = MInst2LVSetAI[MI]) { if (const ValueSet *LVSet = MInst2LVSetAI[MI]) {
@ -227,7 +228,7 @@ static void applyTranferFuncForMInst(ValueSet &LVS, const MachineInstr *MInst) {
// variable sets into a the caches (MInst2LVSetAI, MInst2LVSetBI) // 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(); const MachineCodeForBasicBlock &MIVec = BB->getMachineInstrVec();
if (DEBUG_LV >= LV_DEBUG_Instr) if (DEBUG_LV >= LV_DEBUG_Instr)

6
lib/Analysis/PostDominators.cpp
View File

@ -6,7 +6,7 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Analysis/Dominators.h" #include "llvm/Analysis/Dominators.h"
#include "llvm/Transforms/UnifyMethodExitNodes.h" #include "llvm/Transforms/UnifyFunctionExitNodes.h"
#include "llvm/Function.h" #include "llvm/Function.h"
#include "llvm/Support/CFG.h" #include "llvm/Support/CFG.h"
#include "Support/DepthFirstIterator.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. // that there can be at most one return instruction in the function left.
// Get it. // Get it.
// //
Root = getAnalysis<UnifyMethodExitNodes>().getExitNode(); Root = getAnalysis<UnifyFunctionExitNodes>().getExitNode();
if (Root == 0) { // No exit node for the function? Postdomsets are all empty 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) 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(); AU.setPreservesAll();
if (isPostDominator()) { if (isPostDominator()) {
AU.addProvided(PostDomID); AU.addProvided(PostDomID);
AU.addRequired(UnifyMethodExitNodes::ID); AU.addRequired(UnifyFunctionExitNodes::ID);
} else { } else {
AU.addProvided(ID); AU.addProvided(ID);
} }

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

@ -9,7 +9,7 @@
#include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineCodeForInstruction.h" #include "llvm/CodeGen/MachineCodeForInstruction.h"
#include "llvm/CodeGen/MachineCodeForMethod.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/Target/TargetMachine.h"
#include "llvm/BasicBlock.h" #include "llvm/BasicBlock.h"
#include "llvm/Instruction.h" #include "llvm/Instruction.h"
@ -1487,7 +1487,7 @@ namespace {
// getAnalysisUsage - We use LiveVarInfo... // getAnalysisUsage - We use LiveVarInfo...
virtual void getAnalysisUsage(AnalysisUsage &AU) const { virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired(MethodLiveVarInfo::ID); AU.addRequired(FunctionLiveVarInfo::ID);
} }
bool runOnFunction(Function *F); bool runOnFunction(Function *F);
@ -1521,7 +1521,7 @@ InstructionSchedulingWithSSA::runOnFunction(Function *M)
cerr << "\n*** TRACE OF INSTRUCTION SCHEDULING OPERATIONS\n\n"; cerr << "\n*** TRACE OF INSTRUCTION SCHEDULING OPERATIONS\n\n";
// expensive! // expensive!
SchedPriorities schedPrio(M, graph,getAnalysis<MethodLiveVarInfo>()); SchedPriorities schedPrio(M, graph,getAnalysis<FunctionLiveVarInfo>());
SchedulingManager S(target, graph, schedPrio); SchedulingManager S(target, graph, schedPrio);
ChooseInstructionsForDelaySlots(S, bb, graph); // modifies graph ChooseInstructionsForDelaySlots(S, bb, graph); // modifies graph

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

@ -19,14 +19,14 @@
//**************************************************************************/ //**************************************************************************/
#include "SchedPriorities.h" #include "SchedPriorities.h"
#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h"
#include "llvm/Support/CFG.h" #include "llvm/Support/CFG.h"
#include "Support/PostOrderIterator.h" #include "Support/PostOrderIterator.h"
#include <iostream> #include <iostream>
using std::cerr; using std::cerr;
SchedPriorities::SchedPriorities(const Function *, const SchedGraph *G, SchedPriorities::SchedPriorities(const Function *, const SchedGraph *G,
MethodLiveVarInfo &LVI) FunctionLiveVarInfo &LVI)
: curTime(0), graph(G), methodLiveVarInfo(LVI), : curTime(0), graph(G), methodLiveVarInfo(LVI),
nodeDelayVec(G->getNumNodes(), INVALID_LATENCY), // make errors obvious nodeDelayVec(G->getNumNodes(), INVALID_LATENCY), // make errors obvious
earliestForNode(G->getNumNodes(), 0), earliestForNode(G->getNumNodes(), 0),
@ -266,7 +266,7 @@ SchedPriorities::findSetWithMaxDelay(std::vector<candIndex>& mcands,
bool bool
SchedPriorities::instructionHasLastUse(MethodLiveVarInfo& methodLiveVarInfo, SchedPriorities::instructionHasLastUse(FunctionLiveVarInfo &LVI,
const SchedGraphNode* graphNode) { const SchedGraphNode* graphNode) {
const MachineInstr *MI = graphNode->getMachineInstr(); 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 // else check if instruction is a last use and save it in the hash_map
bool hasLastUse = false; bool hasLastUse = false;
const BasicBlock* bb = graphNode->getBB(); 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(); for (MachineInstr::const_val_op_iterator OI = MI->begin(), OE = MI->end();
OI != OE; ++OI) OI != OE; ++OI)

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

@ -31,7 +31,7 @@
class Function; class Function;
class MachineInstr; class MachineInstr;
class SchedulingManager; class SchedulingManager;
class MethodLiveVarInfo; class FunctionLiveVarInfo;
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// Debug option levels for instruction scheduling // Debug option levels for instruction scheduling
@ -127,7 +127,7 @@ private:
class SchedPriorities: public NonCopyable { class SchedPriorities: public NonCopyable {
public: public:
SchedPriorities(const Function *F, const SchedGraph *G, SchedPriorities(const Function *F, const SchedGraph *G,
MethodLiveVarInfo &LVI); FunctionLiveVarInfo &LVI);
// This must be called before scheduling begins. // This must be called before scheduling begins.
@ -157,7 +157,7 @@ private:
private: private:
cycles_t curTime; cycles_t curTime;
const SchedGraph* graph; const SchedGraph* graph;
MethodLiveVarInfo &methodLiveVarInfo; FunctionLiveVarInfo &methodLiveVarInfo;
std::hash_map<const MachineInstr*, bool> lastUseMap; std::hash_map<const MachineInstr*, bool> lastUseMap;
std::vector<cycles_t> nodeDelayVec; std::vector<cycles_t> nodeDelayVec;
std::vector<cycles_t> earliestForNode; std::vector<cycles_t> earliestForNode;
@ -180,7 +180,7 @@ private:
void initializeReadyHeap (const SchedGraph* graph); void initializeReadyHeap (const SchedGraph* graph);
bool instructionHasLastUse (MethodLiveVarInfo& methodLiveVarInfo, bool instructionHasLastUse (FunctionLiveVarInfo& LVI,
const SchedGraphNode* graphNode); const SchedGraphNode* graphNode);
// NOTE: The next two return references to the actual vector entries. // NOTE: The next two return references to the actual vector entries.

8
lib/CodeGen/RegAlloc/PhyRegAlloc.cpp
View File

@ -14,7 +14,7 @@
#include "llvm/CodeGen/PhyRegAlloc.h" #include "llvm/CodeGen/PhyRegAlloc.h"
#include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineCodeForMethod.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/Analysis/LoopInfo.h"
#include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetMachine.h"
#include "llvm/Target/MachineFrameInfo.h" #include "llvm/Target/MachineFrameInfo.h"
@ -50,7 +50,7 @@ namespace {
cerr << "\n******************** Function "<< F->getName() cerr << "\n******************** Function "<< F->getName()
<< " ********************\n"; << " ********************\n";
PhyRegAlloc PRA(F, Target, &getAnalysis<MethodLiveVarInfo>(), PhyRegAlloc PRA(F, Target, &getAnalysis<FunctionLiveVarInfo>(),
&getAnalysis<cfg::LoopInfo>()); &getAnalysis<cfg::LoopInfo>());
PRA.allocateRegisters(); PRA.allocateRegisters();
@ -60,7 +60,7 @@ namespace {
virtual void getAnalysisUsage(AnalysisUsage &AU) const { virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired(cfg::LoopInfo::ID); 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, PhyRegAlloc::PhyRegAlloc(Function *F,
const TargetMachine& tm, const TargetMachine& tm,
MethodLiveVarInfo *Lvi, FunctionLiveVarInfo *Lvi,
cfg::LoopInfo *LDC) cfg::LoopInfo *LDC)
: TM(tm), Meth(F), : TM(tm), Meth(F),
mcInfo(MachineCodeForMethod::get(F)), mcInfo(MachineCodeForMethod::get(F)),

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

@ -17,13 +17,13 @@
Register allocation must be done as: Register allocation must be done as:
MethodLiveVarInfo LVI(*MethodI ); // compute LV info FunctionLiveVarInfo LVI(*FunctionI ); // compute LV info
LVI.analyze(); LVI.analyze();
TargetMachine &target = .... TargetMachine &target = ....
PhyRegAlloc PRA(*MethodI, target, &LVI); // allocate regs PhyRegAlloc PRA(*FunctionI, target, &LVI); // allocate regs
PRA.allocateRegisters(); PRA.allocateRegisters();
*/ */
@ -35,7 +35,7 @@
#include <deque> #include <deque>
class MachineCodeForMethod; class MachineCodeForMethod;
class MachineRegInfo; class MachineRegInfo;
class MethodLiveVarInfo; class FunctionLiveVarInfo;
class MachineInstr; class MachineInstr;
namespace cfg { class LoopInfo; } namespace cfg { class LoopInfo; }
@ -70,7 +70,7 @@ class PhyRegAlloc: public NonCopyable {
const TargetMachine &TM; // target machine const TargetMachine &TM; // target machine
const Function *Meth; // name of the function we work on const Function *Meth; // name of the function we work on
MachineCodeForMethod &mcInfo; // descriptor for method's native code 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) // (already computed for BBs)
LiveRangeInfo LRI; // LR info (will be computed) LiveRangeInfo LRI; // LR info (will be computed)
const MachineRegInfo &MRI; // Machine Register information const MachineRegInfo &MRI; // Machine Register information
@ -84,7 +84,7 @@ class PhyRegAlloc: public NonCopyable {
// currently not used // currently not used
public: public:
PhyRegAlloc(Function *F, const TargetMachine& TM, MethodLiveVarInfo *Lvi, PhyRegAlloc(Function *F, const TargetMachine& TM, FunctionLiveVarInfo *Lvi,
cfg::LoopInfo *LoopDepthCalc); cfg::LoopInfo *LoopDepthCalc);
~PhyRegAlloc(); ~PhyRegAlloc();

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

@ -9,7 +9,7 @@
#include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineCodeForInstruction.h" #include "llvm/CodeGen/MachineCodeForInstruction.h"
#include "llvm/CodeGen/MachineCodeForMethod.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/Target/TargetMachine.h"
#include "llvm/BasicBlock.h" #include "llvm/BasicBlock.h"
#include "llvm/Instruction.h" #include "llvm/Instruction.h"
@ -1487,7 +1487,7 @@ namespace {
// getAnalysisUsage - We use LiveVarInfo... // getAnalysisUsage - We use LiveVarInfo...
virtual void getAnalysisUsage(AnalysisUsage &AU) const { virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired(MethodLiveVarInfo::ID); AU.addRequired(FunctionLiveVarInfo::ID);
} }
bool runOnFunction(Function *F); bool runOnFunction(Function *F);
@ -1521,7 +1521,7 @@ InstructionSchedulingWithSSA::runOnFunction(Function *M)
cerr << "\n*** TRACE OF INSTRUCTION SCHEDULING OPERATIONS\n\n"; cerr << "\n*** TRACE OF INSTRUCTION SCHEDULING OPERATIONS\n\n";
// expensive! // expensive!
SchedPriorities schedPrio(M, graph,getAnalysis<MethodLiveVarInfo>()); SchedPriorities schedPrio(M, graph,getAnalysis<FunctionLiveVarInfo>());
SchedulingManager S(target, graph, schedPrio); SchedulingManager S(target, graph, schedPrio);
ChooseInstructionsForDelaySlots(S, bb, graph); // modifies graph ChooseInstructionsForDelaySlots(S, bb, graph); // modifies graph

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

@ -19,14 +19,14 @@
//**************************************************************************/ //**************************************************************************/
#include "SchedPriorities.h" #include "SchedPriorities.h"
#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h"
#include "llvm/Support/CFG.h" #include "llvm/Support/CFG.h"
#include "Support/PostOrderIterator.h" #include "Support/PostOrderIterator.h"
#include <iostream> #include <iostream>
using std::cerr; using std::cerr;
SchedPriorities::SchedPriorities(const Function *, const SchedGraph *G, SchedPriorities::SchedPriorities(const Function *, const SchedGraph *G,
MethodLiveVarInfo &LVI) FunctionLiveVarInfo &LVI)
: curTime(0), graph(G), methodLiveVarInfo(LVI), : curTime(0), graph(G), methodLiveVarInfo(LVI),
nodeDelayVec(G->getNumNodes(), INVALID_LATENCY), // make errors obvious nodeDelayVec(G->getNumNodes(), INVALID_LATENCY), // make errors obvious
earliestForNode(G->getNumNodes(), 0), earliestForNode(G->getNumNodes(), 0),
@ -266,7 +266,7 @@ SchedPriorities::findSetWithMaxDelay(std::vector<candIndex>& mcands,
bool bool
SchedPriorities::instructionHasLastUse(MethodLiveVarInfo& methodLiveVarInfo, SchedPriorities::instructionHasLastUse(FunctionLiveVarInfo &LVI,
const SchedGraphNode* graphNode) { const SchedGraphNode* graphNode) {
const MachineInstr *MI = graphNode->getMachineInstr(); 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 // else check if instruction is a last use and save it in the hash_map
bool hasLastUse = false; bool hasLastUse = false;
const BasicBlock* bb = graphNode->getBB(); 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(); for (MachineInstr::const_val_op_iterator OI = MI->begin(), OE = MI->end();
OI != OE; ++OI) OI != OE; ++OI)

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

@ -31,7 +31,7 @@
class Function; class Function;
class MachineInstr; class MachineInstr;
class SchedulingManager; class SchedulingManager;
class MethodLiveVarInfo; class FunctionLiveVarInfo;
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// Debug option levels for instruction scheduling // Debug option levels for instruction scheduling
@ -127,7 +127,7 @@ private:
class SchedPriorities: public NonCopyable { class SchedPriorities: public NonCopyable {
public: public:
SchedPriorities(const Function *F, const SchedGraph *G, SchedPriorities(const Function *F, const SchedGraph *G,
MethodLiveVarInfo &LVI); FunctionLiveVarInfo &LVI);
// This must be called before scheduling begins. // This must be called before scheduling begins.
@ -157,7 +157,7 @@ private:
private: private:
cycles_t curTime; cycles_t curTime;
const SchedGraph* graph; const SchedGraph* graph;
MethodLiveVarInfo &methodLiveVarInfo; FunctionLiveVarInfo &methodLiveVarInfo;
std::hash_map<const MachineInstr*, bool> lastUseMap; std::hash_map<const MachineInstr*, bool> lastUseMap;
std::vector<cycles_t> nodeDelayVec; std::vector<cycles_t> nodeDelayVec;
std::vector<cycles_t> earliestForNode; std::vector<cycles_t> earliestForNode;
@ -180,7 +180,7 @@ private:
void initializeReadyHeap (const SchedGraph* graph); void initializeReadyHeap (const SchedGraph* graph);
bool instructionHasLastUse (MethodLiveVarInfo& methodLiveVarInfo, bool instructionHasLastUse (FunctionLiveVarInfo& LVI,
const SchedGraphNode* graphNode); const SchedGraphNode* graphNode);
// NOTE: The next two return references to the actual vector entries. // NOTE: The next two return references to the actual vector entries.

2
lib/Target/SparcV9/LiveVar/BBLiveVar.cpp
View File

@ -5,7 +5,7 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "BBLiveVar.h" #include "BBLiveVar.h"
#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h"
#include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineInstr.h"
#include "llvm/BasicBlock.h" #include "llvm/BasicBlock.h"
#include "llvm/Support/CFG.h" #include "llvm/Support/CFG.h"

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

@ -5,7 +5,7 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h"
#include "BBLiveVar.h" #include "BBLiveVar.h"
#include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineInstr.h"
#include "llvm/BasicBlock.h" #include "llvm/BasicBlock.h"
@ -14,7 +14,7 @@
#include "Support/SetOperations.h" #include "Support/SetOperations.h"
#include <iostream> #include <iostream>
AnalysisID MethodLiveVarInfo::ID(AnalysisID::create<MethodLiveVarInfo>()); AnalysisID FunctionLiveVarInfo::ID(AnalysisID::create<FunctionLiveVarInfo>());
cl::Enum<LiveVarDebugLevel_t> DEBUG_LV("dlivevar", cl::NoFlags, cl::Enum<LiveVarDebugLevel_t> DEBUG_LV("dlivevar", cl::NoFlags,
"enable live-variable debugging information", "enable live-variable debugging information",
@ -28,12 +28,12 @@ cl::Enum<LiveVarDebugLevel_t> DEBUG_LV("dlivevar", cl::NoFlags,
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// gets OutSet of a BB // 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(); return BBLiveVar::GetFromBB(BB)->getOutSet();
} }
// gets InSet of a BB // 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(); return BBLiveVar::GetFromBB(BB)->getInSet();
} }
@ -42,7 +42,7 @@ const ValueSet &MethodLiveVarInfo::getInSetOfBB(const BasicBlock *BB) const {
// Performs live var analysis for a function // Performs live var analysis for a function
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
bool MethodLiveVarInfo::runOnFunction(Function *Meth) { bool FunctionLiveVarInfo::runOnFunction(Function *Meth) {
M = Meth; M = Meth;
if (DEBUG_LV) std::cerr << "Analysing live variables ...\n"; 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 // 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 unsigned int POId = 0; // Reverse Depth-first Order ID
for(po_iterator<const Function*> BBI = po_begin(M), BBE = po_end(M); for(po_iterator<const Function*> 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) // 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"; if (DEBUG_LV) std::cerr << "\n After Backward Pass " << iter << "...\n";
bool NeedAnotherIteration = false; 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(). // First remove all BBLiveVar annotations created in constructBBs().
if (M) if (M)
for (Function::const_iterator I = M->begin(), E = M->end(); I != E; ++I) for (Function::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
@ -163,7 +164,7 @@ void MethodLiveVarInfo::releaseMemory() {
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
const ValueSet & const ValueSet &
MethodLiveVarInfo::getLiveVarSetBeforeMInst(const MachineInstr *MInst, FunctionLiveVarInfo::getLiveVarSetBeforeMInst(const MachineInstr *MInst,
const BasicBlock *BB) { const BasicBlock *BB) {
if (const ValueSet *LVSet = MInst2LVSetBI[MInst]) { if (const ValueSet *LVSet = MInst2LVSetBI[MInst]) {
return *LVSet; // if found, just return the set return *LVSet; // if found, just return the set
@ -178,7 +179,7 @@ MethodLiveVarInfo::getLiveVarSetBeforeMInst(const MachineInstr *MInst,
// Gives live variable information after a machine instruction // Gives live variable information after a machine instruction
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
const ValueSet & const ValueSet &
MethodLiveVarInfo::getLiveVarSetAfterMInst(const MachineInstr *MI, FunctionLiveVarInfo::getLiveVarSetAfterMInst(const MachineInstr *MI,
const BasicBlock *BB) { const BasicBlock *BB) {
if (const ValueSet *LVSet = MInst2LVSetAI[MI]) { if (const ValueSet *LVSet = MInst2LVSetAI[MI]) {
@ -227,7 +228,7 @@ static void applyTranferFuncForMInst(ValueSet &LVS, const MachineInstr *MInst) {
// variable sets into a the caches (MInst2LVSetAI, MInst2LVSetBI) // 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(); const MachineCodeForBasicBlock &MIVec = BB->getMachineInstrVec();
if (DEBUG_LV >= LV_DEBUG_Instr) if (DEBUG_LV >= LV_DEBUG_Instr)

8
lib/Target/SparcV9/RegAlloc/PhyRegAlloc.cpp
View File

@ -14,7 +14,7 @@
#include "llvm/CodeGen/PhyRegAlloc.h" #include "llvm/CodeGen/PhyRegAlloc.h"
#include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineCodeForMethod.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/Analysis/LoopInfo.h"
#include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetMachine.h"
#include "llvm/Target/MachineFrameInfo.h" #include "llvm/Target/MachineFrameInfo.h"
@ -50,7 +50,7 @@ namespace {
cerr << "\n******************** Function "<< F->getName() cerr << "\n******************** Function "<< F->getName()
<< " ********************\n"; << " ********************\n";
PhyRegAlloc PRA(F, Target, &getAnalysis<MethodLiveVarInfo>(), PhyRegAlloc PRA(F, Target, &getAnalysis<FunctionLiveVarInfo>(),
&getAnalysis<cfg::LoopInfo>()); &getAnalysis<cfg::LoopInfo>());
PRA.allocateRegisters(); PRA.allocateRegisters();
@ -60,7 +60,7 @@ namespace {
virtual void getAnalysisUsage(AnalysisUsage &AU) const { virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired(cfg::LoopInfo::ID); 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, PhyRegAlloc::PhyRegAlloc(Function *F,
const TargetMachine& tm, const TargetMachine& tm,
MethodLiveVarInfo *Lvi, FunctionLiveVarInfo *Lvi,
cfg::LoopInfo *LDC) cfg::LoopInfo *LDC)
: TM(tm), Meth(F), : TM(tm), Meth(F),
mcInfo(MachineCodeForMethod::get(F)), mcInfo(MachineCodeForMethod::get(F)),

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

@ -17,13 +17,13 @@
Register allocation must be done as: Register allocation must be done as:
MethodLiveVarInfo LVI(*MethodI ); // compute LV info FunctionLiveVarInfo LVI(*FunctionI ); // compute LV info
LVI.analyze(); LVI.analyze();
TargetMachine &target = .... TargetMachine &target = ....
PhyRegAlloc PRA(*MethodI, target, &LVI); // allocate regs PhyRegAlloc PRA(*FunctionI, target, &LVI); // allocate regs
PRA.allocateRegisters(); PRA.allocateRegisters();
*/ */
@ -35,7 +35,7 @@
#include <deque> #include <deque>
class MachineCodeForMethod; class MachineCodeForMethod;
class MachineRegInfo; class MachineRegInfo;
class MethodLiveVarInfo; class FunctionLiveVarInfo;
class MachineInstr; class MachineInstr;
namespace cfg { class LoopInfo; } namespace cfg { class LoopInfo; }
@ -70,7 +70,7 @@ class PhyRegAlloc: public NonCopyable {
const TargetMachine &TM; // target machine const TargetMachine &TM; // target machine
const Function *Meth; // name of the function we work on const Function *Meth; // name of the function we work on
MachineCodeForMethod &mcInfo; // descriptor for method's native code 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) // (already computed for BBs)
LiveRangeInfo LRI; // LR info (will be computed) LiveRangeInfo LRI; // LR info (will be computed)
const MachineRegInfo &MRI; // Machine Register information const MachineRegInfo &MRI; // Machine Register information
@ -84,7 +84,7 @@ class PhyRegAlloc: public NonCopyable {
// currently not used // currently not used
public: public:
PhyRegAlloc(Function *F, const TargetMachine& TM, MethodLiveVarInfo *Lvi, PhyRegAlloc(Function *F, const TargetMachine& TM, FunctionLiveVarInfo *Lvi,
cfg::LoopInfo *LoopDepthCalc); cfg::LoopInfo *LoopDepthCalc);
~PhyRegAlloc(); ~PhyRegAlloc();

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

@ -11,7 +11,7 @@
#include "llvm/CodeGen/MachineCodeForMethod.h" #include "llvm/CodeGen/MachineCodeForMethod.h"
#include "llvm/CodeGen/PhyRegAlloc.h" #include "llvm/CodeGen/PhyRegAlloc.h"
#include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineInstr.h"
#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h" #include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h"
#include "llvm/iTerminators.h" #include "llvm/iTerminators.h"
#include "llvm/iOther.h" #include "llvm/iOther.h"
#include "llvm/Function.h" #include "llvm/Function.h"

2
lib/Transforms/IPO/InlineSimple.cpp
View File

@ -18,7 +18,7 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Transforms/MethodInlining.h" #include "llvm/Transforms/FunctionInlining.h"
#include "llvm/Module.h" #include "llvm/Module.h"
#include "llvm/Function.h" #include "llvm/Function.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"

7
lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp
View File

@ -25,7 +25,7 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Transforms/Instrumentation/ProfilePaths.h" #include "llvm/Transforms/Instrumentation/ProfilePaths.h"
#include "llvm/Transforms/UnifyMethodExitNodes.h" #include "llvm/Transforms/UnifyFunctionExitNodes.h"
#include "llvm/Support/CFG.h" #include "llvm/Support/CFG.h"
#include "llvm/Function.h" #include "llvm/Function.h"
#include "llvm/BasicBlock.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 // entry and only one exit node for the function in the CFG of the function
// //
void ProfilePaths::getAnalysisUsage(AnalysisUsage &AU) const { void ProfilePaths::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired(UnifyMethodExitNodes::ID); AU.addRequired(UnifyFunctionExitNodes::ID);
} }
}; };
@ -68,8 +68,7 @@ static Node *findBB(std::set<Node *> &st, BasicBlock *BB){
//Per function pass for inserting counters and trigger code //Per function pass for inserting counters and trigger code
bool ProfilePaths::runOnFunction(Function *M){ bool ProfilePaths::runOnFunction(Function *M){
// Transform the cfg s.t. we have just one exit node // Transform the cfg s.t. we have just one exit node
BasicBlock *ExitNode = BasicBlock *ExitNode = getAnalysis<UnifyFunctionExitNodes>().getExitNode();
getAnalysis<UnifyMethodExitNodes>().getExitNode();
// iterating over BBs and making graph // iterating over BBs and making graph
std::set<Node *> nodes; std::set<Node *> nodes;

2
lib/Transforms/Utils/CloneFunction.cpp
View File

@ -7,7 +7,7 @@
#include "llvm/Instruction.h" #include "llvm/Instruction.h"
#include <map> #include <map>
// FIXME: This should be merged with MethodInlining // FIXME: This should be merged with FunctionInlining
// RemapInstruction - Convert the instruction operands from referencing the // RemapInstruction - Convert the instruction operands from referencing the
// current values into those specified by ValueMap. // current values into those specified by ValueMap.

6
lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
View File

@ -5,7 +5,7 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Transforms/UnifyMethodExitNodes.h" #include "llvm/Transforms/UnifyFunctionExitNodes.h"
#include "llvm/BasicBlock.h" #include "llvm/BasicBlock.h"
#include "llvm/Function.h" #include "llvm/Function.h"
#include "llvm/iTerminators.h" #include "llvm/iTerminators.h"
@ -13,7 +13,7 @@
#include "llvm/Type.h" #include "llvm/Type.h"
using std::vector; using std::vector;
AnalysisID UnifyMethodExitNodes::ID(AnalysisID::create<UnifyMethodExitNodes>()); AnalysisID UnifyFunctionExitNodes::ID(AnalysisID::create<UnifyFunctionExitNodes>());
// UnifyAllExitNodes - Unify all exit nodes of the CFG by creating a new // UnifyAllExitNodes - Unify all exit nodes of the CFG by creating a new
@ -22,7 +22,7 @@ AnalysisID UnifyMethodExitNodes::ID(AnalysisID::create<UnifyMethodExitNodes>());
// //
// If there are no return stmts in the Function, a null pointer is returned. // 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 // Loop over all of the blocks in a function, tracking all of the blocks that
// return. // return.
// //

6
lib/VMCore/Dominators.cpp
View File

@ -6,7 +6,7 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Analysis/Dominators.h" #include "llvm/Analysis/Dominators.h"
#include "llvm/Transforms/UnifyMethodExitNodes.h" #include "llvm/Transforms/UnifyFunctionExitNodes.h"
#include "llvm/Function.h" #include "llvm/Function.h"
#include "llvm/Support/CFG.h" #include "llvm/Support/CFG.h"
#include "Support/DepthFirstIterator.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. // that there can be at most one return instruction in the function left.
// Get it. // Get it.
// //
Root = getAnalysis<UnifyMethodExitNodes>().getExitNode(); Root = getAnalysis<UnifyFunctionExitNodes>().getExitNode();
if (Root == 0) { // No exit node for the function? Postdomsets are all empty 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) 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(); AU.setPreservesAll();
if (isPostDominator()) { if (isPostDominator()) {
AU.addProvided(PostDomID); AU.addProvided(PostDomID);
AU.addRequired(UnifyMethodExitNodes::ID); AU.addRequired(UnifyFunctionExitNodes::ID);
} else { } else {
AU.addProvided(ID); AU.addProvided(ID);
} }

6
tools/opt/opt.cpp
View File

@ -12,11 +12,11 @@
#include "llvm/Bytecode/WriteBytecodePass.h" #include "llvm/Bytecode/WriteBytecodePass.h"
#include "llvm/Assembly/PrintModulePass.h" #include "llvm/Assembly/PrintModulePass.h"
#include "llvm/Analysis/Verifier.h" #include "llvm/Analysis/Verifier.h"
#include "llvm/Transforms/UnifyMethodExitNodes.h" #include "llvm/Transforms/UnifyFunctionExitNodes.h"
#include "llvm/Transforms/ConstantMerge.h" #include "llvm/Transforms/ConstantMerge.h"
#include "llvm/Transforms/CleanupGCCOutput.h" #include "llvm/Transforms/CleanupGCCOutput.h"
#include "llvm/Transforms/LevelChange.h" #include "llvm/Transforms/LevelChange.h"
#include "llvm/Transforms/MethodInlining.h" #include "llvm/Transforms/FunctionInlining.h"
#include "llvm/Transforms/SymbolStripping.h" #include "llvm/Transforms/SymbolStripping.h"
#include "llvm/Transforms/ChangeAllocations.h" #include "llvm/Transforms/ChangeAllocations.h"
#include "llvm/Transforms/IPO/SimpleStructMutation.h" #include "llvm/Transforms/IPO/SimpleStructMutation.h"
@ -77,7 +77,7 @@ struct {
{ constmerge , createConstantMergePass }, { constmerge , createConstantMergePass },
{ strip , createSymbolStrippingPass }, { strip , createSymbolStrippingPass },
{ mstrip , createFullSymbolStrippingPass }, { mstrip , createFullSymbolStrippingPass },
{ mergereturn, createUnifyMethodExitNodesPass }, { mergereturn, createUnifyFunctionExitNodesPass },
{ indvars , createIndVarSimplifyPass }, { indvars , createIndVarSimplifyPass },
{ instcombine, createInstructionCombiningPass }, { instcombine, createInstructionCombiningPass },