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