Add LiveIntervals::addKillFlags() to recompute kill flags after register allocation.

This is a lot easier than trying to get kill flags right during live range
splitting and rematerialization.

llvm-svn: 125113

include/llvm/CodeGen/LiveIntervalAnalysis.h

@@ -320,6 +320,10 @@ namespace llvm {
     MachineBasicBlock::iterator getLastSplitPoint(const LiveInterval &li,
                                                   MachineBasicBlock *mbb);
 
+    /// addKillFlags - Add kill flags to any instruction that kills a virtual
+    /// register.
+    void addKillFlags();
+
   private:
     /// computeIntervals - Compute live intervals.
     void computeIntervals();

lib/CodeGen/LiveIntervalAnalysis.cpp

@@ -890,6 +890,29 @@ LiveIntervals::getLastSplitPoint(const LiveInterval &li,
   return mbb->getFirstTerminator();
 }
 
+void LiveIntervals::addKillFlags() {
+  for (iterator I = begin(), E = end(); I != E; ++I) {
+    unsigned Reg = I->first;
+    if (TargetRegisterInfo::isPhysicalRegister(Reg))
+      continue;
+    if (mri_->reg_nodbg_empty(Reg))
+      continue;
+    LiveInterval *LI = I->second;
+
+    // Every instruction that kills Reg corresponds to a live range end point.
+    for (LiveInterval::iterator RI = LI->begin(), RE = LI->end(); RI != RE;
+         ++RI) {
+      // A LOAD index indicates an MBB edge.
+      if (RI->end.isLoad())
+        continue;
+      MachineInstr *MI = getInstructionFromIndex(RI->end);
+      if (!MI)
+        continue;
+      MI->addRegisterKilled(Reg, NULL);
+    }
+  }
+}
+
 /// getReMatImplicitUse - If the remat definition MI has one (for now, we only
 /// allow one) virtual register operand, then its uses are implicitly using
 /// the register. Returns the virtual register.

lib/CodeGen/RegAllocGreedy.cpp

@@ -1087,6 +1087,7 @@ bool RAGreedy::runOnMachineFunction(MachineFunction &mf) {
 
   allocatePhysRegs();
   addMBBLiveIns(MF);
+  LIS->addKillFlags();
 
   // Run rewriter
   {