#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/Target/TargetMachine.h"
#include "llvm/BasicBlock.h"
#include "SchedPriorities.h"
// are still in SSA form.
//---------------------------------------------------------------------------
-bool
-ScheduleInstructionsWithSSA(Method* method,
- const TargetMachine &target)
-{
- SchedGraphSet graphSet(method, target);
-
- if (SchedDebugLevel >= Sched_PrintSchedGraphs)
- {
- cerr << "\n*** SCHEDULING GRAPHS FOR INSTRUCTION SCHEDULING\n";
- graphSet.dump();
+namespace {
+ class InstructionSchedulingWithSSA : public MethodPass {
+ const TargetMachine &Target;
+ public:
+ inline InstructionSchedulingWithSSA(const TargetMachine &T) : Target(T) {}
+
+ // getAnalysisUsageInfo - We use LiveVarInfo...
+ virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
+ Pass::AnalysisSet &Destroyed,
+ Pass::AnalysisSet &Provided) {
+ Requires.push_back(MethodLiveVarInfo::ID);
}
+
+ bool runOnMethod(Method *M) {
+ cerr << "Instr scheduling failed for method " << ((Value*)M)->getName()
+ << "\n\n";
+ SchedGraphSet graphSet(M, Target);
- for (SchedGraphSet::const_iterator GI=graphSet.begin();
- GI != graphSet.end(); ++GI)
- {
- SchedGraph* graph = GI->second;
- const vector<const BasicBlock*>& bbvec = graph->getBasicBlocks();
- assert(bbvec.size() == 1 && "Cannot schedule multiple basic blocks");
- const BasicBlock* bb = bbvec[0];
-
- if (SchedDebugLevel >= Sched_PrintSchedTrace)
- cerr << "\n*** TRACE OF INSTRUCTION SCHEDULING OPERATIONS\n\n";
-
- SchedPriorities schedPrio(method, graph); // expensive!
- SchedulingManager S(target, graph, schedPrio);
-
- ChooseInstructionsForDelaySlots(S, bb, graph); // modifies graph
+ if (SchedDebugLevel >= Sched_PrintSchedGraphs) {
+ cerr << "\n*** SCHEDULING GRAPHS FOR INSTRUCTION SCHEDULING\n";
+ graphSet.dump();
+ }
+
+ for (SchedGraphSet::const_iterator GI=graphSet.begin();
+ GI != graphSet.end(); ++GI) {
+ SchedGraph* graph = GI->second;
+ const vector<const BasicBlock*> &bbvec = graph->getBasicBlocks();
+ assert(bbvec.size() == 1 && "Cannot schedule multiple basic blocks");
+ const BasicBlock* bb = bbvec[0];
- ForwardListSchedule(S); // computes schedule in S
+ if (SchedDebugLevel >= Sched_PrintSchedTrace)
+ cerr << "\n*** TRACE OF INSTRUCTION SCHEDULING OPERATIONS\n\n";
- RecordSchedule(GI->first, S); // records schedule in BB
- }
+ // expensive!
+ SchedPriorities schedPrio(M, graph, getAnalysis<MethodLiveVarInfo>());
+ SchedulingManager S(Target, graph, schedPrio);
+
+ ChooseInstructionsForDelaySlots(S, bb, graph); // modifies graph
+
+ ForwardListSchedule(S); // computes schedule in S
+
+ RecordSchedule(GI->first, S); // records schedule in BB
+ }
- if (SchedDebugLevel >= Sched_PrintMachineCode)
- {
- cerr << "\n*** Machine instructions after INSTRUCTION SCHEDULING\n";
- MachineCodeForMethod::get(method).dump();
- }
+ if (SchedDebugLevel >= Sched_PrintMachineCode) {
+ cerr << "\n*** Machine instructions after INSTRUCTION SCHEDULING\n";
+ MachineCodeForMethod::get(M).dump();
+ }
- return false; // no reason to fail yet
-}
-
+ return false;
+ }
+ };
+} // end anonymous namespace
+MethodPass *createInstructionSchedulingWithSSAPass(const TargetMachine &T) {
+ return new InstructionSchedulingWithSSA(T);
+}
//**************************************************************************/
#include "SchedPriorities.h"
+#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h"
#include "Support/PostOrderIterator.h"
#include <iostream>
using std::cerr;
-SchedPriorities::SchedPriorities(const Method* method,
- const SchedGraph* _graph)
- : curTime(0),
- graph(_graph),
- methodLiveVarInfo(method), // expensive!
- nodeDelayVec(_graph->getNumNodes(), INVALID_LATENCY), // make errors obvious
- earliestForNode(_graph->getNumNodes(), 0),
+SchedPriorities::SchedPriorities(const Method *method, const SchedGraph *G,
+ MethodLiveVarInfo &LVI)
+ : curTime(0), graph(G), methodLiveVarInfo(LVI),
+ nodeDelayVec(G->getNumNodes(), INVALID_LATENCY), // make errors obvious
+ earliestForNode(G->getNumNodes(), 0),
earliestReadyTime(0),
- nextToTry(candsAsHeap.begin())
-{
- methodLiveVarInfo.analyze();
+ nextToTry(candsAsHeap.begin()) {
computeDelays(graph);
}
#include "SchedGraph.h"
#include "llvm/CodeGen/InstrScheduling.h"
-#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h"
#include "llvm/Target/MachineSchedInfo.h"
#include "Support/CommandLine.h"
#include <list>
class Method;
class MachineInstr;
class SchedulingManager;
+class MethodLiveVarInfo;
//---------------------------------------------------------------------------
// Debug option levels for instruction scheduling
class SchedPriorities: public NonCopyable {
public:
- /*ctor*/ SchedPriorities (const Method* method,
- const SchedGraph* _graph);
+ SchedPriorities(const Method *M, const SchedGraph *G, MethodLiveVarInfo &LVI);
+
// This must be called before scheduling begins.
void initialize ();
private:
cycles_t curTime;
const SchedGraph* graph;
- MethodLiveVarInfo methodLiveVarInfo;
+ MethodLiveVarInfo &methodLiveVarInfo;
std::hash_map<const MachineInstr*, bool> lastUseMap;
std::vector<cycles_t> nodeDelayVec;
std::vector<cycles_t> earliestForNode;
#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/Target/TargetMachine.h"
#include "llvm/BasicBlock.h"
#include "SchedPriorities.h"
// are still in SSA form.
//---------------------------------------------------------------------------
-bool
-ScheduleInstructionsWithSSA(Method* method,
- const TargetMachine &target)
-{
- SchedGraphSet graphSet(method, target);
-
- if (SchedDebugLevel >= Sched_PrintSchedGraphs)
- {
- cerr << "\n*** SCHEDULING GRAPHS FOR INSTRUCTION SCHEDULING\n";
- graphSet.dump();
+namespace {
+ class InstructionSchedulingWithSSA : public MethodPass {
+ const TargetMachine &Target;
+ public:
+ inline InstructionSchedulingWithSSA(const TargetMachine &T) : Target(T) {}
+
+ // getAnalysisUsageInfo - We use LiveVarInfo...
+ virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
+ Pass::AnalysisSet &Destroyed,
+ Pass::AnalysisSet &Provided) {
+ Requires.push_back(MethodLiveVarInfo::ID);
}
+
+ bool runOnMethod(Method *M) {
+ cerr << "Instr scheduling failed for method " << ((Value*)M)->getName()
+ << "\n\n";
+ SchedGraphSet graphSet(M, Target);
- for (SchedGraphSet::const_iterator GI=graphSet.begin();
- GI != graphSet.end(); ++GI)
- {
- SchedGraph* graph = GI->second;
- const vector<const BasicBlock*>& bbvec = graph->getBasicBlocks();
- assert(bbvec.size() == 1 && "Cannot schedule multiple basic blocks");
- const BasicBlock* bb = bbvec[0];
-
- if (SchedDebugLevel >= Sched_PrintSchedTrace)
- cerr << "\n*** TRACE OF INSTRUCTION SCHEDULING OPERATIONS\n\n";
-
- SchedPriorities schedPrio(method, graph); // expensive!
- SchedulingManager S(target, graph, schedPrio);
-
- ChooseInstructionsForDelaySlots(S, bb, graph); // modifies graph
+ if (SchedDebugLevel >= Sched_PrintSchedGraphs) {
+ cerr << "\n*** SCHEDULING GRAPHS FOR INSTRUCTION SCHEDULING\n";
+ graphSet.dump();
+ }
+
+ for (SchedGraphSet::const_iterator GI=graphSet.begin();
+ GI != graphSet.end(); ++GI) {
+ SchedGraph* graph = GI->second;
+ const vector<const BasicBlock*> &bbvec = graph->getBasicBlocks();
+ assert(bbvec.size() == 1 && "Cannot schedule multiple basic blocks");
+ const BasicBlock* bb = bbvec[0];
- ForwardListSchedule(S); // computes schedule in S
+ if (SchedDebugLevel >= Sched_PrintSchedTrace)
+ cerr << "\n*** TRACE OF INSTRUCTION SCHEDULING OPERATIONS\n\n";
- RecordSchedule(GI->first, S); // records schedule in BB
- }
+ // expensive!
+ SchedPriorities schedPrio(M, graph, getAnalysis<MethodLiveVarInfo>());
+ SchedulingManager S(Target, graph, schedPrio);
+
+ ChooseInstructionsForDelaySlots(S, bb, graph); // modifies graph
+
+ ForwardListSchedule(S); // computes schedule in S
+
+ RecordSchedule(GI->first, S); // records schedule in BB
+ }
- if (SchedDebugLevel >= Sched_PrintMachineCode)
- {
- cerr << "\n*** Machine instructions after INSTRUCTION SCHEDULING\n";
- MachineCodeForMethod::get(method).dump();
- }
+ if (SchedDebugLevel >= Sched_PrintMachineCode) {
+ cerr << "\n*** Machine instructions after INSTRUCTION SCHEDULING\n";
+ MachineCodeForMethod::get(M).dump();
+ }
- return false; // no reason to fail yet
-}
-
+ return false;
+ }
+ };
+} // end anonymous namespace
+MethodPass *createInstructionSchedulingWithSSAPass(const TargetMachine &T) {
+ return new InstructionSchedulingWithSSA(T);
+}
//**************************************************************************/
#include "SchedPriorities.h"
+#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h"
#include "Support/PostOrderIterator.h"
#include <iostream>
using std::cerr;
-SchedPriorities::SchedPriorities(const Method* method,
- const SchedGraph* _graph)
- : curTime(0),
- graph(_graph),
- methodLiveVarInfo(method), // expensive!
- nodeDelayVec(_graph->getNumNodes(), INVALID_LATENCY), // make errors obvious
- earliestForNode(_graph->getNumNodes(), 0),
+SchedPriorities::SchedPriorities(const Method *method, const SchedGraph *G,
+ MethodLiveVarInfo &LVI)
+ : curTime(0), graph(G), methodLiveVarInfo(LVI),
+ nodeDelayVec(G->getNumNodes(), INVALID_LATENCY), // make errors obvious
+ earliestForNode(G->getNumNodes(), 0),
earliestReadyTime(0),
- nextToTry(candsAsHeap.begin())
-{
- methodLiveVarInfo.analyze();
+ nextToTry(candsAsHeap.begin()) {
computeDelays(graph);
}
#include "SchedGraph.h"
#include "llvm/CodeGen/InstrScheduling.h"
-#include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h"
#include "llvm/Target/MachineSchedInfo.h"
#include "Support/CommandLine.h"
#include <list>
class Method;
class MachineInstr;
class SchedulingManager;
+class MethodLiveVarInfo;
//---------------------------------------------------------------------------
// Debug option levels for instruction scheduling
class SchedPriorities: public NonCopyable {
public:
- /*ctor*/ SchedPriorities (const Method* method,
- const SchedGraph* _graph);
+ SchedPriorities(const Method *M, const SchedGraph *G, MethodLiveVarInfo &LVI);
+
// This must be called before scheduling begins.
void initialize ();
private:
cycles_t curTime;
const SchedGraph* graph;
- MethodLiveVarInfo methodLiveVarInfo;
+ MethodLiveVarInfo &methodLiveVarInfo;
std::hash_map<const MachineInstr*, bool> lastUseMap;
std::vector<cycles_t> nodeDelayVec;
std::vector<cycles_t> earliestForNode;