LLVM API Documentation
00001 //===- ARMBaseRegisterInfo.cpp - ARM 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 base ARM implementation of TargetRegisterInfo class. 00011 // 00012 //===----------------------------------------------------------------------===// 00013 00014 #include "ARM.h" 00015 #include "ARMAddressingModes.h" 00016 #include "ARMBaseInstrInfo.h" 00017 #include "ARMBaseRegisterInfo.h" 00018 #include "ARMInstrInfo.h" 00019 #include "ARMMachineFunctionInfo.h" 00020 #include "ARMSubtarget.h" 00021 #include "llvm/Constants.h" 00022 #include "llvm/DerivedTypes.h" 00023 #include "llvm/Function.h" 00024 #include "llvm/LLVMContext.h" 00025 #include "llvm/CodeGen/MachineConstantPool.h" 00026 #include "llvm/CodeGen/MachineFrameInfo.h" 00027 #include "llvm/CodeGen/MachineFunction.h" 00028 #include "llvm/CodeGen/MachineInstrBuilder.h" 00029 #include "llvm/CodeGen/MachineLocation.h" 00030 #include "llvm/CodeGen/MachineRegisterInfo.h" 00031 #include "llvm/CodeGen/RegisterScavenging.h" 00032 #include "llvm/Support/ErrorHandling.h" 00033 #include "llvm/Support/raw_ostream.h" 00034 #include "llvm/Target/TargetFrameInfo.h" 00035 #include "llvm/Target/TargetMachine.h" 00036 #include "llvm/Target/TargetOptions.h" 00037 #include "llvm/ADT/BitVector.h" 00038 #include "llvm/ADT/SmallVector.h" 00039 using namespace llvm; 00040 00041 unsigned ARMBaseRegisterInfo::getRegisterNumbering(unsigned RegEnum, 00042 bool *isSPVFP) { 00043 if (isSPVFP) 00044 *isSPVFP = false; 00045 00046 using namespace ARM; 00047 switch (RegEnum) { 00048 default: 00049 llvm_unreachable("Unknown ARM register!"); 00050 case R0: case D0: case Q0: return 0; 00051 case R1: case D1: case Q1: return 1; 00052 case R2: case D2: case Q2: return 2; 00053 case R3: case D3: case Q3: return 3; 00054 case R4: case D4: case Q4: return 4; 00055 case R5: case D5: case Q5: return 5; 00056 case R6: case D6: case Q6: return 6; 00057 case R7: case D7: case Q7: return 7; 00058 case R8: case D8: case Q8: return 8; 00059 case R9: case D9: case Q9: return 9; 00060 case R10: case D10: case Q10: return 10; 00061 case R11: case D11: case Q11: return 11; 00062 case R12: case D12: case Q12: return 12; 00063 case SP: case D13: case Q13: return 13; 00064 case LR: case D14: case Q14: return 14; 00065 case PC: case D15: case Q15: return 15; 00066 00067 case D16: return 16; 00068 case D17: return 17; 00069 case D18: return 18; 00070 case D19: return 19; 00071 case D20: return 20; 00072 case D21: return 21; 00073 case D22: return 22; 00074 case D23: return 23; 00075 case D24: return 24; 00076 case D25: return 25; 00077 case D26: return 27; 00078 case D27: return 27; 00079 case D28: return 28; 00080 case D29: return 29; 00081 case D30: return 30; 00082 case D31: return 31; 00083 00084 case S0: case S1: case S2: case S3: 00085 case S4: case S5: case S6: case S7: 00086 case S8: case S9: case S10: case S11: 00087 case S12: case S13: case S14: case S15: 00088 case S16: case S17: case S18: case S19: 00089 case S20: case S21: case S22: case S23: 00090 case S24: case S25: case S26: case S27: 00091 case S28: case S29: case S30: case S31: { 00092 if (isSPVFP) 00093 *isSPVFP = true; 00094 switch (RegEnum) { 00095 default: return 0; // Avoid compile time warning. 00096 case S0: return 0; 00097 case S1: return 1; 00098 case S2: return 2; 00099 case S3: return 3; 00100 case S4: return 4; 00101 case S5: return 5; 00102 case S6: return 6; 00103 case S7: return 7; 00104 case S8: return 8; 00105 case S9: return 9; 00106 case S10: return 10; 00107 case S11: return 11; 00108 case S12: return 12; 00109 case S13: return 13; 00110 case S14: return 14; 00111 case S15: return 15; 00112 case S16: return 16; 00113 case S17: return 17; 00114 case S18: return 18; 00115 case S19: return 19; 00116 case S20: return 20; 00117 case S21: return 21; 00118 case S22: return 22; 00119 case S23: return 23; 00120 case S24: return 24; 00121 case S25: return 25; 00122 case S26: return 26; 00123 case S27: return 27; 00124 case S28: return 28; 00125 case S29: return 29; 00126 case S30: return 30; 00127 case S31: return 31; 00128 } 00129 } 00130 } 00131 } 00132 00133 ARMBaseRegisterInfo::ARMBaseRegisterInfo(const ARMBaseInstrInfo &tii, 00134 const ARMSubtarget &sti) 00135 : ARMGenRegisterInfo(ARM::ADJCALLSTACKDOWN, ARM::ADJCALLSTACKUP), 00136 TII(tii), STI(sti), 00137 FramePtr((STI.isTargetDarwin() || STI.isThumb()) ? ARM::R7 : ARM::R11) { 00138 } 00139 00140 const unsigned* 00141 ARMBaseRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const { 00142 static const unsigned CalleeSavedRegs[] = { 00143 ARM::LR, ARM::R11, ARM::R10, ARM::R9, ARM::R8, 00144 ARM::R7, ARM::R6, ARM::R5, ARM::R4, 00145 00146 ARM::D15, ARM::D14, ARM::D13, ARM::D12, 00147 ARM::D11, ARM::D10, ARM::D9, ARM::D8, 00148 0 00149 }; 00150 00151 static const unsigned DarwinCalleeSavedRegs[] = { 00152 // Darwin ABI deviates from ARM standard ABI. R9 is not a callee-saved 00153 // register. 00154 ARM::LR, ARM::R7, ARM::R6, ARM::R5, ARM::R4, 00155 ARM::R11, ARM::R10, ARM::R8, 00156 00157 ARM::D15, ARM::D14, ARM::D13, ARM::D12, 00158 ARM::D11, ARM::D10, ARM::D9, ARM::D8, 00159 0 00160 }; 00161 return STI.isTargetDarwin() ? DarwinCalleeSavedRegs : CalleeSavedRegs; 00162 } 00163 00164 const TargetRegisterClass* const * 00165 ARMBaseRegisterInfo::getCalleeSavedRegClasses(const MachineFunction *MF) const { 00166 static const TargetRegisterClass * const CalleeSavedRegClasses[] = { 00167 &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::GPRRegClass, 00168 &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::GPRRegClass, 00169 &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::GPRRegClass, 00170 00171 &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, 00172 &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, 00173 0 00174 }; 00175 00176 static const TargetRegisterClass * const ThumbCalleeSavedRegClasses[] = { 00177 &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::GPRRegClass, 00178 &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::tGPRRegClass, 00179 &ARM::tGPRRegClass,&ARM::tGPRRegClass,&ARM::tGPRRegClass, 00180 00181 &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, 00182 &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, 00183 0 00184 }; 00185 00186 static const TargetRegisterClass * const DarwinCalleeSavedRegClasses[] = { 00187 &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::GPRRegClass, 00188 &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::GPRRegClass, 00189 &ARM::GPRRegClass, &ARM::GPRRegClass, 00190 00191 &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, 00192 &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, 00193 0 00194 }; 00195 00196 static const TargetRegisterClass * const DarwinThumbCalleeSavedRegClasses[] ={ 00197 &ARM::GPRRegClass, &ARM::tGPRRegClass, &ARM::tGPRRegClass, 00198 &ARM::tGPRRegClass, &ARM::tGPRRegClass, &ARM::GPRRegClass, 00199 &ARM::GPRRegClass, &ARM::GPRRegClass, 00200 00201 &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, 00202 &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, 00203 0 00204 }; 00205 00206 if (STI.isThumb1Only()) { 00207 return STI.isTargetDarwin() 00208 ? DarwinThumbCalleeSavedRegClasses : ThumbCalleeSavedRegClasses; 00209 } 00210 return STI.isTargetDarwin() 00211 ? DarwinCalleeSavedRegClasses : CalleeSavedRegClasses; 00212 } 00213 00214 BitVector ARMBaseRegisterInfo::getReservedRegs(const MachineFunction &MF) const { 00215 // FIXME: avoid re-calculating this everytime. 00216 BitVector Reserved(getNumRegs()); 00217 Reserved.set(ARM::SP); 00218 Reserved.set(ARM::PC); 00219 if (STI.isTargetDarwin() || hasFP(MF)) 00220 Reserved.set(FramePtr); 00221 // Some targets reserve R9. 00222 if (STI.isR9Reserved()) 00223 Reserved.set(ARM::R9); 00224 return Reserved; 00225 } 00226 00227 bool ARMBaseRegisterInfo::isReservedReg(const MachineFunction &MF, 00228 unsigned Reg) const { 00229 switch (Reg) { 00230 default: break; 00231 case ARM::SP: 00232 case ARM::PC: 00233 return true; 00234 case ARM::R7: 00235 case ARM::R11: 00236 if (FramePtr == Reg && (STI.isTargetDarwin() || hasFP(MF))) 00237 return true; 00238 break; 00239 case ARM::R9: 00240 return STI.isR9Reserved(); 00241 } 00242 00243 return false; 00244 } 00245 00246 const TargetRegisterClass * 00247 ARMBaseRegisterInfo::getPointerRegClass(unsigned Kind) const { 00248 return &ARM::GPRRegClass; 00249 } 00250 00251 /// getAllocationOrder - Returns the register allocation order for a specified 00252 /// register class in the form of a pair of TargetRegisterClass iterators. 00253 std::pair<TargetRegisterClass::iterator,TargetRegisterClass::iterator> 00254 ARMBaseRegisterInfo::getAllocationOrder(const TargetRegisterClass *RC, 00255 unsigned HintType, unsigned HintReg, 00256 const MachineFunction &MF) const { 00257 // Alternative register allocation orders when favoring even / odd registers 00258 // of register pairs. 00259 00260 // No FP, R9 is available. 00261 static const unsigned GPREven1[] = { 00262 ARM::R0, ARM::R2, ARM::R4, ARM::R6, ARM::R8, ARM::R10, 00263 ARM::R1, ARM::R3, ARM::R12,ARM::LR, ARM::R5, ARM::R7, 00264 ARM::R9, ARM::R11 00265 }; 00266 static const unsigned GPROdd1[] = { 00267 ARM::R1, ARM::R3, ARM::R5, ARM::R7, ARM::R9, ARM::R11, 00268 ARM::R0, ARM::R2, ARM::R12,ARM::LR, ARM::R4, ARM::R6, 00269 ARM::R8, ARM::R10 00270 }; 00271 00272 // FP is R7, R9 is available. 00273 static const unsigned GPREven2[] = { 00274 ARM::R0, ARM::R2, ARM::R4, ARM::R8, ARM::R10, 00275 ARM::R1, ARM::R3, ARM::R12,ARM::LR, ARM::R5, ARM::R6, 00276 ARM::R9, ARM::R11 00277 }; 00278 static const unsigned GPROdd2[] = { 00279 ARM::R1, ARM::R3, ARM::R5, ARM::R9, ARM::R11, 00280 ARM::R0, ARM::R2, ARM::R12,ARM::LR, ARM::R4, ARM::R6, 00281 ARM::R8, ARM::R10 00282 }; 00283 00284 // FP is R11, R9 is available. 00285 static const unsigned GPREven3[] = { 00286 ARM::R0, ARM::R2, ARM::R4, ARM::R6, ARM::R8, 00287 ARM::R1, ARM::R3, ARM::R10,ARM::R12,ARM::LR, ARM::R5, ARM::R7, 00288 ARM::R9 00289 }; 00290 static const unsigned GPROdd3[] = { 00291 ARM::R1, ARM::R3, ARM::R5, ARM::R6, ARM::R9, 00292 ARM::R0, ARM::R2, ARM::R10,ARM::R12,ARM::LR, ARM::R4, ARM::R7, 00293 ARM::R8 00294 }; 00295 00296 // No FP, R9 is not available. 00297 static const unsigned GPREven4[] = { 00298 ARM::R0, ARM::R2, ARM::R4, ARM::R6, ARM::R10, 00299 ARM::R1, ARM::R3, ARM::R12,ARM::LR, ARM::R5, ARM::R7, ARM::R8, 00300 ARM::R11 00301 }; 00302 static const unsigned GPROdd4[] = { 00303 ARM::R1, ARM::R3, ARM::R5, ARM::R7, ARM::R11, 00304 ARM::R0, ARM::R2, ARM::R12,ARM::LR, ARM::R4, ARM::R6, ARM::R8, 00305 ARM::R10 00306 }; 00307 00308 // FP is R7, R9 is not available. 00309 static const unsigned GPREven5[] = { 00310 ARM::R0, ARM::R2, ARM::R4, ARM::R10, 00311 ARM::R1, ARM::R3, ARM::R12,ARM::LR, ARM::R5, ARM::R6, ARM::R8, 00312 ARM::R11 00313 }; 00314 static const unsigned GPROdd5[] = { 00315 ARM::R1, ARM::R3, ARM::R5, ARM::R11, 00316 ARM::R0, ARM::R2, ARM::R12,ARM::LR, ARM::R4, ARM::R6, ARM::R8, 00317 ARM::R10 00318 }; 00319 00320 // FP is R11, R9 is not available. 00321 static const unsigned GPREven6[] = { 00322 ARM::R0, ARM::R2, ARM::R4, ARM::R6, 00323 ARM::R1, ARM::R3, ARM::R10,ARM::R12,ARM::LR, ARM::R5, ARM::R7, ARM::R8 00324 }; 00325 static const unsigned GPROdd6[] = { 00326 ARM::R1, ARM::R3, ARM::R5, ARM::R7, 00327 ARM::R0, ARM::R2, ARM::R10,ARM::R12,ARM::LR, ARM::R4, ARM::R6, ARM::R8 00328 }; 00329 00330 00331 if (HintType == ARMRI::RegPairEven) { 00332 if (isPhysicalRegister(HintReg) && getRegisterPairEven(HintReg, MF) == 0) 00333 // It's no longer possible to fulfill this hint. Return the default 00334 // allocation order. 00335 return std::make_pair(RC->allocation_order_begin(MF), 00336 RC->allocation_order_end(MF)); 00337 00338 if (!STI.isTargetDarwin() && !hasFP(MF)) { 00339 if (!STI.isR9Reserved()) 00340 return std::make_pair(GPREven1, 00341 GPREven1 + (sizeof(GPREven1)/sizeof(unsigned))); 00342 else 00343 return std::make_pair(GPREven4, 00344 GPREven4 + (sizeof(GPREven4)/sizeof(unsigned))); 00345 } else if (FramePtr == ARM::R7) { 00346 if (!STI.isR9Reserved()) 00347 return std::make_pair(GPREven2, 00348 GPREven2 + (sizeof(GPREven2)/sizeof(unsigned))); 00349 else 00350 return std::make_pair(GPREven5, 00351 GPREven5 + (sizeof(GPREven5)/sizeof(unsigned))); 00352 } else { // FramePtr == ARM::R11 00353 if (!STI.isR9Reserved()) 00354 return std::make_pair(GPREven3, 00355 GPREven3 + (sizeof(GPREven3)/sizeof(unsigned))); 00356 else 00357 return std::make_pair(GPREven6, 00358 GPREven6 + (sizeof(GPREven6)/sizeof(unsigned))); 00359 } 00360 } else if (HintType == ARMRI::RegPairOdd) { 00361 if (isPhysicalRegister(HintReg) && getRegisterPairOdd(HintReg, MF) == 0) 00362 // It's no longer possible to fulfill this hint. Return the default 00363 // allocation order. 00364 return std::make_pair(RC->allocation_order_begin(MF), 00365 RC->allocation_order_end(MF)); 00366 00367 if (!STI.isTargetDarwin() && !hasFP(MF)) { 00368 if (!STI.isR9Reserved()) 00369 return std::make_pair(GPROdd1, 00370 GPROdd1 + (sizeof(GPROdd1)/sizeof(unsigned))); 00371 else 00372 return std::make_pair(GPROdd4, 00373 GPROdd4 + (sizeof(GPROdd4)/sizeof(unsigned))); 00374 } else if (FramePtr == ARM::R7) { 00375 if (!STI.isR9Reserved()) 00376 return std::make_pair(GPROdd2, 00377 GPROdd2 + (sizeof(GPROdd2)/sizeof(unsigned))); 00378 else 00379 return std::make_pair(GPROdd5, 00380 GPROdd5 + (sizeof(GPROdd5)/sizeof(unsigned))); 00381 } else { // FramePtr == ARM::R11 00382 if (!STI.isR9Reserved()) 00383 return std::make_pair(GPROdd3, 00384 GPROdd3 + (sizeof(GPROdd3)/sizeof(unsigned))); 00385 else 00386 return std::make_pair(GPROdd6, 00387 GPROdd6 + (sizeof(GPROdd6)/sizeof(unsigned))); 00388 } 00389 } 00390 return std::make_pair(RC->allocation_order_begin(MF), 00391 RC->allocation_order_end(MF)); 00392 } 00393 00394 /// ResolveRegAllocHint - Resolves the specified register allocation hint 00395 /// to a physical register. Returns the physical register if it is successful. 00396 unsigned 00397 ARMBaseRegisterInfo::ResolveRegAllocHint(unsigned Type, unsigned Reg, 00398 const MachineFunction &MF) const { 00399 if (Reg == 0 || !isPhysicalRegister(Reg)) 00400 return 0; 00401 if (Type == 0) 00402 return Reg; 00403 else if (Type == (unsigned)ARMRI::RegPairOdd) 00404 // Odd register. 00405 return getRegisterPairOdd(Reg, MF); 00406 else if (Type == (unsigned)ARMRI::RegPairEven) 00407 // Even register. 00408 return getRegisterPairEven(Reg, MF); 00409 return 0; 00410 } 00411 00412 void 00413 ARMBaseRegisterInfo::UpdateRegAllocHint(unsigned Reg, unsigned NewReg, 00414 MachineFunction &MF) const { 00415 MachineRegisterInfo *MRI = &MF.getRegInfo(); 00416 std::pair<unsigned, unsigned> Hint = MRI->getRegAllocationHint(Reg); 00417 if ((Hint.first == (unsigned)ARMRI::RegPairOdd || 00418 Hint.first == (unsigned)ARMRI::RegPairEven) && 00419 Hint.second && TargetRegisterInfo::isVirtualRegister(Hint.second)) { 00420 // If 'Reg' is one of the even / odd register pair and it's now changed 00421 // (e.g. coalesced) into a different register. The other register of the 00422 // pair allocation hint must be updated to reflect the relationship 00423 // change. 00424 unsigned OtherReg = Hint.second; 00425 Hint = MRI->getRegAllocationHint(OtherReg); 00426 if (Hint.second == Reg) 00427 // Make sure the pair has not already divorced. 00428 MRI->setRegAllocationHint(OtherReg, Hint.first, NewReg); 00429 } 00430 } 00431 00432 /// hasFP - Return true if the specified function should have a dedicated frame 00433 /// pointer register. This is true if the function has variable sized allocas 00434 /// or if frame pointer elimination is disabled. 00435 /// 00436 bool ARMBaseRegisterInfo::hasFP(const MachineFunction &MF) const { 00437 const MachineFrameInfo *MFI = MF.getFrameInfo(); 00438 return (NoFramePointerElim || 00439 MFI->hasVarSizedObjects() || 00440 MFI->isFrameAddressTaken()); 00441 } 00442 00443 bool ARMBaseRegisterInfo::cannotEliminateFrame(const MachineFunction &MF) const { 00444 const MachineFrameInfo *MFI = MF.getFrameInfo(); 00445 if (NoFramePointerElim && MFI->hasCalls()) 00446 return true; 00447 return MFI->hasVarSizedObjects() || MFI->isFrameAddressTaken(); 00448 } 00449 00450 /// estimateStackSize - Estimate and return the size of the frame. 00451 static unsigned estimateStackSize(MachineFunction &MF, MachineFrameInfo *MFI) { 00452 const MachineFrameInfo *FFI = MF.getFrameInfo(); 00453 int Offset = 0; 00454 for (int i = FFI->getObjectIndexBegin(); i != 0; ++i) { 00455 int FixedOff = -FFI->getObjectOffset(i); 00456 if (FixedOff > Offset) Offset = FixedOff; 00457 } 00458 for (unsigned i = 0, e = FFI->getObjectIndexEnd(); i != e; ++i) { 00459 if (FFI->isDeadObjectIndex(i)) 00460 continue; 00461 Offset += FFI->getObjectSize(i); 00462 unsigned Align = FFI->getObjectAlignment(i); 00463 // Adjust to alignment boundary 00464 Offset = (Offset+Align-1)/Align*Align; 00465 } 00466 return (unsigned)Offset; 00467 } 00468 00469 /// estimateRSStackSizeLimit - Look at each instruction that references stack 00470 /// frames and return the stack size limit beyond which some of these 00471 /// instructions will require scratch register during their expansion later. 00472 unsigned 00473 ARMBaseRegisterInfo::estimateRSStackSizeLimit(MachineFunction &MF) const { 00474 unsigned Limit = (1 << 12) - 1; 00475 for (MachineFunction::iterator BB = MF.begin(),E = MF.end(); BB != E; ++BB) { 00476 for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); 00477 I != E; ++I) { 00478 for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) { 00479 if (!I->getOperand(i).isFI()) continue; 00480 00481 const TargetInstrDesc &Desc = TII.get(I->getOpcode()); 00482 unsigned AddrMode = (Desc.TSFlags & ARMII::AddrModeMask); 00483 if (AddrMode == ARMII::AddrMode3 || 00484 AddrMode == ARMII::AddrModeT2_i8) 00485 return (1 << 8) - 1; 00486 00487 if (AddrMode == ARMII::AddrMode5 || 00488 AddrMode == ARMII::AddrModeT2_i8s4) 00489 Limit = std::min(Limit, ((1U << 8) - 1) * 4); 00490 00491 if (AddrMode == ARMII::AddrModeT2_i12 && hasFP(MF)) 00492 // When the stack offset is negative, we will end up using 00493 // the i8 instructions instead. 00494 return (1 << 8) - 1; 00495 break; // At most one FI per instruction 00496 } 00497 } 00498 } 00499 00500 return Limit; 00501 } 00502 00503 void 00504 ARMBaseRegisterInfo::processFunctionBeforeCalleeSavedScan(MachineFunction &MF, 00505 RegScavenger *RS) const { 00506 // This tells PEI to spill the FP as if it is any other callee-save register 00507 // to take advantage the eliminateFrameIndex machinery. This also ensures it 00508 // is spilled in the order specified by getCalleeSavedRegs() to make it easier 00509 // to combine multiple loads / stores. 00510 bool CanEliminateFrame = true; 00511 bool CS1Spilled = false; 00512 bool LRSpilled = false; 00513 unsigned NumGPRSpills = 0; 00514 SmallVector<unsigned, 4> UnspilledCS1GPRs; 00515 SmallVector<unsigned, 4> UnspilledCS2GPRs; 00516 ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>(); 00517 00518 // Don't spill FP if the frame can be eliminated. This is determined 00519 // by scanning the callee-save registers to see if any is used. 00520 const unsigned *CSRegs = getCalleeSavedRegs(); 00521 const TargetRegisterClass* const *CSRegClasses = getCalleeSavedRegClasses(); 00522 for (unsigned i = 0; CSRegs[i]; ++i) { 00523 unsigned Reg = CSRegs[i]; 00524 bool Spilled = false; 00525 if (MF.getRegInfo().isPhysRegUsed(Reg)) { 00526 AFI->setCSRegisterIsSpilled(Reg); 00527 Spilled = true; 00528 CanEliminateFrame = false; 00529 } else { 00530 // Check alias registers too. 00531 for (const unsigned *Aliases = getAliasSet(Reg); *Aliases; ++Aliases) { 00532 if (MF.getRegInfo().isPhysRegUsed(*Aliases)) { 00533 Spilled = true; 00534 CanEliminateFrame = false; 00535 } 00536 } 00537 } 00538 00539 if (CSRegClasses[i] == &ARM::GPRRegClass) { 00540 if (Spilled) { 00541 NumGPRSpills++; 00542 00543 if (!STI.isTargetDarwin()) { 00544 if (Reg == ARM::LR) 00545 LRSpilled = true; 00546 CS1Spilled = true; 00547 continue; 00548 } 00549 00550 // Keep track if LR and any of R4, R5, R6, and R7 is spilled. 00551 switch (Reg) { 00552 case ARM::LR: 00553 LRSpilled = true; 00554 // Fallthrough 00555 case ARM::R4: 00556 case ARM::R5: 00557 case ARM::R6: 00558 case ARM::R7: 00559 CS1Spilled = true; 00560 break; 00561 default: 00562 break; 00563 } 00564 } else { 00565 if (!STI.isTargetDarwin()) { 00566 UnspilledCS1GPRs.push_back(Reg); 00567 continue; 00568 } 00569 00570 switch (Reg) { 00571 case ARM::R4: 00572 case ARM::R5: 00573 case ARM::R6: 00574 case ARM::R7: 00575 case ARM::LR: 00576 UnspilledCS1GPRs.push_back(Reg); 00577 break; 00578 default: 00579 UnspilledCS2GPRs.push_back(Reg); 00580 break; 00581 } 00582 } 00583 } 00584 } 00585 00586 bool ForceLRSpill = false; 00587 if (!LRSpilled && AFI->isThumb1OnlyFunction()) { 00588 unsigned FnSize = TII.GetFunctionSizeInBytes(MF); 00589 // Force LR to be spilled if the Thumb function size is > 2048. This enables 00590 // use of BL to implement far jump. If it turns out that it's not needed 00591 // then the branch fix up path will undo it. 00592 if (FnSize >= (1 << 11)) { 00593 CanEliminateFrame = false; 00594 ForceLRSpill = true; 00595 } 00596 } 00597 00598 bool ExtraCSSpill = false; 00599 if (!CanEliminateFrame || cannotEliminateFrame(MF)) { 00600 AFI->setHasStackFrame(true); 00601 00602 // If LR is not spilled, but at least one of R4, R5, R6, and R7 is spilled. 00603 // Spill LR as well so we can fold BX_RET to the registers restore (LDM). 00604 if (!LRSpilled && CS1Spilled) { 00605 MF.getRegInfo().setPhysRegUsed(ARM::LR); 00606 AFI->setCSRegisterIsSpilled(ARM::LR); 00607 NumGPRSpills++; 00608 UnspilledCS1GPRs.erase(std::find(UnspilledCS1GPRs.begin(), 00609 UnspilledCS1GPRs.end(), (unsigned)ARM::LR)); 00610 ForceLRSpill = false; 00611 ExtraCSSpill = true; 00612 } 00613 00614 // Darwin ABI requires FP to point to the stack slot that contains the 00615 // previous FP. 00616 if (STI.isTargetDarwin() || hasFP(MF)) { 00617 MF.getRegInfo().setPhysRegUsed(FramePtr); 00618 NumGPRSpills++; 00619 } 00620 00621 // If stack and double are 8-byte aligned and we are spilling an odd number 00622 // of GPRs. Spill one extra callee save GPR so we won't have to pad between 00623 // the integer and double callee save areas. 00624 unsigned TargetAlign = MF.getTarget().getFrameInfo()->getStackAlignment(); 00625 if (TargetAlign == 8 && (NumGPRSpills & 1)) { 00626 if (CS1Spilled && !UnspilledCS1GPRs.empty()) { 00627 for (unsigned i = 0, e = UnspilledCS1GPRs.size(); i != e; ++i) { 00628 unsigned Reg = UnspilledCS1GPRs[i]; 00629 // Don't spill high register if the function is thumb1 00630 if (!AFI->isThumb1OnlyFunction() || 00631 isARMLowRegister(Reg) || Reg == ARM::LR) { 00632 MF.getRegInfo().setPhysRegUsed(Reg); 00633 AFI->setCSRegisterIsSpilled(Reg); 00634 if (!isReservedReg(MF, Reg)) 00635 ExtraCSSpill = true; 00636 break; 00637 } 00638 } 00639 } else if (!UnspilledCS2GPRs.empty() && 00640 !AFI->isThumb1OnlyFunction()) { 00641 unsigned Reg = UnspilledCS2GPRs.front(); 00642 MF.getRegInfo().setPhysRegUsed(Reg); 00643 AFI->setCSRegisterIsSpilled(Reg); 00644 if (!isReservedReg(MF, Reg)) 00645 ExtraCSSpill = true; 00646 } 00647 } 00648 00649 // Estimate if we might need to scavenge a register at some point in order 00650 // to materialize a stack offset. If so, either spill one additional 00651 // callee-saved register or reserve a special spill slot to facilitate 00652 // register scavenging. 00653 if (RS && !ExtraCSSpill && !AFI->isThumb1OnlyFunction()) { 00654 MachineFrameInfo *MFI = MF.getFrameInfo(); 00655 if (estimateStackSize(MF, MFI) >= estimateRSStackSizeLimit(MF)) { 00656 // If any non-reserved CS register isn't spilled, just spill one or two 00657 // extra. That should take care of it! 00658 unsigned NumExtras = TargetAlign / 4; 00659 SmallVector<unsigned, 2> Extras; 00660 while (NumExtras && !UnspilledCS1GPRs.empty()) { 00661 unsigned Reg = UnspilledCS1GPRs.back(); 00662 UnspilledCS1GPRs.pop_back(); 00663 if (!isReservedReg(MF, Reg)) { 00664 Extras.push_back(Reg); 00665 NumExtras--; 00666 } 00667 } 00668 while (NumExtras && !UnspilledCS2GPRs.empty()) { 00669 unsigned Reg = UnspilledCS2GPRs.back(); 00670 UnspilledCS2GPRs.pop_back(); 00671 if (!isReservedReg(MF, Reg)) { 00672 Extras.push_back(Reg); 00673 NumExtras--; 00674 } 00675 } 00676 if (Extras.size() && NumExtras == 0) { 00677 for (unsigned i = 0, e = Extras.size(); i != e; ++i) { 00678 MF.getRegInfo().setPhysRegUsed(Extras[i]); 00679 AFI->setCSRegisterIsSpilled(Extras[i]); 00680 } 00681 } else { 00682 // Reserve a slot closest to SP or frame pointer. 00683 const TargetRegisterClass *RC = &ARM::GPRRegClass; 00684 RS->setScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(), 00685 RC->getAlignment())); 00686 } 00687 } 00688 } 00689 } 00690 00691 if (ForceLRSpill) { 00692 MF.getRegInfo().setPhysRegUsed(ARM::LR); 00693 AFI->setCSRegisterIsSpilled(ARM::LR); 00694 AFI->setLRIsSpilledForFarJump(true); 00695 } 00696 } 00697 00698 unsigned ARMBaseRegisterInfo::getRARegister() const { 00699 return ARM::LR; 00700 } 00701 00702 unsigned ARMBaseRegisterInfo::getFrameRegister(MachineFunction &MF) const { 00703 if (STI.isTargetDarwin() || hasFP(MF)) 00704 return FramePtr; 00705 return ARM::SP; 00706 } 00707 00708 unsigned ARMBaseRegisterInfo::getEHExceptionRegister() const { 00709 llvm_unreachable("What is the exception register"); 00710 return 0; 00711 } 00712 00713 unsigned ARMBaseRegisterInfo::getEHHandlerRegister() const { 00714 llvm_unreachable("What is the exception handler register"); 00715 return 0; 00716 } 00717 00718 int ARMBaseRegisterInfo::getDwarfRegNum(unsigned RegNum, bool isEH) const { 00719 return ARMGenRegisterInfo::getDwarfRegNumFull(RegNum, 0); 00720 } 00721 00722 unsigned ARMBaseRegisterInfo::getRegisterPairEven(unsigned Reg, 00723 const MachineFunction &MF) const { 00724 switch (Reg) { 00725 default: break; 00726 // Return 0 if either register of the pair is a special register. 00727 // So no R12, etc. 00728 case ARM::R1: 00729 return ARM::R0; 00730 case ARM::R3: 00731 // FIXME! 00732 return STI.isThumb1Only() ? 0 : ARM::R2; 00733 case ARM::R5: 00734 return ARM::R4; 00735 case ARM::R7: 00736 return isReservedReg(MF, ARM::R7) ? 0 : ARM::R6; 00737 case ARM::R9: 00738 return isReservedReg(MF, ARM::R9) ? 0 :ARM::R8; 00739 case ARM::R11: 00740 return isReservedReg(MF, ARM::R11) ? 0 : ARM::R10; 00741 00742 case ARM::S1: 00743 return ARM::S0; 00744 case ARM::S3: 00745 return ARM::S2; 00746 case ARM::S5: 00747 return ARM::S4; 00748 case ARM::S7: 00749 return ARM::S6; 00750 case ARM::S9: 00751 return ARM::S8; 00752 case ARM::S11: 00753 return ARM::S10; 00754 case ARM::S13: 00755 return ARM::S12; 00756 case ARM::S15: 00757 return ARM::S14; 00758 case ARM::S17: 00759 return ARM::S16; 00760 case ARM::S19: 00761 return ARM::S18; 00762 case ARM::S21: 00763 return ARM::S20; 00764 case ARM::S23: 00765 return ARM::S22; 00766 case ARM::S25: 00767 return ARM::S24; 00768 case ARM::S27: 00769 return ARM::S26; 00770 case ARM::S29: 00771 return ARM::S28; 00772 case ARM::S31: 00773 return ARM::S30; 00774 00775 case ARM::D1: 00776 return ARM::D0; 00777 case ARM::D3: 00778 return ARM::D2; 00779 case ARM::D5: 00780 return ARM::D4; 00781 case ARM::D7: 00782 return ARM::D6; 00783 case ARM::D9: 00784 return ARM::D8; 00785 case ARM::D11: 00786 return ARM::D10; 00787 case ARM::D13: 00788 return ARM::D12; 00789 case ARM::D15: 00790 return ARM::D14; 00791 case ARM::D17: 00792 return ARM::D16; 00793 case ARM::D19: 00794 return ARM::D18; 00795 case ARM::D21: 00796 return ARM::D20; 00797 case ARM::D23: 00798 return ARM::D22; 00799 case ARM::D25: 00800 return ARM::D24; 00801 case ARM::D27: 00802 return ARM::D26; 00803 case ARM::D29: 00804 return ARM::D28; 00805 case ARM::D31: 00806 return ARM::D30; 00807 } 00808 00809 return 0; 00810 } 00811 00812 unsigned ARMBaseRegisterInfo::getRegisterPairOdd(unsigned Reg, 00813 const MachineFunction &MF) const { 00814 switch (Reg) { 00815 default: break; 00816 // Return 0 if either register of the pair is a special register. 00817 // So no R12, etc. 00818 case ARM::R0: 00819 return ARM::R1; 00820 case ARM::R2: 00821 // FIXME! 00822 return STI.isThumb1Only() ? 0 : ARM::R3; 00823 case ARM::R4: 00824 return ARM::R5; 00825 case ARM::R6: 00826 return isReservedReg(MF, ARM::R7) ? 0 : ARM::R7; 00827 case ARM::R8: 00828 return isReservedReg(MF, ARM::R9) ? 0 :ARM::R9; 00829 case ARM::R10: 00830 return isReservedReg(MF, ARM::R11) ? 0 : ARM::R11; 00831 00832 case ARM::S0: 00833 return ARM::S1; 00834 case ARM::S2: 00835 return ARM::S3; 00836 case ARM::S4: 00837 return ARM::S5; 00838 case ARM::S6: 00839 return ARM::S7; 00840 case ARM::S8: 00841 return ARM::S9; 00842 case ARM::S10: 00843 return ARM::S11; 00844 case ARM::S12: 00845 return ARM::S13; 00846 case ARM::S14: 00847 return ARM::S15; 00848 case ARM::S16: 00849 return ARM::S17; 00850 case ARM::S18: 00851 return ARM::S19; 00852 case ARM::S20: 00853 return ARM::S21; 00854 case ARM::S22: 00855 return ARM::S23; 00856 case ARM::S24: 00857 return ARM::S25; 00858 case ARM::S26: 00859 return ARM::S27; 00860 case ARM::S28: 00861 return ARM::S29; 00862 case ARM::S30: 00863 return ARM::S31; 00864 00865 case ARM::D0: 00866 return ARM::D1; 00867 case ARM::D2: 00868 return ARM::D3; 00869 case ARM::D4: 00870 return ARM::D5; 00871 case ARM::D6: 00872 return ARM::D7; 00873 case ARM::D8: 00874 return ARM::D9; 00875 case ARM::D10: 00876 return ARM::D11; 00877 case ARM::D12: 00878 return ARM::D13; 00879 case ARM::D14: 00880 return ARM::D15; 00881 case ARM::D16: 00882 return ARM::D17; 00883 case ARM::D18: 00884 return ARM::D19; 00885 case ARM::D20: 00886 return ARM::D21; 00887 case ARM::D22: 00888 return ARM::D23; 00889 case ARM::D24: 00890 return ARM::D25; 00891 case ARM::D26: 00892 return ARM::D27; 00893 case ARM::D28: 00894 return ARM::D29; 00895 case ARM::D30: 00896 return ARM::D31; 00897 } 00898 00899 return 0; 00900 } 00901 00902 /// emitLoadConstPool - Emits a load from constpool to materialize the 00903 /// specified immediate. 00904 void ARMBaseRegisterInfo:: 00905 emitLoadConstPool(MachineBasicBlock &MBB, 00906 MachineBasicBlock::iterator &MBBI, 00907 DebugLoc dl, 00908 unsigned DestReg, unsigned SubIdx, int Val, 00909 ARMCC::CondCodes Pred, 00910 unsigned PredReg) const { 00911 MachineFunction &MF = *MBB.getParent(); 00912 MachineConstantPool *ConstantPool = MF.getConstantPool(); 00913 Constant *C = 00914 ConstantInt::get(Type::getInt32Ty(MF.getFunction()->getContext()), Val); 00915 unsigned Idx = ConstantPool->getConstantPoolIndex(C, 4); 00916 00917 BuildMI(MBB, MBBI, dl, TII.get(ARM::LDRcp)) 00918 .addReg(DestReg, getDefRegState(true), SubIdx) 00919 .addConstantPoolIndex(Idx) 00920 .addReg(0).addImm(0).addImm(Pred).addReg(PredReg); 00921 } 00922 00923 bool ARMBaseRegisterInfo:: 00924 requiresRegisterScavenging(const MachineFunction &MF) const { 00925 return true; 00926 } 00927 00928 // hasReservedCallFrame - Under normal circumstances, when a frame pointer is 00929 // not required, we reserve argument space for call sites in the function 00930 // immediately on entry to the current function. This eliminates the need for 00931 // add/sub sp brackets around call sites. Returns true if the call frame is 00932 // included as part of the stack frame. 00933 bool ARMBaseRegisterInfo:: 00934 hasReservedCallFrame(MachineFunction &MF) const { 00935 const MachineFrameInfo *FFI = MF.getFrameInfo(); 00936 unsigned CFSize = FFI->getMaxCallFrameSize(); 00937 // It's not always a good idea to include the call frame as part of the 00938 // stack frame. ARM (especially Thumb) has small immediate offset to 00939 // address the stack frame. So a large call frame can cause poor codegen 00940 // and may even makes it impossible to scavenge a register. 00941 if (CFSize >= ((1 << 12) - 1) / 2) // Half of imm12 00942 return false; 00943 00944 return !MF.getFrameInfo()->hasVarSizedObjects(); 00945 } 00946 00947 static void 00948 emitSPUpdate(bool isARM, 00949 MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI, 00950 DebugLoc dl, const ARMBaseInstrInfo &TII, 00951 int NumBytes, 00952 ARMCC::CondCodes Pred = ARMCC::AL, unsigned PredReg = 0) { 00953 if (isARM) 00954 emitARMRegPlusImmediate(MBB, MBBI, dl, ARM::SP, ARM::SP, NumBytes, 00955 Pred, PredReg, TII); 00956 else 00957 emitT2RegPlusImmediate(MBB, MBBI, dl, ARM::SP, ARM::SP, NumBytes, 00958 Pred, PredReg, TII); 00959 } 00960 00961 00962 void ARMBaseRegisterInfo:: 00963 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, 00964 MachineBasicBlock::iterator I) const { 00965 if (!hasReservedCallFrame(MF)) { 00966 // If we have alloca, convert as follows: 00967 // ADJCALLSTACKDOWN -> sub, sp, sp, amount 00968 // ADJCALLSTACKUP -> add, sp, sp, amount 00969 MachineInstr *Old = I; 00970 DebugLoc dl = Old->getDebugLoc(); 00971 unsigned Amount = Old->getOperand(0).getImm(); 00972 if (Amount != 0) { 00973 // We need to keep the stack aligned properly. To do this, we round the 00974 // amount of space needed for the outgoing arguments up to the next 00975 // alignment boundary. 00976 unsigned Align = MF.getTarget().getFrameInfo()->getStackAlignment(); 00977 Amount = (Amount+Align-1)/Align*Align; 00978 00979 ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>(); 00980 assert(!AFI->isThumb1OnlyFunction() && 00981 "This eliminateCallFramePseudoInstr does not suppor Thumb1!"); 00982 bool isARM = !AFI->isThumbFunction(); 00983 00984 // Replace the pseudo instruction with a new instruction... 00985 unsigned Opc = Old->getOpcode(); 00986 ARMCC::CondCodes Pred = (ARMCC::CondCodes)Old->getOperand(1).getImm(); 00987 // FIXME: Thumb2 version of ADJCALLSTACKUP and ADJCALLSTACKDOWN? 00988 if (Opc == ARM::ADJCALLSTACKDOWN || Opc == ARM::tADJCALLSTACKDOWN) { 00989 // Note: PredReg is operand 2 for ADJCALLSTACKDOWN. 00990 unsigned PredReg = Old->getOperand(2).getReg(); 00991 emitSPUpdate(isARM, MBB, I, dl, TII, -Amount, Pred, PredReg); 00992 } else { 00993 // Note: PredReg is operand 3 for ADJCALLSTACKUP. 00994 unsigned PredReg = Old->getOperand(3).getReg(); 00995 assert(Opc == ARM::ADJCALLSTACKUP || Opc == ARM::tADJCALLSTACKUP); 00996 emitSPUpdate(isARM, MBB, I, dl, TII, Amount, Pred, PredReg); 00997 } 00998 } 00999 } 01000 MBB.erase(I); 01001 } 01002 01003 /// findScratchRegister - Find a 'free' ARM register. If register scavenger 01004 /// is not being used, R12 is available. Otherwise, try for a call-clobbered 01005 /// register first and then a spilled callee-saved register if that fails. 01006 static 01007 unsigned findScratchRegister(RegScavenger *RS, const TargetRegisterClass *RC, 01008 ARMFunctionInfo *AFI) { 01009 unsigned Reg = RS ? RS->FindUnusedReg(RC) : (unsigned) ARM::R12; 01010 assert(!AFI->isThumb1OnlyFunction()); 01011 return Reg; 01012 } 01013 01014 void 01015 ARMBaseRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II, 01016 int SPAdj, RegScavenger *RS) const { 01017 unsigned i = 0; 01018 MachineInstr &MI = *II; 01019 MachineBasicBlock &MBB = *MI.getParent(); 01020 MachineFunction &MF = *MBB.getParent(); 01021 const MachineFrameInfo *MFI = MF.getFrameInfo(); 01022 ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>(); 01023 assert(!AFI->isThumb1OnlyFunction() && 01024 "This eliminateFrameIndex does not suppor Thumb1!"); 01025 01026 while (!MI.getOperand(i).isFI()) { 01027 ++i; 01028 assert(i < MI.getNumOperands() && "Instr doesn't have FrameIndex operand!"); 01029 } 01030 01031 unsigned FrameReg = ARM::SP; 01032 int FrameIndex = MI.getOperand(i).getIndex(); 01033 int Offset = MFI->getObjectOffset(FrameIndex) + MFI->getStackSize() + SPAdj; 01034 01035 if (AFI->isGPRCalleeSavedArea1Frame(FrameIndex)) 01036 Offset -= AFI->getGPRCalleeSavedArea1Offset(); 01037 else if (AFI->isGPRCalleeSavedArea2Frame(FrameIndex)) 01038 Offset -= AFI->getGPRCalleeSavedArea2Offset(); 01039 else if (AFI->isDPRCalleeSavedAreaFrame(FrameIndex)) 01040 Offset -= AFI->getDPRCalleeSavedAreaOffset(); 01041 else if (hasFP(MF) && AFI->hasStackFrame()) { 01042 assert(SPAdj == 0 && "Unexpected stack offset!"); 01043 // Use frame pointer to reference fixed objects unless this is a 01044 // frameless function, 01045 FrameReg = getFrameRegister(MF); 01046 Offset -= AFI->getFramePtrSpillOffset(); 01047 } 01048 01049 // modify MI as necessary to handle as much of 'Offset' as possible 01050 if (!AFI->isThumbFunction()) 01051 Offset = rewriteARMFrameIndex(MI, i, FrameReg, Offset, TII); 01052 else { 01053 assert(AFI->isThumb2Function()); 01054 Offset = rewriteT2FrameIndex(MI, i, FrameReg, Offset, TII); 01055 } 01056 if (Offset == 0) 01057 return; 01058 01059 // If we get here, the immediate doesn't fit into the instruction. We folded 01060 // as much as possible above, handle the rest, providing a register that is 01061 // SP+LargeImm. 01062 assert(Offset && "This code isn't needed if offset already handled!"); 01063 01064 // Insert a set of r12 with the full address: r12 = sp + offset 01065 // If the offset we have is too large to fit into the instruction, we need 01066 // to form it with a series of ADDri's. Do this by taking 8-bit chunks 01067 // out of 'Offset'. 01068 unsigned ScratchReg = findScratchRegister(RS, &ARM::GPRRegClass, AFI); 01069 if (ScratchReg == 0) 01070 // No register is "free". Scavenge a register. 01071 ScratchReg = RS->scavengeRegister(&ARM::GPRRegClass, II, SPAdj); 01072 int PIdx = MI.findFirstPredOperandIdx(); 01073 ARMCC::CondCodes Pred = (PIdx == -1) 01074 ? ARMCC::AL : (ARMCC::CondCodes)MI.getOperand(PIdx).getImm(); 01075 unsigned PredReg = (PIdx == -1) ? 0 : MI.getOperand(PIdx+1).getReg(); 01076 if (!AFI->isThumbFunction()) 01077 emitARMRegPlusImmediate(MBB, II, MI.getDebugLoc(), ScratchReg, FrameReg, 01078 Offset, Pred, PredReg, TII); 01079 else { 01080 assert(AFI->isThumb2Function()); 01081 emitT2RegPlusImmediate(MBB, II, MI.getDebugLoc(), ScratchReg, FrameReg, 01082 Offset, Pred, PredReg, TII); 01083 } 01084 MI.getOperand(i).ChangeToRegister(ScratchReg, false, false, true); 01085 } 01086 01087 /// Move iterator pass the next bunch of callee save load / store ops for 01088 /// the particular spill area (1: integer area 1, 2: integer area 2, 01089 /// 3: fp area, 0: don't care). 01090 static void movePastCSLoadStoreOps(MachineBasicBlock &MBB, 01091 MachineBasicBlock::iterator &MBBI, 01092 int Opc1, int Opc2, unsigned Area, 01093 const ARMSubtarget &STI) { 01094 while (MBBI != MBB.end() && 01095 ((MBBI->getOpcode() == Opc1) || (MBBI->getOpcode() == Opc2)) && 01096 MBBI->getOperand(1).isFI()) { 01097 if (Area != 0) { 01098 bool Done = false; 01099 unsigned Category = 0; 01100 switch (MBBI->getOperand(0).getReg()) { 01101 case ARM::R4: case ARM::R5: case ARM::R6: case ARM::R7: 01102 case ARM::LR: 01103 Category = 1; 01104 break; 01105 case ARM::R8: case ARM::R9: case ARM::R10: case ARM::R11: 01106 Category = STI.isTargetDarwin() ? 2 : 1; 01107 break; 01108 case ARM::D8: case ARM::D9: case ARM::D10: case ARM::D11: 01109 case ARM::D12: case ARM::D13: case ARM::D14: case ARM::D15: 01110 Category = 3; 01111 break; 01112 default: 01113 Done = true; 01114 break; 01115 } 01116 if (Done || Category != Area) 01117 break; 01118 } 01119 01120 ++MBBI; 01121 } 01122 } 01123 01124 void ARMBaseRegisterInfo:: 01125 emitPrologue(MachineFunction &MF) const { 01126 MachineBasicBlock &MBB = MF.front(); 01127 MachineBasicBlock::iterator MBBI = MBB.begin(); 01128 MachineFrameInfo *MFI = MF.getFrameInfo(); 01129 ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>(); 01130 assert(!AFI->isThumb1OnlyFunction() && 01131 "This emitPrologue does not suppor Thumb1!"); 01132 bool isARM = !AFI->isThumbFunction(); 01133 unsigned VARegSaveSize = AFI->getVarArgsRegSaveSize(); 01134 unsigned NumBytes = MFI->getStackSize(); 01135 const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo(); 01136 DebugLoc dl = (MBBI != MBB.end() ? 01137 MBBI->getDebugLoc() : DebugLoc::getUnknownLoc()); 01138 01139 // Determine the sizes of each callee-save spill areas and record which frame 01140 // belongs to which callee-save spill areas. 01141 unsigned GPRCS1Size = 0, GPRCS2Size = 0, DPRCSSize = 0; 01142 int FramePtrSpillFI = 0; 01143 01144 if (VARegSaveSize) 01145 emitSPUpdate(isARM, MBB, MBBI, dl, TII, -VARegSaveSize); 01146 01147 if (!AFI->hasStackFrame()) { 01148 if (NumBytes != 0) 01149 emitSPUpdate(isARM, MBB, MBBI, dl, TII, -NumBytes); 01150 return; 01151 } 01152 01153 for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 01154 unsigned Reg = CSI[i].getReg(); 01155 int FI = CSI[i].getFrameIdx(); 01156 switch (Reg) { 01157 case ARM::R4: 01158 case ARM::R5: 01159 case ARM::R6: 01160 case ARM::R7: 01161 case ARM::LR: 01162 if (Reg == FramePtr) 01163 FramePtrSpillFI = FI; 01164 AFI->addGPRCalleeSavedArea1Frame(FI); 01165 GPRCS1Size += 4; 01166 break; 01167 case ARM::R8: 01168 case ARM::R9: 01169 case ARM::R10: 01170 case ARM::R11: 01171 if (Reg == FramePtr) 01172 FramePtrSpillFI = FI; 01173 if (STI.isTargetDarwin()) { 01174 AFI->addGPRCalleeSavedArea2Frame(FI); 01175 GPRCS2Size += 4; 01176 } else { 01177 AFI->addGPRCalleeSavedArea1Frame(FI); 01178 GPRCS1Size += 4; 01179 } 01180 break; 01181 default: 01182 AFI->addDPRCalleeSavedAreaFrame(FI); 01183 DPRCSSize += 8; 01184 } 01185 } 01186 01187 // Build the new SUBri to adjust SP for integer callee-save spill area 1. 01188 emitSPUpdate(isARM, MBB, MBBI, dl, TII, -GPRCS1Size); 01189 movePastCSLoadStoreOps(MBB, MBBI, ARM::STR, ARM::t2STRi12, 1, STI); 01190 01191 // Darwin ABI requires FP to point to the stack slot that contains the 01192 // previous FP. 01193 if (STI.isTargetDarwin() || hasFP(MF)) { 01194 unsigned ADDriOpc = !AFI->isThumbFunction() ? ARM::ADDri : ARM::t2ADDri; 01195 MachineInstrBuilder MIB = 01196 BuildMI(MBB, MBBI, dl, TII.get(ADDriOpc), FramePtr) 01197 .addFrameIndex(FramePtrSpillFI).addImm(0); 01198 AddDefaultCC(AddDefaultPred(MIB)); 01199 } 01200 01201 // Build the new SUBri to adjust SP for integer callee-save spill area 2. 01202 emitSPUpdate(isARM, MBB, MBBI, dl, TII, -GPRCS2Size); 01203 01204 // Build the new SUBri to adjust SP for FP callee-save spill area. 01205 movePastCSLoadStoreOps(MBB, MBBI, ARM::STR, ARM::t2STRi12, 2, STI); 01206 emitSPUpdate(isARM, MBB, MBBI, dl, TII, -DPRCSSize); 01207 01208 // Determine starting offsets of spill areas. 01209 unsigned DPRCSOffset = NumBytes - (GPRCS1Size + GPRCS2Size + DPRCSSize); 01210 unsigned GPRCS2Offset = DPRCSOffset + DPRCSSize; 01211 unsigned GPRCS1Offset = GPRCS2Offset + GPRCS2Size; 01212 AFI->setFramePtrSpillOffset(MFI->getObjectOffset(FramePtrSpillFI) + NumBytes); 01213 AFI->setGPRCalleeSavedArea1Offset(GPRCS1Offset); 01214 AFI->setGPRCalleeSavedArea2Offset(GPRCS2Offset); 01215 AFI->setDPRCalleeSavedAreaOffset(DPRCSOffset); 01216 01217 NumBytes = DPRCSOffset; 01218 if (NumBytes) { 01219 // Insert it after all the callee-save spills. 01220 movePastCSLoadStoreOps(MBB, MBBI, ARM::FSTD, 0, 3, STI); 01221 emitSPUpdate(isARM, MBB, MBBI, dl, TII, -NumBytes); 01222 } 01223 01224 if (STI.isTargetELF() && hasFP(MF)) { 01225 MFI->setOffsetAdjustment(MFI->getOffsetAdjustment() - 01226 AFI->getFramePtrSpillOffset()); 01227 } 01228 01229 AFI->setGPRCalleeSavedArea1Size(GPRCS1Size); 01230 AFI->setGPRCalleeSavedArea2Size(GPRCS2Size); 01231 AFI->setDPRCalleeSavedAreaSize(DPRCSSize); 01232 } 01233 01234 static bool isCalleeSavedRegister(unsigned Reg, const unsigned *CSRegs) { 01235 for (unsigned i = 0; CSRegs[i]; ++i) 01236 if (Reg == CSRegs[i]) 01237 return true; 01238 return false; 01239 } 01240 01241 static bool isCSRestore(MachineInstr *MI, 01242 const ARMBaseInstrInfo &TII, 01243 const unsigned *CSRegs) { 01244 return ((MI->getOpcode() == (int)ARM::FLDD || 01245 MI->getOpcode() == (int)ARM::LDR || 01246 MI->getOpcode() == (int)ARM::t2LDRi12) && 01247 MI->getOperand(1).isFI() && 01248 isCalleeSavedRegister(MI->getOperand(0).getReg(), CSRegs)); 01249 } 01250 01251 void ARMBaseRegisterInfo:: 01252 emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const { 01253 MachineBasicBlock::iterator MBBI = prior(MBB.end()); 01254 assert(MBBI->getDesc().isReturn() && 01255 "Can only insert epilog into returning blocks"); 01256 DebugLoc dl = MBBI->getDebugLoc(); 01257 MachineFrameInfo *MFI = MF.getFrameInfo(); 01258 ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>(); 01259 assert(!AFI->isThumb1OnlyFunction() && 01260 "This emitEpilogue does not suppor Thumb1!"); 01261 bool isARM = !AFI->isThumbFunction(); 01262 01263 unsigned VARegSaveSize = AFI->getVarArgsRegSaveSize(); 01264 int NumBytes = (int)MFI->getStackSize(); 01265 01266 if (!AFI->hasStackFrame()) { 01267 if (NumBytes != 0) 01268 emitSPUpdate(isARM, MBB, MBBI, dl, TII, NumBytes); 01269 } else { 01270 // Unwind MBBI to point to first LDR / FLDD. 01271 const unsigned *CSRegs = getCalleeSavedRegs(); 01272 if (MBBI != MBB.begin()) { 01273 do 01274 --MBBI; 01275 while (MBBI != MBB.begin() && isCSRestore(MBBI, TII, CSRegs)); 01276 if (!isCSRestore(MBBI, TII, CSRegs)) 01277 ++MBBI; 01278 } 01279 01280 // Move SP to start of FP callee save spill area. 01281 NumBytes -= (AFI->getGPRCalleeSavedArea1Size() + 01282 AFI->getGPRCalleeSavedArea2Size() + 01283 AFI->getDPRCalleeSavedAreaSize()); 01284 01285 // Darwin ABI requires FP to point to the stack slot that contains the 01286 // previous FP. 01287 bool HasFP = hasFP(MF); 01288 if ((STI.isTargetDarwin() && NumBytes) || HasFP) { 01289 NumBytes = AFI->getFramePtrSpillOffset() - NumBytes; 01290 // Reset SP based on frame pointer only if the stack frame extends beyond 01291 // frame pointer stack slot or target is ELF and the function has FP. 01292 if (HasFP || 01293 AFI->getGPRCalleeSavedArea2Size() || 01294 AFI->getDPRCalleeSavedAreaSize() || 01295 AFI->getDPRCalleeSavedAreaOffset()) { 01296 if (NumBytes) { 01297 if (isARM) 01298 emitARMRegPlusImmediate(MBB, MBBI, dl, ARM::SP, FramePtr, -NumBytes, 01299 ARMCC::AL, 0, TII); 01300 else 01301 emitT2RegPlusImmediate(MBB, MBBI, dl, ARM::SP, FramePtr, -NumBytes, 01302 ARMCC::AL, 0, TII); 01303 } else { 01304 // Thumb2 or ARM. 01305 if (isARM) 01306 BuildMI(MBB, MBBI, dl, TII.get(ARM::MOVr), ARM::SP) 01307 .addReg(FramePtr) 01308 .addImm((unsigned)ARMCC::AL).addReg(0).addReg(0); 01309 else 01310 BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVgpr2gpr), ARM::SP) 01311 .addReg(FramePtr); 01312 } 01313 } 01314 } else if (NumBytes) 01315 emitSPUpdate(isARM, MBB, MBBI, dl, TII, NumBytes); 01316 01317 // Move SP to start of integer callee save spill area 2. 01318 movePastCSLoadStoreOps(MBB, MBBI, ARM::FLDD, 0, 3, STI); 01319 emitSPUpdate(isARM, MBB, MBBI, dl, TII, AFI->getDPRCalleeSavedAreaSize()); 01320 01321 // Move SP to start of integer callee save spill area 1. 01322 movePastCSLoadStoreOps(MBB, MBBI, ARM::LDR, ARM::t2LDRi12, 2, STI); 01323 emitSPUpdate(isARM, MBB, MBBI, dl, TII, AFI->getGPRCalleeSavedArea2Size()); 01324 01325 // Move SP to SP upon entry to the function. 01326 movePastCSLoadStoreOps(MBB, MBBI, ARM::LDR, ARM::t2LDRi12, 1, STI); 01327 emitSPUpdate(isARM, MBB, MBBI, dl, TII, AFI->getGPRCalleeSavedArea1Size()); 01328 } 01329 01330 if (VARegSaveSize) 01331 emitSPUpdate(isARM, MBB, MBBI, dl, TII, VARegSaveSize); 01332 } 01333 01334 #include "ARMGenRegisterInfo.inc"