contrib/llvm/lib/Target/AMDGPU/SIRegisterInfo.cpp

   1 //===-- SIRegisterInfo.cpp - SI Register Information ---------------------===//
   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 /// \brief SI implementation of the TargetRegisterInfo class.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "SIRegisterInfo.h"
  16 #include "SIInstrInfo.h"
  17 #include "SIMachineFunctionInfo.h"
  18 #include "AMDGPUSubtarget.h"
  19 #include "llvm/CodeGen/MachineFrameInfo.h"
  20 #include "llvm/CodeGen/MachineInstrBuilder.h"
  21 #include "llvm/CodeGen/RegisterScavenging.h"
  22 #include "llvm/IR/Function.h"
  23 #include "llvm/IR/LLVMContext.h"
  24
  25 using namespace llvm;
  26
  27 static bool hasPressureSet(const int *PSets, unsigned PSetID) {
  28   for (unsigned i = 0; PSets[i] != -1; ++i) {
  29     if (PSets[i] == (int)PSetID)
  30       return true;
  31   }
  32   return false;
  33 }
  34
  35 void SIRegisterInfo::classifyPressureSet(unsigned PSetID, unsigned Reg,
  36                                          BitVector &PressureSets) const {
  37   for (MCRegUnitIterator U(Reg, this); U.isValid(); ++U) {
  38     const int *PSets = getRegUnitPressureSets(*U);
  39     if (hasPressureSet(PSets, PSetID)) {
  40       PressureSets.set(PSetID);
  41       break;
  42     }
  43   }
  44 }
  45
  46 static cl::opt<bool> EnableSpillSGPRToSMEM(
  47   "amdgpu-spill-sgpr-to-smem",
  48   cl::desc("Use scalar stores to spill SGPRs if supported by subtarget"),
  49   cl::init(false));
  50
  51 static cl::opt<bool> EnableSpillSGPRToVGPR(
  52   "amdgpu-spill-sgpr-to-vgpr",
  53   cl::desc("Enable spilling VGPRs to SGPRs"),
  54   cl::ReallyHidden,
  55   cl::init(true));
  56
  57 SIRegisterInfo::SIRegisterInfo(const SISubtarget &ST) :
  58   AMDGPURegisterInfo(),
  59   SGPRPressureSets(getNumRegPressureSets()),
  60   VGPRPressureSets(getNumRegPressureSets()),
  61   SpillSGPRToVGPR(false),
  62   SpillSGPRToSMEM(false) {
  63   if (EnableSpillSGPRToSMEM && ST.hasScalarStores())
  64     SpillSGPRToSMEM = true;
  65   else if (EnableSpillSGPRToVGPR)
  66     SpillSGPRToVGPR = true;
  67
  68   unsigned NumRegPressureSets = getNumRegPressureSets();
  69
  70   SGPRSetID = NumRegPressureSets;
  71   VGPRSetID = NumRegPressureSets;
  72
  73   for (unsigned i = 0; i < NumRegPressureSets; ++i) {
  74     classifyPressureSet(i, AMDGPU::SGPR0, SGPRPressureSets);
  75     classifyPressureSet(i, AMDGPU::VGPR0, VGPRPressureSets);
  76   }
  77
  78   // Determine the number of reg units for each pressure set.
  79   std::vector<unsigned> PressureSetRegUnits(NumRegPressureSets, 0);
  80   for (unsigned i = 0, e = getNumRegUnits(); i != e; ++i) {
  81     const int *PSets = getRegUnitPressureSets(i);
  82     for (unsigned j = 0; PSets[j] != -1; ++j) {
  83       ++PressureSetRegUnits[PSets[j]];
  84     }
  85   }
  86
  87   unsigned VGPRMax = 0, SGPRMax = 0;
  88   for (unsigned i = 0; i < NumRegPressureSets; ++i) {
  89     if (isVGPRPressureSet(i) && PressureSetRegUnits[i] > VGPRMax) {
  90       VGPRSetID = i;
  91       VGPRMax = PressureSetRegUnits[i];
  92       continue;
  93     }
  94     if (isSGPRPressureSet(i) && PressureSetRegUnits[i] > SGPRMax) {
  95       SGPRSetID = i;
  96       SGPRMax = PressureSetRegUnits[i];
  97     }
  98   }
  99
 100   assert(SGPRSetID < NumRegPressureSets &&
 101          VGPRSetID < NumRegPressureSets);
 102 }
 103
 104 void SIRegisterInfo::reserveRegisterTuples(BitVector &Reserved, unsigned Reg) const {
 105   MCRegAliasIterator R(Reg, this, true);
 106
 107   for (; R.isValid(); ++R)
 108     Reserved.set(*R);
 109 }
 110
 111 unsigned SIRegisterInfo::reservedPrivateSegmentBufferReg(
 112   const MachineFunction &MF) const {
 113
 114   const SISubtarget &ST = MF.getSubtarget<SISubtarget>();
 115   unsigned BaseIdx = alignDown(ST.getMaxNumSGPRs(MF), 4) - 4;
 116   unsigned BaseReg(AMDGPU::SGPR_32RegClass.getRegister(BaseIdx));
 117   return getMatchingSuperReg(BaseReg, AMDGPU::sub0, &AMDGPU::SReg_128RegClass);
 118 }
 119
 120 static unsigned findPrivateSegmentWaveByteOffsetRegIndex(unsigned RegCount) {
 121   unsigned Reg;
 122
 123   // Try to place it in a hole after PrivateSegmentBufferReg.
 124   if (RegCount & 3) {
 125     // We cannot put the segment buffer in (Idx - 4) ... (Idx - 1) due to
 126     // alignment constraints, so we have a hole where can put the wave offset.
 127     Reg = RegCount - 1;
 128   } else {
 129     // We can put the segment buffer in (Idx - 4) ... (Idx - 1) and put the
 130     // wave offset before it.
 131     Reg = RegCount - 5;
 132   }
 133
 134   return Reg;
 135 }
 136
 137 unsigned SIRegisterInfo::reservedPrivateSegmentWaveByteOffsetReg(
 138   const MachineFunction &MF) const {
 139   const SISubtarget &ST = MF.getSubtarget<SISubtarget>();
 140   unsigned Reg = findPrivateSegmentWaveByteOffsetRegIndex(ST.getMaxNumSGPRs(MF));
 141   return AMDGPU::SGPR_32RegClass.getRegister(Reg);
 142 }
 143
 144 unsigned SIRegisterInfo::reservedStackPtrOffsetReg(
 145   const MachineFunction &MF) const {
 146   return AMDGPU::SGPR32;
 147 }
 148
 149 BitVector SIRegisterInfo::getReservedRegs(const MachineFunction &MF) const {
 150   BitVector Reserved(getNumRegs());
 151   Reserved.set(AMDGPU::INDIRECT_BASE_ADDR);
 152
 153   // EXEC_LO and EXEC_HI could be allocated and used as regular register, but
 154   // this seems likely to result in bugs, so I'm marking them as reserved.
 155   reserveRegisterTuples(Reserved, AMDGPU::EXEC);
 156   reserveRegisterTuples(Reserved, AMDGPU::FLAT_SCR);
 157
 158   // M0 has to be reserved so that llvm accepts it as a live-in into a block.
 159   reserveRegisterTuples(Reserved, AMDGPU::M0);
 160
 161   // Reserve the memory aperture registers.
 162   reserveRegisterTuples(Reserved, AMDGPU::SRC_SHARED_BASE);
 163   reserveRegisterTuples(Reserved, AMDGPU::SRC_SHARED_LIMIT);
 164   reserveRegisterTuples(Reserved, AMDGPU::SRC_PRIVATE_BASE);
 165   reserveRegisterTuples(Reserved, AMDGPU::SRC_PRIVATE_LIMIT);
 166
 167   // Reserve Trap Handler registers - support is not implemented in Codegen.
 168   reserveRegisterTuples(Reserved, AMDGPU::TBA);
 169   reserveRegisterTuples(Reserved, AMDGPU::TMA);
 170   reserveRegisterTuples(Reserved, AMDGPU::TTMP0_TTMP1);
 171   reserveRegisterTuples(Reserved, AMDGPU::TTMP2_TTMP3);
 172   reserveRegisterTuples(Reserved, AMDGPU::TTMP4_TTMP5);
 173   reserveRegisterTuples(Reserved, AMDGPU::TTMP6_TTMP7);
 174   reserveRegisterTuples(Reserved, AMDGPU::TTMP8_TTMP9);
 175   reserveRegisterTuples(Reserved, AMDGPU::TTMP10_TTMP11);
 176
 177   const SISubtarget &ST = MF.getSubtarget<SISubtarget>();
 178
 179   unsigned MaxNumSGPRs = ST.getMaxNumSGPRs(MF);
 180   unsigned TotalNumSGPRs = AMDGPU::SGPR_32RegClass.getNumRegs();
 181   for (unsigned i = MaxNumSGPRs; i < TotalNumSGPRs; ++i) {
 182     unsigned Reg = AMDGPU::SGPR_32RegClass.getRegister(i);
 183     reserveRegisterTuples(Reserved, Reg);
 184   }
 185
 186   unsigned MaxNumVGPRs = ST.getMaxNumVGPRs(MF);
 187   unsigned TotalNumVGPRs = AMDGPU::VGPR_32RegClass.getNumRegs();
 188   for (unsigned i = MaxNumVGPRs; i < TotalNumVGPRs; ++i) {
 189     unsigned Reg = AMDGPU::VGPR_32RegClass.getRegister(i);
 190     reserveRegisterTuples(Reserved, Reg);
 191   }
 192
 193   const SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
 194
 195   unsigned ScratchWaveOffsetReg = MFI->getScratchWaveOffsetReg();
 196   if (ScratchWaveOffsetReg != AMDGPU::NoRegister) {
 197     // Reserve 1 SGPR for scratch wave offset in case we need to spill.
 198     reserveRegisterTuples(Reserved, ScratchWaveOffsetReg);
 199   }
 200
 201   unsigned ScratchRSrcReg = MFI->getScratchRSrcReg();
 202   if (ScratchRSrcReg != AMDGPU::NoRegister) {
 203     // Reserve 4 SGPRs for the scratch buffer resource descriptor in case we need
 204     // to spill.
 205     // TODO: May need to reserve a VGPR if doing LDS spilling.
 206     reserveRegisterTuples(Reserved, ScratchRSrcReg);
 207     assert(!isSubRegister(ScratchRSrcReg, ScratchWaveOffsetReg));
 208   }
 209
 210   unsigned StackPtrReg = MFI->getStackPtrOffsetReg();
 211   if (StackPtrReg != AMDGPU::NoRegister) {
 212     reserveRegisterTuples(Reserved, StackPtrReg);
 213     assert(!isSubRegister(ScratchRSrcReg, StackPtrReg));
 214   }
 215
 216   unsigned FrameReg = MFI->getFrameOffsetReg();
 217   if (FrameReg != AMDGPU::NoRegister) {
 218     reserveRegisterTuples(Reserved, FrameReg);
 219     assert(!isSubRegister(ScratchRSrcReg, FrameReg));
 220   }
 221
 222   return Reserved;
 223 }
 224
 225 bool SIRegisterInfo::requiresRegisterScavenging(const MachineFunction &Fn) const {
 226   const SIMachineFunctionInfo *Info = Fn.getInfo<SIMachineFunctionInfo>();
 227   if (Info->isEntryFunction()) {
 228     const MachineFrameInfo &MFI = Fn.getFrameInfo();
 229     return MFI.hasStackObjects() || MFI.hasCalls();
 230   }
 231
 232   // May need scavenger for dealing with callee saved registers.
 233   return true;
 234 }
 235
 236 bool SIRegisterInfo::requiresFrameIndexScavenging(const MachineFunction &MF) const {
 237   return MF.getFrameInfo().hasStackObjects();
 238 }
 239
 240 bool SIRegisterInfo::requiresFrameIndexReplacementScavenging(
 241   const MachineFunction &MF) const {
 242   // m0 is needed for the scalar store offset. m0 is unallocatable, so we can't
 243   // create a virtual register for it during frame index elimination, so the
 244   // scavenger is directly needed.
 245   return MF.getFrameInfo().hasStackObjects() &&
 246          MF.getSubtarget<SISubtarget>().hasScalarStores() &&
 247          MF.getInfo<SIMachineFunctionInfo>()->hasSpilledSGPRs();
 248 }
 249
 250 bool SIRegisterInfo::requiresVirtualBaseRegisters(
 251   const MachineFunction &) const {
 252   // There are no special dedicated stack or frame pointers.
 253   return true;
 254 }
 255
 256 bool SIRegisterInfo::trackLivenessAfterRegAlloc(const MachineFunction &MF) const {
 257   // This helps catch bugs as verifier errors.
 258   return true;
 259 }
 260
 261 int64_t SIRegisterInfo::getMUBUFInstrOffset(const MachineInstr *MI) const {
 262   assert(SIInstrInfo::isMUBUF(*MI));
 263
 264   int OffIdx = AMDGPU::getNamedOperandIdx(MI->getOpcode(),
 265                                           AMDGPU::OpName::offset);
 266   return MI->getOperand(OffIdx).getImm();
 267 }
 268
 269 int64_t SIRegisterInfo::getFrameIndexInstrOffset(const MachineInstr *MI,
 270                                                  int Idx) const {
 271   if (!SIInstrInfo::isMUBUF(*MI))
 272     return 0;
 273
 274   assert(Idx == AMDGPU::getNamedOperandIdx(MI->getOpcode(),
 275                                            AMDGPU::OpName::vaddr) &&
 276          "Should never see frame index on non-address operand");
 277
 278   return getMUBUFInstrOffset(MI);
 279 }
 280
 281 bool SIRegisterInfo::needsFrameBaseReg(MachineInstr *MI, int64_t Offset) const {
 282   if (!MI->mayLoadOrStore())
 283     return false;
 284
 285   int64_t FullOffset = Offset + getMUBUFInstrOffset(MI);
 286
 287   return !isUInt<12>(FullOffset);
 288 }
 289
 290 void SIRegisterInfo::materializeFrameBaseRegister(MachineBasicBlock *MBB,
 291                                                   unsigned BaseReg,
 292                                                   int FrameIdx,
 293                                                   int64_t Offset) const {
 294   MachineBasicBlock::iterator Ins = MBB->begin();
 295   DebugLoc DL; // Defaults to "unknown"
 296
 297   if (Ins != MBB->end())
 298     DL = Ins->getDebugLoc();
 299
 300   MachineFunction *MF = MBB->getParent();
 301   const SISubtarget &Subtarget = MF->getSubtarget<SISubtarget>();
 302   const SIInstrInfo *TII = Subtarget.getInstrInfo();
 303
 304   if (Offset == 0) {
 305     BuildMI(*MBB, Ins, DL, TII->get(AMDGPU::V_MOV_B32_e32), BaseReg)
 306       .addFrameIndex(FrameIdx);
 307     return;
 308   }
 309
 310   MachineRegisterInfo &MRI = MF->getRegInfo();
 311   unsigned OffsetReg = MRI.createVirtualRegister(&AMDGPU::SReg_32_XM0RegClass);
 312
 313   unsigned FIReg = MRI.createVirtualRegister(&AMDGPU::VGPR_32RegClass);
 314
 315   BuildMI(*MBB, Ins, DL, TII->get(AMDGPU::S_MOV_B32), OffsetReg)
 316     .addImm(Offset);
 317   BuildMI(*MBB, Ins, DL, TII->get(AMDGPU::V_MOV_B32_e32), FIReg)
 318     .addFrameIndex(FrameIdx);
 319
 320   TII->getAddNoCarry(*MBB, Ins, DL, BaseReg)
 321     .addReg(OffsetReg, RegState::Kill)
 322     .addReg(FIReg);
 323 }
 324
 325 void SIRegisterInfo::resolveFrameIndex(MachineInstr &MI, unsigned BaseReg,
 326                                        int64_t Offset) const {
 327
 328   MachineBasicBlock *MBB = MI.getParent();
 329   MachineFunction *MF = MBB->getParent();
 330   const SISubtarget &Subtarget = MF->getSubtarget<SISubtarget>();
 331   const SIInstrInfo *TII = Subtarget.getInstrInfo();
 332
 333 #ifndef NDEBUG
 334   // FIXME: Is it possible to be storing a frame index to itself?
 335   bool SeenFI = false;
 336   for (const MachineOperand &MO: MI.operands()) {
 337     if (MO.isFI()) {
 338       if (SeenFI)
 339         llvm_unreachable("should not see multiple frame indices");
 340
 341       SeenFI = true;
 342     }
 343   }
 344 #endif
 345
 346   MachineOperand *FIOp = TII->getNamedOperand(MI, AMDGPU::OpName::vaddr);
 347   assert(FIOp && FIOp->isFI() && "frame index must be address operand");
 348   assert(TII->isMUBUF(MI));
 349   assert(TII->getNamedOperand(MI, AMDGPU::OpName::soffset)->getReg() ==
 350          MF->getInfo<SIMachineFunctionInfo>()->getFrameOffsetReg() &&
 351          "should only be seeing frame offset relative FrameIndex");
 352
 353
 354   MachineOperand *OffsetOp = TII->getNamedOperand(MI, AMDGPU::OpName::offset);
 355   int64_t NewOffset = OffsetOp->getImm() + Offset;
 356   assert(isUInt<12>(NewOffset) && "offset should be legal");
 357
 358   FIOp->ChangeToRegister(BaseReg, false);
 359   OffsetOp->setImm(NewOffset);
 360 }
 361
 362 bool SIRegisterInfo::isFrameOffsetLegal(const MachineInstr *MI,
 363                                         unsigned BaseReg,
 364                                         int64_t Offset) const {
 365   if (!SIInstrInfo::isMUBUF(*MI))
 366     return false;
 367
 368   int64_t NewOffset = Offset + getMUBUFInstrOffset(MI);
 369
 370   return isUInt<12>(NewOffset);
 371 }
 372
 373 const TargetRegisterClass *SIRegisterInfo::getPointerRegClass(
 374   const MachineFunction &MF, unsigned Kind) const {
 375   // This is inaccurate. It depends on the instruction and address space. The
 376   // only place where we should hit this is for dealing with frame indexes /
 377   // private accesses, so this is correct in that case.
 378   return &AMDGPU::VGPR_32RegClass;
 379 }
 380
 381 static unsigned getNumSubRegsForSpillOp(unsigned Op) {
 382
 383   switch (Op) {
 384   case AMDGPU::SI_SPILL_S512_SAVE:
 385   case AMDGPU::SI_SPILL_S512_RESTORE:
 386   case AMDGPU::SI_SPILL_V512_SAVE:
 387   case AMDGPU::SI_SPILL_V512_RESTORE:
 388     return 16;
 389   case AMDGPU::SI_SPILL_S256_SAVE:
 390   case AMDGPU::SI_SPILL_S256_RESTORE:
 391   case AMDGPU::SI_SPILL_V256_SAVE:
 392   case AMDGPU::SI_SPILL_V256_RESTORE:
 393     return 8;
 394   case AMDGPU::SI_SPILL_S128_SAVE:
 395   case AMDGPU::SI_SPILL_S128_RESTORE:
 396   case AMDGPU::SI_SPILL_V128_SAVE:
 397   case AMDGPU::SI_SPILL_V128_RESTORE:
 398     return 4;
 399   case AMDGPU::SI_SPILL_V96_SAVE:
 400   case AMDGPU::SI_SPILL_V96_RESTORE:
 401     return 3;
 402   case AMDGPU::SI_SPILL_S64_SAVE:
 403   case AMDGPU::SI_SPILL_S64_RESTORE:
 404   case AMDGPU::SI_SPILL_V64_SAVE:
 405   case AMDGPU::SI_SPILL_V64_RESTORE:
 406     return 2;
 407   case AMDGPU::SI_SPILL_S32_SAVE:
 408   case AMDGPU::SI_SPILL_S32_RESTORE:
 409   case AMDGPU::SI_SPILL_V32_SAVE:
 410   case AMDGPU::SI_SPILL_V32_RESTORE:
 411     return 1;
 412   default: llvm_unreachable("Invalid spill opcode");
 413   }
 414 }
 415
 416 static int getOffsetMUBUFStore(unsigned Opc) {
 417   switch (Opc) {
 418   case AMDGPU::BUFFER_STORE_DWORD_OFFEN:
 419     return AMDGPU::BUFFER_STORE_DWORD_OFFSET;
 420   case AMDGPU::BUFFER_STORE_BYTE_OFFEN:
 421     return AMDGPU::BUFFER_STORE_BYTE_OFFSET;
 422   case AMDGPU::BUFFER_STORE_SHORT_OFFEN:
 423     return AMDGPU::BUFFER_STORE_SHORT_OFFSET;
 424   case AMDGPU::BUFFER_STORE_DWORDX2_OFFEN:
 425     return AMDGPU::BUFFER_STORE_DWORDX2_OFFSET;
 426   case AMDGPU::BUFFER_STORE_DWORDX4_OFFEN:
 427     return AMDGPU::BUFFER_STORE_DWORDX4_OFFSET;
 428   default:
 429     return -1;
 430   }
 431 }
 432
 433 static int getOffsetMUBUFLoad(unsigned Opc) {
 434   switch (Opc) {
 435   case AMDGPU::BUFFER_LOAD_DWORD_OFFEN:
 436     return AMDGPU::BUFFER_LOAD_DWORD_OFFSET;
 437   case AMDGPU::BUFFER_LOAD_UBYTE_OFFEN:
 438     return AMDGPU::BUFFER_LOAD_UBYTE_OFFSET;
 439   case AMDGPU::BUFFER_LOAD_SBYTE_OFFEN:
 440     return AMDGPU::BUFFER_LOAD_SBYTE_OFFSET;
 441   case AMDGPU::BUFFER_LOAD_USHORT_OFFEN:
 442     return AMDGPU::BUFFER_LOAD_USHORT_OFFSET;
 443   case AMDGPU::BUFFER_LOAD_SSHORT_OFFEN:
 444     return AMDGPU::BUFFER_LOAD_SSHORT_OFFSET;
 445   case AMDGPU::BUFFER_LOAD_DWORDX2_OFFEN:
 446     return AMDGPU::BUFFER_LOAD_DWORDX2_OFFSET;
 447   case AMDGPU::BUFFER_LOAD_DWORDX4_OFFEN:
 448     return AMDGPU::BUFFER_LOAD_DWORDX4_OFFSET;
 449   default:
 450     return -1;
 451   }
 452 }
 453
 454 // This differs from buildSpillLoadStore by only scavenging a VGPR. It does not
 455 // need to handle the case where an SGPR may need to be spilled while spilling.
 456 static bool buildMUBUFOffsetLoadStore(const SIInstrInfo *TII,
 457                                       MachineFrameInfo &MFI,
 458                                       MachineBasicBlock::iterator MI,
 459                                       int Index,
 460                                       int64_t Offset) {
 461   MachineBasicBlock *MBB = MI->getParent();
 462   const DebugLoc &DL = MI->getDebugLoc();
 463   bool IsStore = MI->mayStore();
 464
 465   unsigned Opc = MI->getOpcode();
 466   int LoadStoreOp = IsStore ?
 467     getOffsetMUBUFStore(Opc) : getOffsetMUBUFLoad(Opc);
 468   if (LoadStoreOp == -1)
 469     return false;
 470
 471   unsigned Reg = TII->getNamedOperand(*MI, AMDGPU::OpName::vdata)->getReg();
 472
 473   BuildMI(*MBB, MI, DL, TII->get(LoadStoreOp))
 474       .addReg(Reg, getDefRegState(!IsStore))
 475       .add(*TII->getNamedOperand(*MI, AMDGPU::OpName::srsrc))
 476       .add(*TII->getNamedOperand(*MI, AMDGPU::OpName::soffset))
 477       .addImm(Offset)
 478       .addImm(0) // glc
 479       .addImm(0) // slc
 480       .addImm(0) // tfe
 481       .setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
 482   return true;
 483 }
 484
 485 void SIRegisterInfo::buildSpillLoadStore(MachineBasicBlock::iterator MI,
 486                                          unsigned LoadStoreOp,
 487                                          int Index,
 488                                          unsigned ValueReg,
 489                                          bool IsKill,
 490                                          unsigned ScratchRsrcReg,
 491                                          unsigned ScratchOffsetReg,
 492                                          int64_t InstOffset,
 493                                          MachineMemOperand *MMO,
 494                                          RegScavenger *RS) const {
 495   MachineBasicBlock *MBB = MI->getParent();
 496   MachineFunction *MF = MI->getParent()->getParent();
 497   const SISubtarget &ST =  MF->getSubtarget<SISubtarget>();
 498   const SIInstrInfo *TII = ST.getInstrInfo();
 499   const MachineFrameInfo &MFI = MF->getFrameInfo();
 500
 501   const MCInstrDesc &Desc = TII->get(LoadStoreOp);
 502   const DebugLoc &DL = MI->getDebugLoc();
 503   bool IsStore = Desc.mayStore();
 504
 505   bool RanOutOfSGPRs = false;
 506   bool Scavenged = false;
 507   unsigned SOffset = ScratchOffsetReg;
 508
 509   const TargetRegisterClass *RC = getRegClassForReg(MF->getRegInfo(), ValueReg);
 510   unsigned NumSubRegs = AMDGPU::getRegBitWidth(RC->getID()) / 32;
 511   unsigned Size = NumSubRegs * 4;
 512   int64_t Offset = InstOffset + MFI.getObjectOffset(Index);
 513   const int64_t OriginalImmOffset = Offset;
 514
 515   unsigned Align = MFI.getObjectAlignment(Index);
 516   const MachinePointerInfo &BasePtrInfo = MMO->getPointerInfo();
 517
 518   if (!isUInt<12>(Offset + Size)) {
 519     SOffset = AMDGPU::NoRegister;
 520
 521     // We don't have access to the register scavenger if this function is called
 522     // during  PEI::scavengeFrameVirtualRegs().
 523     if (RS)
 524       SOffset = RS->FindUnusedReg(&AMDGPU::SGPR_32RegClass);
 525
 526     if (SOffset == AMDGPU::NoRegister) {
 527       // There are no free SGPRs, and since we are in the process of spilling
 528       // VGPRs too.  Since we need a VGPR in order to spill SGPRs (this is true
 529       // on SI/CI and on VI it is true until we implement spilling using scalar
 530       // stores), we have no way to free up an SGPR.  Our solution here is to
 531       // add the offset directly to the ScratchOffset register, and then
 532       // subtract the offset after the spill to return ScratchOffset to it's
 533       // original value.
 534       RanOutOfSGPRs = true;
 535       SOffset = ScratchOffsetReg;
 536     } else {
 537       Scavenged = true;
 538     }
 539
 540     BuildMI(*MBB, MI, DL, TII->get(AMDGPU::S_ADD_U32), SOffset)
 541       .addReg(ScratchOffsetReg)
 542       .addImm(Offset);
 543
 544     Offset = 0;
 545   }
 546
 547   const unsigned EltSize = 4;
 548
 549   for (unsigned i = 0, e = NumSubRegs; i != e; ++i, Offset += EltSize) {
 550     unsigned SubReg = NumSubRegs == 1 ?
 551       ValueReg : getSubReg(ValueReg, getSubRegFromChannel(i));
 552
 553     unsigned SOffsetRegState = 0;
 554     unsigned SrcDstRegState = getDefRegState(!IsStore);
 555     if (i + 1 == e) {
 556       SOffsetRegState |= getKillRegState(Scavenged);
 557       // The last implicit use carries the "Kill" flag.
 558       SrcDstRegState |= getKillRegState(IsKill);
 559     }
 560
 561     MachinePointerInfo PInfo = BasePtrInfo.getWithOffset(EltSize * i);
 562     MachineMemOperand *NewMMO
 563       = MF->getMachineMemOperand(PInfo, MMO->getFlags(),
 564                                  EltSize, MinAlign(Align, EltSize * i));
 565
 566     auto MIB = BuildMI(*MBB, MI, DL, Desc)
 567       .addReg(SubReg, getDefRegState(!IsStore) | getKillRegState(IsKill))
 568       .addReg(ScratchRsrcReg)
 569       .addReg(SOffset, SOffsetRegState)
 570       .addImm(Offset)
 571       .addImm(0) // glc
 572       .addImm(0) // slc
 573       .addImm(0) // tfe
 574       .addMemOperand(NewMMO);
 575
 576     if (NumSubRegs > 1)
 577       MIB.addReg(ValueReg, RegState::Implicit | SrcDstRegState);
 578   }
 579
 580   if (RanOutOfSGPRs) {
 581     // Subtract the offset we added to the ScratchOffset register.
 582     BuildMI(*MBB, MI, DL, TII->get(AMDGPU::S_SUB_U32), ScratchOffsetReg)
 583       .addReg(ScratchOffsetReg)
 584       .addImm(OriginalImmOffset);
 585   }
 586 }
 587
 588 static std::pair<unsigned, unsigned> getSpillEltSize(unsigned SuperRegSize,
 589                                                      bool Store) {
 590   if (SuperRegSize % 16 == 0) {
 591     return { 16, Store ? AMDGPU::S_BUFFER_STORE_DWORDX4_SGPR :
 592                          AMDGPU::S_BUFFER_LOAD_DWORDX4_SGPR };
 593   }
 594
 595   if (SuperRegSize % 8 == 0) {
 596     return { 8, Store ? AMDGPU::S_BUFFER_STORE_DWORDX2_SGPR :
 597                         AMDGPU::S_BUFFER_LOAD_DWORDX2_SGPR };
 598   }
 599
 600   return { 4, Store ? AMDGPU::S_BUFFER_STORE_DWORD_SGPR :
 601                       AMDGPU::S_BUFFER_LOAD_DWORD_SGPR};
 602 }
 603
 604 bool SIRegisterInfo::spillSGPR(MachineBasicBlock::iterator MI,
 605                                int Index,
 606                                RegScavenger *RS,
 607                                bool OnlyToVGPR) const {
 608   MachineBasicBlock *MBB = MI->getParent();
 609   MachineFunction *MF = MBB->getParent();
 610   SIMachineFunctionInfo *MFI = MF->getInfo<SIMachineFunctionInfo>();
 611
 612   ArrayRef<SIMachineFunctionInfo::SpilledReg> VGPRSpills
 613     = MFI->getSGPRToVGPRSpills(Index);
 614   bool SpillToVGPR = !VGPRSpills.empty();
 615   if (OnlyToVGPR && !SpillToVGPR)
 616     return false;
 617
 618   MachineRegisterInfo &MRI = MF->getRegInfo();
 619   const SISubtarget &ST =  MF->getSubtarget<SISubtarget>();
 620   const SIInstrInfo *TII = ST.getInstrInfo();
 621
 622   unsigned SuperReg = MI->getOperand(0).getReg();
 623   bool IsKill = MI->getOperand(0).isKill();
 624   const DebugLoc &DL = MI->getDebugLoc();
 625
 626   MachineFrameInfo &FrameInfo = MF->getFrameInfo();
 627
 628   bool SpillToSMEM = spillSGPRToSMEM();
 629   if (SpillToSMEM && OnlyToVGPR)
 630     return false;
 631
 632   assert(SuperReg != AMDGPU::M0 && "m0 should never spill");
 633
 634   unsigned OffsetReg = AMDGPU::M0;
 635   unsigned M0CopyReg = AMDGPU::NoRegister;
 636
 637   if (SpillToSMEM) {
 638     if (RS->isRegUsed(AMDGPU::M0)) {
 639       M0CopyReg = MRI.createVirtualRegister(&AMDGPU::SReg_32_XM0RegClass);
 640       BuildMI(*MBB, MI, DL, TII->get(AMDGPU::COPY), M0CopyReg)
 641         .addReg(AMDGPU::M0);
 642     }
 643   }
 644
 645   unsigned ScalarStoreOp;
 646   unsigned EltSize = 4;
 647   const TargetRegisterClass *RC = getPhysRegClass(SuperReg);
 648   if (SpillToSMEM && isSGPRClass(RC)) {
 649     // XXX - if private_element_size is larger than 4 it might be useful to be
 650     // able to spill wider vmem spills.
 651     std::tie(EltSize, ScalarStoreOp) =
 652           getSpillEltSize(getRegSizeInBits(*RC) / 8, true);
 653   }
 654
 655   ArrayRef<int16_t> SplitParts = getRegSplitParts(RC, EltSize);
 656   unsigned NumSubRegs = SplitParts.empty() ? 1 : SplitParts.size();
 657
 658   // SubReg carries the "Kill" flag when SubReg == SuperReg.
 659   unsigned SubKillState = getKillRegState((NumSubRegs == 1) && IsKill);
 660   for (unsigned i = 0, e = NumSubRegs; i < e; ++i) {
 661     unsigned SubReg = NumSubRegs == 1 ?
 662       SuperReg : getSubReg(SuperReg, SplitParts[i]);
 663
 664     if (SpillToSMEM) {
 665       int64_t FrOffset = FrameInfo.getObjectOffset(Index);
 666
 667       // The allocated memory size is really the wavefront size * the frame
 668       // index size. The widest register class is 64 bytes, so a 4-byte scratch
 669       // allocation is enough to spill this in a single stack object.
 670       //
 671       // FIXME: Frame size/offsets are computed earlier than this, so the extra
 672       // space is still unnecessarily allocated.
 673
 674       unsigned Align = FrameInfo.getObjectAlignment(Index);
 675       MachinePointerInfo PtrInfo
 676         = MachinePointerInfo::getFixedStack(*MF, Index, EltSize * i);
 677       MachineMemOperand *MMO
 678         = MF->getMachineMemOperand(PtrInfo, MachineMemOperand::MOStore,
 679                                    EltSize, MinAlign(Align, EltSize * i));
 680
 681       // SMEM instructions only support a single offset, so increment the wave
 682       // offset.
 683
 684       int64_t Offset = (ST.getWavefrontSize() * FrOffset) + (EltSize * i);
 685       if (Offset != 0) {
 686         BuildMI(*MBB, MI, DL, TII->get(AMDGPU::S_ADD_U32), OffsetReg)
 687           .addReg(MFI->getFrameOffsetReg())
 688           .addImm(Offset);
 689       } else {
 690         BuildMI(*MBB, MI, DL, TII->get(AMDGPU::S_MOV_B32), OffsetReg)
 691           .addReg(MFI->getFrameOffsetReg());
 692       }
 693
 694       BuildMI(*MBB, MI, DL, TII->get(ScalarStoreOp))
 695         .addReg(SubReg, getKillRegState(IsKill)) // sdata
 696         .addReg(MFI->getScratchRSrcReg())        // sbase
 697         .addReg(OffsetReg, RegState::Kill)       // soff
 698         .addImm(0)                               // glc
 699         .addMemOperand(MMO);
 700
 701       continue;
 702     }
 703
 704     if (SpillToVGPR) {
 705       SIMachineFunctionInfo::SpilledReg Spill = VGPRSpills[i];
 706
 707       BuildMI(*MBB, MI, DL,
 708               TII->getMCOpcodeFromPseudo(AMDGPU::V_WRITELANE_B32),
 709               Spill.VGPR)
 710         .addReg(SubReg, getKillRegState(IsKill))
 711         .addImm(Spill.Lane);
 712
 713       // FIXME: Since this spills to another register instead of an actual
 714       // frame index, we should delete the frame index when all references to
 715       // it are fixed.
 716     } else {
 717       // XXX - Can to VGPR spill fail for some subregisters but not others?
 718       if (OnlyToVGPR)
 719         return false;
 720
 721       // Spill SGPR to a frame index.
 722       // TODO: Should VI try to spill to VGPR and then spill to SMEM?
 723       unsigned TmpReg = MRI.createVirtualRegister(&AMDGPU::VGPR_32RegClass);
 724       // TODO: Should VI try to spill to VGPR and then spill to SMEM?
 725
 726       MachineInstrBuilder Mov
 727         = BuildMI(*MBB, MI, DL, TII->get(AMDGPU::V_MOV_B32_e32), TmpReg)
 728         .addReg(SubReg, SubKillState);
 729
 730
 731       // There could be undef components of a spilled super register.
 732       // TODO: Can we detect this and skip the spill?
 733       if (NumSubRegs > 1) {
 734         // The last implicit use of the SuperReg carries the "Kill" flag.
 735         unsigned SuperKillState = 0;
 736         if (i + 1 == e)
 737           SuperKillState |= getKillRegState(IsKill);
 738         Mov.addReg(SuperReg, RegState::Implicit | SuperKillState);
 739       }
 740
 741       unsigned Align = FrameInfo.getObjectAlignment(Index);
 742       MachinePointerInfo PtrInfo
 743         = MachinePointerInfo::getFixedStack(*MF, Index, EltSize * i);
 744       MachineMemOperand *MMO
 745         = MF->getMachineMemOperand(PtrInfo, MachineMemOperand::MOStore,
 746                                    EltSize, MinAlign(Align, EltSize * i));
 747       BuildMI(*MBB, MI, DL, TII->get(AMDGPU::SI_SPILL_V32_SAVE))
 748         .addReg(TmpReg, RegState::Kill)    // src
 749         .addFrameIndex(Index)              // vaddr
 750         .addReg(MFI->getScratchRSrcReg())  // srrsrc
 751         .addReg(MFI->getFrameOffsetReg())  // soffset
 752         .addImm(i * 4)                     // offset
 753         .addMemOperand(MMO);
 754     }
 755   }
 756
 757   if (M0CopyReg != AMDGPU::NoRegister) {
 758     BuildMI(*MBB, MI, DL, TII->get(AMDGPU::COPY), AMDGPU::M0)
 759       .addReg(M0CopyReg, RegState::Kill);
 760   }
 761
 762   MI->eraseFromParent();
 763   MFI->addToSpilledSGPRs(NumSubRegs);
 764   return true;
 765 }
 766
 767 bool SIRegisterInfo::restoreSGPR(MachineBasicBlock::iterator MI,
 768                                  int Index,
 769                                  RegScavenger *RS,
 770                                  bool OnlyToVGPR) const {
 771   MachineFunction *MF = MI->getParent()->getParent();
 772   MachineRegisterInfo &MRI = MF->getRegInfo();
 773   MachineBasicBlock *MBB = MI->getParent();
 774   SIMachineFunctionInfo *MFI = MF->getInfo<SIMachineFunctionInfo>();
 775
 776   ArrayRef<SIMachineFunctionInfo::SpilledReg> VGPRSpills
 777     = MFI->getSGPRToVGPRSpills(Index);
 778   bool SpillToVGPR = !VGPRSpills.empty();
 779   if (OnlyToVGPR && !SpillToVGPR)
 780     return false;
 781
 782   MachineFrameInfo &FrameInfo = MF->getFrameInfo();
 783   const SISubtarget &ST =  MF->getSubtarget<SISubtarget>();
 784   const SIInstrInfo *TII = ST.getInstrInfo();
 785   const DebugLoc &DL = MI->getDebugLoc();
 786
 787   unsigned SuperReg = MI->getOperand(0).getReg();
 788   bool SpillToSMEM = spillSGPRToSMEM();
 789   if (SpillToSMEM && OnlyToVGPR)
 790     return false;
 791
 792   assert(SuperReg != AMDGPU::M0 && "m0 should never spill");
 793
 794   unsigned OffsetReg = AMDGPU::M0;
 795   unsigned M0CopyReg = AMDGPU::NoRegister;
 796
 797   if (SpillToSMEM) {
 798     if (RS->isRegUsed(AMDGPU::M0)) {
 799       M0CopyReg = MRI.createVirtualRegister(&AMDGPU::SReg_32_XM0RegClass);
 800       BuildMI(*MBB, MI, DL, TII->get(AMDGPU::COPY), M0CopyReg)
 801         .addReg(AMDGPU::M0);
 802     }
 803   }
 804
 805   unsigned EltSize = 4;
 806   unsigned ScalarLoadOp;
 807
 808   const TargetRegisterClass *RC = getPhysRegClass(SuperReg);
 809   if (SpillToSMEM && isSGPRClass(RC)) {
 810     // XXX - if private_element_size is larger than 4 it might be useful to be
 811     // able to spill wider vmem spills.
 812     std::tie(EltSize, ScalarLoadOp) =
 813           getSpillEltSize(getRegSizeInBits(*RC) / 8, false);
 814   }
 815
 816   ArrayRef<int16_t> SplitParts = getRegSplitParts(RC, EltSize);
 817   unsigned NumSubRegs = SplitParts.empty() ? 1 : SplitParts.size();
 818
 819   // SubReg carries the "Kill" flag when SubReg == SuperReg.
 820   int64_t FrOffset = FrameInfo.getObjectOffset(Index);
 821
 822   for (unsigned i = 0, e = NumSubRegs; i < e; ++i) {
 823     unsigned SubReg = NumSubRegs == 1 ?
 824       SuperReg : getSubReg(SuperReg, SplitParts[i]);
 825
 826     if (SpillToSMEM) {
 827       // FIXME: Size may be > 4 but extra bytes wasted.
 828       unsigned Align = FrameInfo.getObjectAlignment(Index);
 829       MachinePointerInfo PtrInfo
 830         = MachinePointerInfo::getFixedStack(*MF, Index, EltSize * i);
 831       MachineMemOperand *MMO
 832         = MF->getMachineMemOperand(PtrInfo, MachineMemOperand::MOLoad,
 833                                    EltSize, MinAlign(Align, EltSize * i));
 834
 835       // Add i * 4 offset
 836       int64_t Offset = (ST.getWavefrontSize() * FrOffset) + (EltSize * i);
 837       if (Offset != 0) {
 838         BuildMI(*MBB, MI, DL, TII->get(AMDGPU::S_ADD_U32), OffsetReg)
 839           .addReg(MFI->getFrameOffsetReg())
 840           .addImm(Offset);
 841       } else {
 842         BuildMI(*MBB, MI, DL, TII->get(AMDGPU::S_MOV_B32), OffsetReg)
 843           .addReg(MFI->getFrameOffsetReg());
 844       }
 845
 846       auto MIB =
 847         BuildMI(*MBB, MI, DL, TII->get(ScalarLoadOp), SubReg)
 848         .addReg(MFI->getScratchRSrcReg()) // sbase
 849         .addReg(OffsetReg, RegState::Kill)                // soff
 850         .addImm(0)                        // glc
 851         .addMemOperand(MMO);
 852
 853       if (NumSubRegs > 1)
 854         MIB.addReg(SuperReg, RegState::ImplicitDefine);
 855
 856       continue;
 857     }
 858
 859     if (SpillToVGPR) {
 860       SIMachineFunctionInfo::SpilledReg Spill = VGPRSpills[i];
 861       auto MIB =
 862         BuildMI(*MBB, MI, DL, TII->getMCOpcodeFromPseudo(AMDGPU::V_READLANE_B32),
 863                 SubReg)
 864         .addReg(Spill.VGPR)
 865         .addImm(Spill.Lane);
 866
 867       if (NumSubRegs > 1)
 868         MIB.addReg(SuperReg, RegState::ImplicitDefine);
 869     } else {
 870       if (OnlyToVGPR)
 871         return false;
 872
 873       // Restore SGPR from a stack slot.
 874       // FIXME: We should use S_LOAD_DWORD here for VI.
 875       unsigned TmpReg = MRI.createVirtualRegister(&AMDGPU::VGPR_32RegClass);
 876       unsigned Align = FrameInfo.getObjectAlignment(Index);
 877
 878       MachinePointerInfo PtrInfo
 879         = MachinePointerInfo::getFixedStack(*MF, Index, EltSize * i);
 880
 881       MachineMemOperand *MMO = MF->getMachineMemOperand(PtrInfo,
 882         MachineMemOperand::MOLoad, EltSize,
 883         MinAlign(Align, EltSize * i));
 884
 885       BuildMI(*MBB, MI, DL, TII->get(AMDGPU::SI_SPILL_V32_RESTORE), TmpReg)
 886         .addFrameIndex(Index)              // vaddr
 887         .addReg(MFI->getScratchRSrcReg())  // srsrc
 888         .addReg(MFI->getFrameOffsetReg())  // soffset
 889         .addImm(i * 4)                     // offset
 890         .addMemOperand(MMO);
 891
 892       auto MIB =
 893         BuildMI(*MBB, MI, DL, TII->get(AMDGPU::V_READFIRSTLANE_B32), SubReg)
 894         .addReg(TmpReg, RegState::Kill);
 895
 896       if (NumSubRegs > 1)
 897         MIB.addReg(MI->getOperand(0).getReg(), RegState::ImplicitDefine);
 898     }
 899   }
 900
 901   if (M0CopyReg != AMDGPU::NoRegister) {
 902     BuildMI(*MBB, MI, DL, TII->get(AMDGPU::COPY), AMDGPU::M0)
 903       .addReg(M0CopyReg, RegState::Kill);
 904   }
 905
 906   MI->eraseFromParent();
 907   return true;
 908 }
 909
 910 /// Special case of eliminateFrameIndex. Returns true if the SGPR was spilled to
 911 /// a VGPR and the stack slot can be safely eliminated when all other users are
 912 /// handled.
 913 bool SIRegisterInfo::eliminateSGPRToVGPRSpillFrameIndex(
 914   MachineBasicBlock::iterator MI,
 915   int FI,
 916   RegScavenger *RS) const {
 917   switch (MI->getOpcode()) {
 918   case AMDGPU::SI_SPILL_S512_SAVE:
 919   case AMDGPU::SI_SPILL_S256_SAVE:
 920   case AMDGPU::SI_SPILL_S128_SAVE:
 921   case AMDGPU::SI_SPILL_S64_SAVE:
 922   case AMDGPU::SI_SPILL_S32_SAVE:
 923     return spillSGPR(MI, FI, RS, true);
 924   case AMDGPU::SI_SPILL_S512_RESTORE:
 925   case AMDGPU::SI_SPILL_S256_RESTORE:
 926   case AMDGPU::SI_SPILL_S128_RESTORE:
 927   case AMDGPU::SI_SPILL_S64_RESTORE:
 928   case AMDGPU::SI_SPILL_S32_RESTORE:
 929     return restoreSGPR(MI, FI, RS, true);
 930   default:
 931     llvm_unreachable("not an SGPR spill instruction");
 932   }
 933 }
 934
 935 void SIRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator MI,
 936                                         int SPAdj, unsigned FIOperandNum,
 937                                         RegScavenger *RS) const {
 938   MachineFunction *MF = MI->getParent()->getParent();
 939   MachineRegisterInfo &MRI = MF->getRegInfo();
 940   MachineBasicBlock *MBB = MI->getParent();
 941   SIMachineFunctionInfo *MFI = MF->getInfo<SIMachineFunctionInfo>();
 942   MachineFrameInfo &FrameInfo = MF->getFrameInfo();
 943   const SISubtarget &ST =  MF->getSubtarget<SISubtarget>();
 944   const SIInstrInfo *TII = ST.getInstrInfo();
 945   DebugLoc DL = MI->getDebugLoc();
 946
 947   MachineOperand &FIOp = MI->getOperand(FIOperandNum);
 948   int Index = MI->getOperand(FIOperandNum).getIndex();
 949
 950   switch (MI->getOpcode()) {
 951     // SGPR register spill
 952     case AMDGPU::SI_SPILL_S512_SAVE:
 953     case AMDGPU::SI_SPILL_S256_SAVE:
 954     case AMDGPU::SI_SPILL_S128_SAVE:
 955     case AMDGPU::SI_SPILL_S64_SAVE:
 956     case AMDGPU::SI_SPILL_S32_SAVE: {
 957       spillSGPR(MI, Index, RS);
 958       break;
 959     }
 960
 961     // SGPR register restore
 962     case AMDGPU::SI_SPILL_S512_RESTORE:
 963     case AMDGPU::SI_SPILL_S256_RESTORE:
 964     case AMDGPU::SI_SPILL_S128_RESTORE:
 965     case AMDGPU::SI_SPILL_S64_RESTORE:
 966     case AMDGPU::SI_SPILL_S32_RESTORE: {
 967       restoreSGPR(MI, Index, RS);
 968       break;
 969     }
 970
 971     // VGPR register spill
 972     case AMDGPU::SI_SPILL_V512_SAVE:
 973     case AMDGPU::SI_SPILL_V256_SAVE:
 974     case AMDGPU::SI_SPILL_V128_SAVE:
 975     case AMDGPU::SI_SPILL_V96_SAVE:
 976     case AMDGPU::SI_SPILL_V64_SAVE:
 977     case AMDGPU::SI_SPILL_V32_SAVE: {
 978       const MachineOperand *VData = TII->getNamedOperand(*MI,
 979                                                          AMDGPU::OpName::vdata);
 980       buildSpillLoadStore(MI, AMDGPU::BUFFER_STORE_DWORD_OFFSET,
 981             Index,
 982             VData->getReg(), VData->isKill(),
 983             TII->getNamedOperand(*MI, AMDGPU::OpName::srsrc)->getReg(),
 984             TII->getNamedOperand(*MI, AMDGPU::OpName::soffset)->getReg(),
 985             TII->getNamedOperand(*MI, AMDGPU::OpName::offset)->getImm(),
 986             *MI->memoperands_begin(),
 987             RS);
 988       MFI->addToSpilledVGPRs(getNumSubRegsForSpillOp(MI->getOpcode()));
 989       MI->eraseFromParent();
 990       break;
 991     }
 992     case AMDGPU::SI_SPILL_V32_RESTORE:
 993     case AMDGPU::SI_SPILL_V64_RESTORE:
 994     case AMDGPU::SI_SPILL_V96_RESTORE:
 995     case AMDGPU::SI_SPILL_V128_RESTORE:
 996     case AMDGPU::SI_SPILL_V256_RESTORE:
 997     case AMDGPU::SI_SPILL_V512_RESTORE: {
 998       const MachineOperand *VData = TII->getNamedOperand(*MI,
 999                                                          AMDGPU::OpName::vdata);
1000
1001       buildSpillLoadStore(MI, AMDGPU::BUFFER_LOAD_DWORD_OFFSET,
1002             Index,
1003             VData->getReg(), VData->isKill(),
1004             TII->getNamedOperand(*MI, AMDGPU::OpName::srsrc)->getReg(),
1005             TII->getNamedOperand(*MI, AMDGPU::OpName::soffset)->getReg(),
1006             TII->getNamedOperand(*MI, AMDGPU::OpName::offset)->getImm(),
1007             *MI->memoperands_begin(),
1008             RS);
1009       MI->eraseFromParent();
1010       break;
1011     }
1012
1013     default: {
1014       const DebugLoc &DL = MI->getDebugLoc();
1015       bool IsMUBUF = TII->isMUBUF(*MI);
1016
1017       if (!IsMUBUF &&
1018           MFI->getFrameOffsetReg() != MFI->getScratchWaveOffsetReg()) {
1019         // Convert to an absolute stack address by finding the offset from the
1020         // scratch wave base and scaling by the wave size.
1021         //
1022         // In an entry function/kernel the stack address is already the absolute
1023         // address relative to the the scratch wave offset.
1024
1025         unsigned DiffReg
1026           = MRI.createVirtualRegister(&AMDGPU::SReg_32_XM0RegClass);
1027
1028         bool IsCopy = MI->getOpcode() == AMDGPU::V_MOV_B32_e32;
1029         unsigned ResultReg = IsCopy ?
1030           MI->getOperand(0).getReg() :
1031           MRI.createVirtualRegister(&AMDGPU::VGPR_32RegClass);
1032
1033         BuildMI(*MBB, MI, DL, TII->get(AMDGPU::S_SUB_U32), DiffReg)
1034           .addReg(MFI->getFrameOffsetReg())
1035           .addReg(MFI->getScratchWaveOffsetReg());
1036
1037         int64_t Offset = FrameInfo.getObjectOffset(Index);
1038         if (Offset == 0) {
1039           // XXX - This never happens because of emergency scavenging slot at 0?
1040           BuildMI(*MBB, MI, DL, TII->get(AMDGPU::V_LSHRREV_B32_e64), ResultReg)
1041             .addImm(Log2_32(ST.getWavefrontSize()))
1042             .addReg(DiffReg);
1043         } else {
1044           unsigned CarryOut
1045             = MRI.createVirtualRegister(&AMDGPU::SReg_64_XEXECRegClass);
1046           unsigned ScaledReg
1047             = MRI.createVirtualRegister(&AMDGPU::SReg_32_XM0RegClass);
1048
1049           // XXX - Should this use a vector shift?
1050           BuildMI(*MBB, MI, DL, TII->get(AMDGPU::S_LSHR_B32), ScaledReg)
1051             .addReg(DiffReg, RegState::Kill)
1052             .addImm(Log2_32(ST.getWavefrontSize()));
1053
1054           // TODO: Fold if use instruction is another add of a constant.
1055           BuildMI(*MBB, MI, DL, TII->get(AMDGPU::V_ADD_I32_e64), ResultReg)
1056             .addReg(CarryOut, RegState::Define | RegState::Dead)
1057             .addImm(Offset)
1058             .addReg(ScaledReg, RegState::Kill);
1059
1060           MRI.setRegAllocationHint(CarryOut, 0, AMDGPU::VCC);
1061         }
1062
1063         // Don't introduce an extra copy if we're just materializing in a mov.
1064         if (IsCopy)
1065           MI->eraseFromParent();
1066         else
1067           FIOp.ChangeToRegister(ResultReg, false, false, true);
1068         return;
1069       }
1070
1071       if (IsMUBUF) {
1072         // Disable offen so we don't need a 0 vgpr base.
1073         assert(static_cast<int>(FIOperandNum) ==
1074                AMDGPU::getNamedOperandIdx(MI->getOpcode(),
1075                                           AMDGPU::OpName::vaddr));
1076
1077         assert(TII->getNamedOperand(*MI, AMDGPU::OpName::soffset)->getReg()
1078                == MFI->getFrameOffsetReg());
1079
1080         int64_t Offset = FrameInfo.getObjectOffset(Index);
1081         int64_t OldImm
1082           = TII->getNamedOperand(*MI, AMDGPU::OpName::offset)->getImm();
1083         int64_t NewOffset = OldImm + Offset;
1084
1085         if (isUInt<12>(NewOffset) &&
1086             buildMUBUFOffsetLoadStore(TII, FrameInfo, MI, Index, NewOffset)) {
1087           MI->eraseFromParent();
1088           return;
1089         }
1090       }
1091
1092       // If the offset is simply too big, don't convert to a scratch wave offset
1093       // relative index.
1094
1095       int64_t Offset = FrameInfo.getObjectOffset(Index);
1096       FIOp.ChangeToImmediate(Offset);
1097       if (!TII->isImmOperandLegal(*MI, FIOperandNum, FIOp)) {
1098         unsigned TmpReg = MRI.createVirtualRegister(&AMDGPU::VGPR_32RegClass);
1099         BuildMI(*MBB, MI, DL, TII->get(AMDGPU::V_MOV_B32_e32), TmpReg)
1100           .addImm(Offset);
1101         FIOp.ChangeToRegister(TmpReg, false, false, true);
1102       }
1103     }
1104   }
1105 }
1106
1107 // FIXME: This is very slow. It might be worth creating a map from physreg to
1108 // register class.
1109 const TargetRegisterClass *SIRegisterInfo::getPhysRegClass(unsigned Reg) const {
1110   assert(!TargetRegisterInfo::isVirtualRegister(Reg));
1111
1112   static const TargetRegisterClass *const BaseClasses[] = {
1113     &AMDGPU::VGPR_32RegClass,
1114     &AMDGPU::SReg_32RegClass,
1115     &AMDGPU::VReg_64RegClass,
1116     &AMDGPU::SReg_64RegClass,
1117     &AMDGPU::VReg_96RegClass,
1118     &AMDGPU::VReg_128RegClass,
1119     &AMDGPU::SReg_128RegClass,
1120     &AMDGPU::VReg_256RegClass,
1121     &AMDGPU::SReg_256RegClass,
1122     &AMDGPU::VReg_512RegClass,
1123     &AMDGPU::SReg_512RegClass,
1124     &AMDGPU::SCC_CLASSRegClass,
1125   };
1126
1127   for (const TargetRegisterClass *BaseClass : BaseClasses) {
1128     if (BaseClass->contains(Reg)) {
1129       return BaseClass;
1130     }
1131   }
1132   return nullptr;
1133 }
1134
1135 // TODO: It might be helpful to have some target specific flags in
1136 // TargetRegisterClass to mark which classes are VGPRs to make this trivial.
1137 bool SIRegisterInfo::hasVGPRs(const TargetRegisterClass *RC) const {
1138   unsigned Size = getRegSizeInBits(*RC);
1139   if (Size < 32)
1140     return false;
1141   switch (Size) {
1142   case 32:
1143     return getCommonSubClass(&AMDGPU::VGPR_32RegClass, RC) != nullptr;
1144   case 64:
1145     return getCommonSubClass(&AMDGPU::VReg_64RegClass, RC) != nullptr;
1146   case 96:
1147     return getCommonSubClass(&AMDGPU::VReg_96RegClass, RC) != nullptr;
1148   case 128:
1149     return getCommonSubClass(&AMDGPU::VReg_128RegClass, RC) != nullptr;
1150   case 256:
1151     return getCommonSubClass(&AMDGPU::VReg_256RegClass, RC) != nullptr;
1152   case 512:
1153     return getCommonSubClass(&AMDGPU::VReg_512RegClass, RC) != nullptr;
1154   default:
1155     llvm_unreachable("Invalid register class size");
1156   }
1157 }
1158
1159 const TargetRegisterClass *SIRegisterInfo::getEquivalentVGPRClass(
1160                                          const TargetRegisterClass *SRC) const {
1161   switch (getRegSizeInBits(*SRC)) {
1162   case 32:
1163     return &AMDGPU::VGPR_32RegClass;
1164   case 64:
1165     return &AMDGPU::VReg_64RegClass;
1166   case 96:
1167     return &AMDGPU::VReg_96RegClass;
1168   case 128:
1169     return &AMDGPU::VReg_128RegClass;
1170   case 256:
1171     return &AMDGPU::VReg_256RegClass;
1172   case 512:
1173     return &AMDGPU::VReg_512RegClass;
1174   default:
1175     llvm_unreachable("Invalid register class size");
1176   }
1177 }
1178
1179 const TargetRegisterClass *SIRegisterInfo::getEquivalentSGPRClass(
1180                                          const TargetRegisterClass *VRC) const {
1181   switch (getRegSizeInBits(*VRC)) {
1182   case 32:
1183     return &AMDGPU::SGPR_32RegClass;
1184   case 64:
1185     return &AMDGPU::SReg_64RegClass;
1186   case 128:
1187     return &AMDGPU::SReg_128RegClass;
1188   case 256:
1189     return &AMDGPU::SReg_256RegClass;
1190   case 512:
1191     return &AMDGPU::SReg_512RegClass;
1192   default:
1193     llvm_unreachable("Invalid register class size");
1194   }
1195 }
1196
1197 const TargetRegisterClass *SIRegisterInfo::getSubRegClass(
1198                          const TargetRegisterClass *RC, unsigned SubIdx) const {
1199   if (SubIdx == AMDGPU::NoSubRegister)
1200     return RC;
1201
1202   // We can assume that each lane corresponds to one 32-bit register.
1203   LaneBitmask::Type Mask = getSubRegIndexLaneMask(SubIdx).getAsInteger();
1204   unsigned Count = countPopulation(Mask);
1205   if (isSGPRClass(RC)) {
1206     switch (Count) {
1207     case 1:
1208       return &AMDGPU::SGPR_32RegClass;
1209     case 2:
1210       return &AMDGPU::SReg_64RegClass;
1211     case 4:
1212       return &AMDGPU::SReg_128RegClass;
1213     case 8:
1214       return &AMDGPU::SReg_256RegClass;
1215     case 16: /* fall-through */
1216     default:
1217       llvm_unreachable("Invalid sub-register class size");
1218     }
1219   } else {
1220     switch (Count) {
1221     case 1:
1222       return &AMDGPU::VGPR_32RegClass;
1223     case 2:
1224       return &AMDGPU::VReg_64RegClass;
1225     case 3:
1226       return &AMDGPU::VReg_96RegClass;
1227     case 4:
1228       return &AMDGPU::VReg_128RegClass;
1229     case 8:
1230       return &AMDGPU::VReg_256RegClass;
1231     case 16: /* fall-through */
1232     default:
1233       llvm_unreachable("Invalid sub-register class size");
1234     }
1235   }
1236 }
1237
1238 bool SIRegisterInfo::shouldRewriteCopySrc(
1239   const TargetRegisterClass *DefRC,
1240   unsigned DefSubReg,
1241   const TargetRegisterClass *SrcRC,
1242   unsigned SrcSubReg) const {
1243   // We want to prefer the smallest register class possible, so we don't want to
1244   // stop and rewrite on anything that looks like a subregister
1245   // extract. Operations mostly don't care about the super register class, so we
1246   // only want to stop on the most basic of copies between the same register
1247   // class.
1248   //
1249   // e.g. if we have something like
1250   // vreg0 = ...
1251   // vreg1 = ...
1252   // vreg2 = REG_SEQUENCE vreg0, sub0, vreg1, sub1, vreg2, sub2
1253   // vreg3 = COPY vreg2, sub0
1254   //
1255   // We want to look through the COPY to find:
1256   //  => vreg3 = COPY vreg0
1257
1258   // Plain copy.
1259   return getCommonSubClass(DefRC, SrcRC) != nullptr;
1260 }
1261
1262 // FIXME: Most of these are flexible with HSA and we don't need to reserve them
1263 // as input registers if unused. Whether the dispatch ptr is necessary should be
1264 // easy to detect from used intrinsics. Scratch setup is harder to know.
1265 unsigned SIRegisterInfo::getPreloadedValue(const MachineFunction &MF,
1266                                            enum PreloadedValue Value) const {
1267
1268   const SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
1269   const SISubtarget &ST = MF.getSubtarget<SISubtarget>();
1270   (void)ST;
1271   switch (Value) {
1272   case SIRegisterInfo::WORKGROUP_ID_X:
1273     assert(MFI->hasWorkGroupIDX());
1274     return MFI->WorkGroupIDXSystemSGPR;
1275   case SIRegisterInfo::WORKGROUP_ID_Y:
1276     assert(MFI->hasWorkGroupIDY());
1277     return MFI->WorkGroupIDYSystemSGPR;
1278   case SIRegisterInfo::WORKGROUP_ID_Z:
1279     assert(MFI->hasWorkGroupIDZ());
1280     return MFI->WorkGroupIDZSystemSGPR;
1281   case SIRegisterInfo::PRIVATE_SEGMENT_WAVE_BYTE_OFFSET:
1282     return MFI->PrivateSegmentWaveByteOffsetSystemSGPR;
1283   case SIRegisterInfo::PRIVATE_SEGMENT_BUFFER:
1284     if (ST.isAmdCodeObjectV2(MF)) {
1285       assert(MFI->hasPrivateSegmentBuffer());
1286       return MFI->PrivateSegmentBufferUserSGPR;
1287     }
1288     assert(MFI->hasPrivateMemoryInputPtr());
1289     return MFI->PrivateMemoryPtrUserSGPR;
1290   case SIRegisterInfo::KERNARG_SEGMENT_PTR:
1291     assert(MFI->hasKernargSegmentPtr());
1292     return MFI->KernargSegmentPtrUserSGPR;
1293   case SIRegisterInfo::DISPATCH_ID:
1294     assert(MFI->hasDispatchID());
1295     return MFI->DispatchIDUserSGPR;
1296   case SIRegisterInfo::FLAT_SCRATCH_INIT:
1297     assert(MFI->hasFlatScratchInit());
1298     return MFI->FlatScratchInitUserSGPR;
1299   case SIRegisterInfo::DISPATCH_PTR:
1300     assert(MFI->hasDispatchPtr());
1301     return MFI->DispatchPtrUserSGPR;
1302   case SIRegisterInfo::QUEUE_PTR:
1303     assert(MFI->hasQueuePtr());
1304     return MFI->QueuePtrUserSGPR;
1305   case SIRegisterInfo::WORKITEM_ID_X:
1306     assert(MFI->hasWorkItemIDX());
1307     return AMDGPU::VGPR0;
1308   case SIRegisterInfo::WORKITEM_ID_Y:
1309     assert(MFI->hasWorkItemIDY());
1310     return AMDGPU::VGPR1;
1311   case SIRegisterInfo::WORKITEM_ID_Z:
1312     assert(MFI->hasWorkItemIDZ());
1313     return AMDGPU::VGPR2;
1314   }
1315   llvm_unreachable("unexpected preloaded value type");
1316 }
1317
1318 /// \brief Returns a register that is not used at any point in the function.
1319 ///        If all registers are used, then this function will return
1320 //         AMDGPU::NoRegister.
1321 unsigned
1322 SIRegisterInfo::findUnusedRegister(const MachineRegisterInfo &MRI,
1323                                    const TargetRegisterClass *RC,
1324                                    const MachineFunction &MF) const {
1325
1326   for (unsigned Reg : *RC)
1327     if (MRI.isAllocatable(Reg) && !MRI.isPhysRegUsed(Reg))
1328       return Reg;
1329   return AMDGPU::NoRegister;
1330 }
1331
1332 ArrayRef<int16_t> SIRegisterInfo::getRegSplitParts(const TargetRegisterClass *RC,
1333                                                    unsigned EltSize) const {
1334   if (EltSize == 4) {
1335     static const int16_t Sub0_15[] = {
1336       AMDGPU::sub0, AMDGPU::sub1, AMDGPU::sub2, AMDGPU::sub3,
1337       AMDGPU::sub4, AMDGPU::sub5, AMDGPU::sub6, AMDGPU::sub7,
1338       AMDGPU::sub8, AMDGPU::sub9, AMDGPU::sub10, AMDGPU::sub11,
1339       AMDGPU::sub12, AMDGPU::sub13, AMDGPU::sub14, AMDGPU::sub15,
1340     };
1341
1342     static const int16_t Sub0_7[] = {
1343       AMDGPU::sub0, AMDGPU::sub1, AMDGPU::sub2, AMDGPU::sub3,
1344       AMDGPU::sub4, AMDGPU::sub5, AMDGPU::sub6, AMDGPU::sub7,
1345     };
1346
1347     static const int16_t Sub0_3[] = {
1348       AMDGPU::sub0, AMDGPU::sub1, AMDGPU::sub2, AMDGPU::sub3,
1349     };
1350
1351     static const int16_t Sub0_2[] = {
1352       AMDGPU::sub0, AMDGPU::sub1, AMDGPU::sub2,
1353     };
1354
1355     static const int16_t Sub0_1[] = {
1356       AMDGPU::sub0, AMDGPU::sub1,
1357     };
1358
1359     switch (AMDGPU::getRegBitWidth(*RC->MC)) {
1360     case 32:
1361       return {};
1362     case 64:
1363       return makeArrayRef(Sub0_1);
1364     case 96:
1365       return makeArrayRef(Sub0_2);
1366     case 128:
1367       return makeArrayRef(Sub0_3);
1368     case 256:
1369       return makeArrayRef(Sub0_7);
1370     case 512:
1371       return makeArrayRef(Sub0_15);
1372     default:
1373       llvm_unreachable("unhandled register size");
1374     }
1375   }
1376
1377   if (EltSize == 8) {
1378     static const int16_t Sub0_15_64[] = {
1379       AMDGPU::sub0_sub1, AMDGPU::sub2_sub3,
1380       AMDGPU::sub4_sub5, AMDGPU::sub6_sub7,
1381       AMDGPU::sub8_sub9, AMDGPU::sub10_sub11,
1382       AMDGPU::sub12_sub13, AMDGPU::sub14_sub15
1383     };
1384
1385     static const int16_t Sub0_7_64[] = {
1386       AMDGPU::sub0_sub1, AMDGPU::sub2_sub3,
1387       AMDGPU::sub4_sub5, AMDGPU::sub6_sub7
1388     };
1389
1390
1391     static const int16_t Sub0_3_64[] = {
1392       AMDGPU::sub0_sub1, AMDGPU::sub2_sub3
1393     };
1394
1395     switch (AMDGPU::getRegBitWidth(*RC->MC)) {
1396     case 64:
1397       return {};
1398     case 128:
1399       return makeArrayRef(Sub0_3_64);
1400     case 256:
1401       return makeArrayRef(Sub0_7_64);
1402     case 512:
1403       return makeArrayRef(Sub0_15_64);
1404     default:
1405       llvm_unreachable("unhandled register size");
1406     }
1407   }
1408
1409   assert(EltSize == 16 && "unhandled register spill split size");
1410
1411   static const int16_t Sub0_15_128[] = {
1412     AMDGPU::sub0_sub1_sub2_sub3,
1413     AMDGPU::sub4_sub5_sub6_sub7,
1414     AMDGPU::sub8_sub9_sub10_sub11,
1415     AMDGPU::sub12_sub13_sub14_sub15
1416   };
1417
1418   static const int16_t Sub0_7_128[] = {
1419     AMDGPU::sub0_sub1_sub2_sub3,
1420     AMDGPU::sub4_sub5_sub6_sub7
1421   };
1422
1423   switch (AMDGPU::getRegBitWidth(*RC->MC)) {
1424   case 128:
1425     return {};
1426   case 256:
1427     return makeArrayRef(Sub0_7_128);
1428   case 512:
1429     return makeArrayRef(Sub0_15_128);
1430   default:
1431     llvm_unreachable("unhandled register size");
1432   }
1433 }
1434
1435 const TargetRegisterClass*
1436 SIRegisterInfo::getRegClassForReg(const MachineRegisterInfo &MRI,
1437                                   unsigned Reg) const {
1438   if (TargetRegisterInfo::isVirtualRegister(Reg))
1439     return  MRI.getRegClass(Reg);
1440
1441   return getPhysRegClass(Reg);
1442 }
1443
1444 bool SIRegisterInfo::isVGPR(const MachineRegisterInfo &MRI,
1445                             unsigned Reg) const {
1446   return hasVGPRs(getRegClassForReg(MRI, Reg));
1447 }
1448
1449 bool SIRegisterInfo::shouldCoalesce(MachineInstr *MI,
1450                                     const TargetRegisterClass *SrcRC,
1451                                     unsigned SubReg,
1452                                     const TargetRegisterClass *DstRC,
1453                                     unsigned DstSubReg,
1454                                     const TargetRegisterClass *NewRC) const {
1455   unsigned SrcSize = getRegSizeInBits(*SrcRC);
1456   unsigned DstSize = getRegSizeInBits(*DstRC);
1457   unsigned NewSize = getRegSizeInBits(*NewRC);
1458
1459   // Do not increase size of registers beyond dword, we would need to allocate
1460   // adjacent registers and constraint regalloc more than needed.
1461
1462   // Always allow dword coalescing.
1463   if (SrcSize <= 32 || DstSize <= 32)
1464     return true;
1465
1466   return NewSize <= DstSize || NewSize <= SrcSize;
1467 }
1468
1469 unsigned SIRegisterInfo::getRegPressureLimit(const TargetRegisterClass *RC,
1470                                              MachineFunction &MF) const {
1471
1472   const SISubtarget &ST = MF.getSubtarget<SISubtarget>();
1473   const SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
1474
1475   unsigned Occupancy = ST.getOccupancyWithLocalMemSize(MFI->getLDSSize(),
1476                                                        *MF.getFunction());
1477   switch (RC->getID()) {
1478   default:
1479     return AMDGPURegisterInfo::getRegPressureLimit(RC, MF);
1480   case AMDGPU::VGPR_32RegClassID:
1481     return std::min(ST.getMaxNumVGPRs(Occupancy), ST.getMaxNumVGPRs(MF));
1482   case AMDGPU::SGPR_32RegClassID:
1483     return std::min(ST.getMaxNumSGPRs(Occupancy, true), ST.getMaxNumSGPRs(MF));
1484   }
1485 }
1486
1487 unsigned SIRegisterInfo::getRegPressureSetLimit(const MachineFunction &MF,
1488                                                 unsigned Idx) const {
1489   if (Idx == getVGPRPressureSet())
1490     return getRegPressureLimit(&AMDGPU::VGPR_32RegClass,
1491                                const_cast<MachineFunction &>(MF));
1492
1493   if (Idx == getSGPRPressureSet())
1494     return getRegPressureLimit(&AMDGPU::SGPR_32RegClass,
1495                                const_cast<MachineFunction &>(MF));
1496
1497   return AMDGPURegisterInfo::getRegPressureSetLimit(MF, Idx);
1498 }
1499
1500 const int *SIRegisterInfo::getRegUnitPressureSets(unsigned RegUnit) const {
1501   static const int Empty[] = { -1 };
1502
1503   if (hasRegUnit(AMDGPU::M0, RegUnit))
1504     return Empty;
1505   return AMDGPURegisterInfo::getRegUnitPressureSets(RegUnit);
1506 }