LLVM API Documentation

BlackfinRegisterInfo.cpp

Go to the documentation of this file.
00001 //===- BlackfinRegisterInfo.cpp - Blackfin Register Information -*- C++ -*-===//
00002 //
00003 //                     The LLVM Compiler Infrastructure
00004 //
00005 // This file is distributed under the University of Illinois Open Source
00006 // License. See LICENSE.TXT for details.
00007 //
00008 //===----------------------------------------------------------------------===//
00009 //
00010 // This file contains the Blackfin implementation of the TargetRegisterInfo
00011 // class.
00012 //
00013 //===----------------------------------------------------------------------===//
00014 
00015 #include "Blackfin.h"
00016 #include "BlackfinRegisterInfo.h"
00017 #include "BlackfinSubtarget.h"
00018 #include "llvm/Support/Debug.h"
00019 #include "llvm/Support/ErrorHandling.h"
00020 #include "llvm/CodeGen/MachineInstrBuilder.h"
00021 #include "llvm/CodeGen/MachineFunction.h"
00022 #include "llvm/CodeGen/MachineFrameInfo.h"
00023 #include "llvm/CodeGen/MachineLocation.h"
00024 #include "llvm/CodeGen/RegisterScavenging.h"
00025 #include "llvm/Target/TargetFrameInfo.h"
00026 #include "llvm/Target/TargetMachine.h"
00027 #include "llvm/Target/TargetOptions.h"
00028 #include "llvm/Target/TargetInstrInfo.h"
00029 #include "llvm/Type.h"
00030 #include "llvm/ADT/BitVector.h"
00031 #include "llvm/ADT/STLExtras.h"
00032 using namespace llvm;
00033 
00034 BlackfinRegisterInfo::BlackfinRegisterInfo(BlackfinSubtarget &st,
00035                                            const TargetInstrInfo &tii)
00036   : BlackfinGenRegisterInfo(BF::ADJCALLSTACKDOWN, BF::ADJCALLSTACKUP),
00037     Subtarget(st),
00038     TII(tii) {}
00039 
00040 const unsigned*
00041 BlackfinRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
00042   using namespace BF;
00043   static const unsigned CalleeSavedRegs[] = {
00044     FP,
00045     R4, R5, R6, R7,
00046     P3, P4, P5,
00047     0 };
00048   return  CalleeSavedRegs;
00049 }
00050 
00051 const TargetRegisterClass* const *BlackfinRegisterInfo::
00052 getCalleeSavedRegClasses(const MachineFunction *MF) const {
00053   using namespace BF;
00054   static const TargetRegisterClass * const CalleeSavedRegClasses[] = {
00055     &PRegClass,
00056     &DRegClass, &DRegClass, &DRegClass, &DRegClass,
00057     &PRegClass, &PRegClass, &PRegClass,
00058     0 };
00059   return CalleeSavedRegClasses;
00060 }
00061 
00062 BitVector
00063 BlackfinRegisterInfo::getReservedRegs(const MachineFunction &MF) const {
00064   using namespace BF;
00065   BitVector Reserved(getNumRegs());
00066   Reserved.set(AZ);
00067   Reserved.set(AN);
00068   Reserved.set(AQ);
00069   Reserved.set(AC0);
00070   Reserved.set(AC1);
00071   Reserved.set(AV0);
00072   Reserved.set(AV0S);
00073   Reserved.set(AV1);
00074   Reserved.set(AV1S);
00075   Reserved.set(V);
00076   Reserved.set(VS);
00077   Reserved.set(CYCLES).set(CYCLES2);
00078   Reserved.set(L0);
00079   Reserved.set(L1);
00080   Reserved.set(L2);
00081   Reserved.set(L3);
00082   Reserved.set(SP);
00083   Reserved.set(RETS);
00084   if (hasFP(MF))
00085     Reserved.set(FP);
00086   return Reserved;
00087 }
00088 
00089 const TargetRegisterClass*
00090 BlackfinRegisterInfo::getPhysicalRegisterRegClass(unsigned reg, EVT VT) const {
00091   assert(isPhysicalRegister(reg) && "reg must be a physical register");
00092 
00093   // Pick the smallest register class of the right type that contains
00094   // this physreg.
00095   const TargetRegisterClass* BestRC = 0;
00096   for (regclass_iterator I = regclass_begin(), E = regclass_end();
00097        I != E; ++I) {
00098     const TargetRegisterClass* RC = *I;
00099     if ((VT == MVT::Other || RC->hasType(VT)) && RC->contains(reg) &&
00100         (!BestRC || RC->getNumRegs() < BestRC->getNumRegs()))
00101       BestRC = RC;
00102   }
00103 
00104   assert(BestRC && "Couldn't find the register class");
00105   return BestRC;
00106 }
00107 
00108 // hasFP - Return true if the specified function should have a dedicated frame
00109 // pointer register.  This is true if the function has variable sized allocas or
00110 // if frame pointer elimination is disabled.
00111 bool BlackfinRegisterInfo::hasFP(const MachineFunction &MF) const {
00112   const MachineFrameInfo *MFI = MF.getFrameInfo();
00113   return NoFramePointerElim || MFI->hasCalls() || MFI->hasVarSizedObjects();
00114 }
00115 
00116 bool BlackfinRegisterInfo::
00117 requiresRegisterScavenging(const MachineFunction &MF) const {
00118   return true;
00119 }
00120 
00121 // Emit instructions to add delta to D/P register. ScratchReg must be of the
00122 // same class as Reg (P).
00123 void BlackfinRegisterInfo::adjustRegister(MachineBasicBlock &MBB,
00124                                           MachineBasicBlock::iterator I,
00125                                           DebugLoc DL,
00126                                           unsigned Reg,
00127                                           unsigned ScratchReg,
00128                                           int delta) const {
00129   if (!delta)
00130     return;
00131   if (isInt<7>(delta)) {
00132     BuildMI(MBB, I, DL, TII.get(BF::ADDpp_imm7), Reg)
00133       .addReg(Reg)              // No kill on two-addr operand
00134       .addImm(delta);
00135     return;
00136   }
00137 
00138   // We must load delta into ScratchReg and add that.
00139   loadConstant(MBB, I, DL, ScratchReg, delta);
00140   if (BF::PRegClass.contains(Reg)) {
00141     assert(BF::PRegClass.contains(ScratchReg) &&
00142            "ScratchReg must be a P register");
00143     BuildMI(MBB, I, DL, TII.get(BF::ADDpp), Reg)
00144       .addReg(Reg, RegState::Kill)
00145       .addReg(ScratchReg, RegState::Kill);
00146   } else {
00147     assert(BF::DRegClass.contains(Reg) && "Reg must be a D or P register");
00148     assert(BF::DRegClass.contains(ScratchReg) &&
00149            "ScratchReg must be a D register");
00150     BuildMI(MBB, I, DL, TII.get(BF::ADD), Reg)
00151       .addReg(Reg, RegState::Kill)
00152       .addReg(ScratchReg, RegState::Kill);
00153   }
00154 }
00155 
00156 // Emit instructions to load a constant into D/P register
00157 void BlackfinRegisterInfo::loadConstant(MachineBasicBlock &MBB,
00158                                         MachineBasicBlock::iterator I,
00159                                         DebugLoc DL,
00160                                         unsigned Reg,
00161                                         int value) const {
00162   if (isInt<7>(value)) {
00163     BuildMI(MBB, I, DL, TII.get(BF::LOADimm7), Reg).addImm(value);
00164     return;
00165   }
00166 
00167   if (isUint<16>(value)) {
00168     BuildMI(MBB, I, DL, TII.get(BF::LOADuimm16), Reg).addImm(value);
00169     return;
00170   }
00171 
00172   if (isInt<16>(value)) {
00173     BuildMI(MBB, I, DL, TII.get(BF::LOADimm16), Reg).addImm(value);
00174     return;
00175   }
00176 
00177   // We must split into halves
00178   BuildMI(MBB, I, DL,
00179           TII.get(BF::LOAD16i), getSubReg(Reg, bfin_subreg_hi16))
00180     .addImm((value >> 16) & 0xffff)
00181     .addReg(Reg, RegState::ImplicitDefine);
00182   BuildMI(MBB, I, DL,
00183           TII.get(BF::LOAD16i), getSubReg(Reg, bfin_subreg_lo16))
00184     .addImm(value & 0xffff)
00185     .addReg(Reg, RegState::ImplicitKill)
00186     .addReg(Reg, RegState::ImplicitDefine);
00187 }
00188 
00189 void BlackfinRegisterInfo::
00190 eliminateCallFramePseudoInstr(MachineFunction &MF,
00191                               MachineBasicBlock &MBB,
00192                               MachineBasicBlock::iterator I) const {
00193   if (!hasReservedCallFrame(MF)) {
00194     int64_t Amount = I->getOperand(0).getImm();
00195     if (Amount != 0) {
00196       assert(Amount%4 == 0 && "Unaligned call frame size");
00197       if (I->getOpcode() == BF::ADJCALLSTACKDOWN) {
00198         adjustRegister(MBB, I, I->getDebugLoc(), BF::SP, BF::P1, -Amount);
00199       } else {
00200         assert(I->getOpcode() == BF::ADJCALLSTACKUP &&
00201                "Unknown call frame pseudo instruction");
00202         adjustRegister(MBB, I, I->getDebugLoc(), BF::SP, BF::P1, Amount);
00203       }
00204     }
00205   }
00206   MBB.erase(I);
00207 }
00208 
00209 /// findScratchRegister - Find a 'free' register. Try for a call-clobbered
00210 /// register first and then a spilled callee-saved register if that fails.
00211 static unsigned findScratchRegister(MachineBasicBlock::iterator II,
00212                                     RegScavenger *RS,
00213                                     const TargetRegisterClass *RC,
00214                                     int SPAdj) {
00215   assert(RS && "Register scavenging must be on");
00216   unsigned Reg = RS->FindUnusedReg(RC);
00217   if (Reg == 0)
00218     Reg = RS->scavengeRegister(RC, II, SPAdj);
00219   return Reg;
00220 }
00221 
00222 void BlackfinRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
00223                                                int SPAdj,
00224                                                RegScavenger *RS) const {
00225   MachineInstr &MI = *II;
00226   MachineBasicBlock &MBB = *MI.getParent();
00227   MachineFunction &MF = *MBB.getParent();
00228   DebugLoc DL = MI.getDebugLoc();
00229 
00230   unsigned FIPos;
00231   for (FIPos=0; !MI.getOperand(FIPos).isFI(); ++FIPos) {
00232     assert(FIPos < MI.getNumOperands() &&
00233            "Instr doesn't have FrameIndex operand!");
00234   }
00235   int FrameIndex = MI.getOperand(FIPos).getIndex();
00236   assert(FIPos+1 < MI.getNumOperands() && MI.getOperand(FIPos+1).isImm());
00237   int Offset = MF.getFrameInfo()->getObjectOffset(FrameIndex)
00238     + MI.getOperand(FIPos+1).getImm();
00239   unsigned BaseReg = BF::FP;
00240   if (hasFP(MF)) {
00241     assert(SPAdj==0 && "Unexpected SP adjust in function with frame pointer");
00242   } else {
00243     BaseReg = BF::SP;
00244     Offset += MF.getFrameInfo()->getStackSize() + SPAdj;
00245   }
00246 
00247   bool isStore = false;
00248 
00249   switch (MI.getOpcode()) {
00250   case BF::STORE32fi:
00251     isStore = true;
00252   case BF::LOAD32fi: {
00253     assert(Offset%4 == 0 && "Unaligned i32 stack access");
00254     assert(FIPos==1 && "Bad frame index operand");
00255     MI.getOperand(FIPos).ChangeToRegister(BaseReg, false);
00256     MI.getOperand(FIPos+1).setImm(Offset);
00257     if (isUint<6>(Offset)) {
00258       MI.setDesc(TII.get(isStore
00259                          ? BF::STORE32p_uimm6m4
00260                          : BF::LOAD32p_uimm6m4));
00261       return;
00262     }
00263     if (BaseReg == BF::FP && isUint<7>(-Offset)) {
00264       MI.setDesc(TII.get(isStore
00265                          ? BF::STORE32fp_nimm7m4
00266                          : BF::LOAD32fp_nimm7m4));
00267       MI.getOperand(FIPos+1).setImm(-Offset);
00268       return;
00269     }
00270     if (isInt<18>(Offset)) {
00271       MI.setDesc(TII.get(isStore
00272                          ? BF::STORE32p_imm18m4
00273                          : BF::LOAD32p_imm18m4));
00274       return;
00275     }
00276     // Use RegScavenger to calculate proper offset...
00277     MI.dump();
00278     llvm_unreachable("Stack frame offset too big");
00279     break;
00280   }
00281   case BF::ADDpp: {
00282     assert(MI.getOperand(0).isReg() && "ADD instruction needs a register");
00283     unsigned DestReg = MI.getOperand(0).getReg();
00284     // We need to produce a stack offset in a P register. We emit:
00285     // P0 = offset;
00286     // P0 = BR + P0;
00287     assert(FIPos==1 && "Bad frame index operand");
00288     loadConstant(MBB, II, DL, DestReg, Offset);
00289     MI.getOperand(1).ChangeToRegister(DestReg, false, false, true);
00290     MI.getOperand(2).ChangeToRegister(BaseReg, false);
00291     break;
00292   }
00293   case BF::STORE16fi:
00294     isStore = true;
00295   case BF::LOAD16fi: {
00296     assert(Offset%2 == 0 && "Unaligned i16 stack access");
00297     assert(FIPos==1 && "Bad frame index operand");
00298     // We need a P register to use as an address
00299     unsigned ScratchReg = findScratchRegister(II, RS, &BF::PRegClass, SPAdj);
00300     assert(ScratchReg && "Could not scavenge register");
00301     loadConstant(MBB, II, DL, ScratchReg, Offset);
00302     BuildMI(MBB, II, DL, TII.get(BF::ADDpp), ScratchReg)
00303       .addReg(ScratchReg, RegState::Kill)
00304       .addReg(BaseReg);
00305     MI.setDesc(TII.get(isStore ? BF::STORE16pi : BF::LOAD16pi));
00306     MI.getOperand(1).ChangeToRegister(ScratchReg, false, false, true);
00307     MI.RemoveOperand(2);
00308     break;
00309   }
00310   case BF::STORE8fi: {
00311     // This is an AnyCC spill, we need a scratch register.
00312     assert(FIPos==1 && "Bad frame index operand");
00313     MachineOperand SpillReg = MI.getOperand(0);
00314     unsigned ScratchReg = findScratchRegister(II, RS, &BF::DRegClass, SPAdj);
00315     assert(ScratchReg && "Could not scavenge register");
00316     if (SpillReg.getReg()==BF::NCC) {
00317       BuildMI(MBB, II, DL, TII.get(BF::MOVENCC_z), ScratchReg)
00318         .addOperand(SpillReg);
00319       BuildMI(MBB, II, DL, TII.get(BF::BITTGL), ScratchReg)
00320         .addReg(ScratchReg).addImm(0);
00321     } else {
00322       BuildMI(MBB, II, DL, TII.get(BF::MOVECC_zext), ScratchReg)
00323         .addOperand(SpillReg);
00324     }
00325     // STORE D
00326     MI.setDesc(TII.get(BF::STORE8p_imm16));
00327     MI.getOperand(0).ChangeToRegister(ScratchReg, false, false, true);
00328     MI.getOperand(FIPos).ChangeToRegister(BaseReg, false);
00329     MI.getOperand(FIPos+1).setImm(Offset);
00330     break;
00331   }
00332   case BF::LOAD8fi: {
00333     // This is an restore, we need a scratch register.
00334     assert(FIPos==1 && "Bad frame index operand");
00335     MachineOperand SpillReg = MI.getOperand(0);
00336     unsigned ScratchReg = findScratchRegister(II, RS, &BF::DRegClass, SPAdj);
00337     assert(ScratchReg && "Could not scavenge register");
00338     MI.setDesc(TII.get(BF::LOAD32p_imm16_8z));
00339     MI.getOperand(0).ChangeToRegister(ScratchReg, true);
00340     MI.getOperand(FIPos).ChangeToRegister(BaseReg, false);
00341     MI.getOperand(FIPos+1).setImm(Offset);
00342     ++II;
00343     if (SpillReg.getReg()==BF::CC) {
00344       // CC = D
00345       BuildMI(MBB, II, DL, TII.get(BF::MOVECC_nz), BF::CC)
00346         .addReg(ScratchReg, RegState::Kill);
00347     } else {
00348       // Restore NCC (CC = D==0)
00349       BuildMI(MBB, II, DL, TII.get(BF::SETEQri_not), BF::NCC)
00350         .addReg(ScratchReg, RegState::Kill)
00351         .addImm(0);
00352     }
00353     break;
00354   }
00355   default:
00356     llvm_unreachable("Cannot eliminate frame index");
00357     break;
00358   }
00359 }
00360 
00361 void BlackfinRegisterInfo::
00362 processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
00363                                      RegScavenger *RS) const {
00364   MachineFrameInfo *MFI = MF.getFrameInfo();
00365   const TargetRegisterClass *RC = BF::DPRegisterClass;
00366   if (requiresRegisterScavenging(MF)) {
00367     // Reserve a slot close to SP or frame pointer.
00368     RS->setScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(),
00369                                                        RC->getAlignment()));
00370   }
00371 }
00372 
00373 void BlackfinRegisterInfo::
00374 processFunctionBeforeFrameFinalized(MachineFunction &MF) const {
00375 }
00376 
00377 // Emit a prologue that sets up a stack frame.
00378 // On function entry, R0-R2 and P0 may hold arguments.
00379 // R3, P1, and P2 may be used as scratch registers
00380 void BlackfinRegisterInfo::emitPrologue(MachineFunction &MF) const {
00381   MachineBasicBlock &MBB = MF.front();   // Prolog goes in entry BB
00382   MachineBasicBlock::iterator MBBI = MBB.begin();
00383   MachineFrameInfo *MFI = MF.getFrameInfo();
00384   DebugLoc dl = (MBBI != MBB.end()
00385                  ? MBBI->getDebugLoc()
00386                  : DebugLoc::getUnknownLoc());
00387 
00388   int FrameSize = MFI->getStackSize();
00389   if (FrameSize%4) {
00390     FrameSize = (FrameSize+3) & ~3;
00391     MFI->setStackSize(FrameSize);
00392   }
00393 
00394   if (!hasFP(MF)) {
00395     assert(!MFI->hasCalls() &&
00396            "FP elimination on a non-leaf function is not supported");
00397     adjustRegister(MBB, MBBI, dl, BF::SP, BF::P1, -FrameSize);
00398     return;
00399   }
00400 
00401   // emit a LINK instruction
00402   if (FrameSize <= 0x3ffff) {
00403     BuildMI(MBB, MBBI, dl, TII.get(BF::LINK)).addImm(FrameSize);
00404     return;
00405   }
00406 
00407   // Frame is too big, do a manual LINK:
00408   // [--SP] = RETS;
00409   // [--SP] = FP;
00410   // FP = SP;
00411   // P1 = -FrameSize;
00412   // SP = SP + P1;
00413   BuildMI(MBB, MBBI, dl, TII.get(BF::PUSH))
00414     .addReg(BF::RETS, RegState::Kill);
00415   BuildMI(MBB, MBBI, dl, TII.get(BF::PUSH))
00416     .addReg(BF::FP, RegState::Kill);
00417   BuildMI(MBB, MBBI, dl, TII.get(BF::MOVE), BF::FP)
00418     .addReg(BF::SP);
00419   loadConstant(MBB, MBBI, dl, BF::P1, -FrameSize);
00420   BuildMI(MBB, MBBI, dl, TII.get(BF::ADDpp), BF::SP)
00421     .addReg(BF::SP, RegState::Kill)
00422     .addReg(BF::P1, RegState::Kill);
00423 
00424 }
00425 
00426 void BlackfinRegisterInfo::emitEpilogue(MachineFunction &MF,
00427                                         MachineBasicBlock &MBB) const {
00428   MachineFrameInfo *MFI = MF.getFrameInfo();
00429   MachineBasicBlock::iterator MBBI = prior(MBB.end());
00430   DebugLoc dl = MBBI->getDebugLoc();
00431 
00432   int FrameSize = MFI->getStackSize();
00433   assert(FrameSize%4 == 0 && "Misaligned frame size");
00434 
00435   if (!hasFP(MF)) {
00436     assert(!MFI->hasCalls() &&
00437            "FP elimination on a non-leaf function is not supported");
00438     adjustRegister(MBB, MBBI, dl, BF::SP, BF::P1, FrameSize);
00439     return;
00440   }
00441 
00442   // emit an UNLINK instruction
00443   BuildMI(MBB, MBBI, dl, TII.get(BF::UNLINK));
00444 }
00445 
00446 unsigned BlackfinRegisterInfo::getRARegister() const {
00447   return BF::RETS;
00448 }
00449 
00450 unsigned BlackfinRegisterInfo::getFrameRegister(MachineFunction &MF) const {
00451   return hasFP(MF) ? BF::FP : BF::SP;
00452 }
00453 
00454 int
00455 BlackfinRegisterInfo::getFrameIndexOffset(MachineFunction &MF, int FI) const {
00456   const TargetFrameInfo &TFI = *MF.getTarget().getFrameInfo();
00457   MachineFrameInfo *MFI = MF.getFrameInfo();
00458   return MFI->getObjectOffset(FI) + MFI->getStackSize() -
00459     TFI.getOffsetOfLocalArea() + MFI->getOffsetAdjustment();
00460 }
00461 
00462 unsigned BlackfinRegisterInfo::getEHExceptionRegister() const {
00463   llvm_unreachable("What is the exception register");
00464   return 0;
00465 }
00466 
00467 unsigned BlackfinRegisterInfo::getEHHandlerRegister() const {
00468   llvm_unreachable("What is the exception handler register");
00469   return 0;
00470 }
00471 
00472 int BlackfinRegisterInfo::getDwarfRegNum(unsigned RegNum, bool isEH) const {
00473   llvm_unreachable("What is the dwarf register number");
00474   return -1;
00475 }
00476 
00477 #include "BlackfinGenRegisterInfo.inc"
00478