LLVM API Documentation
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