[NFC] Move current live interval from being a class member of InsertPointAnalysis to query interfaces argument

[wmi]

Summary

A following patch of http://reviews.llvm.org/D19884.

The patch move current live interval from being a class member of InsertPointAnalysis to its query interfaces argument, so the queries will be more independent and easier to use.

[MatzeB]

LGTM. Nitpick below.

lib/CodeGen/SplitKit.h

72

You should name the parameter MBB as you reference that in the comment.

[MatzeB]

You should also change the title to something like LastInsertPointAnalysis: Move current live interval from being a class member to query interfaces argument; NFC (the thing at the beginning should be the area of the compiler, the NFC usually comes last).

lib/CodeGen/InlineSpiller.cpp

 }
 
 /// Check BB to see if it is a possible target BB to place a hoisted spill,
 /// i.e., there should be a living sibling of OrigReg at the insert point.
 ///
 bool HoistSpillHelper::isSpillCandBB(unsigned OrigReg, VNInfo &OrigVNI,
                                      MachineBasicBlock &BB, unsigned &LiveReg) {
   SlotIndex Idx;
-  MachineBasicBlock::iterator MI = IPA.getLastInsertPointIter(BB);
+  LiveInterval &OrigLI = LIS.getInterval(OrigReg);
+  MachineBasicBlock::iterator MI = IPA.getLastInsertPointIter(OrigLI, BB);
   if (MI != BB.end())
     Idx = LIS.getInstructionIndex(*MI);
   else
     Idx = LIS.getMBBEndIdx(&BB).getPrevSlot();
   SmallSetVector<unsigned, 16> &Siblings = Virt2SiblingsMap[OrigReg];
   assert((LIS.getInterval(OrigReg)).getVNInfoAt(Idx) == &OrigVNI &&
          "Unexpected VNI");
 
if (!MRI.def_empty(Reg))
       Virt2SiblingsMap[Original].insert(Reg);
   }
 
   // Each entry in MergeableSpills contains a spill set with equal values.
   for (auto &Ent : MergeableSpills) {
     int Slot = Ent.first.first;
     unsigned OrigReg = SlotToOrigReg[Slot];
     LiveInterval &OrigLI = LIS.getInterval(OrigReg);
-    IPA.setInterval(&OrigLI);
     VNInfo *OrigVNI = Ent.first.second;
     SmallPtrSet<MachineInstr *, 16> &EqValSpills = Ent.second;
     if (Ent.second.empty())
       continue;
 
     DEBUG({
       dbgs() << "\nFor Slot" << Slot << " and VN" << OrigVNI->id << ":\n"
              << "Equal spills in BB: ";
for (auto &Ent : MergeableSpills) {
     if (!SpillsToIns.empty() || !SpillsToRm.empty())
       StackIntvl.MergeValueInAsValue(OrigLI, OrigVNI,
                                      StackIntvl.getValNumInfo(0));
 
     // Insert hoisted spills.
     for (auto const Insert : SpillsToIns) {
       MachineBasicBlock *BB = Insert.first;
       unsigned LiveReg = Insert.second;
-      MachineBasicBlock::iterator MI = IPA.getLastInsertPointIter(*BB);
+      MachineBasicBlock::iterator MI = IPA.getLastInsertPointIter(OrigLI, *BB);
       TII.storeRegToStackSlot(*BB, MI, LiveReg, false, Slot,
                               MRI.getRegClass(LiveReg), &TRI);
       LIS.InsertMachineInstrRangeInMaps(std::prev(MI), MI);
       ++NumSpills;
     }
 
     // Remove redundant spills or change them to dead instructions.
     NumSpills -= SpillsToRm.size();

lib/CodeGen/SplitKit.h

 class raw_ostream;
 
 /// Determines the latest safe point in a block in which we can insert a split,
 /// spill or other instruction related with CurLI.
 class LLVM_LIBRARY_VISIBILITY InsertPointAnalysis {
 private:
   const LiveIntervals &LIS;
 
-  /// Current LiveInterval for which to insert split or spill.
-  const LiveInterval *CurLI;
-
   /// Last legal insert point in each basic block in the current function.
   /// The first entry is the first terminator, the second entry is the
   /// last valid point to insert a split or spill for a variable that is
   /// live into a landing pad successor.
   SmallVector<std::pair<SlotIndex, SlotIndex>, 8> LastInsertPoint;
 
-  SlotIndex computeLastInsertPoint(const MachineBasicBlock &MBB);
+  SlotIndex computeLastInsertPoint(const LiveInterval &CurLI,
+                                   const MachineBasicBlock &MBB);
 
 public:
   InsertPointAnalysis(const LiveIntervals &lis, unsigned BBNum);
 
-  void setInterval(const LiveInterval *LI) { CurLI = LI; }
-
-  /// Return the base index of the last valid insert point in \pMBB.
-  SlotIndex getLastInsertPoint(const MachineBasicBlock &MBB) {
+  /// Return the base index of the last valid insert point for \pCurLI in \pMBB.
+  SlotIndex getLastInsertPoint(const LiveInterval &CurLI,
+                               const MachineBasicBlock &MBB) {
     unsigned Num = MBB.getNumber();
     // Inline the common simple case.
     if (LastInsertPoint[Num].first.isValid() &&
         !LastInsertPoint[Num].second.isValid())
       return LastInsertPoint[Num].first;
-    return computeLastInsertPoint(MBB);
+    return computeLastInsertPoint(CurLI, MBB);
   }
 
-  /// Returns the last insert point as an iterator.
-  MachineBasicBlock::iterator getLastInsertPointIter(MachineBasicBlock &);
+  /// Returns the last insert point as an iterator for \pCurLI in \pMBB.
+  MachineBasicBlock::iterator getLastInsertPointIter(const LiveInterval &CurLI,
+                                                     MachineBasicBlock &);
 };
 
 /// SplitAnalysis - Analyze a LiveInterval, looking for live range splitting
 /// opportunities.
 class LLVM_LIBRARY_VISIBILITY SplitAnalysis {
 public:
   const MachineFunction &MF;
   const VirtRegMap &VRM;
public:
   /// register class inflation if the instruction has a restricted register
   /// class.
   ///
   /// @param BI           The block to be isolated.
   /// @param SingleInstrs True when single instructions should be isolated.
   bool shouldSplitSingleBlock(const BlockInfo &BI, bool SingleInstrs) const;
 
   SlotIndex getLastSplitPoint(unsigned Num) {
-    return IPA.getLastInsertPoint(*MF.getBlockNumbered(Num));
+    return IPA.getLastInsertPoint(*CurLI, *MF.getBlockNumbered(Num));
   }
 
   MachineBasicBlock::iterator getLastSplitPointIter(MachineBasicBlock *BB) {
-    return IPA.getLastInsertPointIter(*BB);
+    return IPA.getLastInsertPointIter(*CurLI, *BB);
   }
 };
 
 
 /// SplitEditor - Edit machine code and LiveIntervals for live range
 /// splitting.
 ///
 /// - Create a SplitEditor from a SplitAnalysis.

lib/CodeGen/SplitKit.cpp

 STATISTIC(NumRepairs,  "Number of invalid live ranges repaired");
 
 //===----------------------------------------------------------------------===//
 //                     Last Insert Point Analysis
 //===----------------------------------------------------------------------===//
 
 InsertPointAnalysis::InsertPointAnalysis(const LiveIntervals &lis,
                                          unsigned BBNum)
-    : LIS(lis), CurLI(nullptr), LastInsertPoint(BBNum) {}
+    : LIS(lis), LastInsertPoint(BBNum) {}
 
 SlotIndex
-InsertPointAnalysis::computeLastInsertPoint(const MachineBasicBlock &MBB) {
+InsertPointAnalysis::computeLastInsertPoint(const LiveInterval &CurLI,
+                                            const MachineBasicBlock &MBB) {
   unsigned Num = MBB.getNumber();
   std::pair<SlotIndex, SlotIndex> &LIP = LastInsertPoint[Num];
   SlotIndex MBBEnd = LIS.getMBBEndIdx(&MBB);
 
   SmallVector<const MachineBasicBlock *, 1> EHPadSucessors;
   for (const MachineBasicBlock *SMBB : MBB.successors())
     if (SMBB->isEHPad())
       EHPadSucessors.push_back(SMBB);
if (!LIP.first.isValid()) {
     }
   }
 
   // If CurLI is live into a landing pad successor, move the last insert point
   // back to the call that may throw.
   if (!LIP.second)
     return LIP.first;
 
-  assert(CurLI && "CurLI not being set");
   if (none_of(EHPadSucessors, [&](const MachineBasicBlock *EHPad) {
-        return LIS.isLiveInToMBB(*CurLI, EHPad);
+        return LIS.isLiveInToMBB(CurLI, EHPad);
       }))
     return LIP.first;
 
   // Find the value leaving MBB.
-  const VNInfo *VNI = CurLI->getVNInfoBefore(MBBEnd);
+  const VNInfo *VNI = CurLI.getVNInfoBefore(MBBEnd);
   if (!VNI)
     return LIP.first;
 
   // If the value leaving MBB was defined after the call in MBB, it can't
   // really be live-in to the landing pad.  This can happen if the landing pad
   // has a PHI, and this register is undef on the exceptional edge.
   // <rdar://problem/10664933>
   if (!SlotIndex::isEarlierInstr(VNI->def, LIP.second) && VNI->def < MBBEnd)
     return LIP.first;
 
   // Value is properly live-in to the landing pad.
   // Only allow inserts before the call.
   return LIP.second;
 }
 
 MachineBasicBlock::iterator
-InsertPointAnalysis::getLastInsertPointIter(MachineBasicBlock &MBB) {
-  SlotIndex LIP = getLastInsertPoint(MBB);
+InsertPointAnalysis::getLastInsertPointIter(const LiveInterval &CurLI,
+                                            MachineBasicBlock &MBB) {
+  SlotIndex LIP = getLastInsertPoint(CurLI, MBB);
   if (LIP == LIS.getMBBEndIdx(&MBB))
     return MBB.end();
   return LIS.getInstructionFromIndex(LIP);
 }
 
 //===----------------------------------------------------------------------===//
 //                                 Split Analysis
 //===----------------------------------------------------------------------===//
bool SplitAnalysis::isOriginalEndpoint(SlotIndex Idx) const {
 
   // Range does not contain Idx, previous must end at Idx.
   return I != Orig.begin() && (--I)->end == Idx;
 }
 
 void SplitAnalysis::analyze(const LiveInterval *li) {
   clear();
   CurLI = li;
-  IPA.setInterval(li);
   analyzeUses();
 }
 
 
 //===----------------------------------------------------------------------===//
 //                               Split Editor
 //===----------------------------------------------------------------------===//