return true;
}
-void FetchStage::postExecute(const InstRef &IR) { SM.updateNext(); }
+void FetchStage::postExecute() { SM.updateNext(); }
void FetchStage::cycleEnd() {
// Find the first instruction which hasn't been retired.
bool hasWorkToComplete() const override final;
bool execute(InstRef &IR) override final;
- void postExecute(const InstRef &IR) override final;
+ void postExecute() override final;
void cycleEnd() override final;
};
return true;
}
-void Pipeline::preExecuteStages(const InstRef &IR) {
+void Pipeline::preExecuteStages() {
for (const std::unique_ptr<Stage> &S : Stages)
- S->preExecute(IR);
+ S->preExecute();
}
-void Pipeline::postExecuteStages(const InstRef &IR) {
+void Pipeline::postExecuteStages() {
for (const std::unique_ptr<Stage> &S : Stages)
- S->postExecute(IR);
+ S->postExecute();
}
void Pipeline::run() {
// Continue executing this cycle until any stage claims it cannot make
// progress.
while (true) {
- preExecuteStages(IR);
+ preExecuteStages();
if (!executeStages(IR))
break;
- postExecuteStages(IR);
+ postExecuteStages();
}
for (auto &S : Stages)
std::set<HWEventListener *> Listeners;
unsigned Cycles;
- void preExecuteStages(const InstRef &IR);
+ void preExecuteStages();
bool executeStages(InstRef &IR);
- void postExecuteStages(const InstRef &IR);
+ void postExecuteStages();
void runCycle();
bool hasWorkToProcess();
/// Called prior to executing the list of stages.
/// This can be called multiple times per cycle.
- virtual void preExecute(const InstRef &IR) {}
+ virtual void preExecute() {}
/// Called as a cleanup and finalization phase after each execution.
/// This will only be called if all stages return a success from their
/// execute callback. This can be called multiple times per cycle.
- virtual void postExecute(const InstRef &IR) {}
+ virtual void postExecute() {}
/// The primary action that this stage performs.
/// Returning false prevents successor stages from having their 'execute'