lib/Target/NVPTX/NVPTXRegisterInfo.cpp

   1 //===- NVPTXRegisterInfo.cpp - NVPTX 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 // This file contains the NVPTX implementation of the TargetRegisterInfo class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "nvptx-reg-info"
  15
  16 #include "NVPTX.h"
  17 #include "NVPTXRegisterInfo.h"
  18 #include "NVPTXSubtarget.h"
  19 #include "llvm/ADT/BitVector.h"
  20 #include "llvm/CodeGen/MachineInstrBuilder.h"
  21 #include "llvm/CodeGen/MachineFunction.h"
  22 #include "llvm/CodeGen/MachineFrameInfo.h"
  23 #include "llvm/MC/MachineLocation.h"
  24 #include "llvm/Target/TargetInstrInfo.h"
  25
  26
  27 using namespace llvm;
  28
  29 namespace llvm
  30 {
  31 std::string getNVPTXRegClassName (TargetRegisterClass const *RC) {
  32   if (RC == &NVPTX::Float32RegsRegClass) {
  33     return ".f32";
  34   }
  35   if (RC == &NVPTX::Float64RegsRegClass) {
  36     return ".f64";
  37   }
  38   else if (RC == &NVPTX::Int64RegsRegClass) {
  39     return ".s64";
  40   }
  41   else if (RC == &NVPTX::Int32RegsRegClass) {
  42     return ".s32";
  43   }
  44   else if (RC == &NVPTX::Int16RegsRegClass) {
  45     return ".s16";
  46   }
  47   // Int8Regs become 16-bit registers in PTX
  48   else if (RC == &NVPTX::Int8RegsRegClass) {
  49     return ".s16";
  50   }
  51   else if (RC == &NVPTX::Int1RegsRegClass) {
  52     return ".pred";
  53   }
  54   else if (RC == &NVPTX::SpecialRegsRegClass) {
  55     return "!Special!";
  56   }
  57   else if (RC == &NVPTX::V2F32RegsRegClass) {
  58     return ".v2.f32";
  59   }
  60   else if (RC == &NVPTX::V4F32RegsRegClass) {
  61     return ".v4.f32";
  62   }
  63   else if (RC == &NVPTX::V2I32RegsRegClass) {
  64     return ".v2.s32";
  65   }
  66   else if (RC == &NVPTX::V4I32RegsRegClass) {
  67     return ".v4.s32";
  68   }
  69   else if (RC == &NVPTX::V2F64RegsRegClass) {
  70     return ".v2.f64";
  71   }
  72   else if (RC == &NVPTX::V2I64RegsRegClass) {
  73     return ".v2.s64";
  74   }
  75   else if (RC == &NVPTX::V2I16RegsRegClass) {
  76     return ".v2.s16";
  77   }
  78   else if (RC == &NVPTX::V4I16RegsRegClass) {
  79     return ".v4.s16";
  80   }
  81   else if (RC == &NVPTX::V2I8RegsRegClass) {
  82     return ".v2.s16";
  83   }
  84   else if (RC == &NVPTX::V4I8RegsRegClass) {
  85     return ".v4.s16";
  86   }
  87   else {
  88     return "INTERNAL";
  89   }
  90   return "";
  91 }
  92
  93 std::string getNVPTXRegClassStr (TargetRegisterClass const *RC) {
  94   if (RC == &NVPTX::Float32RegsRegClass) {
  95     return "%f";
  96   }
  97   if (RC == &NVPTX::Float64RegsRegClass) {
  98     return "%fd";
  99   }
 100   else if (RC == &NVPTX::Int64RegsRegClass) {
 101     return "%rd";
 102   }
 103   else if (RC == &NVPTX::Int32RegsRegClass) {
 104     return "%r";
 105   }
 106   else if (RC == &NVPTX::Int16RegsRegClass) {
 107     return "%rs";
 108   }
 109   else if (RC == &NVPTX::Int8RegsRegClass) {
 110     return "%rc";
 111   }
 112   else if (RC == &NVPTX::Int1RegsRegClass) {
 113     return "%p";
 114   }
 115   else if (RC == &NVPTX::SpecialRegsRegClass) {
 116     return "!Special!";
 117   }
 118   else if (RC == &NVPTX::V2F32RegsRegClass) {
 119     return "%v2f";
 120   }
 121   else if (RC == &NVPTX::V4F32RegsRegClass) {
 122     return "%v4f";
 123   }
 124   else if (RC == &NVPTX::V2I32RegsRegClass) {
 125     return "%v2r";
 126   }
 127   else if (RC == &NVPTX::V4I32RegsRegClass) {
 128     return "%v4r";
 129   }
 130   else if (RC == &NVPTX::V2F64RegsRegClass) {
 131     return "%v2fd";
 132   }
 133   else if (RC == &NVPTX::V2I64RegsRegClass) {
 134     return "%v2rd";
 135   }
 136   else if (RC == &NVPTX::V2I16RegsRegClass) {
 137     return "%v2s";
 138   }
 139   else if (RC == &NVPTX::V4I16RegsRegClass) {
 140     return "%v4rs";
 141   }
 142   else if (RC == &NVPTX::V2I8RegsRegClass) {
 143     return "%v2rc";
 144   }
 145   else if (RC == &NVPTX::V4I8RegsRegClass) {
 146     return "%v4rc";
 147   }
 148   else {
 149     return "INTERNAL";
 150   }
 151   return "";
 152 }
 153
 154 bool isNVPTXVectorRegClass(TargetRegisterClass const *RC) {
 155   if (RC->getID() == NVPTX::V2F32RegsRegClassID)
 156     return true;
 157   if (RC->getID() == NVPTX::V2F64RegsRegClassID)
 158     return true;
 159   if (RC->getID() == NVPTX::V2I16RegsRegClassID)
 160     return true;
 161   if (RC->getID() == NVPTX::V2I32RegsRegClassID)
 162     return true;
 163   if (RC->getID() == NVPTX::V2I64RegsRegClassID)
 164     return true;
 165   if (RC->getID() == NVPTX::V2I8RegsRegClassID)
 166     return true;
 167   if (RC->getID() == NVPTX::V4F32RegsRegClassID)
 168     return true;
 169   if (RC->getID() == NVPTX::V4I16RegsRegClassID)
 170     return true;
 171   if (RC->getID() == NVPTX::V4I32RegsRegClassID)
 172     return true;
 173   if (RC->getID() == NVPTX::V4I8RegsRegClassID)
 174     return true;
 175   return false;
 176 }
 177
 178 std::string getNVPTXElemClassName(TargetRegisterClass const *RC) {
 179   if (RC->getID() == NVPTX::V2F32RegsRegClassID)
 180     return getNVPTXRegClassName(&NVPTX::Float32RegsRegClass);
 181   if (RC->getID() == NVPTX::V2F64RegsRegClassID)
 182     return getNVPTXRegClassName(&NVPTX::Float64RegsRegClass);
 183   if (RC->getID() == NVPTX::V2I16RegsRegClassID)
 184     return getNVPTXRegClassName(&NVPTX::Int16RegsRegClass);
 185   if (RC->getID() == NVPTX::V2I32RegsRegClassID)
 186     return getNVPTXRegClassName(&NVPTX::Int32RegsRegClass);
 187   if (RC->getID() == NVPTX::V2I64RegsRegClassID)
 188     return getNVPTXRegClassName(&NVPTX::Int64RegsRegClass);
 189   if (RC->getID() == NVPTX::V2I8RegsRegClassID)
 190     return getNVPTXRegClassName(&NVPTX::Int8RegsRegClass);
 191   if (RC->getID() == NVPTX::V4F32RegsRegClassID)
 192     return getNVPTXRegClassName(&NVPTX::Float32RegsRegClass);
 193   if (RC->getID() == NVPTX::V4I16RegsRegClassID)
 194     return getNVPTXRegClassName(&NVPTX::Int16RegsRegClass);
 195   if (RC->getID() == NVPTX::V4I32RegsRegClassID)
 196     return getNVPTXRegClassName(&NVPTX::Int32RegsRegClass);
 197   if (RC->getID() == NVPTX::V4I8RegsRegClassID)
 198     return getNVPTXRegClassName(&NVPTX::Int8RegsRegClass);
 199   assert(0 && "Not a vector register class");
 200   return "Unsupported";
 201 }
 202
 203 const TargetRegisterClass *getNVPTXElemClass(TargetRegisterClass const *RC) {
 204   if (RC->getID() == NVPTX::V2F32RegsRegClassID)
 205     return (&NVPTX::Float32RegsRegClass);
 206   if (RC->getID() == NVPTX::V2F64RegsRegClassID)
 207     return (&NVPTX::Float64RegsRegClass);
 208   if (RC->getID() == NVPTX::V2I16RegsRegClassID)
 209     return (&NVPTX::Int16RegsRegClass);
 210   if (RC->getID() == NVPTX::V2I32RegsRegClassID)
 211     return (&NVPTX::Int32RegsRegClass);
 212   if (RC->getID() == NVPTX::V2I64RegsRegClassID)
 213     return (&NVPTX::Int64RegsRegClass);
 214   if (RC->getID() == NVPTX::V2I8RegsRegClassID)
 215     return (&NVPTX::Int8RegsRegClass);
 216   if (RC->getID() == NVPTX::V4F32RegsRegClassID)
 217     return (&NVPTX::Float32RegsRegClass);
 218   if (RC->getID() == NVPTX::V4I16RegsRegClassID)
 219     return (&NVPTX::Int16RegsRegClass);
 220   if (RC->getID() == NVPTX::V4I32RegsRegClassID)
 221     return (&NVPTX::Int32RegsRegClass);
 222   if (RC->getID() == NVPTX::V4I8RegsRegClassID)
 223     return (&NVPTX::Int8RegsRegClass);
 224   assert(0 && "Not a vector register class");
 225   return 0;
 226 }
 227
 228 int getNVPTXVectorSize(TargetRegisterClass const *RC) {
 229   if (RC->getID() == NVPTX::V2F32RegsRegClassID)
 230     return 2;
 231   if (RC->getID() == NVPTX::V2F64RegsRegClassID)
 232     return 2;
 233   if (RC->getID() == NVPTX::V2I16RegsRegClassID)
 234     return 2;
 235   if (RC->getID() == NVPTX::V2I32RegsRegClassID)
 236     return 2;
 237   if (RC->getID() == NVPTX::V2I64RegsRegClassID)
 238     return 2;
 239   if (RC->getID() == NVPTX::V2I8RegsRegClassID)
 240     return 2;
 241   if (RC->getID() == NVPTX::V4F32RegsRegClassID)
 242     return 4;
 243   if (RC->getID() == NVPTX::V4I16RegsRegClassID)
 244     return 4;
 245   if (RC->getID() == NVPTX::V4I32RegsRegClassID)
 246     return 4;
 247   if (RC->getID() == NVPTX::V4I8RegsRegClassID)
 248     return 4;
 249   assert(0 && "Not a vector register class");
 250   return -1;
 251 }
 252 }
 253
 254 NVPTXRegisterInfo::NVPTXRegisterInfo(const TargetInstrInfo &tii,
 255                                      const NVPTXSubtarget &st)
 256 : NVPTXGenRegisterInfo(0),
 257   TII(tii),
 258   ST(st) {
 259   Is64Bit = st.is64Bit();
 260 }
 261
 262
 263 #define GET_REGINFO_TARGET_DESC
 264 #include "NVPTXGenRegisterInfo.inc"
 265
 266 /// NVPTX Callee Saved Registers
 267 const uint16_t* NVPTXRegisterInfo::
 268 getCalleeSavedRegs(const MachineFunction *MF) const {
 269   static const uint16_t CalleeSavedRegs[] = { 0 };
 270   return CalleeSavedRegs;
 271 }
 272
 273 // NVPTX Callee Saved Reg Classes
 274 const TargetRegisterClass* const*
 275 NVPTXRegisterInfo::getCalleeSavedRegClasses(const MachineFunction *MF) const {
 276   static const TargetRegisterClass * const CalleeSavedRegClasses[] = { 0 };
 277   return CalleeSavedRegClasses;
 278 }
 279
 280 BitVector NVPTXRegisterInfo::getReservedRegs(const MachineFunction &MF) const {
 281   BitVector Reserved(getNumRegs());
 282   return Reserved;
 283 }
 284
 285 void NVPTXRegisterInfo::
 286 eliminateFrameIndex(MachineBasicBlock::iterator II,
 287                     int SPAdj,
 288                     RegScavenger *RS) const {
 289   assert(SPAdj == 0 && "Unexpected");
 290
 291   unsigned i = 0;
 292   MachineInstr &MI = *II;
 293   while (!MI.getOperand(i).isFI()) {
 294     ++i;
 295     assert(i < MI.getNumOperands() &&
 296            "Instr doesn't have FrameIndex operand!");
 297   }
 298
 299   int FrameIndex = MI.getOperand(i).getIndex();
 300
 301   MachineFunction &MF = *MI.getParent()->getParent();
 302   int Offset = MF.getFrameInfo()->getObjectOffset(FrameIndex) +
 303       MI.getOperand(i+1).getImm();
 304
 305   // Using I0 as the frame pointer
 306   MI.getOperand(i).ChangeToRegister(NVPTX::VRFrame, false);
 307   MI.getOperand(i+1).ChangeToImmediate(Offset);
 308 }
 309
 310
 311 int NVPTXRegisterInfo::
 312 getDwarfRegNum(unsigned RegNum, bool isEH) const {
 313   return 0;
 314 }
 315
 316 unsigned NVPTXRegisterInfo::getFrameRegister(const MachineFunction &MF) const {
 317   return NVPTX::VRFrame;
 318 }
 319
 320 unsigned NVPTXRegisterInfo::getRARegister() const {
 321   return 0;
 322 }
 323
 324 // This function eliminates ADJCALLSTACKDOWN,
 325 // ADJCALLSTACKUP pseudo instructions
 326 void NVPTXRegisterInfo::
 327 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
 328                               MachineBasicBlock::iterator I) const {
 329   // Simply discard ADJCALLSTACKDOWN,
 330   // ADJCALLSTACKUP instructions.
 331   MBB.erase(I);
 332 }