AMDGPU/SI: Update LiveVariables

[arsenm]

Summary

This is simple but won't work if/when this pass is moved to be post-SSA.

[• tstellarAMD]

LGTM.

[arsenm]

r245134

lib/Target/AMDGPU/SIFixSGPRLiveRanges.cpp

 ///
 /// Adding this use will make the def live thoughout the IF branch, which is
 /// what we want.
 
 #include "AMDGPU.h"
 #include "SIInstrInfo.h"
 #include "SIRegisterInfo.h"
 #include "llvm/CodeGen/LiveIntervalAnalysis.h"
+#include "llvm/CodeGen/LiveVariables.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachinePostDominators.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 
public:
   }
 };
 
 } // End anonymous namespace.
 
 INITIALIZE_PASS_BEGIN(SIFixSGPRLiveRanges, DEBUG_TYPE,
                       "SI Fix SGPR Live Ranges", false, false)
 INITIALIZE_PASS_DEPENDENCY(LiveIntervals)
+INITIALIZE_PASS_DEPENDENCY(LiveVariables)
 INITIALIZE_PASS_DEPENDENCY(MachinePostDominatorTree)
 INITIALIZE_PASS_END(SIFixSGPRLiveRanges, DEBUG_TYPE,
                     "SI Fix SGPR Live Ranges", false, false)
 
 char SIFixSGPRLiveRanges::ID = 0;
 
 char &llvm::SIFixSGPRLiveRangesID = SIFixSGPRLiveRanges::ID;
 
 FunctionPass *llvm::createSIFixSGPRLiveRangesPass() {
   return new SIFixSGPRLiveRanges();
 }
 
 bool SIFixSGPRLiveRanges::runOnMachineFunction(MachineFunction &MF) {
   MachineRegisterInfo &MRI = MF.getRegInfo();
   const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
   const SIRegisterInfo *TRI = static_cast<const SIRegisterInfo *>(
       MF.getSubtarget().getRegisterInfo());
-  LiveIntervals *LIS = &getAnalysis<LiveIntervals>();
+
   MachinePostDominatorTree *PDT = &getAnalysis<MachinePostDominatorTree>();
   std::vector<std::pair<unsigned, LiveRange *>> SGPRLiveRanges;
 
+  LiveIntervals *LIS = &getAnalysis<LiveIntervals>();
+  LiveVariables *LV = getAnalysisIfAvailable<LiveVariables>();
+
   // First pass, collect all live intervals for SGPRs
   for (const MachineBasicBlock &MBB : MF) {
     for (const MachineInstr &MI : MBB) {
       for (const MachineOperand &MO : MI.defs()) {
         if (MO.isImplicit())
           continue;
         unsigned Def = MO.getReg();
         if (TargetRegisterInfo::isVirtualRegister(Def)) {
for (std::pair<unsigned, LiveRange*> RegLR : SGPRLiveRanges) {
       // This interval is live in to one successor, but not the other, so
       // we need to update its range so it is live in to both.
       DEBUG(dbgs() << "Possible SGPR conflict detected for "
             << PrintReg(Reg, TRI, 0) <<  " in " << *LR
             << " BB#" << SuccA->getNumber() << ", BB#"
             << SuccB->getNumber()
             << " with NCD = BB#" << NCD->getNumber() << '\n');
 
+      assert(TargetRegisterInfo::isVirtualRegister(Reg) &&
+             "Not expecting to extend live range of physreg");
+
       // FIXME: Need to figure out how to update LiveRange here so this pass
       // will be able to preserve LiveInterval analysis.
       MachineInstr *NCDSGPRUse =
         BuildMI(*NCD, NCD->getFirstNonPHI(), DebugLoc(),
                 TII->get(AMDGPU::SGPR_USE))
         .addReg(Reg, RegState::Implicit);
 
       SlotIndex SI = LIS->InsertMachineInstrInMaps(NCDSGPRUse);
       LIS->extendToIndices(*LR, SI);
 
+      if (LV) {
+        // TODO: This won't work post-SSA
+        LV->HandleVirtRegUse(Reg, NCD, NCDSGPRUse);
+      }
+
       DEBUG(NCDSGPRUse->dump());
     }
   }
 
   return false;
 }