1//=- llvm/CodeGen/ScheduleHazardRecognizer.h - Scheduling Support -*- C++ -*-=//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the ScheduleHazardRecognizer class, which implements
11// hazard-avoidance heuristics for scheduling.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CODEGEN_SCHEDULEHAZARDRECOGNIZER_H
16#define LLVM_CODEGEN_SCHEDULEHAZARDRECOGNIZER_H
17
18namespace llvm {
19
20class SUnit;
21
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
24/// the hazard.
25class ScheduleHazardRecognizer {
26protected:
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;
32
33public:
34  ScheduleHazardRecognizer(): MaxLookAhead(0) {}
35  virtual ~ScheduleHazardRecognizer();
36
37  enum HazardType {
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.
41  };
42
43  unsigned getMaxLookAhead() const { return MaxLookAhead; }
44
45  bool isEnabled() const { return MaxLookAhead != 0; }
46
47  /// atIssueLimit - Return true if no more instructions may be issued in this
48  /// cycle.
49  ///
50  /// FIXME: remove this once MachineScheduler is the only client.
51  virtual bool atIssueLimit() const { return false; }
52
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) {
61    return NoHazard;
62  }
63
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() {}
68
69  /// EmitInstruction - This callback is invoked when an instruction is
70  /// emitted, to advance the hazard state.
71  virtual void EmitInstruction(SUnit *) {}
72
73  /// AdvanceCycle - This callback is invoked whenever the next top-down
74  /// instruction to be scheduled cannot issue in the current cycle, either
75  /// because of latency or resource conflicts.  This should increment the
76  /// internal state of the hazard recognizer so that previously "Hazard"
77  /// instructions will now not be hazards.
78  virtual void AdvanceCycle() {}
79
80  /// RecedeCycle - This callback is invoked whenever the next bottom-up
81  /// instruction to be scheduled cannot issue in the current cycle, either
82  /// because of latency or resource conflicts.
83  virtual void RecedeCycle() {}
84
85  /// EmitNoop - This callback is invoked when a noop was added to the
86  /// instruction stream.
87  virtual void EmitNoop() {
88    // Default implementation: count it as a cycle.
89    AdvanceCycle();
90  }
91};
92
93}
94
95#endif
96