lib/Target/AMDGPU/SIFixSGPRLiveRanges.cpp

   1 //===-- SIFixSGPRLiveRanges.cpp - Fix SGPR live ranges ----------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 /// \file SALU instructions ignore the execution mask, so we need to modify the
  11 /// live ranges of the registers they define in some cases.
  12 ///
  13 /// The main case we need to handle is when a def is used in one side of a
  14 /// branch and not another.  For example:
  15 ///
  16 /// %def
  17 /// IF
  18 ///   ...
  19 ///   ...
  20 /// ELSE
  21 ///   %use
  22 ///   ...
  23 /// ENDIF
  24 ///
  25 /// Here we need the register allocator to avoid assigning any of the defs
  26 /// inside of the IF to the same register as %def.  In traditional live
  27 /// interval analysis %def is not live inside the IF branch, however, since
  28 /// SALU instructions inside of IF will be executed even if the branch is not
  29 /// taken, there is the chance that one of the instructions will overwrite the
  30 /// value of %def, so the use in ELSE will see the wrong value.
  31 ///
  32 /// The strategy we use for solving this is to add an extra use after the ENDIF:
  33 ///
  34 /// %def
  35 /// IF
  36 ///   ...
  37 ///   ...
  38 /// ELSE
  39 ///   %use
  40 ///   ...
  41 /// ENDIF
  42 /// %use
  43 ///
  44 /// Adding this use will make the def live throughout the IF branch, which is
  45 /// what we want.
  46
  47 #include "AMDGPU.h"
  48 #include "SIInstrInfo.h"
  49 #include "SIRegisterInfo.h"
  50 #include "llvm/ADT/DepthFirstIterator.h"
  51 #include "llvm/CodeGen/LiveIntervalAnalysis.h"
  52 #include "llvm/CodeGen/LiveVariables.h"
  53 #include "llvm/CodeGen/MachineFunctionPass.h"
  54 #include "llvm/CodeGen/MachineInstrBuilder.h"
  55 #include "llvm/CodeGen/MachinePostDominators.h"
  56 #include "llvm/CodeGen/MachineRegisterInfo.h"
  57 #include "llvm/Support/Debug.h"
  58 #include "llvm/Support/raw_ostream.h"
  59 #include "llvm/Target/TargetMachine.h"
  60
  61 using namespace llvm;
  62
  63 #define DEBUG_TYPE "si-fix-sgpr-live-ranges"
  64
  65 namespace {
  66
  67 class SIFixSGPRLiveRanges : public MachineFunctionPass {
  68 public:
  69   static char ID;
  70
  71 public:
  72   SIFixSGPRLiveRanges() : MachineFunctionPass(ID) {
  73     initializeSIFixSGPRLiveRangesPass(*PassRegistry::getPassRegistry());
  74   }
  75
  76   bool runOnMachineFunction(MachineFunction &MF) override;
  77
  78   const char *getPassName() const override {
  79     return "SI Fix SGPR live ranges";
  80   }
  81
  82   void getAnalysisUsage(AnalysisUsage &AU) const override {
  83     AU.addRequired<LiveVariables>();
  84     AU.addPreserved<LiveVariables>();
  85
  86     AU.addRequired<MachinePostDominatorTree>();
  87     AU.addPreserved<MachinePostDominatorTree>();
  88     AU.setPreservesCFG();
  89
  90     MachineFunctionPass::getAnalysisUsage(AU);
  91   }
  92 };
  93
  94 } // End anonymous namespace.
  95
  96 INITIALIZE_PASS_BEGIN(SIFixSGPRLiveRanges, DEBUG_TYPE,
  97                       "SI Fix SGPR Live Ranges", false, false)
  98 INITIALIZE_PASS_DEPENDENCY(LiveVariables)
  99 INITIALIZE_PASS_DEPENDENCY(MachinePostDominatorTree)
 100 INITIALIZE_PASS_END(SIFixSGPRLiveRanges, DEBUG_TYPE,
 101                     "SI Fix SGPR Live Ranges", false, false)
 102
 103 char SIFixSGPRLiveRanges::ID = 0;
 104
 105 char &llvm::SIFixSGPRLiveRangesID = SIFixSGPRLiveRanges::ID;
 106
 107 FunctionPass *llvm::createSIFixSGPRLiveRangesPass() {
 108   return new SIFixSGPRLiveRanges();
 109 }
 110
 111 bool SIFixSGPRLiveRanges::runOnMachineFunction(MachineFunction &MF) {
 112   MachineRegisterInfo &MRI = MF.getRegInfo();
 113   const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
 114   const SIRegisterInfo *TRI = static_cast<const SIRegisterInfo *>(
 115       MF.getSubtarget().getRegisterInfo());
 116   bool MadeChange = false;
 117
 118   MachinePostDominatorTree *PDT = &getAnalysis<MachinePostDominatorTree>();
 119   SmallVector<unsigned, 16> SGPRLiveRanges;
 120
 121   LiveVariables *LV = &getAnalysis<LiveVariables>();
 122   MachineBasicBlock *Entry = &MF.front();
 123
 124   // Use a depth first order so that in SSA, we encounter all defs before
 125   // uses. Once the defs of the block have been found, attempt to insert
 126   // SGPR_USE instructions in successor blocks if required.
 127   for (MachineBasicBlock *MBB : depth_first(Entry)) {
 128     for (const MachineInstr &MI : *MBB) {
 129       for (const MachineOperand &MO : MI.defs()) {
 130         // We should never see a live out def of a physical register, so we also
 131         // do not need to worry about implicit_defs().
 132         unsigned Def = MO.getReg();
 133         if (TargetRegisterInfo::isVirtualRegister(Def)) {
 134           if (TRI->isSGPRClass(MRI.getRegClass(Def))) {
 135             // Only consider defs that are live outs. We don't care about def /
 136             // use within the same block.
 137
 138             // LiveVariables does not consider registers that are only used in a
 139             // phi in a sucessor block as live out, unlike LiveIntervals.
 140             //
 141             // This is OK because SIFixSGPRCopies replaced any SGPR phis with
 142             // VGPRs.
 143             if (LV->isLiveOut(Def, *MBB))
 144               SGPRLiveRanges.push_back(Def);
 145           }
 146         }
 147       }
 148     }
 149
 150     if (MBB->succ_size() < 2)
 151       continue;
 152
 153     // We have structured control flow, so the number of successors should be
 154     // two.
 155     assert(MBB->succ_size() == 2);
 156     MachineBasicBlock *SuccA = *MBB->succ_begin();
 157     MachineBasicBlock *SuccB = *(++MBB->succ_begin());
 158     MachineBasicBlock *NCD = PDT->findNearestCommonDominator(SuccA, SuccB);
 159
 160     if (!NCD)
 161       continue;
 162
 163     MachineBasicBlock::iterator NCDTerm = NCD->getFirstTerminator();
 164
 165     if (NCDTerm != NCD->end() && NCDTerm->getOpcode() == AMDGPU::SI_ELSE) {
 166       assert(NCD->succ_size() == 2);
 167       // We want to make sure we insert the Use after the ENDIF, not after
 168       // the ELSE.
 169       NCD = PDT->findNearestCommonDominator(*NCD->succ_begin(),
 170                                             *(++NCD->succ_begin()));
 171     }
 172
 173     for (unsigned Reg : SGPRLiveRanges) {
 174       // FIXME: We could be smarter here. If the register is Live-In to one
 175       // block, but the other doesn't have any SGPR defs, then there won't be a
 176       // conflict. Also, if the branch condition is uniform then there will be
 177       // no conflict.
 178       bool LiveInToA = LV->isLiveIn(Reg, *SuccA);
 179       bool LiveInToB = LV->isLiveIn(Reg, *SuccB);
 180
 181       if (!LiveInToA && !LiveInToB) {
 182         DEBUG(dbgs() << PrintReg(Reg, TRI, 0)
 183               << " is live into neither successor\n");
 184         continue;
 185       }
 186
 187       if (LiveInToA && LiveInToB) {
 188         DEBUG(dbgs() << PrintReg(Reg, TRI, 0)
 189               << " is live into both successors\n");
 190         continue;
 191       }
 192
 193       // This interval is live in to one successor, but not the other, so
 194       // we need to update its range so it is live in to both.
 195       DEBUG(dbgs() << "Possible SGPR conflict detected for "
 196             << PrintReg(Reg, TRI, 0)
 197             << " BB#" << SuccA->getNumber()
 198             << ", BB#" << SuccB->getNumber()
 199             << " with NCD = BB#" << NCD->getNumber() << '\n');
 200
 201       assert(TargetRegisterInfo::isVirtualRegister(Reg) &&
 202              "Not expecting to extend live range of physreg");
 203
 204       // FIXME: Need to figure out how to update LiveRange here so this pass
 205       // will be able to preserve LiveInterval analysis.
 206       MachineInstr *NCDSGPRUse =
 207         BuildMI(*NCD, NCD->getFirstNonPHI(), DebugLoc(),
 208                 TII->get(AMDGPU::SGPR_USE))
 209         .addReg(Reg, RegState::Implicit);
 210
 211       MadeChange = true;
 212       LV->HandleVirtRegUse(Reg, NCD, NCDSGPRUse);
 213
 214       DEBUG(NCDSGPRUse->dump());
 215     }
 216   }
 217
 218   return MadeChange;
 219 }