include/llvm/CodeGen/ScheduleHazardRecognizer.h

   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 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 public:
  27   virtual ~ScheduleHazardRecognizer();
  28
  29   enum HazardType {
  30     NoHazard,      // This instruction can be emitted at this cycle.
  31     Hazard,        // This instruction can't be emitted at this cycle.
  32     NoopHazard     // This instruction can't be emitted, and needs noops.
  33   };
  34
  35   /// getHazardType - Return the hazard type of emitting this node.  There are
  36   /// three possible results.  Either:
  37   ///  * NoHazard: it is legal to issue this instruction on this cycle.
  38   ///  * Hazard: issuing this instruction would stall the machine.  If some
  39   ///     other instruction is available, issue it first.
  40   ///  * NoopHazard: issuing this instruction would break the program.  If
  41   ///     some other instruction can be issued, do so, otherwise issue a noop.
  42   virtual HazardType getHazardType(SUnit *) {
  43     return NoHazard;
  44   }
  45
  46   /// EmitInstruction - This callback is invoked when an instruction is
  47   /// emitted, to advance the hazard state.
  48   virtual void EmitInstruction(SUnit *) {}
  49
  50   /// AdvanceCycle - This callback is invoked when no instructions can be
  51   /// issued on this cycle without a hazard.  This should increment the
  52   /// internal state of the hazard recognizer so that previously "Hazard"
  53   /// instructions will now not be hazards.
  54   virtual void AdvanceCycle() {}
  55
  56   /// EmitNoop - This callback is invoked when a noop was added to the
  57   /// instruction stream.
  58   virtual void EmitNoop() {
  59     // Default implementation: count it as a cycle.
  60     AdvanceCycle();
  61   }
  62 };
  63
  64 }
  65
  66 #endif