lib/Target/ARM/ARMFrameLowering.cpp

   1 //=======- ARMFrameLowering.cpp - ARM Frame 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 ARM implementation of TargetFrameLowering class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ARMFrameLowering.h"
  15 #include "ARMAddressingModes.h"
  16 #include "ARMBaseInstrInfo.h"
  17 #include "ARMBaseRegisterInfo.h"
  18 #include "ARMMachineFunctionInfo.h"
  19 #include "llvm/CodeGen/MachineFrameInfo.h"
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/CodeGen/MachineInstrBuilder.h"
  22 #include "llvm/CodeGen/MachineRegisterInfo.h"
  23 #include "llvm/CodeGen/RegisterScavenging.h"
  24 #include "llvm/Target/TargetOptions.h"
  25
  26 using namespace llvm;
  27
  28 /// hasFP - Return true if the specified function should have a dedicated frame
  29 /// pointer register.  This is true if the function has variable sized allocas
  30 /// or if frame pointer elimination is disabled.
  31 bool ARMFrameLowering::hasFP(const MachineFunction &MF) const {
  32   const TargetRegisterInfo *RegInfo = MF.getTarget().getRegisterInfo();
  33
  34   // Mac OS X requires FP not to be clobbered for backtracing purpose.
  35   if (STI.isTargetDarwin())
  36     return true;
  37
  38   const MachineFrameInfo *MFI = MF.getFrameInfo();
  39   // Always eliminate non-leaf frame pointers.
  40   return ((DisableFramePointerElim(MF) && MFI->hasCalls()) ||
  41           RegInfo->needsStackRealignment(MF) ||
  42           MFI->hasVarSizedObjects() ||
  43           MFI->isFrameAddressTaken());
  44 }
  45
  46 /// hasReservedCallFrame - Under normal circumstances, when a frame pointer is
  47 /// not required, we reserve argument space for call sites in the function
  48 /// immediately on entry to the current function.  This eliminates the need for
  49 /// add/sub sp brackets around call sites.  Returns true if the call frame is
  50 /// included as part of the stack frame.
  51 bool ARMFrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
  52   const MachineFrameInfo *FFI = MF.getFrameInfo();
  53   unsigned CFSize = FFI->getMaxCallFrameSize();
  54   // It's not always a good idea to include the call frame as part of the
  55   // stack frame. ARM (especially Thumb) has small immediate offset to
  56   // address the stack frame. So a large call frame can cause poor codegen
  57   // and may even makes it impossible to scavenge a register.
  58   if (CFSize >= ((1 << 12) - 1) / 2)  // Half of imm12
  59     return false;
  60
  61   return !MF.getFrameInfo()->hasVarSizedObjects();
  62 }
  63
  64 /// canSimplifyCallFramePseudos - If there is a reserved call frame, the
  65 /// call frame pseudos can be simplified.  Unlike most targets, having a FP
  66 /// is not sufficient here since we still may reference some objects via SP
  67 /// even when FP is available in Thumb2 mode.
  68 bool
  69 ARMFrameLowering::canSimplifyCallFramePseudos(const MachineFunction &MF) const {
  70   return hasReservedCallFrame(MF) || MF.getFrameInfo()->hasVarSizedObjects();
  71 }
  72
  73 static bool isCalleeSavedRegister(unsigned Reg, const unsigned *CSRegs) {
  74   for (unsigned i = 0; CSRegs[i]; ++i)
  75     if (Reg == CSRegs[i])
  76       return true;
  77   return false;
  78 }
  79
  80 static bool isCSRestore(MachineInstr *MI,
  81                         const ARMBaseInstrInfo &TII,
  82                         const unsigned *CSRegs) {
  83   // Integer spill area is handled with "pop".
  84   if (MI->getOpcode() == ARM::LDMIA_RET ||
  85       MI->getOpcode() == ARM::t2LDMIA_RET ||
  86       MI->getOpcode() == ARM::LDMIA_UPD ||
  87       MI->getOpcode() == ARM::t2LDMIA_UPD ||
  88       MI->getOpcode() == ARM::VLDMDIA_UPD) {
  89     // The first two operands are predicates. The last two are
  90     // imp-def and imp-use of SP. Check everything in between.
  91     for (int i = 5, e = MI->getNumOperands(); i != e; ++i)
  92       if (!isCalleeSavedRegister(MI->getOperand(i).getReg(), CSRegs))
  93         return false;
  94     return true;
  95   }
  96   if ((MI->getOpcode() == ARM::LDR_POST ||
  97        MI->getOpcode() == ARM::t2LDR_POST) &&
  98       isCalleeSavedRegister(MI->getOperand(0).getReg(), CSRegs) &&
  99       MI->getOperand(1).getReg() == ARM::SP)
 100     return true;
 101
 102   return false;
 103 }
 104
 105 static void
 106 emitSPUpdate(bool isARM,
 107              MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
 108              DebugLoc dl, const ARMBaseInstrInfo &TII,
 109              int NumBytes,
 110              ARMCC::CondCodes Pred = ARMCC::AL, unsigned PredReg = 0) {
 111   if (isARM)
 112     emitARMRegPlusImmediate(MBB, MBBI, dl, ARM::SP, ARM::SP, NumBytes,
 113                             Pred, PredReg, TII);
 114   else
 115     emitT2RegPlusImmediate(MBB, MBBI, dl, ARM::SP, ARM::SP, NumBytes,
 116                            Pred, PredReg, TII);
 117 }
 118
 119 void ARMFrameLowering::emitPrologue(MachineFunction &MF) const {
 120   MachineBasicBlock &MBB = MF.front();
 121   MachineBasicBlock::iterator MBBI = MBB.begin();
 122   MachineFrameInfo  *MFI = MF.getFrameInfo();
 123   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
 124   const ARMBaseRegisterInfo *RegInfo =
 125     static_cast<const ARMBaseRegisterInfo*>(MF.getTarget().getRegisterInfo());
 126   const ARMBaseInstrInfo &TII =
 127     *static_cast<const ARMBaseInstrInfo*>(MF.getTarget().getInstrInfo());
 128   assert(!AFI->isThumb1OnlyFunction() &&
 129          "This emitPrologue does not support Thumb1!");
 130   bool isARM = !AFI->isThumbFunction();
 131   unsigned VARegSaveSize = AFI->getVarArgsRegSaveSize();
 132   unsigned NumBytes = MFI->getStackSize();
 133   const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
 134   DebugLoc dl = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
 135   unsigned FramePtr = RegInfo->getFrameRegister(MF);
 136
 137   // Determine the sizes of each callee-save spill areas and record which frame
 138   // belongs to which callee-save spill areas.
 139   unsigned GPRCS1Size = 0, GPRCS2Size = 0, DPRCSSize = 0;
 140   int FramePtrSpillFI = 0;
 141
 142   // Allocate the vararg register save area. This is not counted in NumBytes.
 143   if (VARegSaveSize)
 144     emitSPUpdate(isARM, MBB, MBBI, dl, TII, -VARegSaveSize);
 145
 146   if (!AFI->hasStackFrame()) {
 147     if (NumBytes != 0)
 148       emitSPUpdate(isARM, MBB, MBBI, dl, TII, -NumBytes);
 149     return;
 150   }
 151
 152   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 153     unsigned Reg = CSI[i].getReg();
 154     int FI = CSI[i].getFrameIdx();
 155     switch (Reg) {
 156     case ARM::R4:
 157     case ARM::R5:
 158     case ARM::R6:
 159     case ARM::R7:
 160     case ARM::LR:
 161       if (Reg == FramePtr)
 162         FramePtrSpillFI = FI;
 163       AFI->addGPRCalleeSavedArea1Frame(FI);
 164       GPRCS1Size += 4;
 165       break;
 166     case ARM::R8:
 167     case ARM::R9:
 168     case ARM::R10:
 169     case ARM::R11:
 170       if (Reg == FramePtr)
 171         FramePtrSpillFI = FI;
 172       if (STI.isTargetDarwin()) {
 173         AFI->addGPRCalleeSavedArea2Frame(FI);
 174         GPRCS2Size += 4;
 175       } else {
 176         AFI->addGPRCalleeSavedArea1Frame(FI);
 177         GPRCS1Size += 4;
 178       }
 179       break;
 180     default:
 181       AFI->addDPRCalleeSavedAreaFrame(FI);
 182       DPRCSSize += 8;
 183     }
 184   }
 185
 186   // Move past area 1.
 187   if (GPRCS1Size > 0) MBBI++;
 188
 189   // Set FP to point to the stack slot that contains the previous FP.
 190   // For Darwin, FP is R7, which has now been stored in spill area 1.
 191   // Otherwise, if this is not Darwin, all the callee-saved registers go
 192   // into spill area 1, including the FP in R11.  In either case, it is
 193   // now safe to emit this assignment.
 194   bool HasFP = hasFP(MF);
 195   if (HasFP) {
 196     unsigned ADDriOpc = !AFI->isThumbFunction() ? ARM::ADDri : ARM::t2ADDri;
 197     MachineInstrBuilder MIB =
 198       BuildMI(MBB, MBBI, dl, TII.get(ADDriOpc), FramePtr)
 199       .addFrameIndex(FramePtrSpillFI).addImm(0);
 200     AddDefaultCC(AddDefaultPred(MIB));
 201   }
 202
 203   // Move past area 2.
 204   if (GPRCS2Size > 0) MBBI++;
 205
 206   // Determine starting offsets of spill areas.
 207   unsigned DPRCSOffset  = NumBytes - (GPRCS1Size + GPRCS2Size + DPRCSSize);
 208   unsigned GPRCS2Offset = DPRCSOffset + DPRCSSize;
 209   unsigned GPRCS1Offset = GPRCS2Offset + GPRCS2Size;
 210   if (HasFP)
 211     AFI->setFramePtrSpillOffset(MFI->getObjectOffset(FramePtrSpillFI) +
 212                                 NumBytes);
 213   AFI->setGPRCalleeSavedArea1Offset(GPRCS1Offset);
 214   AFI->setGPRCalleeSavedArea2Offset(GPRCS2Offset);
 215   AFI->setDPRCalleeSavedAreaOffset(DPRCSOffset);
 216
 217   // Move past area 3.
 218   if (DPRCSSize > 0) MBBI++;
 219
 220   NumBytes = DPRCSOffset;
 221   if (NumBytes) {
 222     // Adjust SP after all the callee-save spills.
 223     emitSPUpdate(isARM, MBB, MBBI, dl, TII, -NumBytes);
 224     if (HasFP && isARM)
 225       // Restore from fp only in ARM mode: e.g. sub sp, r7, #24
 226       // Note it's not safe to do this in Thumb2 mode because it would have
 227       // taken two instructions:
 228       // mov sp, r7
 229       // sub sp, #24
 230       // If an interrupt is taken between the two instructions, then sp is in
 231       // an inconsistent state (pointing to the middle of callee-saved area).
 232       // The interrupt handler can end up clobbering the registers.
 233       AFI->setShouldRestoreSPFromFP(true);
 234   }
 235
 236   if (STI.isTargetELF() && hasFP(MF))
 237     MFI->setOffsetAdjustment(MFI->getOffsetAdjustment() -
 238                              AFI->getFramePtrSpillOffset());
 239
 240   AFI->setGPRCalleeSavedArea1Size(GPRCS1Size);
 241   AFI->setGPRCalleeSavedArea2Size(GPRCS2Size);
 242   AFI->setDPRCalleeSavedAreaSize(DPRCSSize);
 243
 244   // If we need dynamic stack realignment, do it here. Be paranoid and make
 245   // sure if we also have VLAs, we have a base pointer for frame access.
 246   if (RegInfo->needsStackRealignment(MF)) {
 247     unsigned MaxAlign = MFI->getMaxAlignment();
 248     assert (!AFI->isThumb1OnlyFunction());
 249     if (!AFI->isThumbFunction()) {
 250       // Emit bic sp, sp, MaxAlign
 251       AddDefaultCC(AddDefaultPred(BuildMI(MBB, MBBI, dl,
 252                                           TII.get(ARM::BICri), ARM::SP)
 253                                   .addReg(ARM::SP, RegState::Kill)
 254                                   .addImm(MaxAlign-1)));
 255     } else {
 256       // We cannot use sp as source/dest register here, thus we're emitting the
 257       // following sequence:
 258       // mov r4, sp
 259       // bic r4, r4, MaxAlign
 260       // mov sp, r4
 261       // FIXME: It will be better just to find spare register here.
 262       BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVgpr2tgpr), ARM::R4)
 263         .addReg(ARM::SP, RegState::Kill);
 264       AddDefaultCC(AddDefaultPred(BuildMI(MBB, MBBI, dl,
 265                                           TII.get(ARM::t2BICri), ARM::R4)
 266                                   .addReg(ARM::R4, RegState::Kill)
 267                                   .addImm(MaxAlign-1)));
 268       BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVtgpr2gpr), ARM::SP)
 269         .addReg(ARM::R4, RegState::Kill);
 270     }
 271
 272     AFI->setShouldRestoreSPFromFP(true);
 273   }
 274
 275   // If we need a base pointer, set it up here. It's whatever the value
 276   // of the stack pointer is at this point. Any variable size objects
 277   // will be allocated after this, so we can still use the base pointer
 278   // to reference locals.
 279   if (RegInfo->hasBasePointer(MF)) {
 280     if (isARM)
 281       BuildMI(MBB, MBBI, dl,
 282               TII.get(ARM::MOVr), RegInfo->getBaseRegister())
 283         .addReg(ARM::SP)
 284         .addImm((unsigned)ARMCC::AL).addReg(0).addReg(0);
 285     else
 286       BuildMI(MBB, MBBI, dl,
 287               TII.get(ARM::tMOVgpr2gpr), RegInfo->getBaseRegister())
 288         .addReg(ARM::SP);
 289   }
 290
 291   // If the frame has variable sized objects then the epilogue must restore
 292   // the sp from fp. We can assume there's an FP here since hasFP already
 293   // checks for hasVarSizedObjects.
 294   if (MFI->hasVarSizedObjects())
 295     AFI->setShouldRestoreSPFromFP(true);
 296 }
 297
 298 void ARMFrameLowering::emitEpilogue(MachineFunction &MF,
 299                                     MachineBasicBlock &MBB) const {
 300   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
 301   assert(MBBI->getDesc().isReturn() &&
 302          "Can only insert epilog into returning blocks");
 303   unsigned RetOpcode = MBBI->getOpcode();
 304   DebugLoc dl = MBBI->getDebugLoc();
 305   MachineFrameInfo *MFI = MF.getFrameInfo();
 306   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
 307   const TargetRegisterInfo *RegInfo = MF.getTarget().getRegisterInfo();
 308   const ARMBaseInstrInfo &TII =
 309     *static_cast<const ARMBaseInstrInfo*>(MF.getTarget().getInstrInfo());
 310   assert(!AFI->isThumb1OnlyFunction() &&
 311          "This emitEpilogue does not support Thumb1!");
 312   bool isARM = !AFI->isThumbFunction();
 313
 314   unsigned VARegSaveSize = AFI->getVarArgsRegSaveSize();
 315   int NumBytes = (int)MFI->getStackSize();
 316   unsigned FramePtr = RegInfo->getFrameRegister(MF);
 317
 318   if (!AFI->hasStackFrame()) {
 319     if (NumBytes != 0)
 320       emitSPUpdate(isARM, MBB, MBBI, dl, TII, NumBytes);
 321   } else {
 322     // Unwind MBBI to point to first LDR / VLDRD.
 323     const unsigned *CSRegs = RegInfo->getCalleeSavedRegs();
 324     if (MBBI != MBB.begin()) {
 325       do
 326         --MBBI;
 327       while (MBBI != MBB.begin() && isCSRestore(MBBI, TII, CSRegs));
 328       if (!isCSRestore(MBBI, TII, CSRegs))
 329         ++MBBI;
 330     }
 331
 332     // Move SP to start of FP callee save spill area.
 333     NumBytes -= (AFI->getGPRCalleeSavedArea1Size() +
 334                  AFI->getGPRCalleeSavedArea2Size() +
 335                  AFI->getDPRCalleeSavedAreaSize());
 336
 337     // Reset SP based on frame pointer only if the stack frame extends beyond
 338     // frame pointer stack slot or target is ELF and the function has FP.
 339     if (AFI->shouldRestoreSPFromFP()) {
 340       NumBytes = AFI->getFramePtrSpillOffset() - NumBytes;
 341       if (NumBytes) {
 342         if (isARM)
 343           emitARMRegPlusImmediate(MBB, MBBI, dl, ARM::SP, FramePtr, -NumBytes,
 344                                   ARMCC::AL, 0, TII);
 345         else {
 346           // It's not possible to restore SP from FP in a single instruction.
 347           // For Darwin, this looks like:
 348           // mov sp, r7
 349           // sub sp, #24
 350           // This is bad, if an interrupt is taken after the mov, sp is in an
 351           // inconsistent state.
 352           // Use the first callee-saved register as a scratch register.
 353           assert(MF.getRegInfo().isPhysRegUsed(ARM::R4) &&
 354                  "No scratch register to restore SP from FP!");
 355           emitT2RegPlusImmediate(MBB, MBBI, dl, ARM::R4, FramePtr, -NumBytes,
 356                                  ARMCC::AL, 0, TII);
 357           BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVgpr2gpr), ARM::SP)
 358             .addReg(ARM::R4);
 359         }
 360       } else {
 361         // Thumb2 or ARM.
 362         if (isARM)
 363           BuildMI(MBB, MBBI, dl, TII.get(ARM::MOVr), ARM::SP)
 364             .addReg(FramePtr).addImm((unsigned)ARMCC::AL).addReg(0).addReg(0);
 365         else
 366           BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVgpr2gpr), ARM::SP)
 367             .addReg(FramePtr);
 368       }
 369     } else if (NumBytes)
 370       emitSPUpdate(isARM, MBB, MBBI, dl, TII, NumBytes);
 371
 372     // Increment past our save areas.
 373     if (AFI->getDPRCalleeSavedAreaSize()) MBBI++;
 374     if (AFI->getGPRCalleeSavedArea2Size()) MBBI++;
 375     if (AFI->getGPRCalleeSavedArea1Size()) MBBI++;
 376   }
 377
 378   if (RetOpcode == ARM::TCRETURNdi || RetOpcode == ARM::TCRETURNdiND ||
 379       RetOpcode == ARM::TCRETURNri || RetOpcode == ARM::TCRETURNriND) {
 380     // Tail call return: adjust the stack pointer and jump to callee.
 381     MBBI = MBB.getLastNonDebugInstr();
 382     MachineOperand &JumpTarget = MBBI->getOperand(0);
 383
 384     // Jump to label or value in register.
 385     if (RetOpcode == ARM::TCRETURNdi || RetOpcode == ARM::TCRETURNdiND) {
 386       unsigned TCOpcode = (RetOpcode == ARM::TCRETURNdi)
 387         ? (STI.isThumb() ? ARM::TAILJMPdt : ARM::TAILJMPd)
 388         : (STI.isThumb() ? ARM::TAILJMPdNDt : ARM::TAILJMPdND);
 389       MachineInstrBuilder MIB = BuildMI(MBB, MBBI, dl, TII.get(TCOpcode));
 390       if (JumpTarget.isGlobal())
 391         MIB.addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset(),
 392                              JumpTarget.getTargetFlags());
 393       else {
 394         assert(JumpTarget.isSymbol());
 395         MIB.addExternalSymbol(JumpTarget.getSymbolName(),
 396                               JumpTarget.getTargetFlags());
 397       }
 398     } else if (RetOpcode == ARM::TCRETURNri) {
 399       BuildMI(MBB, MBBI, dl, TII.get(ARM::TAILJMPr)).
 400         addReg(JumpTarget.getReg(), RegState::Kill);
 401     } else if (RetOpcode == ARM::TCRETURNriND) {
 402       BuildMI(MBB, MBBI, dl, TII.get(ARM::TAILJMPrND)).
 403         addReg(JumpTarget.getReg(), RegState::Kill);
 404     }
 405
 406     MachineInstr *NewMI = prior(MBBI);
 407     for (unsigned i = 1, e = MBBI->getNumOperands(); i != e; ++i)
 408       NewMI->addOperand(MBBI->getOperand(i));
 409
 410     // Delete the pseudo instruction TCRETURN.
 411     MBB.erase(MBBI);
 412   }
 413
 414   if (VARegSaveSize)
 415     emitSPUpdate(isARM, MBB, MBBI, dl, TII, VARegSaveSize);
 416 }
 417
 418 /// getFrameIndexReference - Provide a base+offset reference to an FI slot for
 419 /// debug info.  It's the same as what we use for resolving the code-gen
 420 /// references for now.  FIXME: This can go wrong when references are
 421 /// SP-relative and simple call frames aren't used.
 422 int
 423 ARMFrameLowering::getFrameIndexReference(const MachineFunction &MF, int FI,
 424                                          unsigned &FrameReg) const {
 425   return ResolveFrameIndexReference(MF, FI, FrameReg, 0);
 426 }
 427
 428 int
 429 ARMFrameLowering::ResolveFrameIndexReference(const MachineFunction &MF,
 430                                              int FI,
 431                                              unsigned &FrameReg,
 432                                              int SPAdj) const {
 433   const MachineFrameInfo *MFI = MF.getFrameInfo();
 434   const ARMBaseRegisterInfo *RegInfo =
 435     static_cast<const ARMBaseRegisterInfo*>(MF.getTarget().getRegisterInfo());
 436   const ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
 437   int Offset = MFI->getObjectOffset(FI) + MFI->getStackSize();
 438   int FPOffset = Offset - AFI->getFramePtrSpillOffset();
 439   bool isFixed = MFI->isFixedObjectIndex(FI);
 440
 441   FrameReg = ARM::SP;
 442   Offset += SPAdj;
 443   if (AFI->isGPRCalleeSavedArea1Frame(FI))
 444     return Offset - AFI->getGPRCalleeSavedArea1Offset();
 445   else if (AFI->isGPRCalleeSavedArea2Frame(FI))
 446     return Offset - AFI->getGPRCalleeSavedArea2Offset();
 447   else if (AFI->isDPRCalleeSavedAreaFrame(FI))
 448     return Offset - AFI->getDPRCalleeSavedAreaOffset();
 449
 450   // When dynamically realigning the stack, use the frame pointer for
 451   // parameters, and the stack/base pointer for locals.
 452   if (RegInfo->needsStackRealignment(MF)) {
 453     assert (hasFP(MF) && "dynamic stack realignment without a FP!");
 454     if (isFixed) {
 455       FrameReg = RegInfo->getFrameRegister(MF);
 456       Offset = FPOffset;
 457     } else if (MFI->hasVarSizedObjects()) {
 458       assert(RegInfo->hasBasePointer(MF) &&
 459              "VLAs and dynamic stack alignment, but missing base pointer!");
 460       FrameReg = RegInfo->getBaseRegister();
 461     }
 462     return Offset;
 463   }
 464
 465   // If there is a frame pointer, use it when we can.
 466   if (hasFP(MF) && AFI->hasStackFrame()) {
 467     // Use frame pointer to reference fixed objects. Use it for locals if
 468     // there are VLAs (and thus the SP isn't reliable as a base).
 469     if (isFixed || (MFI->hasVarSizedObjects() &&
 470                     !RegInfo->hasBasePointer(MF))) {
 471       FrameReg = RegInfo->getFrameRegister(MF);
 472       return FPOffset;
 473     } else if (MFI->hasVarSizedObjects()) {
 474       assert(RegInfo->hasBasePointer(MF) && "missing base pointer!");
 475       // Try to use the frame pointer if we can, else use the base pointer
 476       // since it's available. This is handy for the emergency spill slot, in
 477       // particular.
 478       if (AFI->isThumb2Function()) {
 479         if (FPOffset >= -255 && FPOffset < 0) {
 480           FrameReg = RegInfo->getFrameRegister(MF);
 481           return FPOffset;
 482         }
 483       } else
 484         FrameReg = RegInfo->getBaseRegister();
 485     } else if (AFI->isThumb2Function()) {
 486       // In Thumb2 mode, the negative offset is very limited. Try to avoid
 487       // out of range references.
 488       if (FPOffset >= -255 && FPOffset < 0) {
 489         FrameReg = RegInfo->getFrameRegister(MF);
 490         return FPOffset;
 491       }
 492     } else if (Offset > (FPOffset < 0 ? -FPOffset : FPOffset)) {
 493       // Otherwise, use SP or FP, whichever is closer to the stack slot.
 494       FrameReg = RegInfo->getFrameRegister(MF);
 495       return FPOffset;
 496     }
 497   }
 498   // Use the base pointer if we have one.
 499   if (RegInfo->hasBasePointer(MF))
 500     FrameReg = RegInfo->getBaseRegister();
 501   return Offset;
 502 }
 503
 504 int ARMFrameLowering::getFrameIndexOffset(const MachineFunction &MF,
 505                                           int FI) const {
 506   unsigned FrameReg;
 507   return getFrameIndexReference(MF, FI, FrameReg);
 508 }
 509
 510 void ARMFrameLowering::emitPushInst(MachineBasicBlock &MBB,
 511                                     MachineBasicBlock::iterator MI,
 512                                     const std::vector<CalleeSavedInfo> &CSI,
 513                                     unsigned StmOpc, unsigned StrOpc,
 514                                     bool NoGap,
 515                                     bool(*Func)(unsigned, bool)) const {
 516   MachineFunction &MF = *MBB.getParent();
 517   const TargetInstrInfo &TII = *MF.getTarget().getInstrInfo();
 518
 519   DebugLoc DL;
 520   if (MI != MBB.end()) DL = MI->getDebugLoc();
 521
 522   SmallVector<std::pair<unsigned,bool>, 4> Regs;
 523   unsigned i = CSI.size();
 524   while (i != 0) {
 525     unsigned LastReg = 0;
 526     for (; i != 0; --i) {
 527       unsigned Reg = CSI[i-1].getReg();
 528       if (!(Func)(Reg, STI.isTargetDarwin())) continue;
 529
 530       // Add the callee-saved register as live-in unless it's LR and
 531       // @llvm.returnaddress is called. If LR is returned for
 532       // @llvm.returnaddress then it's already added to the function and
 533       // entry block live-in sets.
 534       bool isKill = true;
 535       if (Reg == ARM::LR) {
 536         if (MF.getFrameInfo()->isReturnAddressTaken() &&
 537             MF.getRegInfo().isLiveIn(Reg))
 538           isKill = false;
 539       }
 540
 541       if (isKill)
 542         MBB.addLiveIn(Reg);
 543
 544       // If NoGap is true, push consecutive registers and then leave the rest
 545       // for other instructions. e.g.
 546       // vpush {d8, d10, d11} -> vpush {d8}, vpush {d10, d11}
 547       if (NoGap && LastReg && LastReg != Reg-1)
 548         break;
 549       LastReg = Reg;
 550       Regs.push_back(std::make_pair(Reg, isKill));
 551     }
 552
 553     if (Regs.empty())
 554       continue;
 555     if (Regs.size() > 1 || StrOpc== 0) {
 556       MachineInstrBuilder MIB =
 557         AddDefaultPred(BuildMI(MBB, MI, DL, TII.get(StmOpc), ARM::SP)
 558                        .addReg(ARM::SP));
 559       for (unsigned i = 0, e = Regs.size(); i < e; ++i)
 560         MIB.addReg(Regs[i].first, getKillRegState(Regs[i].second));
 561     } else if (Regs.size() == 1) {
 562       MachineInstrBuilder MIB = BuildMI(MBB, MI, DL, TII.get(StrOpc),
 563                                         ARM::SP)
 564         .addReg(Regs[0].first, getKillRegState(Regs[0].second))
 565         .addReg(ARM::SP);
 566       // ARM mode needs an extra reg0 here due to addrmode2. Will go away once
 567       // that refactoring is complete (eventually).
 568       if (StrOpc == ARM::STR_PRE) {
 569         MIB.addReg(0);
 570         MIB.addImm(ARM_AM::getAM2Opc(ARM_AM::sub, 4, ARM_AM::no_shift));
 571       } else
 572         MIB.addImm(-4);
 573       AddDefaultPred(MIB);
 574     }
 575     Regs.clear();
 576   }
 577 }
 578
 579 void ARMFrameLowering::emitPopInst(MachineBasicBlock &MBB,
 580                                    MachineBasicBlock::iterator MI,
 581                                    const std::vector<CalleeSavedInfo> &CSI,
 582                                    unsigned LdmOpc, unsigned LdrOpc,
 583                                    bool isVarArg, bool NoGap,
 584                                    bool(*Func)(unsigned, bool)) const {
 585   MachineFunction &MF = *MBB.getParent();
 586   const TargetInstrInfo &TII = *MF.getTarget().getInstrInfo();
 587   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
 588   DebugLoc DL = MI->getDebugLoc();
 589
 590   SmallVector<unsigned, 4> Regs;
 591   unsigned i = CSI.size();
 592   while (i != 0) {
 593     unsigned LastReg = 0;
 594     bool DeleteRet = false;
 595     for (; i != 0; --i) {
 596       unsigned Reg = CSI[i-1].getReg();
 597       if (!(Func)(Reg, STI.isTargetDarwin())) continue;
 598
 599       if (Reg == ARM::LR && !isVarArg && STI.hasV5TOps()) {
 600         Reg = ARM::PC;
 601         LdmOpc = AFI->isThumbFunction() ? ARM::t2LDMIA_RET : ARM::LDMIA_RET;
 602         // Fold the return instruction into the LDM.
 603         DeleteRet = true;
 604       }
 605
 606       // If NoGap is true, pop consecutive registers and then leave the rest
 607       // for other instructions. e.g.
 608       // vpop {d8, d10, d11} -> vpop {d8}, vpop {d10, d11}
 609       if (NoGap && LastReg && LastReg != Reg-1)
 610         break;
 611
 612       LastReg = Reg;
 613       Regs.push_back(Reg);
 614     }
 615
 616     if (Regs.empty())
 617       continue;
 618     if (Regs.size() > 1 || LdrOpc == 0) {
 619       MachineInstrBuilder MIB =
 620         AddDefaultPred(BuildMI(MBB, MI, DL, TII.get(LdmOpc), ARM::SP)
 621                        .addReg(ARM::SP));
 622       for (unsigned i = 0, e = Regs.size(); i < e; ++i)
 623         MIB.addReg(Regs[i], getDefRegState(true));
 624       if (DeleteRet)
 625         MI->eraseFromParent();
 626       MI = MIB;
 627     } else if (Regs.size() == 1) {
 628       // If we adjusted the reg to PC from LR above, switch it back here. We
 629       // only do that for LDM.
 630       if (Regs[0] == ARM::PC)
 631         Regs[0] = ARM::LR;
 632       MachineInstrBuilder MIB =
 633         BuildMI(MBB, MI, DL, TII.get(LdrOpc), Regs[0])
 634           .addReg(ARM::SP, RegState::Define)
 635           .addReg(ARM::SP);
 636       // ARM mode needs an extra reg0 here due to addrmode2. Will go away once
 637       // that refactoring is complete (eventually).
 638       if (LdrOpc == ARM::LDR_POST) {
 639         MIB.addReg(0);
 640         MIB.addImm(ARM_AM::getAM2Opc(ARM_AM::add, 4, ARM_AM::no_shift));
 641       } else
 642         MIB.addImm(4);
 643       AddDefaultPred(MIB);
 644     }
 645     Regs.clear();
 646   }
 647 }
 648
 649 bool ARMFrameLowering::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
 650                                         MachineBasicBlock::iterator MI,
 651                                         const std::vector<CalleeSavedInfo> &CSI,
 652                                         const TargetRegisterInfo *TRI) const {
 653   if (CSI.empty())
 654     return false;
 655
 656   MachineFunction &MF = *MBB.getParent();
 657   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
 658
 659   unsigned PushOpc = AFI->isThumbFunction() ? ARM::t2STMDB_UPD : ARM::STMDB_UPD;
 660   unsigned PushOneOpc = AFI->isThumbFunction() ? ARM::t2STR_PRE : ARM::STR_PRE;
 661   unsigned FltOpc = ARM::VSTMDDB_UPD;
 662   emitPushInst(MBB, MI, CSI, PushOpc, PushOneOpc, false, &isARMArea1Register);
 663   emitPushInst(MBB, MI, CSI, PushOpc, PushOneOpc, false, &isARMArea2Register);
 664   emitPushInst(MBB, MI, CSI, FltOpc, 0, true, &isARMArea3Register);
 665
 666   return true;
 667 }
 668
 669 bool ARMFrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
 670                                         MachineBasicBlock::iterator MI,
 671                                         const std::vector<CalleeSavedInfo> &CSI,
 672                                         const TargetRegisterInfo *TRI) const {
 673   if (CSI.empty())
 674     return false;
 675
 676   MachineFunction &MF = *MBB.getParent();
 677   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
 678   bool isVarArg = AFI->getVarArgsRegSaveSize() > 0;
 679
 680   unsigned PopOpc = AFI->isThumbFunction() ? ARM::t2LDMIA_UPD : ARM::LDMIA_UPD;
 681   unsigned LdrOpc = AFI->isThumbFunction() ? ARM::t2LDR_POST : ARM::LDR_POST;
 682   unsigned FltOpc = ARM::VLDMDIA_UPD;
 683   emitPopInst(MBB, MI, CSI, FltOpc, 0, isVarArg, true, &isARMArea3Register);
 684   emitPopInst(MBB, MI, CSI, PopOpc, LdrOpc, isVarArg, false,
 685               &isARMArea2Register);
 686   emitPopInst(MBB, MI, CSI, PopOpc, LdrOpc, isVarArg, false,
 687               &isARMArea1Register);
 688
 689   return true;
 690 }
 691
 692 // FIXME: Make generic?
 693 static unsigned GetFunctionSizeInBytes(const MachineFunction &MF,
 694                                        const ARMBaseInstrInfo &TII) {
 695   unsigned FnSize = 0;
 696   for (MachineFunction::const_iterator MBBI = MF.begin(), E = MF.end();
 697        MBBI != E; ++MBBI) {
 698     const MachineBasicBlock &MBB = *MBBI;
 699     for (MachineBasicBlock::const_iterator I = MBB.begin(),E = MBB.end();
 700          I != E; ++I)
 701       FnSize += TII.GetInstSizeInBytes(I);
 702   }
 703   return FnSize;
 704 }
 705
 706 /// estimateStackSize - Estimate and return the size of the frame.
 707 /// FIXME: Make generic?
 708 static unsigned estimateStackSize(MachineFunction &MF) {
 709   const MachineFrameInfo *FFI = MF.getFrameInfo();
 710   int Offset = 0;
 711   for (int i = FFI->getObjectIndexBegin(); i != 0; ++i) {
 712     int FixedOff = -FFI->getObjectOffset(i);
 713     if (FixedOff > Offset) Offset = FixedOff;
 714   }
 715   for (unsigned i = 0, e = FFI->getObjectIndexEnd(); i != e; ++i) {
 716     if (FFI->isDeadObjectIndex(i))
 717       continue;
 718     Offset += FFI->getObjectSize(i);
 719     unsigned Align = FFI->getObjectAlignment(i);
 720     // Adjust to alignment boundary
 721     Offset = (Offset+Align-1)/Align*Align;
 722   }
 723   return (unsigned)Offset;
 724 }
 725
 726 /// estimateRSStackSizeLimit - Look at each instruction that references stack
 727 /// frames and return the stack size limit beyond which some of these
 728 /// instructions will require a scratch register during their expansion later.
 729 // FIXME: Move to TII?
 730 static unsigned estimateRSStackSizeLimit(MachineFunction &MF,
 731                                          const TargetFrameLowering *TFI) {
 732   const ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
 733   unsigned Limit = (1 << 12) - 1;
 734   for (MachineFunction::iterator BB = MF.begin(),E = MF.end(); BB != E; ++BB) {
 735     for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end();
 736          I != E; ++I) {
 737       for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
 738         if (!I->getOperand(i).isFI()) continue;
 739
 740         // When using ADDri to get the address of a stack object, 255 is the
 741         // largest offset guaranteed to fit in the immediate offset.
 742         if (I->getOpcode() == ARM::ADDri) {
 743           Limit = std::min(Limit, (1U << 8) - 1);
 744           break;
 745         }
 746
 747         // Otherwise check the addressing mode.
 748         switch (I->getDesc().TSFlags & ARMII::AddrModeMask) {
 749         case ARMII::AddrMode3:
 750         case ARMII::AddrModeT2_i8:
 751           Limit = std::min(Limit, (1U << 8) - 1);
 752           break;
 753         case ARMII::AddrMode5:
 754         case ARMII::AddrModeT2_i8s4:
 755           Limit = std::min(Limit, ((1U << 8) - 1) * 4);
 756           break;
 757         case ARMII::AddrModeT2_i12:
 758           // i12 supports only positive offset so these will be converted to
 759           // i8 opcodes. See llvm::rewriteT2FrameIndex.
 760           if (TFI->hasFP(MF) && AFI->hasStackFrame())
 761             Limit = std::min(Limit, (1U << 8) - 1);
 762           break;
 763         case ARMII::AddrMode4:
 764         case ARMII::AddrMode6:
 765           // Addressing modes 4 & 6 (load/store) instructions can't encode an
 766           // immediate offset for stack references.
 767           return 0;
 768         default:
 769           break;
 770         }
 771         break; // At most one FI per instruction
 772       }
 773     }
 774   }
 775
 776   return Limit;
 777 }
 778
 779 void
 780 ARMFrameLowering::processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
 781                                                        RegScavenger *RS) const {
 782   // This tells PEI to spill the FP as if it is any other callee-save register
 783   // to take advantage the eliminateFrameIndex machinery. This also ensures it
 784   // is spilled in the order specified by getCalleeSavedRegs() to make it easier
 785   // to combine multiple loads / stores.
 786   bool CanEliminateFrame = true;
 787   bool CS1Spilled = false;
 788   bool LRSpilled = false;
 789   unsigned NumGPRSpills = 0;
 790   SmallVector<unsigned, 4> UnspilledCS1GPRs;
 791   SmallVector<unsigned, 4> UnspilledCS2GPRs;
 792   const ARMBaseRegisterInfo *RegInfo =
 793     static_cast<const ARMBaseRegisterInfo*>(MF.getTarget().getRegisterInfo());
 794   const ARMBaseInstrInfo &TII =
 795     *static_cast<const ARMBaseInstrInfo*>(MF.getTarget().getInstrInfo());
 796   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
 797   MachineFrameInfo *MFI = MF.getFrameInfo();
 798   unsigned FramePtr = RegInfo->getFrameRegister(MF);
 799
 800   // Spill R4 if Thumb2 function requires stack realignment - it will be used as
 801   // scratch register. Also spill R4 if Thumb2 function has varsized objects,
 802   // since it's not always possible to restore sp from fp in a single
 803   // instruction.
 804   // FIXME: It will be better just to find spare register here.
 805   if (AFI->isThumb2Function() &&
 806       (MFI->hasVarSizedObjects() || RegInfo->needsStackRealignment(MF)))
 807     MF.getRegInfo().setPhysRegUsed(ARM::R4);
 808
 809   if (AFI->isThumb1OnlyFunction()) {
 810     // Spill LR if Thumb1 function uses variable length argument lists.
 811     if (AFI->getVarArgsRegSaveSize() > 0)
 812       MF.getRegInfo().setPhysRegUsed(ARM::LR);
 813
 814     // Spill R4 if Thumb1 epilogue has to restore SP from FP since
 815     // FIXME: It will be better just to find spare register here.
 816     if (MFI->hasVarSizedObjects())
 817       MF.getRegInfo().setPhysRegUsed(ARM::R4);
 818   }
 819
 820   // Spill the BasePtr if it's used.
 821   if (RegInfo->hasBasePointer(MF))
 822     MF.getRegInfo().setPhysRegUsed(RegInfo->getBaseRegister());
 823
 824   // Don't spill FP if the frame can be eliminated. This is determined
 825   // by scanning the callee-save registers to see if any is used.
 826   const unsigned *CSRegs = RegInfo->getCalleeSavedRegs();
 827   for (unsigned i = 0; CSRegs[i]; ++i) {
 828     unsigned Reg = CSRegs[i];
 829     bool Spilled = false;
 830     if (MF.getRegInfo().isPhysRegUsed(Reg)) {
 831       AFI->setCSRegisterIsSpilled(Reg);
 832       Spilled = true;
 833       CanEliminateFrame = false;
 834     } else {
 835       // Check alias registers too.
 836       for (const unsigned *Aliases =
 837              RegInfo->getAliasSet(Reg); *Aliases; ++Aliases) {
 838         if (MF.getRegInfo().isPhysRegUsed(*Aliases)) {
 839           Spilled = true;
 840           CanEliminateFrame = false;
 841         }
 842       }
 843     }
 844
 845     if (!ARM::GPRRegisterClass->contains(Reg))
 846       continue;
 847
 848     if (Spilled) {
 849       NumGPRSpills++;
 850
 851       if (!STI.isTargetDarwin()) {
 852         if (Reg == ARM::LR)
 853           LRSpilled = true;
 854         CS1Spilled = true;
 855         continue;
 856       }
 857
 858       // Keep track if LR and any of R4, R5, R6, and R7 is spilled.
 859       switch (Reg) {
 860       case ARM::LR:
 861         LRSpilled = true;
 862         // Fallthrough
 863       case ARM::R4: case ARM::R5:
 864       case ARM::R6: case ARM::R7:
 865         CS1Spilled = true;
 866         break;
 867       default:
 868         break;
 869       }
 870     } else {
 871       if (!STI.isTargetDarwin()) {
 872         UnspilledCS1GPRs.push_back(Reg);
 873         continue;
 874       }
 875
 876       switch (Reg) {
 877       case ARM::R4: case ARM::R5:
 878       case ARM::R6: case ARM::R7:
 879       case ARM::LR:
 880         UnspilledCS1GPRs.push_back(Reg);
 881         break;
 882       default:
 883         UnspilledCS2GPRs.push_back(Reg);
 884         break;
 885       }
 886     }
 887   }
 888
 889   bool ForceLRSpill = false;
 890   if (!LRSpilled && AFI->isThumb1OnlyFunction()) {
 891     unsigned FnSize = GetFunctionSizeInBytes(MF, TII);
 892     // Force LR to be spilled if the Thumb function size is > 2048. This enables
 893     // use of BL to implement far jump. If it turns out that it's not needed
 894     // then the branch fix up path will undo it.
 895     if (FnSize >= (1 << 11)) {
 896       CanEliminateFrame = false;
 897       ForceLRSpill = true;
 898     }
 899   }
 900
 901   // If any of the stack slot references may be out of range of an immediate
 902   // offset, make sure a register (or a spill slot) is available for the
 903   // register scavenger. Note that if we're indexing off the frame pointer, the
 904   // effective stack size is 4 bytes larger since the FP points to the stack
 905   // slot of the previous FP. Also, if we have variable sized objects in the
 906   // function, stack slot references will often be negative, and some of
 907   // our instructions are positive-offset only, so conservatively consider
 908   // that case to want a spill slot (or register) as well. Similarly, if
 909   // the function adjusts the stack pointer during execution and the
 910   // adjustments aren't already part of our stack size estimate, our offset
 911   // calculations may be off, so be conservative.
 912   // FIXME: We could add logic to be more precise about negative offsets
 913   //        and which instructions will need a scratch register for them. Is it
 914   //        worth the effort and added fragility?
 915   bool BigStack =
 916     (RS &&
 917      (estimateStackSize(MF) + ((hasFP(MF) && AFI->hasStackFrame()) ? 4:0) >=
 918       estimateRSStackSizeLimit(MF, this)))
 919     || MFI->hasVarSizedObjects()
 920     || (MFI->adjustsStack() && !canSimplifyCallFramePseudos(MF));
 921
 922   bool ExtraCSSpill = false;
 923   if (BigStack || !CanEliminateFrame || RegInfo->cannotEliminateFrame(MF)) {
 924     AFI->setHasStackFrame(true);
 925
 926     // If LR is not spilled, but at least one of R4, R5, R6, and R7 is spilled.
 927     // Spill LR as well so we can fold BX_RET to the registers restore (LDM).
 928     if (!LRSpilled && CS1Spilled) {
 929       MF.getRegInfo().setPhysRegUsed(ARM::LR);
 930       AFI->setCSRegisterIsSpilled(ARM::LR);
 931       NumGPRSpills++;
 932       UnspilledCS1GPRs.erase(std::find(UnspilledCS1GPRs.begin(),
 933                                     UnspilledCS1GPRs.end(), (unsigned)ARM::LR));
 934       ForceLRSpill = false;
 935       ExtraCSSpill = true;
 936     }
 937
 938     if (hasFP(MF)) {
 939       MF.getRegInfo().setPhysRegUsed(FramePtr);
 940       NumGPRSpills++;
 941     }
 942
 943     // If stack and double are 8-byte aligned and we are spilling an odd number
 944     // of GPRs, spill one extra callee save GPR so we won't have to pad between
 945     // the integer and double callee save areas.
 946     unsigned TargetAlign = getStackAlignment();
 947     if (TargetAlign == 8 && (NumGPRSpills & 1)) {
 948       if (CS1Spilled && !UnspilledCS1GPRs.empty()) {
 949         for (unsigned i = 0, e = UnspilledCS1GPRs.size(); i != e; ++i) {
 950           unsigned Reg = UnspilledCS1GPRs[i];
 951           // Don't spill high register if the function is thumb1
 952           if (!AFI->isThumb1OnlyFunction() ||
 953               isARMLowRegister(Reg) || Reg == ARM::LR) {
 954             MF.getRegInfo().setPhysRegUsed(Reg);
 955             AFI->setCSRegisterIsSpilled(Reg);
 956             if (!RegInfo->isReservedReg(MF, Reg))
 957               ExtraCSSpill = true;
 958             break;
 959           }
 960         }
 961       } else if (!UnspilledCS2GPRs.empty() && !AFI->isThumb1OnlyFunction()) {
 962         unsigned Reg = UnspilledCS2GPRs.front();
 963         MF.getRegInfo().setPhysRegUsed(Reg);
 964         AFI->setCSRegisterIsSpilled(Reg);
 965         if (!RegInfo->isReservedReg(MF, Reg))
 966           ExtraCSSpill = true;
 967       }
 968     }
 969
 970     // Estimate if we might need to scavenge a register at some point in order
 971     // to materialize a stack offset. If so, either spill one additional
 972     // callee-saved register or reserve a special spill slot to facilitate
 973     // register scavenging. Thumb1 needs a spill slot for stack pointer
 974     // adjustments also, even when the frame itself is small.
 975     if (BigStack && !ExtraCSSpill) {
 976       // If any non-reserved CS register isn't spilled, just spill one or two
 977       // extra. That should take care of it!
 978       unsigned NumExtras = TargetAlign / 4;
 979       SmallVector<unsigned, 2> Extras;
 980       while (NumExtras && !UnspilledCS1GPRs.empty()) {
 981         unsigned Reg = UnspilledCS1GPRs.back();
 982         UnspilledCS1GPRs.pop_back();
 983         if (!RegInfo->isReservedReg(MF, Reg) &&
 984             (!AFI->isThumb1OnlyFunction() || isARMLowRegister(Reg) ||
 985              Reg == ARM::LR)) {
 986           Extras.push_back(Reg);
 987           NumExtras--;
 988         }
 989       }
 990       // For non-Thumb1 functions, also check for hi-reg CS registers
 991       if (!AFI->isThumb1OnlyFunction()) {
 992         while (NumExtras && !UnspilledCS2GPRs.empty()) {
 993           unsigned Reg = UnspilledCS2GPRs.back();
 994           UnspilledCS2GPRs.pop_back();
 995           if (!RegInfo->isReservedReg(MF, Reg)) {
 996             Extras.push_back(Reg);
 997             NumExtras--;
 998           }
 999         }
1000       }
1001       if (Extras.size() && NumExtras == 0) {
1002         for (unsigned i = 0, e = Extras.size(); i != e; ++i) {
1003           MF.getRegInfo().setPhysRegUsed(Extras[i]);
1004           AFI->setCSRegisterIsSpilled(Extras[i]);
1005         }
1006       } else if (!AFI->isThumb1OnlyFunction()) {
1007         // note: Thumb1 functions spill to R12, not the stack.  Reserve a slot
1008         // closest to SP or frame pointer.
1009         const TargetRegisterClass *RC = ARM::GPRRegisterClass;
1010         RS->setScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(),
1011                                                            RC->getAlignment(),
1012                                                            false));
1013       }
1014     }
1015   }
1016
1017   if (ForceLRSpill) {
1018     MF.getRegInfo().setPhysRegUsed(ARM::LR);
1019     AFI->setCSRegisterIsSpilled(ARM::LR);
1020     AFI->setLRIsSpilledForFarJump(true);
1021   }
1022 }