lib/Target/Blackfin/BlackfinRegisterInfo.cpp

   1 //===- BlackfinRegisterInfo.cpp - Blackfin Register Information -*- C++ -*-===//
   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 Blackfin implementation of the TargetRegisterInfo
  11 // class.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "Blackfin.h"
  16 #include "BlackfinRegisterInfo.h"
  17 #include "BlackfinSubtarget.h"
  18 #include "llvm/Support/Debug.h"
  19 #include "llvm/Support/ErrorHandling.h"
  20 #include "llvm/CodeGen/MachineInstrBuilder.h"
  21 #include "llvm/CodeGen/MachineFunction.h"
  22 #include "llvm/CodeGen/MachineFrameInfo.h"
  23 #include "llvm/CodeGen/MachineLocation.h"
  24 #include "llvm/CodeGen/RegisterScavenging.h"
  25 #include "llvm/Target/TargetFrameInfo.h"
  26 #include "llvm/Target/TargetMachine.h"
  27 #include "llvm/Target/TargetOptions.h"
  28 #include "llvm/Target/TargetInstrInfo.h"
  29 #include "llvm/Type.h"
  30 #include "llvm/ADT/BitVector.h"
  31 #include "llvm/ADT/STLExtras.h"
  32 using namespace llvm;
  33
  34 BlackfinRegisterInfo::BlackfinRegisterInfo(BlackfinSubtarget &st,
  35                                            const TargetInstrInfo &tii)
  36   : BlackfinGenRegisterInfo(BF::ADJCALLSTACKDOWN, BF::ADJCALLSTACKUP),
  37     Subtarget(st),
  38     TII(tii) {}
  39
  40 const unsigned*
  41 BlackfinRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
  42   using namespace BF;
  43   static const unsigned CalleeSavedRegs[] = {
  44     FP,
  45     R4, R5, R6, R7,
  46     P3, P4, P5,
  47     0 };
  48   return  CalleeSavedRegs;
  49 }
  50
  51 const TargetRegisterClass* const *BlackfinRegisterInfo::
  52 getCalleeSavedRegClasses(const MachineFunction *MF) const {
  53   using namespace BF;
  54   static const TargetRegisterClass * const CalleeSavedRegClasses[] = {
  55     &PRegClass,
  56     &DRegClass, &DRegClass, &DRegClass, &DRegClass,
  57     &PRegClass, &PRegClass, &PRegClass,
  58     0 };
  59   return CalleeSavedRegClasses;
  60 }
  61
  62 BitVector
  63 BlackfinRegisterInfo::getReservedRegs(const MachineFunction &MF) const {
  64   using namespace BF;
  65   BitVector Reserved(getNumRegs());
  66   Reserved.set(L0);
  67   Reserved.set(L1);
  68   Reserved.set(L2);
  69   Reserved.set(L3);
  70   Reserved.set(SP);
  71   Reserved.set(RETS);
  72   if (hasFP(MF))
  73     Reserved.set(FP);
  74   return Reserved;
  75 }
  76
  77 const TargetRegisterClass*
  78 BlackfinRegisterInfo::getPhysicalRegisterRegClass(unsigned reg, MVT VT) const {
  79   assert(isPhysicalRegister(reg) && "reg must be a physical register");
  80
  81   // Pick the smallest register class of the right type that contains
  82   // this physreg.
  83   const TargetRegisterClass* BestRC = 0;
  84   for (regclass_iterator I = regclass_begin(), E = regclass_end();
  85        I != E; ++I) {
  86     const TargetRegisterClass* RC = *I;
  87     if ((VT == MVT::Other || RC->hasType(VT)) && RC->contains(reg) &&
  88         (!BestRC || RC->getNumRegs() < BestRC->getNumRegs()))
  89       BestRC = RC;
  90   }
  91
  92   assert(BestRC && "Couldn't find the register class");
  93   return BestRC;
  94 }
  95
  96 // hasFP - Return true if the specified function should have a dedicated frame
  97 // pointer register.  This is true if the function has variable sized allocas or
  98 // if frame pointer elimination is disabled.
  99 bool BlackfinRegisterInfo::hasFP(const MachineFunction &MF) const {
 100   const MachineFrameInfo *MFI = MF.getFrameInfo();
 101   return NoFramePointerElim || MFI->hasCalls() || MFI->hasVarSizedObjects();
 102 }
 103
 104 bool BlackfinRegisterInfo::
 105 requiresRegisterScavenging(const MachineFunction &MF) const {
 106   return true;
 107 }
 108
 109 // Emit instructions to add delta to D/P register. ScratchReg must be of the
 110 // same class as Reg (P).
 111 void BlackfinRegisterInfo::adjustRegister(MachineBasicBlock &MBB,
 112                                           MachineBasicBlock::iterator I,
 113                                           DebugLoc DL,
 114                                           unsigned Reg,
 115                                           unsigned ScratchReg,
 116                                           int delta) const {
 117   if (!delta)
 118     return;
 119   if (isImm<7>(delta)) {
 120     BuildMI(MBB, I, DL, TII.get(BF::ADDpp_imm7), Reg)
 121       .addReg(Reg)              // No kill on two-addr operand
 122       .addImm(delta);
 123     return;
 124   }
 125
 126   // We must load delta into ScratchReg and add that.
 127   loadConstant(MBB, I, DL, ScratchReg, delta);
 128   if (BF::PRegClass.contains(Reg)) {
 129     assert (BF::PRegClass.contains(ScratchReg));
 130     BuildMI(MBB, I, DL, TII.get(BF::ADDpp), Reg)
 131       .addReg(Reg, RegState::Kill)
 132       .addReg(ScratchReg, RegState::Kill);
 133   } else {
 134     assert (BF::DRegClass.contains(Reg));
 135     assert (BF::DRegClass.contains(ScratchReg));
 136     BuildMI(MBB, I, DL, TII.get(BF::ADD), Reg)
 137       .addReg(Reg, RegState::Kill)
 138       .addReg(ScratchReg, RegState::Kill);
 139   }
 140 }
 141
 142 // Emit instructions to load a constant into D/P register
 143 void BlackfinRegisterInfo::loadConstant(MachineBasicBlock &MBB,
 144                                         MachineBasicBlock::iterator I,
 145                                         DebugLoc DL,
 146                                         unsigned Reg,
 147                                         int value) const {
 148   if (isImm<7>(value)) {
 149     BuildMI(MBB, I, DL, TII.get(BF::LOADimm7), Reg).addImm(value);
 150     return;
 151   }
 152
 153   if (isUimm<16>(value)) {
 154     BuildMI(MBB, I, DL, TII.get(BF::LOADuimm16), Reg).addImm(value);
 155     return;
 156   }
 157
 158   if (isImm<16>(value)) {
 159     BuildMI(MBB, I, DL, TII.get(BF::LOADimm16), Reg).addImm(value);
 160     return;
 161   }
 162
 163   // We must split into halves
 164   BuildMI(MBB, I, DL,
 165           TII.get(BF::LOAD16i), getSubReg(Reg, bfin_subreg_hi16))
 166     .addImm((value >> 16) & 0xffff)
 167     .addReg(Reg, RegState::ImplicitDefine);
 168   BuildMI(MBB, I, DL,
 169           TII.get(BF::LOAD16i), getSubReg(Reg, bfin_subreg_lo16))
 170     .addImm(value & 0xffff)
 171     .addReg(Reg, RegState::ImplicitKill)
 172     .addReg(Reg, RegState::ImplicitDefine);
 173 }
 174
 175 void BlackfinRegisterInfo::
 176 eliminateCallFramePseudoInstr(MachineFunction &MF,
 177                               MachineBasicBlock &MBB,
 178                               MachineBasicBlock::iterator I) const {
 179   if (!hasReservedCallFrame(MF)) {
 180     int64_t Amount = I->getOperand(0).getImm();
 181     if (Amount != 0) {
 182       assert(Amount%4 == 0);
 183       if (I->getOpcode() == BF::ADJCALLSTACKDOWN) {
 184         adjustRegister(MBB, I, I->getDebugLoc(), BF::SP, BF::P1, -Amount);
 185       } else {
 186         assert(I->getOpcode() == BF::ADJCALLSTACKUP);
 187         adjustRegister(MBB, I, I->getDebugLoc(), BF::SP, BF::P1, Amount);
 188       }
 189     }
 190   }
 191   MBB.erase(I);
 192 }
 193
 194 /// findScratchRegister - Find a 'free' register. Try for a call-clobbered
 195 /// register first and then a spilled callee-saved register if that fails.
 196 static unsigned findScratchRegister(MachineBasicBlock::iterator II,
 197                                     RegScavenger *RS,
 198                                     const TargetRegisterClass *RC,
 199                                     int SPAdj) {
 200   assert(RS && "Register scavenging must be on");
 201   unsigned Reg = RS->FindUnusedReg(RC, true);
 202   if (Reg == 0)
 203     Reg = RS->scavengeRegister(RC, II, SPAdj);
 204   return Reg;
 205 }
 206
 207 void BlackfinRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
 208                                                int SPAdj,
 209                                                RegScavenger *RS) const {
 210   unsigned i;
 211   MachineInstr &MI = *II;
 212   MachineBasicBlock &MBB = *MI.getParent();
 213   MachineFunction &MF = *MBB.getParent();
 214   DebugLoc DL = MI.getDebugLoc();
 215
 216   for (i=0; !MI.getOperand(i).isFI(); i++) {
 217     assert(i < MI.getNumOperands() && "Instr doesn't have FrameIndex operand!");
 218   }
 219   int FrameIndex = MI.getOperand(i).getIndex();
 220   assert(i+1 < MI.getNumOperands() && MI.getOperand(i+1).isImm());
 221   int Offset = MF.getFrameInfo()->getObjectOffset(FrameIndex)
 222     + MI.getOperand(i+1).getImm();
 223   unsigned BaseReg = BF::FP;
 224   if (hasFP(MF)) {
 225     assert(SPAdj==0);
 226   } else {
 227     BaseReg = BF::SP;
 228     Offset += MF.getFrameInfo()->getStackSize() + SPAdj;
 229   }
 230
 231   bool isStore = false;
 232
 233   switch (MI.getOpcode()) {
 234   case BF::STORE32fi:
 235     isStore = true;
 236   case BF::LOAD32fi: {
 237     assert(Offset%4 == 0 && "Badly aligned i32 stack access");
 238     assert(i==1);
 239     MI.getOperand(i).ChangeToRegister(BaseReg, false);
 240     MI.getOperand(i+1).setImm(Offset);
 241     if (isUimm<6>(Offset)) {
 242       MI.setDesc(TII.get(isStore
 243                          ? BF::STORE32p_uimm6m4
 244                          : BF::LOAD32p_uimm6m4));
 245       return;
 246     }
 247     if (BaseReg == BF::FP && isUimm<7>(-Offset)) {
 248       MI.setDesc(TII.get(isStore
 249                          ? BF::STORE32fp_nimm7m4
 250                          : BF::LOAD32fp_nimm7m4));
 251       MI.getOperand(i+1).setImm(-Offset);
 252       return;
 253     }
 254     if (isImm<18>(Offset)) {
 255       MI.setDesc(TII.get(isStore
 256                          ? BF::STORE32p_imm18m4
 257                          : BF::LOAD32p_imm18m4));
 258       return;
 259     }
 260     // Use RegScavenger to calculate proper offset...
 261     MI.dump();
 262     llvm_unreachable("Stack frame offset too big");
 263     break;
 264   }
 265   case BF::ADDpp: {
 266     assert(MI.getOperand(0).isReg());
 267     unsigned DestReg = MI.getOperand(0).getReg();
 268     // We need to produce a stack offset in a P register. We emit:
 269     // P0 = offset;
 270     // P0 = BR + P0;
 271     assert(i==1);
 272     loadConstant(MBB, II, DL, DestReg, Offset);
 273     MI.getOperand(1).ChangeToRegister(DestReg, false, false, true);
 274     MI.getOperand(2).ChangeToRegister(BaseReg, false);
 275     break;
 276   }
 277   case BF::STORE16fi:
 278     isStore = true;
 279   case BF::LOAD16fi: {
 280     assert(Offset%2 == 0 && "Badly aligned i16 stack access");
 281     assert(i==1);
 282     // We need a P register to use as an address
 283     unsigned ScratchReg = findScratchRegister(II, RS, &BF::PRegClass, SPAdj);
 284     assert(ScratchReg);
 285     loadConstant(MBB, II, DL, ScratchReg, Offset);
 286     BuildMI(MBB, II, DL, TII.get(BF::ADDpp), ScratchReg)
 287       .addReg(ScratchReg, RegState::Kill)
 288       .addReg(BaseReg);
 289     MI.setDesc(TII.get(isStore ? BF::STORE16pi : BF::LOAD16pi));
 290     MI.getOperand(1).ChangeToRegister(ScratchReg, false, false, true);
 291     MI.RemoveOperand(2);
 292     break;
 293   }
 294   case BF::STORE8fi: {
 295     // This is an AnyCC spill, we need a scratch register.
 296     assert(i==1);
 297     MachineOperand SpillReg = MI.getOperand(0);
 298     unsigned ScratchReg = findScratchRegister(II, RS, &BF::DRegClass, SPAdj);
 299     assert(ScratchReg);
 300     if (SpillReg.getReg()==BF::NCC) {
 301       BuildMI(MBB, II, DL, TII.get(BF::MOVENCC_z), ScratchReg)
 302         .addOperand(SpillReg);
 303       BuildMI(MBB, II, DL, TII.get(BF::BITTGL), ScratchReg)
 304         .addReg(ScratchReg).addImm(0);
 305     } else {
 306       BuildMI(MBB, II, DL, TII.get(BF::MOVECC_zext), ScratchReg)
 307         .addOperand(SpillReg);
 308     }
 309     // STORE D
 310     MI.setDesc(TII.get(BF::STORE8p_imm16));
 311     MI.getOperand(0).ChangeToRegister(ScratchReg, false, false, true);
 312     MI.getOperand(i).ChangeToRegister(BaseReg, false);
 313     MI.getOperand(i+1).setImm(Offset);
 314     break;
 315   }
 316   case BF::LOAD8fi: {
 317     // This is an restore, we need a scratch register.
 318     assert(i==1);
 319     MachineOperand SpillReg = MI.getOperand(0);
 320     unsigned ScratchReg = findScratchRegister(II, RS, &BF::DRegClass, SPAdj);
 321     assert(ScratchReg);
 322     MI.setDesc(TII.get(BF::LOAD32p_imm16_8z));
 323     MI.getOperand(0).ChangeToRegister(ScratchReg, true);
 324     MI.getOperand(i).ChangeToRegister(BaseReg, false);
 325     MI.getOperand(i+1).setImm(Offset);
 326     ++II;
 327     if (SpillReg.getReg()==BF::CC) {
 328       // CC = D
 329       BuildMI(MBB, II, DL, TII.get(BF::MOVECC_nz), BF::CC)
 330         .addReg(ScratchReg, RegState::Kill);
 331     } else {
 332       // Restore NCC (CC = D==0)
 333       BuildMI(MBB, II, DL, TII.get(BF::SETEQri_not), BF::NCC)
 334         .addReg(ScratchReg, RegState::Kill)
 335         .addImm(0);
 336     }
 337     break;
 338   }
 339   default:
 340     llvm_unreachable("Cannot eliminate frame index");
 341     break;
 342   }
 343 }
 344
 345 void BlackfinRegisterInfo::
 346 processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
 347                                      RegScavenger *RS) const {
 348   MachineFrameInfo *MFI = MF.getFrameInfo();
 349   const TargetRegisterClass *RC = BF::DPRegisterClass;
 350   if (requiresRegisterScavenging(MF)) {
 351     // Reserve a slot close to SP or frame pointer.
 352     RS->setScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(),
 353                                                        RC->getAlignment()));
 354   }
 355 }
 356
 357 void BlackfinRegisterInfo::
 358 processFunctionBeforeFrameFinalized(MachineFunction &MF) const {
 359 }
 360
 361 // Emit a prologue that sets up a stack frame.
 362 // On function entry, R0-R2 and P0 may hold arguments.
 363 // R3, P1, and P2 may be used as scratch registers
 364 void BlackfinRegisterInfo::emitPrologue(MachineFunction &MF) const {
 365   MachineBasicBlock &MBB = MF.front();   // Prolog goes in entry BB
 366   MachineBasicBlock::iterator MBBI = MBB.begin();
 367   MachineFrameInfo *MFI = MF.getFrameInfo();
 368   DebugLoc dl = (MBBI != MBB.end()
 369                  ? MBBI->getDebugLoc()
 370                  : DebugLoc::getUnknownLoc());
 371
 372   int FrameSize = MFI->getStackSize();
 373   if (FrameSize%4) {
 374     FrameSize = (FrameSize+3) & ~3;
 375     MFI->setStackSize(FrameSize);
 376   }
 377
 378   if (!hasFP(MF)) {
 379     // So far we only support FP elimination on leaf functions
 380     assert(!MFI->hasCalls());
 381     adjustRegister(MBB, MBBI, dl, BF::SP, BF::P1, -FrameSize);
 382     return;
 383   }
 384
 385   // emit a LINK instruction
 386   if (FrameSize <= 0x3ffff) {
 387     BuildMI(MBB, MBBI, dl, TII.get(BF::LINK)).addImm(FrameSize);
 388     return;
 389   }
 390
 391   // Frame is too big, do a manual LINK:
 392   // [--SP] = RETS;
 393   // [--SP] = FP;
 394   // FP = SP;
 395   // P1 = -FrameSize;
 396   // SP = SP + P1;
 397   BuildMI(MBB, MBBI, dl, TII.get(BF::PUSH))
 398     .addReg(BF::RETS, RegState::Kill);
 399   BuildMI(MBB, MBBI, dl, TII.get(BF::PUSH))
 400     .addReg(BF::FP, RegState::Kill);
 401   BuildMI(MBB, MBBI, dl, TII.get(BF::MOVE), BF::FP)
 402     .addReg(BF::SP);
 403   loadConstant(MBB, MBBI, dl, BF::P1, -FrameSize);
 404   BuildMI(MBB, MBBI, dl, TII.get(BF::ADDpp), BF::SP)
 405     .addReg(BF::SP, RegState::Kill)
 406     .addReg(BF::P1, RegState::Kill);
 407
 408 }
 409
 410 void BlackfinRegisterInfo::emitEpilogue(MachineFunction &MF,
 411                                         MachineBasicBlock &MBB) const {
 412   MachineFrameInfo *MFI = MF.getFrameInfo();
 413   MachineBasicBlock::iterator MBBI = prior(MBB.end());
 414   DebugLoc dl = MBBI->getDebugLoc();
 415
 416   int FrameSize = MFI->getStackSize();
 417   assert(FrameSize%4 == 0 && "Misaligned frame size");
 418
 419   if (!hasFP(MF)) {
 420     // So far we only support FP elimination on leaf functions
 421     assert(!MFI->hasCalls());
 422     adjustRegister(MBB, MBBI, dl, BF::SP, BF::P1, FrameSize);
 423     return;
 424   }
 425
 426   // emit an UNLINK instruction
 427   BuildMI(MBB, MBBI, dl, TII.get(BF::UNLINK));
 428 }
 429
 430 unsigned BlackfinRegisterInfo::getRARegister() const {
 431   return BF::RETS;
 432 }
 433
 434 unsigned BlackfinRegisterInfo::getFrameRegister(MachineFunction &MF) const {
 435   return hasFP(MF) ? BF::FP : BF::SP;
 436 }
 437
 438 int
 439 BlackfinRegisterInfo::getFrameIndexOffset(MachineFunction &MF, int FI) const {
 440   const TargetFrameInfo &TFI = *MF.getTarget().getFrameInfo();
 441   MachineFrameInfo *MFI = MF.getFrameInfo();
 442   return MFI->getObjectOffset(FI) + MFI->getStackSize() -
 443     TFI.getOffsetOfLocalArea() + MFI->getOffsetAdjustment();
 444 }
 445
 446 unsigned BlackfinRegisterInfo::getEHExceptionRegister() const {
 447   llvm_unreachable("What is the exception register");
 448   return 0;
 449 }
 450
 451 unsigned BlackfinRegisterInfo::getEHHandlerRegister() const {
 452   llvm_unreachable("What is the exception handler register");
 453   return 0;
 454 }
 455
 456 int BlackfinRegisterInfo::getDwarfRegNum(unsigned RegNum, bool isEH) const {
 457   llvm_unreachable("What is the dwarf register number");
 458   return -1;
 459 }
 460
 461 #include "BlackfinGenRegisterInfo.inc"
 462