lib/Target/R600/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
  16 #include "SIRegisterInfo.h"
  17 #include "AMDGPUSubtarget.h"
  18 #include "SIInstrInfo.h"
  19 #include "SIMachineFunctionInfo.h"
  20 #include "llvm/CodeGen/MachineFrameInfo.h"
  21 #include "llvm/CodeGen/MachineInstrBuilder.h"
  22 #include "llvm/CodeGen/RegisterScavenging.h"
  23 #include "llvm/IR/Function.h"
  24 #include "llvm/IR/LLVMContext.h"
  25
  26 using namespace llvm;
  27
  28 SIRegisterInfo::SIRegisterInfo(const AMDGPUSubtarget &st)
  29 : AMDGPURegisterInfo(st)
  30   { }
  31
  32 BitVector SIRegisterInfo::getReservedRegs(const MachineFunction &MF) const {
  33   BitVector Reserved(getNumRegs());
  34   Reserved.set(AMDGPU::EXEC);
  35
  36   // EXEC_LO and EXEC_HI could be allocated and used as regular register,
  37   // but this seems likely to result in bugs, so I'm marking them as reserved.
  38   Reserved.set(AMDGPU::EXEC_LO);
  39   Reserved.set(AMDGPU::EXEC_HI);
  40
  41   Reserved.set(AMDGPU::INDIRECT_BASE_ADDR);
  42   Reserved.set(AMDGPU::FLAT_SCR);
  43
  44   // Reserve some VGPRs to use as temp registers in case we have to spill VGPRs
  45   Reserved.set(AMDGPU::VGPR255);
  46   Reserved.set(AMDGPU::VGPR254);
  47
  48   return Reserved;
  49 }
  50
  51 unsigned SIRegisterInfo::getRegPressureLimit(const TargetRegisterClass *RC,
  52                                              MachineFunction &MF) const {
  53   return RC->getNumRegs();
  54 }
  55
  56 bool SIRegisterInfo::requiresRegisterScavenging(const MachineFunction &Fn) const {
  57   return Fn.getFrameInfo()->hasStackObjects();
  58 }
  59
  60 static unsigned getNumSubRegsForSpillOp(unsigned Op) {
  61
  62   switch (Op) {
  63   case AMDGPU::SI_SPILL_S512_SAVE:
  64   case AMDGPU::SI_SPILL_S512_RESTORE:
  65   case AMDGPU::SI_SPILL_V512_SAVE:
  66   case AMDGPU::SI_SPILL_V512_RESTORE:
  67     return 16;
  68   case AMDGPU::SI_SPILL_S256_SAVE:
  69   case AMDGPU::SI_SPILL_S256_RESTORE:
  70   case AMDGPU::SI_SPILL_V256_SAVE:
  71   case AMDGPU::SI_SPILL_V256_RESTORE:
  72     return 8;
  73   case AMDGPU::SI_SPILL_S128_SAVE:
  74   case AMDGPU::SI_SPILL_S128_RESTORE:
  75   case AMDGPU::SI_SPILL_V128_SAVE:
  76   case AMDGPU::SI_SPILL_V128_RESTORE:
  77     return 4;
  78   case AMDGPU::SI_SPILL_V96_SAVE:
  79   case AMDGPU::SI_SPILL_V96_RESTORE:
  80     return 3;
  81   case AMDGPU::SI_SPILL_S64_SAVE:
  82   case AMDGPU::SI_SPILL_S64_RESTORE:
  83   case AMDGPU::SI_SPILL_V64_SAVE:
  84   case AMDGPU::SI_SPILL_V64_RESTORE:
  85     return 2;
  86   case AMDGPU::SI_SPILL_S32_SAVE:
  87   case AMDGPU::SI_SPILL_S32_RESTORE:
  88   case AMDGPU::SI_SPILL_V32_SAVE:
  89   case AMDGPU::SI_SPILL_V32_RESTORE:
  90     return 1;
  91   default: llvm_unreachable("Invalid spill opcode");
  92   }
  93 }
  94
  95 void SIRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator MI,
  96                                         int SPAdj, unsigned FIOperandNum,
  97                                         RegScavenger *RS) const {
  98   MachineFunction *MF = MI->getParent()->getParent();
  99   MachineBasicBlock *MBB = MI->getParent();
 100   SIMachineFunctionInfo *MFI = MF->getInfo<SIMachineFunctionInfo>();
 101   MachineFrameInfo *FrameInfo = MF->getFrameInfo();
 102   const SIInstrInfo *TII = static_cast<const SIInstrInfo*>(ST.getInstrInfo());
 103   DebugLoc DL = MI->getDebugLoc();
 104
 105   MachineOperand &FIOp = MI->getOperand(FIOperandNum);
 106   int Index = MI->getOperand(FIOperandNum).getIndex();
 107
 108   switch (MI->getOpcode()) {
 109     // SGPR register spill
 110     case AMDGPU::SI_SPILL_S512_SAVE:
 111     case AMDGPU::SI_SPILL_S256_SAVE:
 112     case AMDGPU::SI_SPILL_S128_SAVE:
 113     case AMDGPU::SI_SPILL_S64_SAVE:
 114     case AMDGPU::SI_SPILL_S32_SAVE: {
 115       unsigned NumSubRegs = getNumSubRegsForSpillOp(MI->getOpcode());
 116
 117       for (unsigned i = 0, e = NumSubRegs; i < e; ++i) {
 118         unsigned SubReg = getPhysRegSubReg(MI->getOperand(0).getReg(),
 119                                            &AMDGPU::SGPR_32RegClass, i);
 120         struct SIMachineFunctionInfo::SpilledReg Spill =
 121             MFI->getSpilledReg(MF, Index, i);
 122
 123         if (Spill.VGPR == AMDGPU::NoRegister) {
 124            LLVMContext &Ctx = MF->getFunction()->getContext();
 125            Ctx.emitError("Ran out of VGPRs for spilling SGPR");
 126         }
 127
 128         BuildMI(*MBB, MI, DL, TII->get(AMDGPU::V_WRITELANE_B32), Spill.VGPR)
 129                 .addReg(SubReg)
 130                 .addImm(Spill.Lane);
 131
 132       }
 133       MI->eraseFromParent();
 134       break;
 135     }
 136
 137     // SGPR register restore
 138     case AMDGPU::SI_SPILL_S512_RESTORE:
 139     case AMDGPU::SI_SPILL_S256_RESTORE:
 140     case AMDGPU::SI_SPILL_S128_RESTORE:
 141     case AMDGPU::SI_SPILL_S64_RESTORE:
 142     case AMDGPU::SI_SPILL_S32_RESTORE: {
 143       unsigned NumSubRegs = getNumSubRegsForSpillOp(MI->getOpcode());
 144
 145       for (unsigned i = 0, e = NumSubRegs; i < e; ++i) {
 146         unsigned SubReg = getPhysRegSubReg(MI->getOperand(0).getReg(),
 147                                            &AMDGPU::SGPR_32RegClass, i);
 148         struct SIMachineFunctionInfo::SpilledReg Spill =
 149             MFI->getSpilledReg(MF, Index, i);
 150
 151         if (Spill.VGPR == AMDGPU::NoRegister) {
 152            LLVMContext &Ctx = MF->getFunction()->getContext();
 153            Ctx.emitError("Ran out of VGPRs for spilling SGPR");
 154         }
 155
 156         BuildMI(*MBB, MI, DL, TII->get(AMDGPU::V_READLANE_B32), SubReg)
 157                 .addReg(Spill.VGPR)
 158                 .addImm(Spill.Lane);
 159
 160       }
 161       TII->insertNOPs(MI, 3);
 162       MI->eraseFromParent();
 163       break;
 164     }
 165
 166     // VGPR register spill
 167     case AMDGPU::SI_SPILL_V512_SAVE:
 168     case AMDGPU::SI_SPILL_V256_SAVE:
 169     case AMDGPU::SI_SPILL_V128_SAVE:
 170     case AMDGPU::SI_SPILL_V96_SAVE:
 171     case AMDGPU::SI_SPILL_V64_SAVE:
 172     case AMDGPU::SI_SPILL_V32_SAVE: {
 173       unsigned NumSubRegs = getNumSubRegsForSpillOp(MI->getOpcode());
 174       unsigned SrcReg = MI->getOperand(0).getReg();
 175       int64_t Offset = FrameInfo->getObjectOffset(Index);
 176       unsigned Size = NumSubRegs * 4;
 177       unsigned TmpReg = RS->scavengeRegister(&AMDGPU::VGPR_32RegClass, MI, 0);
 178
 179       for (unsigned i = 0, e = NumSubRegs; i != e; ++i) {
 180         unsigned SubReg = NumSubRegs > 1 ?
 181             getPhysRegSubReg(SrcReg, &AMDGPU::VGPR_32RegClass, i) :
 182             SrcReg;
 183         Offset += (i * 4);
 184         MFI->LDSWaveSpillSize = std::max((unsigned)Offset + 4, (unsigned)MFI->LDSWaveSpillSize);
 185
 186         unsigned AddrReg = TII->calculateLDSSpillAddress(*MBB, MI, RS, TmpReg,
 187                                                          Offset, Size);
 188
 189         if (AddrReg == AMDGPU::NoRegister) {
 190            LLVMContext &Ctx = MF->getFunction()->getContext();
 191            Ctx.emitError("Ran out of VGPRs for spilling VGPRS");
 192            AddrReg = AMDGPU::VGPR0;
 193         }
 194
 195         // Store the value in LDS
 196         BuildMI(*MBB, MI, DL, TII->get(AMDGPU::DS_WRITE_B32))
 197                 .addImm(0) // gds
 198                 .addReg(AddrReg, RegState::Kill) // addr
 199                 .addReg(SubReg) // data0
 200                 .addImm(0); // offset
 201       }
 202
 203       MI->eraseFromParent();
 204       break;
 205     }
 206     case AMDGPU::SI_SPILL_V32_RESTORE:
 207     case AMDGPU::SI_SPILL_V64_RESTORE:
 208     case AMDGPU::SI_SPILL_V128_RESTORE:
 209     case AMDGPU::SI_SPILL_V256_RESTORE:
 210     case AMDGPU::SI_SPILL_V512_RESTORE: {
 211       unsigned NumSubRegs = getNumSubRegsForSpillOp(MI->getOpcode());
 212       unsigned DstReg = MI->getOperand(0).getReg();
 213       int64_t Offset = FrameInfo->getObjectOffset(Index);
 214       unsigned Size = NumSubRegs * 4;
 215       unsigned TmpReg = RS->scavengeRegister(&AMDGPU::VGPR_32RegClass, MI, 0);
 216
 217       // FIXME: We could use DS_READ_B64 here to optimize for larger registers.
 218       for (unsigned i = 0, e = NumSubRegs; i != e; ++i) {
 219         unsigned SubReg = NumSubRegs > 1 ?
 220             getPhysRegSubReg(DstReg, &AMDGPU::VGPR_32RegClass, i) :
 221             DstReg;
 222
 223         Offset += (i * 4);
 224         unsigned AddrReg = TII->calculateLDSSpillAddress(*MBB, MI, RS, TmpReg,
 225                                                           Offset, Size);
 226         if (AddrReg == AMDGPU::NoRegister) {
 227            LLVMContext &Ctx = MF->getFunction()->getContext();
 228            Ctx.emitError("Ran out of VGPRs for spilling VGPRs");
 229            AddrReg = AMDGPU::VGPR0;
 230         }
 231
 232         BuildMI(*MBB, MI, DL, TII->get(AMDGPU::DS_READ_B32), SubReg)
 233                 .addImm(0) // gds
 234                 .addReg(AddrReg, RegState::Kill) // addr
 235                 .addImm(0); //offset
 236       }
 237       MI->eraseFromParent();
 238       break;
 239     }
 240
 241     default: {
 242       int64_t Offset = FrameInfo->getObjectOffset(Index);
 243       FIOp.ChangeToImmediate(Offset);
 244       if (!TII->isImmOperandLegal(MI, FIOperandNum, FIOp)) {
 245         unsigned TmpReg = RS->scavengeRegister(&AMDGPU::VReg_32RegClass, MI, SPAdj);
 246         BuildMI(*MBB, MI, MI->getDebugLoc(),
 247                 TII->get(AMDGPU::V_MOV_B32_e32), TmpReg)
 248                 .addImm(Offset);
 249         FIOp.ChangeToRegister(TmpReg, false);
 250       }
 251     }
 252   }
 253 }
 254
 255 const TargetRegisterClass * SIRegisterInfo::getCFGStructurizerRegClass(
 256                                                                    MVT VT) const {
 257   switch(VT.SimpleTy) {
 258     default:
 259     case MVT::i32: return &AMDGPU::VReg_32RegClass;
 260   }
 261 }
 262
 263 unsigned SIRegisterInfo::getHWRegIndex(unsigned Reg) const {
 264   return getEncodingValue(Reg) & 0xff;
 265 }
 266
 267 const TargetRegisterClass *SIRegisterInfo::getPhysRegClass(unsigned Reg) const {
 268   assert(!TargetRegisterInfo::isVirtualRegister(Reg));
 269
 270   static const TargetRegisterClass *BaseClasses[] = {
 271     &AMDGPU::VReg_32RegClass,
 272     &AMDGPU::SReg_32RegClass,
 273     &AMDGPU::VReg_64RegClass,
 274     &AMDGPU::SReg_64RegClass,
 275     &AMDGPU::VReg_96RegClass,
 276     &AMDGPU::VReg_128RegClass,
 277     &AMDGPU::SReg_128RegClass,
 278     &AMDGPU::VReg_256RegClass,
 279     &AMDGPU::SReg_256RegClass,
 280     &AMDGPU::VReg_512RegClass
 281   };
 282
 283   for (const TargetRegisterClass *BaseClass : BaseClasses) {
 284     if (BaseClass->contains(Reg)) {
 285       return BaseClass;
 286     }
 287   }
 288   return nullptr;
 289 }
 290
 291 bool SIRegisterInfo::hasVGPRs(const TargetRegisterClass *RC) const {
 292   return getCommonSubClass(&AMDGPU::VReg_32RegClass, RC) ||
 293          getCommonSubClass(&AMDGPU::VReg_64RegClass, RC) ||
 294          getCommonSubClass(&AMDGPU::VReg_96RegClass, RC) ||
 295          getCommonSubClass(&AMDGPU::VReg_128RegClass, RC) ||
 296          getCommonSubClass(&AMDGPU::VReg_256RegClass, RC) ||
 297          getCommonSubClass(&AMDGPU::VReg_512RegClass, RC);
 298 }
 299
 300 const TargetRegisterClass *SIRegisterInfo::getEquivalentVGPRClass(
 301                                          const TargetRegisterClass *SRC) const {
 302     if (hasVGPRs(SRC)) {
 303       return SRC;
 304     } else if (SRC == &AMDGPU::SCCRegRegClass) {
 305       return &AMDGPU::VCCRegRegClass;
 306     } else if (getCommonSubClass(SRC, &AMDGPU::SGPR_32RegClass)) {
 307       return &AMDGPU::VReg_32RegClass;
 308     } else if (getCommonSubClass(SRC, &AMDGPU::SGPR_64RegClass)) {
 309       return &AMDGPU::VReg_64RegClass;
 310     } else if (getCommonSubClass(SRC, &AMDGPU::SReg_128RegClass)) {
 311       return &AMDGPU::VReg_128RegClass;
 312     } else if (getCommonSubClass(SRC, &AMDGPU::SReg_256RegClass)) {
 313       return &AMDGPU::VReg_256RegClass;
 314     } else if (getCommonSubClass(SRC, &AMDGPU::SReg_512RegClass)) {
 315       return &AMDGPU::VReg_512RegClass;
 316     }
 317     return nullptr;
 318 }
 319
 320 const TargetRegisterClass *SIRegisterInfo::getSubRegClass(
 321                          const TargetRegisterClass *RC, unsigned SubIdx) const {
 322   if (SubIdx == AMDGPU::NoSubRegister)
 323     return RC;
 324
 325   // If this register has a sub-register, we can safely assume it is a 32-bit
 326   // register, because all of SI's sub-registers are 32-bit.
 327   if (isSGPRClass(RC)) {
 328     return &AMDGPU::SGPR_32RegClass;
 329   } else {
 330     return &AMDGPU::VGPR_32RegClass;
 331   }
 332 }
 333
 334 unsigned SIRegisterInfo::getPhysRegSubReg(unsigned Reg,
 335                                           const TargetRegisterClass *SubRC,
 336                                           unsigned Channel) const {
 337
 338   switch (Reg) {
 339     case AMDGPU::VCC:
 340       switch(Channel) {
 341         case 0: return AMDGPU::VCC_LO;
 342         case 1: return AMDGPU::VCC_HI;
 343         default: llvm_unreachable("Invalid SubIdx for VCC");
 344       }
 345
 346   case AMDGPU::FLAT_SCR:
 347     switch (Channel) {
 348     case 0:
 349       return AMDGPU::FLAT_SCR_LO;
 350     case 1:
 351       return AMDGPU::FLAT_SCR_HI;
 352     default:
 353       llvm_unreachable("Invalid SubIdx for FLAT_SCR");
 354     }
 355     break;
 356
 357   case AMDGPU::EXEC:
 358     switch (Channel) {
 359     case 0:
 360       return AMDGPU::EXEC_LO;
 361     case 1:
 362       return AMDGPU::EXEC_HI;
 363     default:
 364       llvm_unreachable("Invalid SubIdx for EXEC");
 365     }
 366     break;
 367   }
 368
 369   const TargetRegisterClass *RC = getPhysRegClass(Reg);
 370   // 32-bit registers don't have sub-registers, so we can just return the
 371   // Reg.  We need to have this check here, because the calculation below
 372   // using getHWRegIndex() will fail with special 32-bit registers like
 373   // VCC_LO, VCC_HI, EXEC_LO, EXEC_HI and M0.
 374   if (RC->getSize() == 4) {
 375     assert(Channel == 0);
 376     return Reg;
 377   }
 378
 379   unsigned Index = getHWRegIndex(Reg);
 380   return SubRC->getRegister(Index + Channel);
 381 }
 382
 383 bool SIRegisterInfo::regClassCanUseLiteralConstant(int RCID) const {
 384   switch (RCID) {
 385   default: return false;
 386   case AMDGPU::SSrc_32RegClassID:
 387   case AMDGPU::SSrc_64RegClassID:
 388   case AMDGPU::VSrc_32RegClassID:
 389   case AMDGPU::VSrc_64RegClassID:
 390     return true;
 391   }
 392 }
 393
 394 bool SIRegisterInfo::regClassCanUseLiteralConstant(
 395                              const TargetRegisterClass *RC) const {
 396   return regClassCanUseLiteralConstant(RC->getID());
 397 }
 398
 399 bool SIRegisterInfo::regClassCanUseInlineConstant(int RCID) const {
 400   if (regClassCanUseLiteralConstant(RCID))
 401     return true;
 402
 403   switch (RCID) {
 404   default: return false;
 405   case AMDGPU::VCSrc_32RegClassID:
 406   case AMDGPU::VCSrc_64RegClassID:
 407     return true;
 408   }
 409 }
 410
 411 bool SIRegisterInfo::regClassCanUseInlineConstant(
 412                             const TargetRegisterClass *RC) const {
 413   return regClassCanUseInlineConstant(RC->getID());
 414 }
 415
 416
 417 unsigned SIRegisterInfo::getPreloadedValue(const MachineFunction &MF,
 418                                            enum PreloadedValue Value) const {
 419
 420   const SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
 421   switch (Value) {
 422   case SIRegisterInfo::TGID_X:
 423     return AMDGPU::SReg_32RegClass.getRegister(MFI->NumUserSGPRs + 0);
 424   case SIRegisterInfo::TGID_Y:
 425     return AMDGPU::SReg_32RegClass.getRegister(MFI->NumUserSGPRs + 1);
 426   case SIRegisterInfo::TGID_Z:
 427     return AMDGPU::SReg_32RegClass.getRegister(MFI->NumUserSGPRs + 2);
 428   case SIRegisterInfo::SCRATCH_WAVE_OFFSET:
 429     return AMDGPU::SReg_32RegClass.getRegister(MFI->NumUserSGPRs + 4);
 430   case SIRegisterInfo::SCRATCH_PTR:
 431     return AMDGPU::SGPR2_SGPR3;
 432   case SIRegisterInfo::INPUT_PTR:
 433     return AMDGPU::SGPR0_SGPR1;
 434   case SIRegisterInfo::TIDIG_X:
 435     return AMDGPU::VGPR0;
 436   case SIRegisterInfo::TIDIG_Y:
 437     return AMDGPU::VGPR1;
 438   case SIRegisterInfo::TIDIG_Z:
 439     return AMDGPU::VGPR2;
 440   }
 441   llvm_unreachable("unexpected preloaded value type");
 442 }
 443
 444 /// \brief Returns a register that is not used at any point in the function.
 445 ///        If all registers are used, then this function will return
 446 //         AMDGPU::NoRegister.
 447 unsigned SIRegisterInfo::findUnusedVGPR(const MachineRegisterInfo &MRI) const {
 448
 449   const TargetRegisterClass *RC = &AMDGPU::VGPR_32RegClass;
 450
 451   for (TargetRegisterClass::iterator I = RC->begin(), E = RC->end();
 452        I != E; ++I) {
 453     if (!MRI.isPhysRegUsed(*I))
 454       return *I;
 455   }
 456   return AMDGPU::NoRegister;
 457 }
 458