Coverage Report

Created: 2018-07-12 09:57

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/CodeGen/ScheduleHazardRecognizer.h
Line
Count
Source (jump to first uncovered line)
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
18
namespace llvm {
19
20
class MachineInstr;
21
class SUnit;
22
23
/// HazardRecognizer - This determines whether or not an instruction can be
24
/// issued this cycle, and whether or not a noop needs to be inserted to handle
25
/// the hazard.
26
class ScheduleHazardRecognizer {
27
protected:
28
  /// MaxLookAhead - Indicate the number of cycles in the scoreboard
29
  /// state. Important to restore the state after backtracking. Additionally,
30
  /// MaxLookAhead=0 identifies a fake recognizer, allowing the client to
31
  /// bypass virtual calls. Currently the PostRA scheduler ignores it.
32
  unsigned MaxLookAhead = 0;
33
34
public:
35
2.58M
  ScheduleHazardRecognizer() = default;
36
  virtual ~ScheduleHazardRecognizer();
37
38
  enum HazardType {
39
    NoHazard,      // This instruction can be emitted at this cycle.
40
    Hazard,        // This instruction can't be emitted at this cycle.
41
    NoopHazard     // This instruction can't be emitted, and needs noops.
42
  };
43
44
981k
  unsigned getMaxLookAhead() const { return MaxLookAhead; }
45
46
140M
  bool isEnabled() const { return MaxLookAhead != 0; }
47
48
  /// atIssueLimit - Return true if no more instructions may be issued in this
49
  /// cycle.
50
  ///
51
  /// FIXME: remove this once MachineScheduler is the only client.
52
21.6k
  virtual bool atIssueLimit() const { return false; }
53
54
  /// getHazardType - Return the hazard type of emitting this node.  There are
55
  /// three possible results.  Either:
56
  ///  * NoHazard: it is legal to issue this instruction on this cycle.
57
  ///  * Hazard: issuing this instruction would stall the machine.  If some
58
  ///     other instruction is available, issue it first.
59
  ///  * NoopHazard: issuing this instruction would break the program.  If
60
  ///     some other instruction can be issued, do so, otherwise issue a noop.
61
21.5M
  virtual HazardType getHazardType(SUnit *m, int Stalls = 0) {
62
21.5M
    return NoHazard;
63
21.5M
  }
64
65
  /// Reset - This callback is invoked when a new block of
66
  /// instructions is about to be schedule. The hazard state should be
67
  /// set to an initialized state.
68
1.71M
  virtual void Reset() {}
69
70
  /// EmitInstruction - This callback is invoked when an instruction is
71
  /// emitted, to advance the hazard state.
72
0
  virtual void EmitInstruction(SUnit *) {}
73
74
  /// This overload will be used when the hazard recognizer is being used
75
  /// by a non-scheduling pass, which does not use SUnits.
76
0
  virtual void EmitInstruction(MachineInstr *) {}
77
78
  /// PreEmitNoops - This callback is invoked prior to emitting an instruction.
79
  /// It should return the number of noops to emit prior to the provided
80
  /// instruction.
81
  /// Note: This is only used during PostRA scheduling. EmitNoop is not called
82
  /// for these noops.
83
425k
  virtual unsigned PreEmitNoops(SUnit *) {
84
425k
    return 0;
85
425k
  }
86
87
  /// This overload will be used when the hazard recognizer is being used
88
  /// by a non-scheduling pass, which does not use SUnits.
89
0
  virtual unsigned PreEmitNoops(MachineInstr *) {
90
0
    return 0;
91
0
  }
92
93
  /// ShouldPreferAnother - This callback may be invoked if getHazardType
94
  /// returns NoHazard. If, even though there is no hazard, it would be better to
95
  /// schedule another available instruction, this callback should return true.
96
599k
  virtual bool ShouldPreferAnother(SUnit *) {
97
599k
    return false;
98
599k
  }
99
100
  /// AdvanceCycle - This callback is invoked whenever the next top-down
101
  /// instruction to be scheduled cannot issue in the current cycle, either
102
  /// because of latency or resource conflicts.  This should increment the
103
  /// internal state of the hazard recognizer so that previously "Hazard"
104
  /// instructions will now not be hazards.
105
0
  virtual void AdvanceCycle() {}
106
107
  /// RecedeCycle - This callback is invoked whenever the next bottom-up
108
  /// instruction to be scheduled cannot issue in the current cycle, either
109
  /// because of latency or resource conflicts.
110
0
  virtual void RecedeCycle() {}
111
112
  /// EmitNoop - This callback is invoked when a noop was added to the
113
  /// instruction stream.
114
0
  virtual void EmitNoop() {
115
0
    // Default implementation: count it as a cycle.
116
0
    AdvanceCycle();
117
0
  }
118
};
119
120
} // end namespace llvm
121
122
#endif // LLVM_CODEGEN_SCHEDULEHAZARDRECOGNIZER_H