lib/Target/ARM/ARMBaseRegisterInfo.cpp

   1 //===- ARMBaseRegisterInfo.cpp - ARM Register Information -----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains the base ARM implementation of TargetRegisterInfo class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ARM.h"
  15 #include "ARMAddressingModes.h"
  16 #include "ARMBaseRegisterInfo.h"
  17 #include "ARMInstrInfo.h"
  18 #include "ARMMachineFunctionInfo.h"
  19 #include "ARMSubtarget.h"
  20 #include "llvm/Constants.h"
  21 #include "llvm/DerivedTypes.h"
  22 #include "llvm/CodeGen/MachineConstantPool.h"
  23 #include "llvm/CodeGen/MachineFrameInfo.h"
  24 #include "llvm/CodeGen/MachineFunction.h"
  25 #include "llvm/CodeGen/MachineInstrBuilder.h"
  26 #include "llvm/CodeGen/MachineLocation.h"
  27 #include "llvm/CodeGen/MachineRegisterInfo.h"
  28 #include "llvm/CodeGen/RegisterScavenging.h"
  29 #include "llvm/Support/ErrorHandling.h"
  30 #include "llvm/Target/TargetFrameInfo.h"
  31 #include "llvm/Target/TargetMachine.h"
  32 #include "llvm/Target/TargetOptions.h"
  33 #include "llvm/ADT/BitVector.h"
  34 #include "llvm/ADT/SmallVector.h"
  35 using namespace llvm;
  36
  37 unsigned ARMBaseRegisterInfo::getRegisterNumbering(unsigned RegEnum) {
  38   using namespace ARM;
  39   switch (RegEnum) {
  40   case R0:  case S0:  case D0:  return 0;
  41   case R1:  case S1:  case D1:  return 1;
  42   case R2:  case S2:  case D2:  return 2;
  43   case R3:  case S3:  case D3:  return 3;
  44   case R4:  case S4:  case D4:  return 4;
  45   case R5:  case S5:  case D5:  return 5;
  46   case R6:  case S6:  case D6:  return 6;
  47   case R7:  case S7:  case D7:  return 7;
  48   case R8:  case S8:  case D8:  return 8;
  49   case R9:  case S9:  case D9:  return 9;
  50   case R10: case S10: case D10: return 10;
  51   case R11: case S11: case D11: return 11;
  52   case R12: case S12: case D12: return 12;
  53   case SP:  case S13: case D13: return 13;
  54   case LR:  case S14: case D14: return 14;
  55   case PC:  case S15: case D15: return 15;
  56   case S16: return 16;
  57   case S17: return 17;
  58   case S18: return 18;
  59   case S19: return 19;
  60   case S20: return 20;
  61   case S21: return 21;
  62   case S22: return 22;
  63   case S23: return 23;
  64   case S24: return 24;
  65   case S25: return 25;
  66   case S26: return 26;
  67   case S27: return 27;
  68   case S28: return 28;
  69   case S29: return 29;
  70   case S30: return 30;
  71   case S31: return 31;
  72   default:
  73     LLVM_UNREACHABLE("Unknown ARM register!");
  74   }
  75 }
  76
  77 unsigned ARMBaseRegisterInfo::getRegisterNumbering(unsigned RegEnum,
  78                                                    bool &isSPVFP) {
  79   isSPVFP = false;
  80
  81   using namespace ARM;
  82   switch (RegEnum) {
  83   default:
  84     LLVM_UNREACHABLE("Unknown ARM register!");
  85   case R0:  case D0:  return 0;
  86   case R1:  case D1:  return 1;
  87   case R2:  case D2:  return 2;
  88   case R3:  case D3:  return 3;
  89   case R4:  case D4:  return 4;
  90   case R5:  case D5:  return 5;
  91   case R6:  case D6:  return 6;
  92   case R7:  case D7:  return 7;
  93   case R8:  case D8:  return 8;
  94   case R9:  case D9:  return 9;
  95   case R10: case D10: return 10;
  96   case R11: case D11: return 11;
  97   case R12: case D12: return 12;
  98   case SP:  case D13: return 13;
  99   case LR:  case D14: return 14;
 100   case PC:  case D15: return 15;
 101
 102   case S0: case S1: case S2: case S3:
 103   case S4: case S5: case S6: case S7:
 104   case S8: case S9: case S10: case S11:
 105   case S12: case S13: case S14: case S15:
 106   case S16: case S17: case S18: case S19:
 107   case S20: case S21: case S22: case S23:
 108   case S24: case S25: case S26: case S27:
 109   case S28: case S29: case S30: case S31:  {
 110     isSPVFP = true;
 111     switch (RegEnum) {
 112     default: return 0; // Avoid compile time warning.
 113     case S0: return 0;
 114     case S1: return 1;
 115     case S2: return 2;
 116     case S3: return 3;
 117     case S4: return 4;
 118     case S5: return 5;
 119     case S6: return 6;
 120     case S7: return 7;
 121     case S8: return 8;
 122     case S9: return 9;
 123     case S10: return 10;
 124     case S11: return 11;
 125     case S12: return 12;
 126     case S13: return 13;
 127     case S14: return 14;
 128     case S15: return 15;
 129     case S16: return 16;
 130     case S17: return 17;
 131     case S18: return 18;
 132     case S19: return 19;
 133     case S20: return 20;
 134     case S21: return 21;
 135     case S22: return 22;
 136     case S23: return 23;
 137     case S24: return 24;
 138     case S25: return 25;
 139     case S26: return 26;
 140     case S27: return 27;
 141     case S28: return 28;
 142     case S29: return 29;
 143     case S30: return 30;
 144     case S31: return 31;
 145     }
 146   }
 147   }
 148 }
 149
 150 ARMBaseRegisterInfo::ARMBaseRegisterInfo(const TargetInstrInfo &tii,
 151                                          const ARMSubtarget &sti)
 152   : ARMGenRegisterInfo(ARM::ADJCALLSTACKDOWN, ARM::ADJCALLSTACKUP),
 153     TII(tii), STI(sti),
 154     FramePtr((STI.isTargetDarwin() || STI.isThumb()) ? ARM::R7 : ARM::R11) {
 155 }
 156
 157 const unsigned*
 158 ARMBaseRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
 159   static const unsigned CalleeSavedRegs[] = {
 160     ARM::LR, ARM::R11, ARM::R10, ARM::R9, ARM::R8,
 161     ARM::R7, ARM::R6,  ARM::R5,  ARM::R4,
 162
 163     ARM::D15, ARM::D14, ARM::D13, ARM::D12,
 164     ARM::D11, ARM::D10, ARM::D9,  ARM::D8,
 165     0
 166   };
 167
 168   static const unsigned DarwinCalleeSavedRegs[] = {
 169     // Darwin ABI deviates from ARM standard ABI. R9 is not a callee-saved
 170     // register.
 171     ARM::LR,  ARM::R7,  ARM::R6, ARM::R5, ARM::R4,
 172     ARM::R11, ARM::R10, ARM::R8,
 173
 174     ARM::D15, ARM::D14, ARM::D13, ARM::D12,
 175     ARM::D11, ARM::D10, ARM::D9,  ARM::D8,
 176     0
 177   };
 178   return STI.isTargetDarwin() ? DarwinCalleeSavedRegs : CalleeSavedRegs;
 179 }
 180
 181 const TargetRegisterClass* const *
 182 ARMBaseRegisterInfo::getCalleeSavedRegClasses(const MachineFunction *MF) const {
 183   static const TargetRegisterClass * const CalleeSavedRegClasses[] = {
 184     &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::GPRRegClass,
 185     &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::GPRRegClass,
 186     &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::GPRRegClass,
 187
 188     &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass,
 189     &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass,
 190     0
 191   };
 192
 193   static const TargetRegisterClass * const ThumbCalleeSavedRegClasses[] = {
 194     &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::GPRRegClass,
 195     &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::tGPRRegClass,
 196     &ARM::tGPRRegClass,&ARM::tGPRRegClass,&ARM::tGPRRegClass,
 197
 198     &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass,
 199     &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass,
 200     0
 201   };
 202
 203   static const TargetRegisterClass * const DarwinCalleeSavedRegClasses[] = {
 204     &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::GPRRegClass,
 205     &ARM::GPRRegClass, &ARM::GPRRegClass, &ARM::GPRRegClass,
 206     &ARM::GPRRegClass, &ARM::GPRRegClass,
 207
 208     &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass,
 209     &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass,
 210     0
 211   };
 212
 213   static const TargetRegisterClass * const DarwinThumbCalleeSavedRegClasses[] ={
 214     &ARM::GPRRegClass,  &ARM::tGPRRegClass, &ARM::tGPRRegClass,
 215     &ARM::tGPRRegClass, &ARM::tGPRRegClass, &ARM::GPRRegClass,
 216     &ARM::GPRRegClass,  &ARM::GPRRegClass,
 217
 218     &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass,
 219     &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass, &ARM::DPRRegClass,
 220     0
 221   };
 222
 223   if (STI.isThumb()) {
 224     return STI.isTargetDarwin()
 225       ? DarwinThumbCalleeSavedRegClasses : ThumbCalleeSavedRegClasses;
 226   }
 227   return STI.isTargetDarwin()
 228     ? DarwinCalleeSavedRegClasses : CalleeSavedRegClasses;
 229 }
 230
 231 BitVector ARMBaseRegisterInfo::getReservedRegs(const MachineFunction &MF) const {
 232   // FIXME: avoid re-calculating this everytime.
 233   BitVector Reserved(getNumRegs());
 234   Reserved.set(ARM::SP);
 235   Reserved.set(ARM::PC);
 236   if (STI.isTargetDarwin() || hasFP(MF))
 237     Reserved.set(FramePtr);
 238   // Some targets reserve R9.
 239   if (STI.isR9Reserved())
 240     Reserved.set(ARM::R9);
 241   return Reserved;
 242 }
 243
 244 bool
 245 ARMBaseRegisterInfo::isReservedReg(const MachineFunction &MF, unsigned Reg) const {
 246   switch (Reg) {
 247   default: break;
 248   case ARM::SP:
 249   case ARM::PC:
 250     return true;
 251   case ARM::R7:
 252   case ARM::R11:
 253     if (FramePtr == Reg && (STI.isTargetDarwin() || hasFP(MF)))
 254       return true;
 255     break;
 256   case ARM::R9:
 257     return STI.isR9Reserved();
 258   }
 259
 260   return false;
 261 }
 262
 263 const TargetRegisterClass *ARMBaseRegisterInfo::getPointerRegClass() const {
 264   return &ARM::GPRRegClass;
 265 }
 266
 267 /// getAllocationOrder - Returns the register allocation order for a specified
 268 /// register class in the form of a pair of TargetRegisterClass iterators.
 269 std::pair<TargetRegisterClass::iterator,TargetRegisterClass::iterator>
 270 ARMBaseRegisterInfo::getAllocationOrder(const TargetRegisterClass *RC,
 271                                         unsigned HintType, unsigned HintReg,
 272                                         const MachineFunction &MF) const {
 273   // Alternative register allocation orders when favoring even / odd registers
 274   // of register pairs.
 275
 276   // No FP, R9 is available.
 277   static const unsigned GPREven1[] = {
 278     ARM::R0, ARM::R2, ARM::R4, ARM::R6, ARM::R8, ARM::R10,
 279     ARM::R1, ARM::R3, ARM::R12,ARM::LR, ARM::R5, ARM::R7,
 280     ARM::R9, ARM::R11
 281   };
 282   static const unsigned GPROdd1[] = {
 283     ARM::R1, ARM::R3, ARM::R5, ARM::R7, ARM::R9, ARM::R11,
 284     ARM::R0, ARM::R2, ARM::R12,ARM::LR, ARM::R4, ARM::R6,
 285     ARM::R8, ARM::R10
 286   };
 287
 288   // FP is R7, R9 is available.
 289   static const unsigned GPREven2[] = {
 290     ARM::R0, ARM::R2, ARM::R4,          ARM::R8, ARM::R10,
 291     ARM::R1, ARM::R3, ARM::R12,ARM::LR, ARM::R5, ARM::R6,
 292     ARM::R9, ARM::R11
 293   };
 294   static const unsigned GPROdd2[] = {
 295     ARM::R1, ARM::R3, ARM::R5,          ARM::R9, ARM::R11,
 296     ARM::R0, ARM::R2, ARM::R12,ARM::LR, ARM::R4, ARM::R6,
 297     ARM::R8, ARM::R10
 298   };
 299
 300   // FP is R11, R9 is available.
 301   static const unsigned GPREven3[] = {
 302     ARM::R0, ARM::R2, ARM::R4, ARM::R6, ARM::R8,
 303     ARM::R1, ARM::R3, ARM::R10,ARM::R12,ARM::LR, ARM::R5, ARM::R7,
 304     ARM::R9
 305   };
 306   static const unsigned GPROdd3[] = {
 307     ARM::R1, ARM::R3, ARM::R5, ARM::R6, ARM::R9,
 308     ARM::R0, ARM::R2, ARM::R10,ARM::R12,ARM::LR, ARM::R4, ARM::R7,
 309     ARM::R8
 310   };
 311
 312   // No FP, R9 is not available.
 313   static const unsigned GPREven4[] = {
 314     ARM::R0, ARM::R2, ARM::R4, ARM::R6,          ARM::R10,
 315     ARM::R1, ARM::R3, ARM::R12,ARM::LR, ARM::R5, ARM::R7, ARM::R8,
 316     ARM::R11
 317   };
 318   static const unsigned GPROdd4[] = {
 319     ARM::R1, ARM::R3, ARM::R5, ARM::R7,          ARM::R11,
 320     ARM::R0, ARM::R2, ARM::R12,ARM::LR, ARM::R4, ARM::R6, ARM::R8,
 321     ARM::R10
 322   };
 323
 324   // FP is R7, R9 is not available.
 325   static const unsigned GPREven5[] = {
 326     ARM::R0, ARM::R2, ARM::R4,                   ARM::R10,
 327     ARM::R1, ARM::R3, ARM::R12,ARM::LR, ARM::R5, ARM::R6, ARM::R8,
 328     ARM::R11
 329   };
 330   static const unsigned GPROdd5[] = {
 331     ARM::R1, ARM::R3, ARM::R5,                   ARM::R11,
 332     ARM::R0, ARM::R2, ARM::R12,ARM::LR, ARM::R4, ARM::R6, ARM::R8,
 333     ARM::R10
 334   };
 335
 336   // FP is R11, R9 is not available.
 337   static const unsigned GPREven6[] = {
 338     ARM::R0, ARM::R2, ARM::R4, ARM::R6,
 339     ARM::R1, ARM::R3, ARM::R10,ARM::R12,ARM::LR, ARM::R5, ARM::R7, ARM::R8
 340   };
 341   static const unsigned GPROdd6[] = {
 342     ARM::R1, ARM::R3, ARM::R5, ARM::R7,
 343     ARM::R0, ARM::R2, ARM::R10,ARM::R12,ARM::LR, ARM::R4, ARM::R6, ARM::R8
 344   };
 345
 346
 347   if (HintType == ARMRI::RegPairEven) {
 348     if (isPhysicalRegister(HintReg) && getRegisterPairEven(HintReg, MF) == 0)
 349       // It's no longer possible to fulfill this hint. Return the default
 350       // allocation order.
 351       return std::make_pair(RC->allocation_order_begin(MF),
 352                             RC->allocation_order_end(MF));
 353
 354     if (!STI.isTargetDarwin() && !hasFP(MF)) {
 355       if (!STI.isR9Reserved())
 356         return std::make_pair(GPREven1,
 357                               GPREven1 + (sizeof(GPREven1)/sizeof(unsigned)));
 358       else
 359         return std::make_pair(GPREven4,
 360                               GPREven4 + (sizeof(GPREven4)/sizeof(unsigned)));
 361     } else if (FramePtr == ARM::R7) {
 362       if (!STI.isR9Reserved())
 363         return std::make_pair(GPREven2,
 364                               GPREven2 + (sizeof(GPREven2)/sizeof(unsigned)));
 365       else
 366         return std::make_pair(GPREven5,
 367                               GPREven5 + (sizeof(GPREven5)/sizeof(unsigned)));
 368     } else { // FramePtr == ARM::R11
 369       if (!STI.isR9Reserved())
 370         return std::make_pair(GPREven3,
 371                               GPREven3 + (sizeof(GPREven3)/sizeof(unsigned)));
 372       else
 373         return std::make_pair(GPREven6,
 374                               GPREven6 + (sizeof(GPREven6)/sizeof(unsigned)));
 375     }
 376   } else if (HintType == ARMRI::RegPairOdd) {
 377     if (isPhysicalRegister(HintReg) && getRegisterPairOdd(HintReg, MF) == 0)
 378       // It's no longer possible to fulfill this hint. Return the default
 379       // allocation order.
 380       return std::make_pair(RC->allocation_order_begin(MF),
 381                             RC->allocation_order_end(MF));
 382
 383     if (!STI.isTargetDarwin() && !hasFP(MF)) {
 384       if (!STI.isR9Reserved())
 385         return std::make_pair(GPROdd1,
 386                               GPROdd1 + (sizeof(GPROdd1)/sizeof(unsigned)));
 387       else
 388         return std::make_pair(GPROdd4,
 389                               GPROdd4 + (sizeof(GPROdd4)/sizeof(unsigned)));
 390     } else if (FramePtr == ARM::R7) {
 391       if (!STI.isR9Reserved())
 392         return std::make_pair(GPROdd2,
 393                               GPROdd2 + (sizeof(GPROdd2)/sizeof(unsigned)));
 394       else
 395         return std::make_pair(GPROdd5,
 396                               GPROdd5 + (sizeof(GPROdd5)/sizeof(unsigned)));
 397     } else { // FramePtr == ARM::R11
 398       if (!STI.isR9Reserved())
 399         return std::make_pair(GPROdd3,
 400                               GPROdd3 + (sizeof(GPROdd3)/sizeof(unsigned)));
 401       else
 402         return std::make_pair(GPROdd6,
 403                               GPROdd6 + (sizeof(GPROdd6)/sizeof(unsigned)));
 404     }
 405   }
 406   return std::make_pair(RC->allocation_order_begin(MF),
 407                         RC->allocation_order_end(MF));
 408 }
 409
 410 /// ResolveRegAllocHint - Resolves the specified register allocation hint
 411 /// to a physical register. Returns the physical register if it is successful.
 412 unsigned
 413 ARMBaseRegisterInfo::ResolveRegAllocHint(unsigned Type, unsigned Reg,
 414                                          const MachineFunction &MF) const {
 415   if (Reg == 0 || !isPhysicalRegister(Reg))
 416     return 0;
 417   if (Type == 0)
 418     return Reg;
 419   else if (Type == (unsigned)ARMRI::RegPairOdd)
 420     // Odd register.
 421     return getRegisterPairOdd(Reg, MF);
 422   else if (Type == (unsigned)ARMRI::RegPairEven)
 423     // Even register.
 424     return getRegisterPairEven(Reg, MF);
 425   return 0;
 426 }
 427
 428 void
 429 ARMBaseRegisterInfo::UpdateRegAllocHint(unsigned Reg, unsigned NewReg,
 430                                         MachineFunction &MF) const {
 431   MachineRegisterInfo *MRI = &MF.getRegInfo();
 432   std::pair<unsigned, unsigned> Hint = MRI->getRegAllocationHint(Reg);
 433   if ((Hint.first == (unsigned)ARMRI::RegPairOdd ||
 434        Hint.first == (unsigned)ARMRI::RegPairEven) &&
 435       Hint.second && TargetRegisterInfo::isVirtualRegister(Hint.second)) {
 436     // If 'Reg' is one of the even / odd register pair and it's now changed
 437     // (e.g. coalesced) into a different register. The other register of the
 438     // pair allocation hint must be updated to reflect the relationship
 439     // change.
 440     unsigned OtherReg = Hint.second;
 441     Hint = MRI->getRegAllocationHint(OtherReg);
 442     if (Hint.second == Reg)
 443       // Make sure the pair has not already divorced.
 444       MRI->setRegAllocationHint(OtherReg, Hint.first, NewReg);
 445   }
 446 }
 447
 448 /// hasFP - Return true if the specified function should have a dedicated frame
 449 /// pointer register.  This is true if the function has variable sized allocas
 450 /// or if frame pointer elimination is disabled.
 451 ///
 452 bool ARMBaseRegisterInfo::hasFP(const MachineFunction &MF) const {
 453   const MachineFrameInfo *MFI = MF.getFrameInfo();
 454   return (NoFramePointerElim ||
 455           MFI->hasVarSizedObjects() ||
 456           MFI->isFrameAddressTaken());
 457 }
 458
 459 static unsigned estimateStackSize(MachineFunction &MF, MachineFrameInfo *MFI) {
 460   const MachineFrameInfo *FFI = MF.getFrameInfo();
 461   int Offset = 0;
 462   for (int i = FFI->getObjectIndexBegin(); i != 0; ++i) {
 463     int FixedOff = -FFI->getObjectOffset(i);
 464     if (FixedOff > Offset) Offset = FixedOff;
 465   }
 466   for (unsigned i = 0, e = FFI->getObjectIndexEnd(); i != e; ++i) {
 467     if (FFI->isDeadObjectIndex(i))
 468       continue;
 469     Offset += FFI->getObjectSize(i);
 470     unsigned Align = FFI->getObjectAlignment(i);
 471     // Adjust to alignment boundary
 472     Offset = (Offset+Align-1)/Align*Align;
 473   }
 474   return (unsigned)Offset;
 475 }
 476
 477 void
 478 ARMBaseRegisterInfo::processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
 479                                                           RegScavenger *RS) const {
 480   // This tells PEI to spill the FP as if it is any other callee-save register
 481   // to take advantage the eliminateFrameIndex machinery. This also ensures it
 482   // is spilled in the order specified by getCalleeSavedRegs() to make it easier
 483   // to combine multiple loads / stores.
 484   bool CanEliminateFrame = true;
 485   bool CS1Spilled = false;
 486   bool LRSpilled = false;
 487   unsigned NumGPRSpills = 0;
 488   SmallVector<unsigned, 4> UnspilledCS1GPRs;
 489   SmallVector<unsigned, 4> UnspilledCS2GPRs;
 490   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
 491
 492   // Don't spill FP if the frame can be eliminated. This is determined
 493   // by scanning the callee-save registers to see if any is used.
 494   const unsigned *CSRegs = getCalleeSavedRegs();
 495   const TargetRegisterClass* const *CSRegClasses = getCalleeSavedRegClasses();
 496   for (unsigned i = 0; CSRegs[i]; ++i) {
 497     unsigned Reg = CSRegs[i];
 498     bool Spilled = false;
 499     if (MF.getRegInfo().isPhysRegUsed(Reg)) {
 500       AFI->setCSRegisterIsSpilled(Reg);
 501       Spilled = true;
 502       CanEliminateFrame = false;
 503     } else {
 504       // Check alias registers too.
 505       for (const unsigned *Aliases = getAliasSet(Reg); *Aliases; ++Aliases) {
 506         if (MF.getRegInfo().isPhysRegUsed(*Aliases)) {
 507           Spilled = true;
 508           CanEliminateFrame = false;
 509         }
 510       }
 511     }
 512
 513     if (CSRegClasses[i] == &ARM::GPRRegClass) {
 514       if (Spilled) {
 515         NumGPRSpills++;
 516
 517         if (!STI.isTargetDarwin()) {
 518           if (Reg == ARM::LR)
 519             LRSpilled = true;
 520           CS1Spilled = true;
 521           continue;
 522         }
 523
 524         // Keep track if LR and any of R4, R5, R6, and R7 is spilled.
 525         switch (Reg) {
 526         case ARM::LR:
 527           LRSpilled = true;
 528           // Fallthrough
 529         case ARM::R4:
 530         case ARM::R5:
 531         case ARM::R6:
 532         case ARM::R7:
 533           CS1Spilled = true;
 534           break;
 535         default:
 536           break;
 537         }
 538       } else {
 539         if (!STI.isTargetDarwin()) {
 540           UnspilledCS1GPRs.push_back(Reg);
 541           continue;
 542         }
 543
 544         switch (Reg) {
 545         case ARM::R4:
 546         case ARM::R5:
 547         case ARM::R6:
 548         case ARM::R7:
 549         case ARM::LR:
 550           UnspilledCS1GPRs.push_back(Reg);
 551           break;
 552         default:
 553           UnspilledCS2GPRs.push_back(Reg);
 554           break;
 555         }
 556       }
 557     }
 558   }
 559
 560   bool ForceLRSpill = false;
 561   if (!LRSpilled && AFI->isThumbFunction()) {
 562     unsigned FnSize = TII.GetFunctionSizeInBytes(MF);
 563     // Force LR to be spilled if the Thumb function size is > 2048. This enables
 564     // use of BL to implement far jump. If it turns out that it's not needed
 565     // then the branch fix up path will undo it.
 566     if (FnSize >= (1 << 11)) {
 567       CanEliminateFrame = false;
 568       ForceLRSpill = true;
 569     }
 570   }
 571
 572   bool ExtraCSSpill = false;
 573   if (!CanEliminateFrame || hasFP(MF)) {
 574     AFI->setHasStackFrame(true);
 575
 576     // If LR is not spilled, but at least one of R4, R5, R6, and R7 is spilled.
 577     // Spill LR as well so we can fold BX_RET to the registers restore (LDM).
 578     if (!LRSpilled && CS1Spilled) {
 579       MF.getRegInfo().setPhysRegUsed(ARM::LR);
 580       AFI->setCSRegisterIsSpilled(ARM::LR);
 581       NumGPRSpills++;
 582       UnspilledCS1GPRs.erase(std::find(UnspilledCS1GPRs.begin(),
 583                                     UnspilledCS1GPRs.end(), (unsigned)ARM::LR));
 584       ForceLRSpill = false;
 585       ExtraCSSpill = true;
 586     }
 587
 588     // Darwin ABI requires FP to point to the stack slot that contains the
 589     // previous FP.
 590     if (STI.isTargetDarwin() || hasFP(MF)) {
 591       MF.getRegInfo().setPhysRegUsed(FramePtr);
 592       NumGPRSpills++;
 593     }
 594
 595     // If stack and double are 8-byte aligned and we are spilling an odd number
 596     // of GPRs. Spill one extra callee save GPR so we won't have to pad between
 597     // the integer and double callee save areas.
 598     unsigned TargetAlign = MF.getTarget().getFrameInfo()->getStackAlignment();
 599     if (TargetAlign == 8 && (NumGPRSpills & 1)) {
 600       if (CS1Spilled && !UnspilledCS1GPRs.empty()) {
 601         for (unsigned i = 0, e = UnspilledCS1GPRs.size(); i != e; ++i) {
 602           unsigned Reg = UnspilledCS1GPRs[i];
 603           // Don't spiil high register if the function is thumb
 604           if (!AFI->isThumbFunction() ||
 605               isARMLowRegister(Reg) || Reg == ARM::LR) {
 606             MF.getRegInfo().setPhysRegUsed(Reg);
 607             AFI->setCSRegisterIsSpilled(Reg);
 608             if (!isReservedReg(MF, Reg))
 609               ExtraCSSpill = true;
 610             break;
 611           }
 612         }
 613       } else if (!UnspilledCS2GPRs.empty() &&
 614                  !AFI->isThumbFunction()) {
 615         unsigned Reg = UnspilledCS2GPRs.front();
 616         MF.getRegInfo().setPhysRegUsed(Reg);
 617         AFI->setCSRegisterIsSpilled(Reg);
 618         if (!isReservedReg(MF, Reg))
 619           ExtraCSSpill = true;
 620       }
 621     }
 622
 623     // Estimate if we might need to scavenge a register at some point in order
 624     // to materialize a stack offset. If so, either spill one additional
 625     // callee-saved register or reserve a special spill slot to facilitate
 626     // register scavenging.
 627     if (RS && !ExtraCSSpill && !AFI->isThumbFunction()) {
 628       MachineFrameInfo  *MFI = MF.getFrameInfo();
 629       unsigned Size = estimateStackSize(MF, MFI);
 630       unsigned Limit = (1 << 12) - 1;
 631       for (MachineFunction::iterator BB = MF.begin(),E = MF.end();BB != E; ++BB)
 632         for (MachineBasicBlock::iterator I= BB->begin(); I != BB->end(); ++I) {
 633           for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
 634             if (I->getOperand(i).isFI()) {
 635               unsigned Opcode = I->getOpcode();
 636               const TargetInstrDesc &Desc = TII.get(Opcode);
 637               unsigned AddrMode = (Desc.TSFlags & ARMII::AddrModeMask);
 638               if (AddrMode == ARMII::AddrMode3) {
 639                 Limit = (1 << 8) - 1;
 640                 goto DoneEstimating;
 641               } else if (AddrMode == ARMII::AddrMode5) {
 642                 unsigned ThisLimit = ((1 << 8) - 1) * 4;
 643                 if (ThisLimit < Limit)
 644                   Limit = ThisLimit;
 645               }
 646             }
 647         }
 648     DoneEstimating:
 649       if (Size >= Limit) {
 650         // If any non-reserved CS register isn't spilled, just spill one or two
 651         // extra. That should take care of it!
 652         unsigned NumExtras = TargetAlign / 4;
 653         SmallVector<unsigned, 2> Extras;
 654         while (NumExtras && !UnspilledCS1GPRs.empty()) {
 655           unsigned Reg = UnspilledCS1GPRs.back();
 656           UnspilledCS1GPRs.pop_back();
 657           if (!isReservedReg(MF, Reg)) {
 658             Extras.push_back(Reg);
 659             NumExtras--;
 660           }
 661         }
 662         while (NumExtras && !UnspilledCS2GPRs.empty()) {
 663           unsigned Reg = UnspilledCS2GPRs.back();
 664           UnspilledCS2GPRs.pop_back();
 665           if (!isReservedReg(MF, Reg)) {
 666             Extras.push_back(Reg);
 667             NumExtras--;
 668           }
 669         }
 670         if (Extras.size() && NumExtras == 0) {
 671           for (unsigned i = 0, e = Extras.size(); i != e; ++i) {
 672             MF.getRegInfo().setPhysRegUsed(Extras[i]);
 673             AFI->setCSRegisterIsSpilled(Extras[i]);
 674           }
 675         } else {
 676           // Reserve a slot closest to SP or frame pointer.
 677           const TargetRegisterClass *RC = &ARM::GPRRegClass;
 678           RS->setScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(),
 679                                                            RC->getAlignment()));
 680         }
 681       }
 682     }
 683   }
 684
 685   if (ForceLRSpill) {
 686     MF.getRegInfo().setPhysRegUsed(ARM::LR);
 687     AFI->setCSRegisterIsSpilled(ARM::LR);
 688     AFI->setLRIsSpilledForFarJump(true);
 689   }
 690 }
 691
 692 unsigned ARMBaseRegisterInfo::getRARegister() const {
 693   return ARM::LR;
 694 }
 695
 696 unsigned ARMBaseRegisterInfo::getFrameRegister(MachineFunction &MF) const {
 697   if (STI.isTargetDarwin() || hasFP(MF))
 698     return FramePtr;
 699   return ARM::SP;
 700 }
 701
 702 unsigned ARMBaseRegisterInfo::getEHExceptionRegister() const {
 703   assert(0 && "What is the exception register");
 704   return 0;
 705 }
 706
 707 unsigned ARMBaseRegisterInfo::getEHHandlerRegister() const {
 708   assert(0 && "What is the exception handler register");
 709   return 0;
 710 }
 711
 712 int ARMBaseRegisterInfo::getDwarfRegNum(unsigned RegNum, bool isEH) const {
 713   return ARMGenRegisterInfo::getDwarfRegNumFull(RegNum, 0);
 714 }
 715
 716 unsigned ARMBaseRegisterInfo::getRegisterPairEven(unsigned Reg,
 717                                                const MachineFunction &MF) const {
 718   switch (Reg) {
 719   default: break;
 720   // Return 0 if either register of the pair is a special register.
 721   // So no R12, etc.
 722   case ARM::R1:
 723     return ARM::R0;
 724   case ARM::R3:
 725     // FIXME!
 726     return STI.isThumb() ? 0 : ARM::R2;
 727   case ARM::R5:
 728     return ARM::R4;
 729   case ARM::R7:
 730     return isReservedReg(MF, ARM::R7)  ? 0 : ARM::R6;
 731   case ARM::R9:
 732     return isReservedReg(MF, ARM::R9)  ? 0 :ARM::R8;
 733   case ARM::R11:
 734     return isReservedReg(MF, ARM::R11) ? 0 : ARM::R10;
 735
 736   case ARM::S1:
 737     return ARM::S0;
 738   case ARM::S3:
 739     return ARM::S2;
 740   case ARM::S5:
 741     return ARM::S4;
 742   case ARM::S7:
 743     return ARM::S6;
 744   case ARM::S9:
 745     return ARM::S8;
 746   case ARM::S11:
 747     return ARM::S10;
 748   case ARM::S13:
 749     return ARM::S12;
 750   case ARM::S15:
 751     return ARM::S14;
 752   case ARM::S17:
 753     return ARM::S16;
 754   case ARM::S19:
 755     return ARM::S18;
 756   case ARM::S21:
 757     return ARM::S20;
 758   case ARM::S23:
 759     return ARM::S22;
 760   case ARM::S25:
 761     return ARM::S24;
 762   case ARM::S27:
 763     return ARM::S26;
 764   case ARM::S29:
 765     return ARM::S28;
 766   case ARM::S31:
 767     return ARM::S30;
 768
 769   case ARM::D1:
 770     return ARM::D0;
 771   case ARM::D3:
 772     return ARM::D2;
 773   case ARM::D5:
 774     return ARM::D4;
 775   case ARM::D7:
 776     return ARM::D6;
 777   case ARM::D9:
 778     return ARM::D8;
 779   case ARM::D11:
 780     return ARM::D10;
 781   case ARM::D13:
 782     return ARM::D12;
 783   case ARM::D15:
 784     return ARM::D14;
 785   }
 786
 787   return 0;
 788 }
 789
 790 unsigned ARMBaseRegisterInfo::getRegisterPairOdd(unsigned Reg,
 791                                              const MachineFunction &MF) const {
 792   switch (Reg) {
 793   default: break;
 794   // Return 0 if either register of the pair is a special register.
 795   // So no R12, etc.
 796   case ARM::R0:
 797     return ARM::R1;
 798   case ARM::R2:
 799     // FIXME!
 800     return STI.isThumb() ? 0 : ARM::R3;
 801   case ARM::R4:
 802     return ARM::R5;
 803   case ARM::R6:
 804     return isReservedReg(MF, ARM::R7)  ? 0 : ARM::R7;
 805   case ARM::R8:
 806     return isReservedReg(MF, ARM::R9)  ? 0 :ARM::R9;
 807   case ARM::R10:
 808     return isReservedReg(MF, ARM::R11) ? 0 : ARM::R11;
 809
 810   case ARM::S0:
 811     return ARM::S1;
 812   case ARM::S2:
 813     return ARM::S3;
 814   case ARM::S4:
 815     return ARM::S5;
 816   case ARM::S6:
 817     return ARM::S7;
 818   case ARM::S8:
 819     return ARM::S9;
 820   case ARM::S10:
 821     return ARM::S11;
 822   case ARM::S12:
 823     return ARM::S13;
 824   case ARM::S14:
 825     return ARM::S15;
 826   case ARM::S16:
 827     return ARM::S17;
 828   case ARM::S18:
 829     return ARM::S19;
 830   case ARM::S20:
 831     return ARM::S21;
 832   case ARM::S22:
 833     return ARM::S23;
 834   case ARM::S24:
 835     return ARM::S25;
 836   case ARM::S26:
 837     return ARM::S27;
 838   case ARM::S28:
 839     return ARM::S29;
 840   case ARM::S30:
 841     return ARM::S31;
 842
 843   case ARM::D0:
 844     return ARM::D1;
 845   case ARM::D2:
 846     return ARM::D3;
 847   case ARM::D4:
 848     return ARM::D5;
 849   case ARM::D6:
 850     return ARM::D7;
 851   case ARM::D8:
 852     return ARM::D9;
 853   case ARM::D10:
 854     return ARM::D11;
 855   case ARM::D12:
 856     return ARM::D13;
 857   case ARM::D14:
 858     return ARM::D15;
 859   }
 860
 861   return 0;
 862 }
 863
 864 #include "ARMGenRegisterInfo.inc"