R600/SI: Fix simple-loop.ll test
[opencl/llvm.git] / 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 //===----------------------------------------------------------------------===//
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"
32 using namespace llvm;
34 namespace {
36 class SIPrepareScratchRegs : public MachineFunctionPass {
38 private:
39   static char ID;
41 public:
42   SIPrepareScratchRegs() : MachineFunctionPass(ID) { }
44   bool runOnMachineFunction(MachineFunction &MF) override;
46   const char *getPassName() const override {
47     return "SI prepare scratch registers";
48   }
50 };
52 } // End anonymous namespace
54 char SIPrepareScratchRegs::ID = 0;
56 FunctionPass *llvm::createSIPrepareScratchRegs() {
57   return new SIPrepareScratchRegs();
58 }
60 bool SIPrepareScratchRegs::runOnMachineFunction(MachineFunction &MF) {
61   SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
62   const SIInstrInfo *TII =
63       static_cast<const SIInstrInfo *>(MF.getSubtarget().getInstrInfo());
64   const SIRegisterInfo *TRI = &TII->getRegisterInfo();
65   MachineRegisterInfo &MRI = MF.getRegInfo();
66   MachineFrameInfo *FrameInfo = MF.getFrameInfo();
67   MachineBasicBlock *Entry = MF.begin();
68   MachineBasicBlock::iterator I = Entry->begin();
69   DebugLoc DL = I->getDebugLoc();
71   // FIXME: If we don't have enough VGPRs for SGPR spilling we will need to
72   // run this pass.
73   if (!MFI->hasSpilledVGPRs())
74     return false;
76   unsigned ScratchPtrPreloadReg =
77       TRI->getPreloadedValue(MF, SIRegisterInfo::SCRATCH_PTR);
78   unsigned ScratchOffsetPreloadReg =
79       TRI->getPreloadedValue(MF, SIRegisterInfo::SCRATCH_WAVE_OFFSET);
81   if (!Entry->isLiveIn(ScratchPtrPreloadReg))
82     Entry->addLiveIn(ScratchPtrPreloadReg);
84   if (!Entry->isLiveIn(ScratchOffsetPreloadReg))
85     Entry->addLiveIn(ScratchOffsetPreloadReg);
87   // Load the scratch offset.
88   unsigned ScratchOffsetReg =
89       TRI->findUnusedRegister(MRI, &AMDGPU::SGPR_32RegClass);
90   int ScratchOffsetFI = -1;
92   if (ScratchOffsetReg != AMDGPU::NoRegister) {
93     // Found an SGPR to use
94     MRI.setPhysRegUsed(ScratchOffsetReg);
95     BuildMI(*Entry, I, DL, TII->get(AMDGPU::S_MOV_B32), ScratchOffsetReg)
96             .addReg(ScratchOffsetPreloadReg);
97   } else {
98     // No SGPR is available, we must spill.
99     ScratchOffsetFI = FrameInfo->CreateSpillStackObject(4,4);
100     BuildMI(*Entry, I, DL, TII->get(AMDGPU::SI_SPILL_S32_SAVE))
101             .addReg(ScratchOffsetPreloadReg)
102             .addFrameIndex(ScratchOffsetFI)
103             .addReg(AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3, RegState::Undef)
104             .addReg(AMDGPU::SGPR0, RegState::Undef);
105   }
108   // Now that we have the scratch pointer and offset values, we need to
109   // add them to all the SI_SPILL_V* instructions.
111   RegScavenger RS;
112   unsigned ScratchRsrcFI = FrameInfo->CreateSpillStackObject(16, 4);
113   RS.addScavengingFrameIndex(ScratchRsrcFI);
115   for (MachineFunction::iterator BI = MF.begin(), BE = MF.end();
116        BI != BE; ++BI) {
118     MachineBasicBlock &MBB = *BI;
119     // Add the scratch offset reg as a live-in so that the register scavenger
120     // doesn't re-use it.
121     if (!MBB.isLiveIn(ScratchOffsetReg) &&
122         ScratchOffsetReg != AMDGPU::NoRegister)
123       MBB.addLiveIn(ScratchOffsetReg);
124     RS.enterBasicBlock(&MBB);
126     for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end();
127          I != E; ++I) {
128       MachineInstr &MI = *I;
129       RS.forward(I);
130       DebugLoc DL = MI.getDebugLoc();
131       switch(MI.getOpcode()) {
132         default: break;
133         case AMDGPU::SI_SPILL_V512_SAVE:
134         case AMDGPU::SI_SPILL_V256_SAVE:
135         case AMDGPU::SI_SPILL_V128_SAVE:
136         case AMDGPU::SI_SPILL_V96_SAVE:
137         case AMDGPU::SI_SPILL_V64_SAVE:
138         case AMDGPU::SI_SPILL_V32_SAVE:
139         case AMDGPU::SI_SPILL_V32_RESTORE:
140         case AMDGPU::SI_SPILL_V64_RESTORE:
141         case AMDGPU::SI_SPILL_V128_RESTORE:
142         case AMDGPU::SI_SPILL_V256_RESTORE:
143         case AMDGPU::SI_SPILL_V512_RESTORE:
145           // Scratch resource
146           unsigned ScratchRsrcReg =
147               RS.scavengeRegister(&AMDGPU::SReg_128RegClass, 0);
149           uint64_t Rsrc = AMDGPU::RSRC_DATA_FORMAT | AMDGPU::RSRC_TID_ENABLE |
150                           0xffffffff; // Size
152           unsigned Rsrc0 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub0);
153           unsigned Rsrc1 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub1);
154           unsigned Rsrc2 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub2);
155           unsigned Rsrc3 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub3);
157           BuildMI(MBB, I, DL, TII->get(AMDGPU::S_MOV_B32), Rsrc0)
158                   .addExternalSymbol("SCRATCH_RSRC_DWORD0")
159                   .addReg(ScratchRsrcReg, RegState::ImplicitDefine);
161           BuildMI(MBB, I, DL, TII->get(AMDGPU::S_MOV_B32), Rsrc1)
162                   .addExternalSymbol("SCRATCH_RSRC_DWORD1")
163                   .addReg(ScratchRsrcReg, RegState::ImplicitDefine);
165           BuildMI(MBB, I, DL, TII->get(AMDGPU::S_MOV_B32), Rsrc2)
166                   .addImm(Rsrc & 0xffffffff)
167                   .addReg(ScratchRsrcReg, RegState::ImplicitDefine);
169           BuildMI(MBB, I, DL, TII->get(AMDGPU::S_MOV_B32), Rsrc3)
170                   .addImm(Rsrc >> 32)
171                   .addReg(ScratchRsrcReg, RegState::ImplicitDefine);
173           // Scratch Offset
174           if (ScratchOffsetReg == AMDGPU::NoRegister) {
175             ScratchOffsetReg = RS.scavengeRegister(&AMDGPU::SGPR_32RegClass, 0);
176             BuildMI(MBB, I, DL, TII->get(AMDGPU::SI_SPILL_S32_RESTORE),
177                     ScratchOffsetReg)
178                     .addFrameIndex(ScratchOffsetFI)
179                     .addReg(AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3, RegState::Undef)
180                     .addReg(AMDGPU::SGPR0, RegState::Undef);
181           } else if (!MBB.isLiveIn(ScratchOffsetReg)) {
182             MBB.addLiveIn(ScratchOffsetReg);
183           }
185           if (ScratchRsrcReg == AMDGPU::NoRegister ||
186               ScratchOffsetReg == AMDGPU::NoRegister) {
187             LLVMContext &Ctx = MF.getFunction()->getContext();
188             Ctx.emitError("ran out of SGPRs for spilling VGPRs");
189             ScratchRsrcReg = AMDGPU::SGPR0;
190             ScratchOffsetReg = AMDGPU::SGPR0;
191           }
192           MI.getOperand(2).setReg(ScratchRsrcReg);
193           MI.getOperand(2).setIsKill(true);
194           MI.getOperand(2).setIsUndef(false);
195           MI.getOperand(3).setReg(ScratchOffsetReg);
196           MI.getOperand(3).setIsUndef(false);
197           MI.getOperand(3).setIsKill(false);
198           MI.addOperand(MachineOperand::CreateReg(Rsrc0, false, true, true));
199           MI.addOperand(MachineOperand::CreateReg(Rsrc1, false, true, true));
200           MI.addOperand(MachineOperand::CreateReg(Rsrc2, false, true, true));
201           MI.addOperand(MachineOperand::CreateReg(Rsrc3, false, true, true));
203           break;
204       }
205     }
206   }
207   return true;