Line data    Source code

       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     2927790 : 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     1300152 :   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           0 :   unsigned getMaxLookAhead() const { return MaxLookAhead; }
      45             : 
      46           0 :   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       21359 :   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    21435382 :   virtual HazardType getHazardType(SUnit *m, int Stalls = 0) {
      62    21435382 :     return NoHazard;
      63             :   }
      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     1312478 :   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      683664 :   virtual unsigned PreEmitNoops(SUnit *) {
      84      683664 :     return 0;
      85             :   }
      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             :   }
      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      878864 :   virtual bool ShouldPreferAnother(SUnit *) {
      97      878864 :     return false;
      98             :   }
      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             :     // 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