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 "AMDGPUTargetMachine.h"
  18 #include "SIInstrInfo.h"
  19
  20 using namespace llvm;
  21
  22 SIRegisterInfo::SIRegisterInfo(AMDGPUTargetMachine &tm)
  23 : AMDGPURegisterInfo(tm),
  24   TM(tm)
  25   { }
  26
  27 BitVector SIRegisterInfo::getReservedRegs(const MachineFunction &MF) const {
  28   BitVector Reserved(getNumRegs());
  29   Reserved.set(AMDGPU::EXEC);
  30   Reserved.set(AMDGPU::INDIRECT_BASE_ADDR);
  31   const SIInstrInfo *TII = static_cast<const SIInstrInfo*>(TM.getInstrInfo());
  32   TII->reserveIndirectRegisters(Reserved, MF);
  33   return Reserved;
  34 }
  35
  36 unsigned SIRegisterInfo::getRegPressureLimit(const TargetRegisterClass *RC,
  37                                              MachineFunction &MF) const {
  38   return RC->getNumRegs();
  39 }
  40
  41 const TargetRegisterClass *
  42 SIRegisterInfo::getISARegClass(const TargetRegisterClass * rc) const {
  43   switch (rc->getID()) {
  44   case AMDGPU::GPRF32RegClassID:
  45     return &AMDGPU::VReg_32RegClass;
  46   default: return rc;
  47   }
  48 }
  49
  50 const TargetRegisterClass * SIRegisterInfo::getCFGStructurizerRegClass(
  51                                                                    MVT VT) const {
  52   switch(VT.SimpleTy) {
  53     default:
  54     case MVT::i32: return &AMDGPU::VReg_32RegClass;
  55   }
  56 }
  57
  58 unsigned SIRegisterInfo::getHWRegIndex(unsigned Reg) const {
  59   return getEncodingValue(Reg);
  60 }
  61
  62 const TargetRegisterClass *SIRegisterInfo::getPhysRegClass(unsigned Reg) const {
  63   assert(!TargetRegisterInfo::isVirtualRegister(Reg));
  64
  65   const TargetRegisterClass *BaseClasses[] = {
  66     &AMDGPU::VReg_32RegClass,
  67     &AMDGPU::SReg_32RegClass,
  68     &AMDGPU::VReg_64RegClass,
  69     &AMDGPU::SReg_64RegClass,
  70     &AMDGPU::SReg_128RegClass,
  71     &AMDGPU::SReg_256RegClass
  72   };
  73
  74   for (unsigned i = 0, e = sizeof(BaseClasses) /
  75                            sizeof(const TargetRegisterClass*); i != e; ++i) {
  76     if (BaseClasses[i]->contains(Reg)) {
  77       return BaseClasses[i];
  78     }
  79   }
  80   return NULL;
  81 }
  82
  83 bool SIRegisterInfo::isSGPRClass(const TargetRegisterClass *RC) const {
  84   if (!RC) {
  85     return false;
  86   }
  87   return !hasVGPRs(RC);
  88 }
  89
  90 bool SIRegisterInfo::hasVGPRs(const TargetRegisterClass *RC) const {
  91   return getCommonSubClass(&AMDGPU::VReg_32RegClass, RC) ||
  92          getCommonSubClass(&AMDGPU::VReg_64RegClass, RC) ||
  93          getCommonSubClass(&AMDGPU::VReg_128RegClass, RC) ||
  94          getCommonSubClass(&AMDGPU::VReg_256RegClass, RC) ||
  95          getCommonSubClass(&AMDGPU::VReg_512RegClass, RC);
  96 }
  97
  98 const TargetRegisterClass *SIRegisterInfo::getEquivalentVGPRClass(
  99                                          const TargetRegisterClass *SRC) const {
 100     if (hasVGPRs(SRC)) {
 101       return SRC;
 102     } else if (getCommonSubClass(SRC, &AMDGPU::SGPR_32RegClass)) {
 103       return &AMDGPU::VReg_32RegClass;
 104     } else if (getCommonSubClass(SRC, &AMDGPU::SGPR_64RegClass)) {
 105       return &AMDGPU::VReg_64RegClass;
 106     } else if (getCommonSubClass(SRC, &AMDGPU::SReg_128RegClass)) {
 107       return &AMDGPU::VReg_128RegClass;
 108     } else if (getCommonSubClass(SRC, &AMDGPU::SReg_256RegClass)) {
 109       return &AMDGPU::VReg_256RegClass;
 110     } else if (getCommonSubClass(SRC, &AMDGPU::SReg_512RegClass)) {
 111       return &AMDGPU::VReg_512RegClass;
 112     }
 113     return NULL;
 114 }
 115
 116 const TargetRegisterClass *SIRegisterInfo::getSubRegClass(
 117                          const TargetRegisterClass *RC, unsigned SubIdx) const {
 118   if (SubIdx == AMDGPU::NoSubRegister)
 119     return RC;
 120
 121   // If this register has a sub-register, we can safely assume it is a 32-bit
 122   // register, becuase all of SI's sub-registers are 32-bit.
 123   if (isSGPRClass(RC)) {
 124     return &AMDGPU::SGPR_32RegClass;
 125   } else {
 126     return &AMDGPU::VGPR_32RegClass;
 127   }
 128 }