[AMDGPU] Fix recorded region boundaries in max-occupancy scheduler

[rampitec]

Summary

This is incorrect to record region boundaries before scheduling,
it may change after scheduling. As a result second pass may see less
instructions to schedule than it should.

[vpykhtin]

This looks elegant, mine was longer :), thanks!

lib/Target/AMDGPU/GCNSchedStrategy.h

class GCNScheduleDAGMILive : public ScheduleDAGMILive {
 
   // Minimal real occupancy recorder for the function.
   unsigned MinOccupancy;
 
   // Scheduling stage number.
   unsigned Stage;
 
   // Vecor of regions recorder for later rescheduling
-  SmallVector<std::pair<const MachineBasicBlock::iterator,
-                        const MachineBasicBlock::iterator>, 32> Regions;
+  SmallVector<std::pair<MachineBasicBlock::iterator,
+                        MachineBasicBlock::iterator>, 32> Regions;
 
   // Region live-ins.
   DenseMap<unsigned, LaneBitmask> LiveIns;
 
   // Number of live-ins to the current region, first SGPR then VGPR.
   std::pair<unsigned, unsigned> LiveInPressure;
 
   // Collect current region live-ins.
   void discoverLiveIns();
 
   // Return current region pressure. First value is SGPR number, second is VGPR.
   std::pair<unsigned, unsigned> getRealRegPressure() const;
 
 public:
   GCNScheduleDAGMILive(MachineSchedContext *C,
                        std::unique_ptr<MachineSchedStrategy> S);
 
-  void enterRegion(MachineBasicBlock *bb,
-                   MachineBasicBlock::iterator begin,
-                   MachineBasicBlock::iterator end,
-                   unsigned regioninstrs) override;
-
   void schedule() override;
 
   void finalizeSchedule() override;
 };
 
 } // End namespace llvm
 
 #endif // GCNSCHEDSTRATEGY_H

lib/Target/AMDGPU/GCNSchedStrategy.cpp

GCNScheduleDAGMILive::GCNScheduleDAGMILive(MachineSchedContext *C,
   MFI(*MF.getInfo<SIMachineFunctionInfo>()),
   StartingOccupancy(ST.getOccupancyWithLocalMemSize(MFI.getLDSSize(),
                                                     *MF.getFunction())),
   MinOccupancy(StartingOccupancy), Stage(0) {
 
   DEBUG(dbgs() << "Starting occupancy is " << StartingOccupancy << ".\n");
 }
 
-void GCNScheduleDAGMILive::enterRegion(MachineBasicBlock *bb,
-                                       MachineBasicBlock::iterator begin,
-                                       MachineBasicBlock::iterator end,
-                                       unsigned regioninstrs) {
-  ScheduleDAGMILive::enterRegion(bb, begin, end, regioninstrs);
-
-  if (Stage == 0)
-    Regions.push_back(std::make_pair(begin, end));
-}
-
 void GCNScheduleDAGMILive::schedule() {
   std::vector<MachineInstr*> Unsched;
   Unsched.reserve(NumRegionInstrs);
   for (auto &I : *this)
     Unsched.push_back(&I);
 
   std::pair<unsigned, unsigned> PressureBefore;
   if (LIS) {
     DEBUG(dbgs() << "Pressure before scheduling:\n");
     discoverLiveIns();
     PressureBefore = getRealRegPressure();
   }
 
   ScheduleDAGMILive::schedule();
+  if (Stage == 0)
+    Regions.push_back(std::make_pair(RegionBegin, RegionEnd));
+
   if (!LIS)
     return;
 
   // Check the results of scheduling.
   GCNMaxOccupancySchedStrategy &S = (GCNMaxOccupancySchedStrategy&)*SchedImpl;
   DEBUG(dbgs() << "Pressure after scheduling:\n");
   auto PressureAfter = getRealRegPressure();
   LiveIns.clear();
if (ShouldTrackLaneMasks) {
       // Adjust for missing dead-def flags.
       RegOpers.detectDeadDefs(*MI, *LIS);
     }
     RegionEnd = MI->getIterator();
     ++RegionEnd;
     DEBUG(dbgs() << "Scheduling " << *MI);
   }
   RegionBegin = Unsched.front()->getIterator();
+  if (Stage == 0)
+    Regions.back() = std::make_pair(RegionBegin, RegionEnd);
 
   placeDebugValues();
 }
 
 static inline void setMask(const MachineRegisterInfo &MRI,
                            const SIRegisterInfo *SRI, unsigned Reg,
                            LaneBitmask &PrevMask, LaneBitmask NewMask,
                            unsigned &SGPRs, unsigned &VGPRs) {