[AMDGPU] Use GCNRPTracker dumper methods in scheduler

[vpykhtin]

LGTM.

llvm/trunk/lib/Target/AMDGPU/GCNRegPressure.h

public:
   decltype(MaxPressure) moveMaxPressure() {
     auto Res = MaxPressure;
     MaxPressure.clear();
     return Res;
   }
   decltype(LiveRegs) moveLiveRegs() {
     return std::move(LiveRegs);
   }
+  static void printLiveRegs(raw_ostream &OS, const LiveRegSet& LiveRegs,
+                            const MachineRegisterInfo &MRI);
 };
 
 class GCNUpwardRPTracker : public GCNRPTracker {
 public:
   GCNUpwardRPTracker(const LiveIntervals &LIS_) : GCNRPTracker(LIS_) {}
   // reset tracker to the point just below MI
   // filling live regs upon this point using LIS
   void reset(const MachineInstr &MI, const LiveRegSet *LiveRegs = nullptr);

llvm/trunk/lib/Target/AMDGPU/GCNRegPressure.cpp

if (LISPressure != CurPressure) {
     CurPressure.print(dbgs());
     dbgs() << "LIS rpt: ";
     LISPressure.print(dbgs());
     return false;
   }
   return true;
 }
 
+void GCNRPTracker::printLiveRegs(raw_ostream &OS, const LiveRegSet& LiveRegs,
+                                 const MachineRegisterInfo &MRI) {
+  const TargetRegisterInfo *TRI = MRI.getTargetRegisterInfo();
+  for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) {
+    unsigned Reg = TargetRegisterInfo::index2VirtReg(I);
+    auto It = LiveRegs.find(Reg);
+    if (It != LiveRegs.end() && It->second.any())
+      OS << ' ' << PrintVRegOrUnit(Reg, TRI) << ':'
+         << PrintLaneMask(It->second);
+  }
+  OS << '\n';
+}
 #endif

llvm/trunk/lib/Target/AMDGPU/GCNSchedStrategy.cpp

void GCNScheduleDAGMILive::schedule() {
   Unsched.reserve(NumRegionInstrs);
   for (auto &I : *this)
     Unsched.push_back(&I);
 
   GCNRegPressure PressureBefore;
   if (LIS) {
     PressureBefore = Pressure[RegionIdx];
 
-    DEBUG(const SIRegisterInfo *SRI = static_cast<const SIRegisterInfo*>(TRI);
-          dbgs() << "Pressure before scheduling:\nRegion live-ins:";
-          for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) {
-            unsigned Reg = TargetRegisterInfo::index2VirtReg(I);
-            auto It = LiveIns[RegionIdx].find(Reg);
-            if (It != LiveIns[RegionIdx].end() && It->second.any())
-              dbgs() << ' ' << PrintVRegOrUnit(Reg, SRI) << ':'
-                     << PrintLaneMask(It->second);
-          }
-          auto P = llvm::getRegPressure(MRI, LiveIns[RegionIdx]);
-          dbgs() << "\nLive-in pressure:\nSGPR = " << P.getSGPRNum()
-                 << "\nVGPR = " << P.getVGPRNum()
-                 << "\nReal region's register pressure:\nSGPR = "
-                 << PressureBefore.getSGPRNum()
-                 << "\nVGPR = " << PressureBefore.getVGPRNum() << '\n');
+    DEBUG(dbgs() << "Pressure before scheduling:\nRegion live-ins:";
+          GCNRPTracker::printLiveRegs(dbgs(), LiveIns[RegionIdx], MRI);
+          dbgs() << "Region live-in pressure:  ";
+          llvm::getRegPressure(MRI, LiveIns[RegionIdx]).print(dbgs());
+          dbgs() << "Region register pressure: ";
+          PressureBefore.print(dbgs()));
   }
 
   ScheduleDAGMILive::schedule();
   Regions[RegionIdx] = std::make_pair(RegionBegin, RegionEnd);
 
   if (!LIS)
     return;
 
   // Check the results of scheduling.
   GCNMaxOccupancySchedStrategy &S = (GCNMaxOccupancySchedStrategy&)*SchedImpl;
   auto PressureAfter = getRealRegPressure();
 
-  DEBUG(dbgs() << "Pressure after scheduling:\nSGPR = "
-               << PressureAfter.getSGPRNum()
-               << "\nVGPR = " << PressureAfter.getVGPRNum() << '\n');
+  DEBUG(dbgs() << "Pressure after scheduling: "; PressureAfter.print(dbgs()));
 
   if (PressureAfter.getSGPRNum() <= S.SGPRCriticalLimit &&
       PressureAfter.getVGPRNum() <= S.VGPRCriticalLimit) {
     Pressure[RegionIdx] = PressureAfter;
     DEBUG(dbgs() << "Pressure in desired limits, done.\n");
     return;
   }
   unsigned WavesAfter = getMaxWaves(PressureAfter.getSGPRNum(),