1 //=- llvm/CodeGen/ScheduleHazardRecognizer.h - Scheduling Support -*- C++ -*-=//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the ScheduleHazardRecognizer class, which implements
11 // hazard-avoidance heuristics for scheduling.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_CODEGEN_SCHEDULEHAZARDRECOGNIZER_H
16 #define LLVM_CODEGEN_SCHEDULEHAZARDRECOGNIZER_H
22 /// HazardRecognizer - This determines whether or not an instruction can be
23 /// issued this cycle, and whether or not a noop needs to be inserted to handle
25 class ScheduleHazardRecognizer {
27 /// MaxLookAhead - Indicate the number of cycles in the scoreboard
28 /// state. Important to restore the state after backtracking. Additionally,
29 /// MaxLookAhead=0 identifies a fake recognizer, allowing the client to
30 /// bypass virtual calls. Currently the PostRA scheduler ignores it.
31 unsigned MaxLookAhead;
34 ScheduleHazardRecognizer(): MaxLookAhead(0) {}
35 virtual ~ScheduleHazardRecognizer();
38 NoHazard, // This instruction can be emitted at this cycle.
39 Hazard, // This instruction can't be emitted at this cycle.
40 NoopHazard // This instruction can't be emitted, and needs noops.
43 unsigned getMaxLookAhead() const { return MaxLookAhead; }
45 bool isEnabled() const { return MaxLookAhead != 0; }
47 /// atIssueLimit - Return true if no more instructions may be issued in this
50 /// FIXME: remove this once MachineScheduler is the only client.
51 virtual bool atIssueLimit() const { return false; }
53 /// getHazardType - Return the hazard type of emitting this node. There are
54 /// three possible results. Either:
55 /// * NoHazard: it is legal to issue this instruction on this cycle.
56 /// * Hazard: issuing this instruction would stall the machine. If some
57 /// other instruction is available, issue it first.
58 /// * NoopHazard: issuing this instruction would break the program. If
59 /// some other instruction can be issued, do so, otherwise issue a noop.
60 virtual HazardType getHazardType(SUnit *m, int Stalls = 0) {
64 /// Reset - This callback is invoked when a new block of
65 /// instructions is about to be schedule. The hazard state should be
66 /// set to an initialized state.
67 virtual void Reset() {}
69 /// EmitInstruction - This callback is invoked when an instruction is
70 /// emitted, to advance the hazard state.
71 virtual void EmitInstruction(SUnit *) {}
73 /// PreEmitNoops - This callback is invoked prior to emitting an instruction.
74 /// It should return the number of noops to emit prior to the provided
76 /// Note: This is only used during PostRA scheduling. EmitNoop is not called
78 virtual unsigned PreEmitNoops(SUnit *) {
82 /// ShouldPreferAnother - This callback may be invoked if getHazardType
83 /// returns NoHazard. If, even though there is no hazard, it would be better to
84 /// schedule another available instruction, this callback should return true.
85 virtual bool ShouldPreferAnother(SUnit *) {
89 /// AdvanceCycle - This callback is invoked whenever the next top-down
90 /// instruction to be scheduled cannot issue in the current cycle, either
91 /// because of latency or resource conflicts. This should increment the
92 /// internal state of the hazard recognizer so that previously "Hazard"
93 /// instructions will now not be hazards.
94 virtual void AdvanceCycle() {}
96 /// RecedeCycle - This callback is invoked whenever the next bottom-up
97 /// instruction to be scheduled cannot issue in the current cycle, either
98 /// because of latency or resource conflicts.
99 virtual void RecedeCycle() {}
101 /// EmitNoop - This callback is invoked when a noop was added to the
102 /// instruction stream.
103 virtual void EmitNoop() {
104 // Default implementation: count it as a cycle.