change passing ScheduleDAG with ScheduleDAGInstrs when creating HazaradRec

[atheel.ma]

Summary

• let CreateTargetMIHazardRecognizer and CreateTargetPostRAHazardRecognizer to use ScheduleDAGInstrs instead of ScheduleDAG.

this way we will be able to use AliasAnalysis inside the HazaradRec

[atrick]

Fine with me. I don't know if it's possible anyone still uses ScoreBoardHazardRecognizer with SelectionDAG scheduler, but they really need to stop doing that.

[atheel.ma]

thanks,
I dont have commit permissions:

Permission to llvm-mirror/llvm.git denied to atheelm

[dmgreen]

include/llvm/CodeGen/TargetInstrInfo.h

54

Nit: two semicolons

[atheel.ma]

removed extra ";"

[atheel.ma]

two semicolons: fixed

[atheel.ma]

anyone can push it please?

include/llvm/CodeGen/ScoreboardHazardRecognizer.h

 #include "llvm/CodeGen/ScheduleHazardRecognizer.h"
 #include <cassert>
 #include <cstddef>
 #include <cstring>
 
 namespace llvm {
 
 class InstrItineraryData;
-class ScheduleDAG;
+class ScheduleDAGInstrs;
 class SUnit;
 
 class ScoreboardHazardRecognizer : public ScheduleHazardRecognizer {
   // Scoreboard to track function unit usage. Scoreboard[0] is a
   // mask of the FUs in use in the cycle currently being
   // schedule. Scoreboard[1] is a mask for the next cycle. The
   // Scoreboard is used as a circular buffer with the current cycle
   // indicated by Head.
class ScoreboardHazardRecognizer : public ScheduleHazardRecognizer {
 
   // Support for tracing ScoreboardHazardRecognizer as a component within
   // another module.
   const char *DebugType;
 
   // Itinerary data for the target.
   const InstrItineraryData *ItinData;
 
-  const ScheduleDAG *DAG;
+  const ScheduleDAGInstrs *DAG;
 
   /// IssueWidth - Max issue per cycle. 0=Unknown.
   unsigned IssueWidth = 0;
 
   /// IssueCount - Count instructions issued in this cycle.
   unsigned IssueCount = 0;
 
   Scoreboard ReservedScoreboard;
   Scoreboard RequiredScoreboard;
 
 public:
   ScoreboardHazardRecognizer(const InstrItineraryData *ItinData,
-                             const ScheduleDAG *DAG,
+                             const ScheduleDAGInstrs *DAG,
                              const char *ParentDebugType = "");
 
   /// atIssueLimit - Return true if no more instructions may be issued in this
   /// cycle.
   bool atIssueLimit() const override;
 
   // Stalls provides an cycle offset at which SU will be scheduled. It will be
   // negative for bottom-up scheduling.

include/llvm/CodeGen/TargetInstrInfo.h

 class MCAsmInfo;
 class MCInst;
 struct MCSchedModel;
 class Module;
 class ScheduleDAG;
 class ScheduleHazardRecognizer;
 class SDNode;
 class SelectionDAG;
+class ScheduleDAGInstrs;;
 class RegScavenger;
 class TargetRegisterClass;
 class TargetRegisterInfo;
 class TargetSchedModel;
 class TargetSubtargetInfo;
 
 template <class T> class SmallVectorImpl;
 
public:
   virtual ScheduleHazardRecognizer *
   CreateTargetHazardRecognizer(const TargetSubtargetInfo *STI,
                                const ScheduleDAG *DAG) const;
 
   /// Allocate and return a hazard recognizer to use for this target when
   /// scheduling the machine instructions before register allocation.
   virtual ScheduleHazardRecognizer *
   CreateTargetMIHazardRecognizer(const InstrItineraryData *,
-                                 const ScheduleDAG *DAG) const;
+                                 const ScheduleDAGInstrs *DAG) const;
 
   /// Allocate and return a hazard recognizer to use for this target when
   /// scheduling the machine instructions after register allocation.
   virtual ScheduleHazardRecognizer *
   CreateTargetPostRAHazardRecognizer(const InstrItineraryData *,
-                                     const ScheduleDAG *DAG) const;
+                                     const ScheduleDAGInstrs *DAG) const;
 
   /// Allocate and return a hazard recognizer to use for by non-scheduling
   /// passes.
   virtual ScheduleHazardRecognizer *
   CreateTargetPostRAHazardRecognizer(const MachineFunction &MF) const {
     return nullptr;
   }
 

lib/CodeGen/ScoreboardHazardRecognizer.cpp

 //===- ScoreboardHazardRecognizer.cpp - Scheduler Support -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the ScoreboardHazardRecognizer class, which
 // encapsultes hazard-avoidance heuristics for scheduling, based on the
 // scheduling itineraries specified for the target.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/ScoreboardHazardRecognizer.h"
-#include "llvm/CodeGen/ScheduleDAG.h"
+#include "llvm/CodeGen/ScheduleDAGInstrs.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCInstrItineraries.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 
 using namespace llvm;
 
 #define DEBUG_TYPE DebugType
 
 ScoreboardHazardRecognizer::ScoreboardHazardRecognizer(
-    const InstrItineraryData *II, const ScheduleDAG *SchedDAG,
+    const InstrItineraryData *II, const ScheduleDAGInstrs *SchedDAG,
     const char *ParentDebugType)
     : ScheduleHazardRecognizer(), DebugType(ParentDebugType), ItinData(II),
       DAG(SchedDAG) {
   (void)DebugType;
   // Determine the maximum depth of any itinerary. This determines the depth of
   // the scoreboard. We always make the scoreboard at least 1 cycle deep to
   // avoid dealing with the boundary condition.
   unsigned ScoreboardDepth = 1;

lib/CodeGen/TargetInstrInfo.cpp

CreateTargetHazardRecognizer(const TargetSubtargetInfo *STI,
                              const ScheduleDAG *DAG) const {
   // Dummy hazard recognizer allows all instructions to issue.
   return new ScheduleHazardRecognizer();
 }
 
 // Default implementation of CreateTargetMIHazardRecognizer.
 ScheduleHazardRecognizer *TargetInstrInfo::
 CreateTargetMIHazardRecognizer(const InstrItineraryData *II,
-                               const ScheduleDAG *DAG) const {
+                               const ScheduleDAGInstrs *DAG) const {
   return (ScheduleHazardRecognizer *)
     new ScoreboardHazardRecognizer(II, DAG, "misched");
 }
 
 // Default implementation of CreateTargetPostRAHazardRecognizer.
 ScheduleHazardRecognizer *TargetInstrInfo::
 CreateTargetPostRAHazardRecognizer(const InstrItineraryData *II,
-                                   const ScheduleDAG *DAG) const {
+                                   const ScheduleDAGInstrs *DAG) const {
   return (ScheduleHazardRecognizer *)
     new ScoreboardHazardRecognizer(II, DAG, "post-RA-sched");
 }
 
 //===----------------------------------------------------------------------===//
 //  SelectionDAG latency interface.
 //===----------------------------------------------------------------------===//