Coverage Report

Created: 2019-07-24 05:18

/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
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// This file implements the ScheduleHazardRecognizer class, which implements
10
// hazard-avoidance heuristics for scheduling.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_CODEGEN_SCHEDULEHAZARDRECOGNIZER_H
15
#define LLVM_CODEGEN_SCHEDULEHAZARDRECOGNIZER_H
16
17
namespace llvm {
18
19
class MachineInstr;
20
class 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.
25
class ScheduleHazardRecognizer {
26
protected:
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 = 0;
32
33
public:
34
2.17M
  ScheduleHazardRecognizer() = default;
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
1.39M
  unsigned getMaxLookAhead() const { return MaxLookAhead; }
44
45
134M
  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
21.4k
  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
18.4M
  virtual HazardType getHazardType(SUnit *m, int Stalls = 0) {
61
18.4M
    return NoHazard;
62
18.4M
  }
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
1.25M
  virtual void Reset() {}
68
69
  /// EmitInstruction - This callback is invoked when an instruction is
70
  /// emitted, to advance the hazard state.
71
0
  virtual void EmitInstruction(SUnit *) {}
72
73
  /// This overload will be used when the hazard recognizer is being used
74
  /// by a non-scheduling pass, which does not use SUnits.
75
0
  virtual void EmitInstruction(MachineInstr *) {}
76
77
  /// PreEmitNoops - This callback is invoked prior to emitting an instruction.
78
  /// It should return the number of noops to emit prior to the provided
79
  /// instruction.
80
  /// Note: This is only used during PostRA scheduling. EmitNoop is not called
81
  /// for these noops.
82
382k
  virtual unsigned PreEmitNoops(SUnit *) {
83
382k
    return 0;
84
382k
  }
85
86
  /// This overload will be used when the hazard recognizer is being used
87
  /// by a non-scheduling pass, which does not use SUnits.
88
0
  virtual unsigned PreEmitNoops(MachineInstr *) {
89
0
    return 0;
90
0
  }
91
92
  /// ShouldPreferAnother - This callback may be invoked if getHazardType
93
  /// returns NoHazard. If, even though there is no hazard, it would be better to
94
  /// schedule another available instruction, this callback should return true.
95
631k
  virtual bool ShouldPreferAnother(SUnit *) {
96
631k
    return false;
97
631k
  }
98
99
  /// AdvanceCycle - This callback is invoked whenever the next top-down
100
  /// instruction to be scheduled cannot issue in the current cycle, either
101
  /// because of latency or resource conflicts.  This should increment the
102
  /// internal state of the hazard recognizer so that previously "Hazard"
103
  /// instructions will now not be hazards.
104
0
  virtual void AdvanceCycle() {}
105
106
  /// RecedeCycle - This callback is invoked whenever the next bottom-up
107
  /// instruction to be scheduled cannot issue in the current cycle, either
108
  /// because of latency or resource conflicts.
109
0
  virtual void RecedeCycle() {}
110
111
  /// EmitNoop - This callback is invoked when a noop was added to the
112
  /// instruction stream.
113
0
  virtual void EmitNoop() {
114
0
    // Default implementation: count it as a cycle.
115
0
    AdvanceCycle();
116
0
  }
117
};
118
119
} // end namespace llvm
120
121
#endif // LLVM_CODEGEN_SCHEDULEHAZARDRECOGNIZER_H