lib/Target/R600/SIPrepareScratchRegs.cpp

   1 //===-- SIPrepareScratchRegs.cpp - Use predicates for control flow --------===//
   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
  11 ///
  12 /// This pass loads scratch pointer and scratch offset into a register or a
  13 /// frame index which can be used anywhere in the program.  These values will
  14 /// be used for spilling VGPRs.
  15 ///
  16 //===----------------------------------------------------------------------===//
  17
  18 #include "AMDGPU.h"
  19 #include "AMDGPUSubtarget.h"
  20 #include "SIDefines.h"
  21 #include "SIInstrInfo.h"
  22 #include "SIMachineFunctionInfo.h"
  23 #include "llvm/CodeGen/MachineFrameInfo.h"
  24 #include "llvm/CodeGen/MachineFunction.h"
  25 #include "llvm/CodeGen/MachineFunctionPass.h"
  26 #include "llvm/CodeGen/MachineInstrBuilder.h"
  27 #include "llvm/CodeGen/MachineRegisterInfo.h"
  28 #include "llvm/CodeGen/RegisterScavenging.h"
  29 #include "llvm/IR/Function.h"
  30 #include "llvm/IR/LLVMContext.h"
  31
  32 #include "llvm/Support/Debug.h"
  33 using namespace llvm;
  34
  35 namespace {
  36
  37 class SIPrepareScratchRegs : public MachineFunctionPass {
  38
  39 private:
  40   static char ID;
  41
  42 public:
  43   SIPrepareScratchRegs() : MachineFunctionPass(ID) { }
  44
  45   bool runOnMachineFunction(MachineFunction &MF) override;
  46
  47   const char *getPassName() const override {
  48     return "SI prepare scratch registers";
  49   }
  50
  51 };
  52
  53 } // End anonymous namespace
  54
  55 char SIPrepareScratchRegs::ID = 0;
  56
  57 FunctionPass *llvm::createSIPrepareScratchRegs() {
  58   return new SIPrepareScratchRegs();
  59 }
  60
  61 bool SIPrepareScratchRegs::runOnMachineFunction(MachineFunction &MF) {
  62   SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
  63   const SIInstrInfo *TII =
  64       static_cast<const SIInstrInfo *>(MF.getSubtarget().getInstrInfo());
  65   const SIRegisterInfo *TRI = &TII->getRegisterInfo();
  66   MachineRegisterInfo &MRI = MF.getRegInfo();
  67   MachineFrameInfo *FrameInfo = MF.getFrameInfo();
  68   MachineBasicBlock *Entry = MF.begin();
  69   MachineBasicBlock::iterator I = Entry->begin();
  70   DebugLoc DL = I->getDebugLoc();
  71
  72   // FIXME: If we don't have enough VGPRs for SGPR spilling we will need to
  73   // run this pass.
  74   if (!MFI->hasSpilledVGPRs())
  75     return false;
  76
  77   unsigned ScratchPtrPreloadReg =
  78       TRI->getPreloadedValue(MF, SIRegisterInfo::SCRATCH_PTR);
  79   unsigned ScratchOffsetPreloadReg =
  80       TRI->getPreloadedValue(MF, SIRegisterInfo::SCRATCH_WAVE_OFFSET);
  81
  82   if (!Entry->isLiveIn(ScratchPtrPreloadReg))
  83     Entry->addLiveIn(ScratchPtrPreloadReg);
  84
  85   if (!Entry->isLiveIn(ScratchOffsetPreloadReg))
  86     Entry->addLiveIn(ScratchOffsetPreloadReg);
  87
  88   // Load the scratch offset.
  89   unsigned ScratchOffsetReg =
  90       TRI->findUnusedRegister(MRI, &AMDGPU::SGPR_32RegClass);
  91   int ScratchOffsetFI = -1;
  92
  93   if (ScratchOffsetReg != AMDGPU::NoRegister) {
  94     // Found an SGPR to use
  95     MRI.setPhysRegUsed(ScratchOffsetReg);
  96     BuildMI(*Entry, I, DL, TII->get(AMDGPU::S_MOV_B32), ScratchOffsetReg)
  97             .addReg(ScratchOffsetPreloadReg);
  98   } else {
  99     // No SGPR is available, we must spill.
 100     ScratchOffsetFI = FrameInfo->CreateSpillStackObject(4,4);
 101     BuildMI(*Entry, I, DL, TII->get(AMDGPU::SI_SPILL_S32_SAVE))
 102             .addReg(ScratchOffsetPreloadReg)
 103             .addFrameIndex(ScratchOffsetFI);
 104   }
 105
 106
 107   // Now that we have the scratch pointer and offset values, we need to
 108   // add them to all the SI_SPILL_V* instructions.
 109
 110   RegScavenger RS;
 111   unsigned ScratchRsrcFI = FrameInfo->CreateSpillStackObject(16, 4);
 112   RS.addScavengingFrameIndex(ScratchRsrcFI);
 113
 114   for (MachineFunction::iterator BI = MF.begin(), BE = MF.end();
 115        BI != BE; ++BI) {
 116
 117     MachineBasicBlock &MBB = *BI;
 118     // Add the scratch offset reg as a live-in so that the register scavenger
 119     // doesn't re-use it.
 120     if (!MBB.isLiveIn(ScratchOffsetReg))
 121       MBB.addLiveIn(ScratchOffsetReg);
 122     RS.enterBasicBlock(&MBB);
 123
 124     for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end();
 125          I != E; ++I) {
 126       MachineInstr &MI = *I;
 127       RS.forward(I);
 128       DebugLoc DL = MI.getDebugLoc();
 129       switch(MI.getOpcode()) {
 130         default: break;
 131         case AMDGPU::SI_SPILL_V512_SAVE:
 132         case AMDGPU::SI_SPILL_V256_SAVE:
 133         case AMDGPU::SI_SPILL_V128_SAVE:
 134         case AMDGPU::SI_SPILL_V96_SAVE:
 135         case AMDGPU::SI_SPILL_V64_SAVE:
 136         case AMDGPU::SI_SPILL_V32_SAVE:
 137         case AMDGPU::SI_SPILL_V32_RESTORE:
 138         case AMDGPU::SI_SPILL_V64_RESTORE:
 139         case AMDGPU::SI_SPILL_V128_RESTORE:
 140         case AMDGPU::SI_SPILL_V256_RESTORE:
 141         case AMDGPU::SI_SPILL_V512_RESTORE:
 142
 143           // Scratch resource
 144           unsigned ScratchRsrcReg =
 145               RS.scavengeRegister(&AMDGPU::SReg_128RegClass, 0);
 146
 147           uint64_t Rsrc = AMDGPU::RSRC_DATA_FORMAT | AMDGPU::RSRC_TID_ENABLE |
 148                           0xffffffff; // Size
 149
 150           unsigned Rsrc0 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub0);
 151           unsigned Rsrc1 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub1);
 152           unsigned Rsrc2 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub2);
 153           unsigned Rsrc3 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub3);
 154
 155           BuildMI(MBB, I, DL, TII->get(AMDGPU::S_MOV_B32), Rsrc0)
 156                   .addExternalSymbol("SCRATCH_RSRC_DWORD0")
 157                   .addReg(ScratchRsrcReg, RegState::ImplicitDefine);
 158
 159           BuildMI(MBB, I, DL, TII->get(AMDGPU::S_MOV_B32), Rsrc1)
 160                   .addExternalSymbol("SCRATCH_RSRC_DWORD1")
 161                   .addReg(ScratchRsrcReg, RegState::ImplicitDefine);
 162
 163           BuildMI(MBB, I, DL, TII->get(AMDGPU::S_MOV_B32), Rsrc2)
 164                   .addImm(Rsrc & 0xffffffff)
 165                   .addReg(ScratchRsrcReg, RegState::ImplicitDefine);
 166
 167           BuildMI(MBB, I, DL, TII->get(AMDGPU::S_MOV_B32), Rsrc3)
 168                   .addImm(Rsrc >> 32)
 169                   .addReg(ScratchRsrcReg, RegState::ImplicitDefine);
 170
 171           // Scratch Offset
 172           if (ScratchOffsetReg == AMDGPU::NoRegister) {
 173             ScratchOffsetReg = RS.scavengeRegister(&AMDGPU::SGPR_32RegClass, 0);
 174             BuildMI(MBB, I, DL, TII->get(AMDGPU::SI_SPILL_S32_RESTORE),
 175                     ScratchOffsetReg)
 176                     .addFrameIndex(ScratchOffsetFI)
 177                     .addReg(AMDGPU::NoRegister)
 178                     .addReg(AMDGPU::NoRegister);
 179           } else if (!MBB.isLiveIn(ScratchOffsetReg)) {
 180             MBB.addLiveIn(ScratchOffsetReg);
 181           }
 182
 183           if (ScratchRsrcReg == AMDGPU::NoRegister ||
 184               ScratchOffsetReg == AMDGPU::NoRegister) {
 185             LLVMContext &Ctx = MF.getFunction()->getContext();
 186             Ctx.emitError("ran out of SGPRs for spilling VGPRs");
 187             ScratchRsrcReg = AMDGPU::SGPR0;
 188             ScratchOffsetReg = AMDGPU::SGPR0;
 189           }
 190           MI.getOperand(2).setReg(ScratchRsrcReg);
 191           MI.getOperand(2).setIsKill(true);
 192           MI.getOperand(2).setIsUndef(false);
 193           MI.getOperand(3).setReg(ScratchOffsetReg);
 194           MI.getOperand(3).setIsUndef(false);
 195           MI.addOperand(MachineOperand::CreateReg(Rsrc0, false, true, true));
 196           MI.addOperand(MachineOperand::CreateReg(Rsrc1, false, true, true));
 197           MI.addOperand(MachineOperand::CreateReg(Rsrc2, false, true, true));
 198           MI.addOperand(MachineOperand::CreateReg(Rsrc3, false, true, true));
 199
 200           MI.dump();
 201           break;
 202       }
 203     }
 204   }
 205   return true;
 206 }