lib/Target/PowerPC/PPCFrameLowering.cpp

   1 //===-- PPCFrameLowering.cpp - PPC Frame Information ----------------------===//
   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 PPC implementation of TargetFrameLowering class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "PPCFrameLowering.h"
  15 #include "PPCInstrBuilder.h"
  16 #include "PPCInstrInfo.h"
  17 #include "PPCMachineFunctionInfo.h"
  18 #include "llvm/CodeGen/MachineFrameInfo.h"
  19 #include "llvm/CodeGen/MachineFunction.h"
  20 #include "llvm/CodeGen/MachineInstrBuilder.h"
  21 #include "llvm/CodeGen/MachineModuleInfo.h"
  22 #include "llvm/CodeGen/MachineRegisterInfo.h"
  23 #include "llvm/CodeGen/RegisterScavenging.h"
  24 #include "llvm/IR/Function.h"
  25 #include "llvm/Target/TargetOptions.h"
  26
  27 using namespace llvm;
  28
  29 /// VRRegNo - Map from a numbered VR register to its enum value.
  30 ///
  31 static const uint16_t VRRegNo[] = {
  32  PPC::V0 , PPC::V1 , PPC::V2 , PPC::V3 , PPC::V4 , PPC::V5 , PPC::V6 , PPC::V7 ,
  33  PPC::V8 , PPC::V9 , PPC::V10, PPC::V11, PPC::V12, PPC::V13, PPC::V14, PPC::V15,
  34  PPC::V16, PPC::V17, PPC::V18, PPC::V19, PPC::V20, PPC::V21, PPC::V22, PPC::V23,
  35  PPC::V24, PPC::V25, PPC::V26, PPC::V27, PPC::V28, PPC::V29, PPC::V30, PPC::V31
  36 };
  37
  38 /// RemoveVRSaveCode - We have found that this function does not need any code
  39 /// to manipulate the VRSAVE register, even though it uses vector registers.
  40 /// This can happen when the only registers used are known to be live in or out
  41 /// of the function.  Remove all of the VRSAVE related code from the function.
  42 /// FIXME: The removal of the code results in a compile failure at -O0 when the
  43 /// function contains a function call, as the GPR containing original VRSAVE
  44 /// contents is spilled and reloaded around the call.  Without the prolog code,
  45 /// the spill instruction refers to an undefined register.  This code needs
  46 /// to account for all uses of that GPR.
  47 static void RemoveVRSaveCode(MachineInstr *MI) {
  48   MachineBasicBlock *Entry = MI->getParent();
  49   MachineFunction *MF = Entry->getParent();
  50
  51   // We know that the MTVRSAVE instruction immediately follows MI.  Remove it.
  52   MachineBasicBlock::iterator MBBI = MI;
  53   ++MBBI;
  54   assert(MBBI != Entry->end() && MBBI->getOpcode() == PPC::MTVRSAVE);
  55   MBBI->eraseFromParent();
  56
  57   bool RemovedAllMTVRSAVEs = true;
  58   // See if we can find and remove the MTVRSAVE instruction from all of the
  59   // epilog blocks.
  60   for (MachineFunction::iterator I = MF->begin(), E = MF->end(); I != E; ++I) {
  61     // If last instruction is a return instruction, add an epilogue
  62     if (!I->empty() && I->back().isReturn()) {
  63       bool FoundIt = false;
  64       for (MBBI = I->end(); MBBI != I->begin(); ) {
  65         --MBBI;
  66         if (MBBI->getOpcode() == PPC::MTVRSAVE) {
  67           MBBI->eraseFromParent();  // remove it.
  68           FoundIt = true;
  69           break;
  70         }
  71       }
  72       RemovedAllMTVRSAVEs &= FoundIt;
  73     }
  74   }
  75
  76   // If we found and removed all MTVRSAVE instructions, remove the read of
  77   // VRSAVE as well.
  78   if (RemovedAllMTVRSAVEs) {
  79     MBBI = MI;
  80     assert(MBBI != Entry->begin() && "UPDATE_VRSAVE is first instr in block?");
  81     --MBBI;
  82     assert(MBBI->getOpcode() == PPC::MFVRSAVE && "VRSAVE instrs wandered?");
  83     MBBI->eraseFromParent();
  84   }
  85
  86   // Finally, nuke the UPDATE_VRSAVE.
  87   MI->eraseFromParent();
  88 }
  89
  90 // HandleVRSaveUpdate - MI is the UPDATE_VRSAVE instruction introduced by the
  91 // instruction selector.  Based on the vector registers that have been used,
  92 // transform this into the appropriate ORI instruction.
  93 static void HandleVRSaveUpdate(MachineInstr *MI, const TargetInstrInfo &TII) {
  94   MachineFunction *MF = MI->getParent()->getParent();
  95   const TargetRegisterInfo *TRI = MF->getTarget().getRegisterInfo();
  96   DebugLoc dl = MI->getDebugLoc();
  97
  98   unsigned UsedRegMask = 0;
  99   for (unsigned i = 0; i != 32; ++i)
 100     if (MF->getRegInfo().isPhysRegUsed(VRRegNo[i]))
 101       UsedRegMask |= 1 << (31-i);
 102
 103   // Live in and live out values already must be in the mask, so don't bother
 104   // marking them.
 105   for (MachineRegisterInfo::livein_iterator
 106        I = MF->getRegInfo().livein_begin(),
 107        E = MF->getRegInfo().livein_end(); I != E; ++I) {
 108     unsigned RegNo = TRI->getEncodingValue(I->first);
 109     if (VRRegNo[RegNo] == I->first)        // If this really is a vector reg.
 110       UsedRegMask &= ~(1 << (31-RegNo));   // Doesn't need to be marked.
 111   }
 112
 113   // Live out registers appear as use operands on return instructions.
 114   for (MachineFunction::const_iterator BI = MF->begin(), BE = MF->end();
 115        UsedRegMask != 0 && BI != BE; ++BI) {
 116     const MachineBasicBlock &MBB = *BI;
 117     if (MBB.empty() || !MBB.back().isReturn())
 118       continue;
 119     const MachineInstr &Ret = MBB.back();
 120     for (unsigned I = 0, E = Ret.getNumOperands(); I != E; ++I) {
 121       const MachineOperand &MO = Ret.getOperand(I);
 122       if (!MO.isReg() || !PPC::VRRCRegClass.contains(MO.getReg()))
 123         continue;
 124       unsigned RegNo = TRI->getEncodingValue(MO.getReg());
 125       UsedRegMask &= ~(1 << (31-RegNo));
 126     }
 127   }
 128
 129   // If no registers are used, turn this into a copy.
 130   if (UsedRegMask == 0) {
 131     // Remove all VRSAVE code.
 132     RemoveVRSaveCode(MI);
 133     return;
 134   }
 135
 136   unsigned SrcReg = MI->getOperand(1).getReg();
 137   unsigned DstReg = MI->getOperand(0).getReg();
 138
 139   if ((UsedRegMask & 0xFFFF) == UsedRegMask) {
 140     if (DstReg != SrcReg)
 141       BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORI), DstReg)
 142         .addReg(SrcReg)
 143         .addImm(UsedRegMask);
 144     else
 145       BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORI), DstReg)
 146         .addReg(SrcReg, RegState::Kill)
 147         .addImm(UsedRegMask);
 148   } else if ((UsedRegMask & 0xFFFF0000) == UsedRegMask) {
 149     if (DstReg != SrcReg)
 150       BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORIS), DstReg)
 151         .addReg(SrcReg)
 152         .addImm(UsedRegMask >> 16);
 153     else
 154       BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORIS), DstReg)
 155         .addReg(SrcReg, RegState::Kill)
 156         .addImm(UsedRegMask >> 16);
 157   } else {
 158     if (DstReg != SrcReg)
 159       BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORIS), DstReg)
 160         .addReg(SrcReg)
 161         .addImm(UsedRegMask >> 16);
 162     else
 163       BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORIS), DstReg)
 164         .addReg(SrcReg, RegState::Kill)
 165         .addImm(UsedRegMask >> 16);
 166
 167     BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORI), DstReg)
 168       .addReg(DstReg, RegState::Kill)
 169       .addImm(UsedRegMask & 0xFFFF);
 170   }
 171
 172   // Remove the old UPDATE_VRSAVE instruction.
 173   MI->eraseFromParent();
 174 }
 175
 176 static bool spillsCR(const MachineFunction &MF) {
 177   const PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
 178   return FuncInfo->isCRSpilled();
 179 }
 180
 181 static bool spillsVRSAVE(const MachineFunction &MF) {
 182   const PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
 183   return FuncInfo->isVRSAVESpilled();
 184 }
 185
 186 static bool hasSpills(const MachineFunction &MF) {
 187   const PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
 188   return FuncInfo->hasSpills();
 189 }
 190
 191 static bool hasNonRISpills(const MachineFunction &MF) {
 192   const PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
 193   return FuncInfo->hasNonRISpills();
 194 }
 195
 196 /// determineFrameLayout - Determine the size of the frame and maximum call
 197 /// frame size.
 198 unsigned PPCFrameLowering::determineFrameLayout(MachineFunction &MF,
 199                                                 bool UpdateMF,
 200                                                 bool UseEstimate) const {
 201   MachineFrameInfo *MFI = MF.getFrameInfo();
 202
 203   // Get the number of bytes to allocate from the FrameInfo
 204   unsigned FrameSize =
 205     UseEstimate ? MFI->estimateStackSize(MF) : MFI->getStackSize();
 206
 207   // Get stack alignments. The frame must be aligned to the greatest of these:
 208   unsigned TargetAlign = getStackAlignment(); // alignment required per the ABI
 209   unsigned MaxAlign = MFI->getMaxAlignment(); // algmt required by data in frame
 210   unsigned AlignMask = std::max(MaxAlign, TargetAlign) - 1;
 211
 212   const PPCRegisterInfo *RegInfo =
 213     static_cast<const PPCRegisterInfo*>(MF.getTarget().getRegisterInfo());
 214
 215   // If we are a leaf function, and use up to 224 bytes of stack space,
 216   // don't have a frame pointer, calls, or dynamic alloca then we do not need
 217   // to adjust the stack pointer (we fit in the Red Zone).
 218   // The 32-bit SVR4 ABI has no Red Zone. However, it can still generate
 219   // stackless code if all local vars are reg-allocated.
 220   bool DisableRedZone = MF.getFunction()->getAttributes().
 221     hasAttribute(AttributeSet::FunctionIndex, Attribute::NoRedZone);
 222   if (!DisableRedZone &&
 223       (Subtarget.isPPC64() ||                      // 32-bit SVR4, no stack-
 224        !Subtarget.isSVR4ABI() ||                   //   allocated locals.
 225         FrameSize == 0) &&
 226       FrameSize <= 224 &&                          // Fits in red zone.
 227       !MFI->hasVarSizedObjects() &&                // No dynamic alloca.
 228       !MFI->adjustsStack() &&                      // No calls.
 229       !RegInfo->hasBasePointer(MF)) { // No special alignment.
 230     // No need for frame
 231     if (UpdateMF)
 232       MFI->setStackSize(0);
 233     return 0;
 234   }
 235
 236   // Get the maximum call frame size of all the calls.
 237   unsigned maxCallFrameSize = MFI->getMaxCallFrameSize();
 238
 239   // Maximum call frame needs to be at least big enough for linkage and 8 args.
 240   unsigned minCallFrameSize = getMinCallFrameSize(Subtarget.isPPC64(),
 241                                                   Subtarget.isDarwinABI());
 242   maxCallFrameSize = std::max(maxCallFrameSize, minCallFrameSize);
 243
 244   // If we have dynamic alloca then maxCallFrameSize needs to be aligned so
 245   // that allocations will be aligned.
 246   if (MFI->hasVarSizedObjects())
 247     maxCallFrameSize = (maxCallFrameSize + AlignMask) & ~AlignMask;
 248
 249   // Update maximum call frame size.
 250   if (UpdateMF)
 251     MFI->setMaxCallFrameSize(maxCallFrameSize);
 252
 253   // Include call frame size in total.
 254   FrameSize += maxCallFrameSize;
 255
 256   // Make sure the frame is aligned.
 257   FrameSize = (FrameSize + AlignMask) & ~AlignMask;
 258
 259   // Update frame info.
 260   if (UpdateMF)
 261     MFI->setStackSize(FrameSize);
 262
 263   return FrameSize;
 264 }
 265
 266 // hasFP - Return true if the specified function actually has a dedicated frame
 267 // pointer register.
 268 bool PPCFrameLowering::hasFP(const MachineFunction &MF) const {
 269   const MachineFrameInfo *MFI = MF.getFrameInfo();
 270   // FIXME: This is pretty much broken by design: hasFP() might be called really
 271   // early, before the stack layout was calculated and thus hasFP() might return
 272   // true or false here depending on the time of call.
 273   return (MFI->getStackSize()) && needsFP(MF);
 274 }
 275
 276 // needsFP - Return true if the specified function should have a dedicated frame
 277 // pointer register.  This is true if the function has variable sized allocas or
 278 // if frame pointer elimination is disabled.
 279 bool PPCFrameLowering::needsFP(const MachineFunction &MF) const {
 280   const MachineFrameInfo *MFI = MF.getFrameInfo();
 281
 282   // Naked functions have no stack frame pushed, so we don't have a frame
 283   // pointer.
 284   if (MF.getFunction()->getAttributes().hasAttribute(
 285           AttributeSet::FunctionIndex, Attribute::Naked))
 286     return false;
 287
 288   return MF.getTarget().Options.DisableFramePointerElim(MF) ||
 289     MFI->hasVarSizedObjects() ||
 290     (MF.getTarget().Options.GuaranteedTailCallOpt &&
 291      MF.getInfo<PPCFunctionInfo>()->hasFastCall());
 292 }
 293
 294 void PPCFrameLowering::replaceFPWithRealFP(MachineFunction &MF) const {
 295   bool is31 = needsFP(MF);
 296   unsigned FPReg  = is31 ? PPC::R31 : PPC::R1;
 297   unsigned FP8Reg = is31 ? PPC::X31 : PPC::X1;
 298
 299   const PPCRegisterInfo *RegInfo =
 300     static_cast<const PPCRegisterInfo*>(MF.getTarget().getRegisterInfo());
 301   bool HasBP = RegInfo->hasBasePointer(MF);
 302   unsigned BPReg  = HasBP ? (unsigned) PPC::R30 : FPReg;
 303   unsigned BP8Reg = HasBP ? (unsigned) PPC::X30 : FPReg;
 304
 305   for (MachineFunction::iterator BI = MF.begin(), BE = MF.end();
 306        BI != BE; ++BI)
 307     for (MachineBasicBlock::iterator MBBI = BI->end(); MBBI != BI->begin(); ) {
 308       --MBBI;
 309       for (unsigned I = 0, E = MBBI->getNumOperands(); I != E; ++I) {
 310         MachineOperand &MO = MBBI->getOperand(I);
 311         if (!MO.isReg())
 312           continue;
 313
 314         switch (MO.getReg()) {
 315         case PPC::FP:
 316           MO.setReg(FPReg);
 317           break;
 318         case PPC::FP8:
 319           MO.setReg(FP8Reg);
 320           break;
 321         case PPC::BP:
 322           MO.setReg(BPReg);
 323           break;
 324         case PPC::BP8:
 325           MO.setReg(BP8Reg);
 326           break;
 327
 328         }
 329       }
 330     }
 331 }
 332
 333 void PPCFrameLowering::emitPrologue(MachineFunction &MF) const {
 334   MachineBasicBlock &MBB = MF.front();   // Prolog goes in entry BB
 335   MachineBasicBlock::iterator MBBI = MBB.begin();
 336   MachineFrameInfo *MFI = MF.getFrameInfo();
 337   const PPCInstrInfo &TII =
 338     *static_cast<const PPCInstrInfo*>(MF.getTarget().getInstrInfo());
 339   const PPCRegisterInfo *RegInfo =
 340     static_cast<const PPCRegisterInfo*>(MF.getTarget().getRegisterInfo());
 341
 342   MachineModuleInfo &MMI = MF.getMMI();
 343   const MCRegisterInfo *MRI = MMI.getContext().getRegisterInfo();
 344   DebugLoc dl;
 345   bool needsFrameMoves = MMI.hasDebugInfo() ||
 346     MF.getFunction()->needsUnwindTableEntry();
 347
 348   // Get processor type.
 349   bool isPPC64 = Subtarget.isPPC64();
 350   // Get the ABI.
 351   bool isDarwinABI = Subtarget.isDarwinABI();
 352   bool isSVR4ABI = Subtarget.isSVR4ABI();
 353   assert((isDarwinABI || isSVR4ABI) &&
 354          "Currently only Darwin and SVR4 ABIs are supported for PowerPC.");
 355
 356   // Scan the prolog, looking for an UPDATE_VRSAVE instruction.  If we find it,
 357   // process it.
 358   if (!isSVR4ABI)
 359     for (unsigned i = 0; MBBI != MBB.end(); ++i, ++MBBI) {
 360       if (MBBI->getOpcode() == PPC::UPDATE_VRSAVE) {
 361         HandleVRSaveUpdate(MBBI, TII);
 362         break;
 363       }
 364     }
 365
 366   // Move MBBI back to the beginning of the function.
 367   MBBI = MBB.begin();
 368
 369   // Work out frame sizes.
 370   unsigned FrameSize = determineFrameLayout(MF);
 371   int NegFrameSize = -FrameSize;
 372   if (!isInt<32>(NegFrameSize))
 373     llvm_unreachable("Unhandled stack size!");
 374
 375   if (MFI->isFrameAddressTaken())
 376     replaceFPWithRealFP(MF);
 377
 378   // Check if the link register (LR) must be saved.
 379   PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>();
 380   bool MustSaveLR = FI->mustSaveLR();
 381   const SmallVectorImpl<unsigned> &MustSaveCRs = FI->getMustSaveCRs();
 382   // Do we have a frame pointer and/or base pointer for this function?
 383   bool HasFP = hasFP(MF);
 384   bool HasBP = RegInfo->hasBasePointer(MF);
 385
 386   unsigned SPReg       = isPPC64 ? PPC::X1  : PPC::R1;
 387   unsigned BPReg       = isPPC64 ? PPC::X30 : PPC::R30;
 388   unsigned FPReg       = isPPC64 ? PPC::X31 : PPC::R31;
 389   unsigned LRReg       = isPPC64 ? PPC::LR8 : PPC::LR;
 390   unsigned ScratchReg  = isPPC64 ? PPC::X0  : PPC::R0;
 391   unsigned TempReg     = isPPC64 ? PPC::X12 : PPC::R12; // another scratch reg
 392   //  ...(R12/X12 is volatile in both Darwin & SVR4, & can't be a function arg.)
 393   const MCInstrDesc& MFLRInst = TII.get(isPPC64 ? PPC::MFLR8
 394                                                 : PPC::MFLR );
 395   const MCInstrDesc& StoreInst = TII.get(isPPC64 ? PPC::STD
 396                                                  : PPC::STW );
 397   const MCInstrDesc& StoreUpdtInst = TII.get(isPPC64 ? PPC::STDU
 398                                                      : PPC::STWU );
 399   const MCInstrDesc& StoreUpdtIdxInst = TII.get(isPPC64 ? PPC::STDUX
 400                                                         : PPC::STWUX);
 401   const MCInstrDesc& LoadImmShiftedInst = TII.get(isPPC64 ? PPC::LIS8
 402                                                           : PPC::LIS );
 403   const MCInstrDesc& OrImmInst = TII.get(isPPC64 ? PPC::ORI8
 404                                                  : PPC::ORI );
 405   const MCInstrDesc& OrInst = TII.get(isPPC64 ? PPC::OR8
 406                                               : PPC::OR );
 407   const MCInstrDesc& SubtractCarryingInst = TII.get(isPPC64 ? PPC::SUBFC8
 408                                                             : PPC::SUBFC);
 409   const MCInstrDesc& SubtractImmCarryingInst = TII.get(isPPC64 ? PPC::SUBFIC8
 410                                                                : PPC::SUBFIC);
 411
 412   // Regarding this assert: Even though LR is saved in the caller's frame (i.e.,
 413   // LROffset is positive), that slot is callee-owned. Because PPC32 SVR4 has no
 414   // Red Zone, an asynchronous event (a form of "callee") could claim a frame &
 415   // overwrite it, so PPC32 SVR4 must claim at least a minimal frame to save LR.
 416   assert((isPPC64 || !isSVR4ABI || !(!FrameSize && (MustSaveLR || HasFP))) &&
 417          "FrameSize must be >0 to save/restore the FP or LR for 32-bit SVR4.");
 418
 419   int LROffset = PPCFrameLowering::getReturnSaveOffset(isPPC64, isDarwinABI);
 420
 421   int FPOffset = 0;
 422   if (HasFP) {
 423     if (isSVR4ABI) {
 424       MachineFrameInfo *FFI = MF.getFrameInfo();
 425       int FPIndex = FI->getFramePointerSaveIndex();
 426       assert(FPIndex && "No Frame Pointer Save Slot!");
 427       FPOffset = FFI->getObjectOffset(FPIndex);
 428     } else {
 429       FPOffset =
 430           PPCFrameLowering::getFramePointerSaveOffset(isPPC64, isDarwinABI);
 431     }
 432   }
 433
 434   int BPOffset = 0;
 435   if (HasBP) {
 436     if (isSVR4ABI) {
 437       MachineFrameInfo *FFI = MF.getFrameInfo();
 438       int BPIndex = FI->getBasePointerSaveIndex();
 439       assert(BPIndex && "No Base Pointer Save Slot!");
 440       BPOffset = FFI->getObjectOffset(BPIndex);
 441     } else {
 442       BPOffset =
 443         PPCFrameLowering::getBasePointerSaveOffset(isPPC64, isDarwinABI);
 444     }
 445   }
 446
 447   // Get stack alignments.
 448   unsigned MaxAlign = MFI->getMaxAlignment();
 449   if (HasBP && MaxAlign > 1)
 450     assert(isPowerOf2_32(MaxAlign) && isInt<16>(MaxAlign) &&
 451            "Invalid alignment!");
 452
 453   // Frames of 32KB & larger require special handling because they cannot be
 454   // indexed into with a simple STDU/STWU/STD/STW immediate offset operand.
 455   bool isLargeFrame = !isInt<16>(NegFrameSize);
 456
 457   if (MustSaveLR)
 458     BuildMI(MBB, MBBI, dl, MFLRInst, ScratchReg);
 459
 460   assert((isPPC64 || MustSaveCRs.empty()) &&
 461          "Prologue CR saving supported only in 64-bit mode");
 462
 463   if (!MustSaveCRs.empty()) { // will only occur for PPC64
 464     MachineInstrBuilder MIB =
 465       BuildMI(MBB, MBBI, dl, TII.get(PPC::MFCR8), TempReg);
 466     for (unsigned i = 0, e = MustSaveCRs.size(); i != e; ++i)
 467       MIB.addReg(MustSaveCRs[i], RegState::ImplicitKill);
 468   }
 469
 470   if (HasFP)
 471     // FIXME: On PPC32 SVR4, we must not spill before claiming the stackframe.
 472     BuildMI(MBB, MBBI, dl, StoreInst)
 473       .addReg(FPReg)
 474       .addImm(FPOffset)
 475       .addReg(SPReg);
 476
 477   if (HasBP)
 478     // FIXME: On PPC32 SVR4, we must not spill before claiming the stackframe.
 479     BuildMI(MBB, MBBI, dl, StoreInst)
 480       .addReg(BPReg)
 481       .addImm(BPOffset)
 482       .addReg(SPReg);
 483
 484   if (MustSaveLR)
 485     // FIXME: On PPC32 SVR4, we must not spill before claiming the stackframe.
 486     BuildMI(MBB, MBBI, dl, StoreInst)
 487       .addReg(ScratchReg)
 488       .addImm(LROffset)
 489       .addReg(SPReg);
 490
 491   if (!MustSaveCRs.empty()) // will only occur for PPC64
 492     BuildMI(MBB, MBBI, dl, TII.get(PPC::STW8))
 493       .addReg(TempReg, getKillRegState(true))
 494       .addImm(8)
 495       .addReg(SPReg);
 496
 497   // Skip the rest if this is a leaf function & all spills fit in the Red Zone.
 498   if (!FrameSize) return;
 499
 500   // Adjust stack pointer: r1 += NegFrameSize.
 501   // If there is a preferred stack alignment, align R1 now
 502
 503   if (HasBP) {
 504     // Save a copy of r1 as the base pointer.
 505     BuildMI(MBB, MBBI, dl, OrInst, BPReg)
 506       .addReg(SPReg)
 507       .addReg(SPReg);
 508   }
 509
 510   if (HasBP && MaxAlign > 1) {
 511     if (isPPC64)
 512       BuildMI(MBB, MBBI, dl, TII.get(PPC::RLDICL), ScratchReg)
 513         .addReg(SPReg)
 514         .addImm(0)
 515         .addImm(64 - Log2_32(MaxAlign));
 516     else // PPC32...
 517       BuildMI(MBB, MBBI, dl, TII.get(PPC::RLWINM), ScratchReg)
 518         .addReg(SPReg)
 519         .addImm(0)
 520         .addImm(32 - Log2_32(MaxAlign))
 521         .addImm(31);
 522     if (!isLargeFrame) {
 523       BuildMI(MBB, MBBI, dl, SubtractImmCarryingInst, ScratchReg)
 524         .addReg(ScratchReg, RegState::Kill)
 525         .addImm(NegFrameSize);
 526     } else {
 527       BuildMI(MBB, MBBI, dl, LoadImmShiftedInst, TempReg)
 528         .addImm(NegFrameSize >> 16);
 529       BuildMI(MBB, MBBI, dl, OrImmInst, TempReg)
 530         .addReg(TempReg, RegState::Kill)
 531         .addImm(NegFrameSize & 0xFFFF);
 532       BuildMI(MBB, MBBI, dl, SubtractCarryingInst, ScratchReg)
 533         .addReg(ScratchReg, RegState::Kill)
 534         .addReg(TempReg, RegState::Kill);
 535     }
 536     BuildMI(MBB, MBBI, dl, StoreUpdtIdxInst, SPReg)
 537       .addReg(SPReg, RegState::Kill)
 538       .addReg(SPReg)
 539       .addReg(ScratchReg);
 540
 541   } else if (!isLargeFrame) {
 542     BuildMI(MBB, MBBI, dl, StoreUpdtInst, SPReg)
 543       .addReg(SPReg)
 544       .addImm(NegFrameSize)
 545       .addReg(SPReg);
 546
 547   } else {
 548     BuildMI(MBB, MBBI, dl, LoadImmShiftedInst, ScratchReg)
 549       .addImm(NegFrameSize >> 16);
 550     BuildMI(MBB, MBBI, dl, OrImmInst, ScratchReg)
 551       .addReg(ScratchReg, RegState::Kill)
 552       .addImm(NegFrameSize & 0xFFFF);
 553     BuildMI(MBB, MBBI, dl, StoreUpdtIdxInst, SPReg)
 554       .addReg(SPReg, RegState::Kill)
 555       .addReg(SPReg)
 556       .addReg(ScratchReg);
 557   }
 558
 559   // Add the "machine moves" for the instructions we generated above, but in
 560   // reverse order.
 561   if (needsFrameMoves) {
 562     // Show update of SP.
 563     assert(NegFrameSize);
 564     unsigned CFIIndex = MMI.addFrameInst(
 565         MCCFIInstruction::createDefCfaOffset(nullptr, NegFrameSize));
 566     BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 567         .addCFIIndex(CFIIndex);
 568
 569     if (HasFP) {
 570       unsigned Reg = MRI->getDwarfRegNum(FPReg, true);
 571       CFIIndex = MMI.addFrameInst(
 572           MCCFIInstruction::createOffset(nullptr, Reg, FPOffset));
 573       BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 574           .addCFIIndex(CFIIndex);
 575     }
 576
 577     if (HasBP) {
 578       unsigned Reg = MRI->getDwarfRegNum(BPReg, true);
 579       CFIIndex = MMI.addFrameInst(
 580           MCCFIInstruction::createOffset(nullptr, Reg, BPOffset));
 581       BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 582           .addCFIIndex(CFIIndex);
 583     }
 584
 585     if (MustSaveLR) {
 586       unsigned Reg = MRI->getDwarfRegNum(LRReg, true);
 587       CFIIndex = MMI.addFrameInst(
 588           MCCFIInstruction::createOffset(nullptr, Reg, LROffset));
 589       BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 590           .addCFIIndex(CFIIndex);
 591     }
 592   }
 593
 594   // If there is a frame pointer, copy R1 into R31
 595   if (HasFP) {
 596     BuildMI(MBB, MBBI, dl, OrInst, FPReg)
 597       .addReg(SPReg)
 598       .addReg(SPReg);
 599
 600     if (needsFrameMoves) {
 601       // Mark effective beginning of when frame pointer is ready.
 602       unsigned Reg = MRI->getDwarfRegNum(FPReg, true);
 603       unsigned CFIIndex = MMI.addFrameInst(
 604           MCCFIInstruction::createDefCfaRegister(nullptr, Reg));
 605
 606       BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 607           .addCFIIndex(CFIIndex);
 608     }
 609   }
 610
 611   if (needsFrameMoves) {
 612     // Add callee saved registers to move list.
 613     const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
 614     for (unsigned I = 0, E = CSI.size(); I != E; ++I) {
 615       unsigned Reg = CSI[I].getReg();
 616       if (Reg == PPC::LR || Reg == PPC::LR8 || Reg == PPC::RM) continue;
 617
 618       // This is a bit of a hack: CR2LT, CR2GT, CR2EQ and CR2UN are just
 619       // subregisters of CR2. We just need to emit a move of CR2.
 620       if (PPC::CRBITRCRegClass.contains(Reg))
 621         continue;
 622
 623       // For SVR4, don't emit a move for the CR spill slot if we haven't
 624       // spilled CRs.
 625       if (isSVR4ABI && (PPC::CR2 <= Reg && Reg <= PPC::CR4)
 626           && MustSaveCRs.empty())
 627         continue;
 628
 629       // For 64-bit SVR4 when we have spilled CRs, the spill location
 630       // is SP+8, not a frame-relative slot.
 631       if (isSVR4ABI && isPPC64 && (PPC::CR2 <= Reg && Reg <= PPC::CR4)) {
 632         unsigned CFIIndex = MMI.addFrameInst(MCCFIInstruction::createOffset(
 633             nullptr, MRI->getDwarfRegNum(PPC::CR2, true), 8));
 634         BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 635             .addCFIIndex(CFIIndex);
 636         continue;
 637       }
 638
 639       int Offset = MFI->getObjectOffset(CSI[I].getFrameIdx());
 640       unsigned CFIIndex = MMI.addFrameInst(MCCFIInstruction::createOffset(
 641           nullptr, MRI->getDwarfRegNum(Reg, true), Offset));
 642       BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
 643           .addCFIIndex(CFIIndex);
 644     }
 645   }
 646 }
 647
 648 void PPCFrameLowering::emitEpilogue(MachineFunction &MF,
 649                                 MachineBasicBlock &MBB) const {
 650   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
 651   assert(MBBI != MBB.end() && "Returning block has no terminator");
 652   const PPCInstrInfo &TII =
 653     *static_cast<const PPCInstrInfo*>(MF.getTarget().getInstrInfo());
 654   const PPCRegisterInfo *RegInfo =
 655     static_cast<const PPCRegisterInfo*>(MF.getTarget().getRegisterInfo());
 656
 657   unsigned RetOpcode = MBBI->getOpcode();
 658   DebugLoc dl;
 659
 660   assert((RetOpcode == PPC::BLR ||
 661           RetOpcode == PPC::TCRETURNri ||
 662           RetOpcode == PPC::TCRETURNdi ||
 663           RetOpcode == PPC::TCRETURNai ||
 664           RetOpcode == PPC::TCRETURNri8 ||
 665           RetOpcode == PPC::TCRETURNdi8 ||
 666           RetOpcode == PPC::TCRETURNai8) &&
 667          "Can only insert epilog into returning blocks");
 668
 669   // Get alignment info so we know how to restore the SP.
 670   const MachineFrameInfo *MFI = MF.getFrameInfo();
 671
 672   // Get the number of bytes allocated from the FrameInfo.
 673   int FrameSize = MFI->getStackSize();
 674
 675   // Get processor type.
 676   bool isPPC64 = Subtarget.isPPC64();
 677   // Get the ABI.
 678   bool isDarwinABI = Subtarget.isDarwinABI();
 679   bool isSVR4ABI = Subtarget.isSVR4ABI();
 680
 681   // Check if the link register (LR) has been saved.
 682   PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>();
 683   bool MustSaveLR = FI->mustSaveLR();
 684   const SmallVectorImpl<unsigned> &MustSaveCRs = FI->getMustSaveCRs();
 685   // Do we have a frame pointer and/or base pointer for this function?
 686   bool HasFP = hasFP(MF);
 687   bool HasBP = RegInfo->hasBasePointer(MF);
 688
 689   unsigned SPReg      = isPPC64 ? PPC::X1  : PPC::R1;
 690   unsigned BPReg      = isPPC64 ? PPC::X30 : PPC::R30;
 691   unsigned FPReg      = isPPC64 ? PPC::X31 : PPC::R31;
 692   unsigned ScratchReg  = isPPC64 ? PPC::X0  : PPC::R0;
 693   unsigned TempReg     = isPPC64 ? PPC::X12 : PPC::R12; // another scratch reg
 694   const MCInstrDesc& MTLRInst = TII.get( isPPC64 ? PPC::MTLR8
 695                                                  : PPC::MTLR );
 696   const MCInstrDesc& LoadInst = TII.get( isPPC64 ? PPC::LD
 697                                                  : PPC::LWZ );
 698   const MCInstrDesc& LoadImmShiftedInst = TII.get( isPPC64 ? PPC::LIS8
 699                                                            : PPC::LIS );
 700   const MCInstrDesc& OrImmInst = TII.get( isPPC64 ? PPC::ORI8
 701                                                   : PPC::ORI );
 702   const MCInstrDesc& AddImmInst = TII.get( isPPC64 ? PPC::ADDI8
 703                                                    : PPC::ADDI );
 704   const MCInstrDesc& AddInst = TII.get( isPPC64 ? PPC::ADD8
 705                                                 : PPC::ADD4 );
 706
 707   int LROffset = PPCFrameLowering::getReturnSaveOffset(isPPC64, isDarwinABI);
 708
 709   int FPOffset = 0;
 710   if (HasFP) {
 711     if (isSVR4ABI) {
 712       MachineFrameInfo *FFI = MF.getFrameInfo();
 713       int FPIndex = FI->getFramePointerSaveIndex();
 714       assert(FPIndex && "No Frame Pointer Save Slot!");
 715       FPOffset = FFI->getObjectOffset(FPIndex);
 716     } else {
 717       FPOffset =
 718           PPCFrameLowering::getFramePointerSaveOffset(isPPC64, isDarwinABI);
 719     }
 720   }
 721
 722   int BPOffset = 0;
 723   if (HasBP) {
 724     if (isSVR4ABI) {
 725       MachineFrameInfo *FFI = MF.getFrameInfo();
 726       int BPIndex = FI->getBasePointerSaveIndex();
 727       assert(BPIndex && "No Base Pointer Save Slot!");
 728       BPOffset = FFI->getObjectOffset(BPIndex);
 729     } else {
 730       BPOffset =
 731         PPCFrameLowering::getBasePointerSaveOffset(isPPC64, isDarwinABI);
 732     }
 733   }
 734
 735   bool UsesTCRet =  RetOpcode == PPC::TCRETURNri ||
 736     RetOpcode == PPC::TCRETURNdi ||
 737     RetOpcode == PPC::TCRETURNai ||
 738     RetOpcode == PPC::TCRETURNri8 ||
 739     RetOpcode == PPC::TCRETURNdi8 ||
 740     RetOpcode == PPC::TCRETURNai8;
 741
 742   if (UsesTCRet) {
 743     int MaxTCRetDelta = FI->getTailCallSPDelta();
 744     MachineOperand &StackAdjust = MBBI->getOperand(1);
 745     assert(StackAdjust.isImm() && "Expecting immediate value.");
 746     // Adjust stack pointer.
 747     int StackAdj = StackAdjust.getImm();
 748     int Delta = StackAdj - MaxTCRetDelta;
 749     assert((Delta >= 0) && "Delta must be positive");
 750     if (MaxTCRetDelta>0)
 751       FrameSize += (StackAdj +Delta);
 752     else
 753       FrameSize += StackAdj;
 754   }
 755
 756   // Frames of 32KB & larger require special handling because they cannot be
 757   // indexed into with a simple LD/LWZ immediate offset operand.
 758   bool isLargeFrame = !isInt<16>(FrameSize);
 759
 760   if (FrameSize) {
 761     // In the prologue, the loaded (or persistent) stack pointer value is offset
 762     // by the STDU/STDUX/STWU/STWUX instruction.  Add this offset back now.
 763
 764     // If this function contained a fastcc call and GuaranteedTailCallOpt is
 765     // enabled (=> hasFastCall()==true) the fastcc call might contain a tail
 766     // call which invalidates the stack pointer value in SP(0). So we use the
 767     // value of R31 in this case.
 768     if (FI->hasFastCall()) {
 769       assert(HasFP && "Expecting a valid frame pointer.");
 770       if (!isLargeFrame) {
 771         BuildMI(MBB, MBBI, dl, AddImmInst, SPReg)
 772           .addReg(FPReg).addImm(FrameSize);
 773       } else {
 774         BuildMI(MBB, MBBI, dl, LoadImmShiftedInst, ScratchReg)
 775           .addImm(FrameSize >> 16);
 776         BuildMI(MBB, MBBI, dl, OrImmInst, ScratchReg)
 777           .addReg(ScratchReg, RegState::Kill)
 778           .addImm(FrameSize & 0xFFFF);
 779         BuildMI(MBB, MBBI, dl, AddInst)
 780           .addReg(SPReg)
 781           .addReg(FPReg)
 782           .addReg(ScratchReg);
 783       }
 784     } else if (!isLargeFrame && !HasBP && !MFI->hasVarSizedObjects()) {
 785       BuildMI(MBB, MBBI, dl, AddImmInst, SPReg)
 786         .addReg(SPReg)
 787         .addImm(FrameSize);
 788     } else {
 789       BuildMI(MBB, MBBI, dl, LoadInst, SPReg)
 790         .addImm(0)
 791         .addReg(SPReg);
 792     }
 793
 794   }
 795
 796   if (MustSaveLR)
 797     BuildMI(MBB, MBBI, dl, LoadInst, ScratchReg)
 798       .addImm(LROffset)
 799       .addReg(SPReg);
 800
 801   assert((isPPC64 || MustSaveCRs.empty()) &&
 802          "Epilogue CR restoring supported only in 64-bit mode");
 803
 804   if (!MustSaveCRs.empty()) // will only occur for PPC64
 805     BuildMI(MBB, MBBI, dl, TII.get(PPC::LWZ8), TempReg)
 806       .addImm(8)
 807       .addReg(SPReg);
 808
 809   if (HasFP)
 810     BuildMI(MBB, MBBI, dl, LoadInst, FPReg)
 811       .addImm(FPOffset)
 812       .addReg(SPReg);
 813
 814   if (HasBP)
 815     BuildMI(MBB, MBBI, dl, LoadInst, BPReg)
 816       .addImm(BPOffset)
 817       .addReg(SPReg);
 818
 819   if (!MustSaveCRs.empty()) // will only occur for PPC64
 820     for (unsigned i = 0, e = MustSaveCRs.size(); i != e; ++i)
 821       BuildMI(MBB, MBBI, dl, TII.get(PPC::MTOCRF8), MustSaveCRs[i])
 822         .addReg(TempReg, getKillRegState(i == e-1));
 823
 824   if (MustSaveLR)
 825     BuildMI(MBB, MBBI, dl, MTLRInst).addReg(ScratchReg);
 826
 827   // Callee pop calling convention. Pop parameter/linkage area. Used for tail
 828   // call optimization
 829   if (MF.getTarget().Options.GuaranteedTailCallOpt && RetOpcode == PPC::BLR &&
 830       MF.getFunction()->getCallingConv() == CallingConv::Fast) {
 831      PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>();
 832      unsigned CallerAllocatedAmt = FI->getMinReservedArea();
 833
 834      if (CallerAllocatedAmt && isInt<16>(CallerAllocatedAmt)) {
 835        BuildMI(MBB, MBBI, dl, AddImmInst, SPReg)
 836          .addReg(SPReg).addImm(CallerAllocatedAmt);
 837      } else {
 838        BuildMI(MBB, MBBI, dl, LoadImmShiftedInst, ScratchReg)
 839           .addImm(CallerAllocatedAmt >> 16);
 840        BuildMI(MBB, MBBI, dl, OrImmInst, ScratchReg)
 841           .addReg(ScratchReg, RegState::Kill)
 842           .addImm(CallerAllocatedAmt & 0xFFFF);
 843        BuildMI(MBB, MBBI, dl, AddInst)
 844           .addReg(SPReg)
 845           .addReg(FPReg)
 846           .addReg(ScratchReg);
 847      }
 848   } else if (RetOpcode == PPC::TCRETURNdi) {
 849     MBBI = MBB.getLastNonDebugInstr();
 850     MachineOperand &JumpTarget = MBBI->getOperand(0);
 851     BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILB)).
 852       addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset());
 853   } else if (RetOpcode == PPC::TCRETURNri) {
 854     MBBI = MBB.getLastNonDebugInstr();
 855     assert(MBBI->getOperand(0).isReg() && "Expecting register operand.");
 856     BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILBCTR));
 857   } else if (RetOpcode == PPC::TCRETURNai) {
 858     MBBI = MBB.getLastNonDebugInstr();
 859     MachineOperand &JumpTarget = MBBI->getOperand(0);
 860     BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILBA)).addImm(JumpTarget.getImm());
 861   } else if (RetOpcode == PPC::TCRETURNdi8) {
 862     MBBI = MBB.getLastNonDebugInstr();
 863     MachineOperand &JumpTarget = MBBI->getOperand(0);
 864     BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILB8)).
 865       addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset());
 866   } else if (RetOpcode == PPC::TCRETURNri8) {
 867     MBBI = MBB.getLastNonDebugInstr();
 868     assert(MBBI->getOperand(0).isReg() && "Expecting register operand.");
 869     BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILBCTR8));
 870   } else if (RetOpcode == PPC::TCRETURNai8) {
 871     MBBI = MBB.getLastNonDebugInstr();
 872     MachineOperand &JumpTarget = MBBI->getOperand(0);
 873     BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILBA8)).addImm(JumpTarget.getImm());
 874   }
 875 }
 876
 877 /// MustSaveLR - Return true if this function requires that we save the LR
 878 /// register onto the stack in the prolog and restore it in the epilog of the
 879 /// function.
 880 static bool MustSaveLR(const MachineFunction &MF, unsigned LR) {
 881   const PPCFunctionInfo *MFI = MF.getInfo<PPCFunctionInfo>();
 882
 883   // We need a save/restore of LR if there is any def of LR (which is
 884   // defined by calls, including the PIC setup sequence), or if there is
 885   // some use of the LR stack slot (e.g. for builtin_return_address).
 886   // (LR comes in 32 and 64 bit versions.)
 887   MachineRegisterInfo::def_iterator RI = MF.getRegInfo().def_begin(LR);
 888   return RI !=MF.getRegInfo().def_end() || MFI->isLRStoreRequired();
 889 }
 890
 891 void
 892 PPCFrameLowering::processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
 893                                                    RegScavenger *) const {
 894   const PPCRegisterInfo *RegInfo =
 895     static_cast<const PPCRegisterInfo*>(MF.getTarget().getRegisterInfo());
 896
 897   //  Save and clear the LR state.
 898   PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>();
 899   unsigned LR = RegInfo->getRARegister();
 900   FI->setMustSaveLR(MustSaveLR(MF, LR));
 901   MachineRegisterInfo &MRI = MF.getRegInfo();
 902   MRI.setPhysRegUnused(LR);
 903
 904   //  Save R31 if necessary
 905   int FPSI = FI->getFramePointerSaveIndex();
 906   bool isPPC64 = Subtarget.isPPC64();
 907   bool isDarwinABI  = Subtarget.isDarwinABI();
 908   MachineFrameInfo *MFI = MF.getFrameInfo();
 909
 910   // If the frame pointer save index hasn't been defined yet.
 911   if (!FPSI && needsFP(MF)) {
 912     // Find out what the fix offset of the frame pointer save area.
 913     int FPOffset = getFramePointerSaveOffset(isPPC64, isDarwinABI);
 914     // Allocate the frame index for frame pointer save area.
 915     FPSI = MFI->CreateFixedObject(isPPC64? 8 : 4, FPOffset, true);
 916     // Save the result.
 917     FI->setFramePointerSaveIndex(FPSI);
 918   }
 919
 920   int BPSI = FI->getBasePointerSaveIndex();
 921   if (!BPSI && RegInfo->hasBasePointer(MF)) {
 922     int BPOffset = getBasePointerSaveOffset(isPPC64, isDarwinABI);
 923     // Allocate the frame index for the base pointer save area.
 924     BPSI = MFI->CreateFixedObject(isPPC64? 8 : 4, BPOffset, true);
 925     // Save the result.
 926     FI->setBasePointerSaveIndex(BPSI);
 927   }
 928
 929   // Reserve stack space to move the linkage area to in case of a tail call.
 930   int TCSPDelta = 0;
 931   if (MF.getTarget().Options.GuaranteedTailCallOpt &&
 932       (TCSPDelta = FI->getTailCallSPDelta()) < 0) {
 933     MFI->CreateFixedObject(-1 * TCSPDelta, TCSPDelta, true);
 934   }
 935
 936   // For 32-bit SVR4, allocate the nonvolatile CR spill slot iff the
 937   // function uses CR 2, 3, or 4.
 938   if (!isPPC64 && !isDarwinABI &&
 939       (MRI.isPhysRegUsed(PPC::CR2) ||
 940        MRI.isPhysRegUsed(PPC::CR3) ||
 941        MRI.isPhysRegUsed(PPC::CR4))) {
 942     int FrameIdx = MFI->CreateFixedObject((uint64_t)4, (int64_t)-4, true);
 943     FI->setCRSpillFrameIndex(FrameIdx);
 944   }
 945 }
 946
 947 void PPCFrameLowering::processFunctionBeforeFrameFinalized(MachineFunction &MF,
 948                                                        RegScavenger *RS) const {
 949   // Early exit if not using the SVR4 ABI.
 950   if (!Subtarget.isSVR4ABI()) {
 951     addScavengingSpillSlot(MF, RS);
 952     return;
 953   }
 954
 955   // Get callee saved register information.
 956   MachineFrameInfo *FFI = MF.getFrameInfo();
 957   const std::vector<CalleeSavedInfo> &CSI = FFI->getCalleeSavedInfo();
 958
 959   // Early exit if no callee saved registers are modified!
 960   if (CSI.empty() && !needsFP(MF)) {
 961     addScavengingSpillSlot(MF, RS);
 962     return;
 963   }
 964
 965   unsigned MinGPR = PPC::R31;
 966   unsigned MinG8R = PPC::X31;
 967   unsigned MinFPR = PPC::F31;
 968   unsigned MinVR = PPC::V31;
 969
 970   bool HasGPSaveArea = false;
 971   bool HasG8SaveArea = false;
 972   bool HasFPSaveArea = false;
 973   bool HasVRSAVESaveArea = false;
 974   bool HasVRSaveArea = false;
 975
 976   SmallVector<CalleeSavedInfo, 18> GPRegs;
 977   SmallVector<CalleeSavedInfo, 18> G8Regs;
 978   SmallVector<CalleeSavedInfo, 18> FPRegs;
 979   SmallVector<CalleeSavedInfo, 18> VRegs;
 980
 981   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 982     unsigned Reg = CSI[i].getReg();
 983     if (PPC::GPRCRegClass.contains(Reg)) {
 984       HasGPSaveArea = true;
 985
 986       GPRegs.push_back(CSI[i]);
 987
 988       if (Reg < MinGPR) {
 989         MinGPR = Reg;
 990       }
 991     } else if (PPC::G8RCRegClass.contains(Reg)) {
 992       HasG8SaveArea = true;
 993
 994       G8Regs.push_back(CSI[i]);
 995
 996       if (Reg < MinG8R) {
 997         MinG8R = Reg;
 998       }
 999     } else if (PPC::F8RCRegClass.contains(Reg)) {
1000       HasFPSaveArea = true;
1001
1002       FPRegs.push_back(CSI[i]);
1003
1004       if (Reg < MinFPR) {
1005         MinFPR = Reg;
1006       }
1007     } else if (PPC::CRBITRCRegClass.contains(Reg) ||
1008                PPC::CRRCRegClass.contains(Reg)) {
1009       ; // do nothing, as we already know whether CRs are spilled
1010     } else if (PPC::VRSAVERCRegClass.contains(Reg)) {
1011       HasVRSAVESaveArea = true;
1012     } else if (PPC::VRRCRegClass.contains(Reg)) {
1013       HasVRSaveArea = true;
1014
1015       VRegs.push_back(CSI[i]);
1016
1017       if (Reg < MinVR) {
1018         MinVR = Reg;
1019       }
1020     } else {
1021       llvm_unreachable("Unknown RegisterClass!");
1022     }
1023   }
1024
1025   PPCFunctionInfo *PFI = MF.getInfo<PPCFunctionInfo>();
1026   const TargetRegisterInfo *TRI = MF.getTarget().getRegisterInfo();
1027
1028   int64_t LowerBound = 0;
1029
1030   // Take into account stack space reserved for tail calls.
1031   int TCSPDelta = 0;
1032   if (MF.getTarget().Options.GuaranteedTailCallOpt &&
1033       (TCSPDelta = PFI->getTailCallSPDelta()) < 0) {
1034     LowerBound = TCSPDelta;
1035   }
1036
1037   // The Floating-point register save area is right below the back chain word
1038   // of the previous stack frame.
1039   if (HasFPSaveArea) {
1040     for (unsigned i = 0, e = FPRegs.size(); i != e; ++i) {
1041       int FI = FPRegs[i].getFrameIdx();
1042
1043       FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI));
1044     }
1045
1046     LowerBound -= (31 - TRI->getEncodingValue(MinFPR) + 1) * 8;
1047   }
1048
1049   // Check whether the frame pointer register is allocated. If so, make sure it
1050   // is spilled to the correct offset.
1051   if (needsFP(MF)) {
1052     HasGPSaveArea = true;
1053
1054     int FI = PFI->getFramePointerSaveIndex();
1055     assert(FI && "No Frame Pointer Save Slot!");
1056
1057     FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI));
1058   }
1059
1060   const PPCRegisterInfo *RegInfo =
1061     static_cast<const PPCRegisterInfo*>(MF.getTarget().getRegisterInfo());
1062   if (RegInfo->hasBasePointer(MF)) {
1063     HasGPSaveArea = true;
1064
1065     int FI = PFI->getBasePointerSaveIndex();
1066     assert(FI && "No Base Pointer Save Slot!");
1067
1068     FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI));
1069   }
1070
1071   // General register save area starts right below the Floating-point
1072   // register save area.
1073   if (HasGPSaveArea || HasG8SaveArea) {
1074     // Move general register save area spill slots down, taking into account
1075     // the size of the Floating-point register save area.
1076     for (unsigned i = 0, e = GPRegs.size(); i != e; ++i) {
1077       int FI = GPRegs[i].getFrameIdx();
1078
1079       FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI));
1080     }
1081
1082     // Move general register save area spill slots down, taking into account
1083     // the size of the Floating-point register save area.
1084     for (unsigned i = 0, e = G8Regs.size(); i != e; ++i) {
1085       int FI = G8Regs[i].getFrameIdx();
1086
1087       FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI));
1088     }
1089
1090     unsigned MinReg =
1091       std::min<unsigned>(TRI->getEncodingValue(MinGPR),
1092                          TRI->getEncodingValue(MinG8R));
1093
1094     if (Subtarget.isPPC64()) {
1095       LowerBound -= (31 - MinReg + 1) * 8;
1096     } else {
1097       LowerBound -= (31 - MinReg + 1) * 4;
1098     }
1099   }
1100
1101   // For 32-bit only, the CR save area is below the general register
1102   // save area.  For 64-bit SVR4, the CR save area is addressed relative
1103   // to the stack pointer and hence does not need an adjustment here.
1104   // Only CR2 (the first nonvolatile spilled) has an associated frame
1105   // index so that we have a single uniform save area.
1106   if (spillsCR(MF) && !(Subtarget.isPPC64() && Subtarget.isSVR4ABI())) {
1107     // Adjust the frame index of the CR spill slot.
1108     for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
1109       unsigned Reg = CSI[i].getReg();
1110
1111       if ((Subtarget.isSVR4ABI() && Reg == PPC::CR2)
1112           // Leave Darwin logic as-is.
1113           || (!Subtarget.isSVR4ABI() &&
1114               (PPC::CRBITRCRegClass.contains(Reg) ||
1115                PPC::CRRCRegClass.contains(Reg)))) {
1116         int FI = CSI[i].getFrameIdx();
1117
1118         FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI));
1119       }
1120     }
1121
1122     LowerBound -= 4; // The CR save area is always 4 bytes long.
1123   }
1124
1125   if (HasVRSAVESaveArea) {
1126     // FIXME SVR4: Is it actually possible to have multiple elements in CSI
1127     //             which have the VRSAVE register class?
1128     // Adjust the frame index of the VRSAVE spill slot.
1129     for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
1130       unsigned Reg = CSI[i].getReg();
1131
1132       if (PPC::VRSAVERCRegClass.contains(Reg)) {
1133         int FI = CSI[i].getFrameIdx();
1134
1135         FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI));
1136       }
1137     }
1138
1139     LowerBound -= 4; // The VRSAVE save area is always 4 bytes long.
1140   }
1141
1142   if (HasVRSaveArea) {
1143     // Insert alignment padding, we need 16-byte alignment.
1144     LowerBound = (LowerBound - 15) & ~(15);
1145
1146     for (unsigned i = 0, e = VRegs.size(); i != e; ++i) {
1147       int FI = VRegs[i].getFrameIdx();
1148
1149       FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI));
1150     }
1151   }
1152
1153   addScavengingSpillSlot(MF, RS);
1154 }
1155
1156 void
1157 PPCFrameLowering::addScavengingSpillSlot(MachineFunction &MF,
1158                                          RegScavenger *RS) const {
1159   // Reserve a slot closest to SP or frame pointer if we have a dynalloc or
1160   // a large stack, which will require scavenging a register to materialize a
1161   // large offset.
1162
1163   // We need to have a scavenger spill slot for spills if the frame size is
1164   // large. In case there is no free register for large-offset addressing,
1165   // this slot is used for the necessary emergency spill. Also, we need the
1166   // slot for dynamic stack allocations.
1167
1168   // The scavenger might be invoked if the frame offset does not fit into
1169   // the 16-bit immediate. We don't know the complete frame size here
1170   // because we've not yet computed callee-saved register spills or the
1171   // needed alignment padding.
1172   unsigned StackSize = determineFrameLayout(MF, false, true);
1173   MachineFrameInfo *MFI = MF.getFrameInfo();
1174   if (MFI->hasVarSizedObjects() || spillsCR(MF) || spillsVRSAVE(MF) ||
1175       hasNonRISpills(MF) || (hasSpills(MF) && !isInt<16>(StackSize))) {
1176     const TargetRegisterClass *GPRC = &PPC::GPRCRegClass;
1177     const TargetRegisterClass *G8RC = &PPC::G8RCRegClass;
1178     const TargetRegisterClass *RC = Subtarget.isPPC64() ? G8RC : GPRC;
1179     RS->addScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(),
1180                                                        RC->getAlignment(),
1181                                                        false));
1182
1183     // Might we have over-aligned allocas?
1184     bool HasAlVars = MFI->hasVarSizedObjects() &&
1185                      MFI->getMaxAlignment() > getStackAlignment();
1186
1187     // These kinds of spills might need two registers.
1188     if (spillsCR(MF) || spillsVRSAVE(MF) || HasAlVars)
1189       RS->addScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(),
1190                                                          RC->getAlignment(),
1191                                                          false));
1192
1193   }
1194 }
1195
1196 bool
1197 PPCFrameLowering::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
1198                                      MachineBasicBlock::iterator MI,
1199                                      const std::vector<CalleeSavedInfo> &CSI,
1200                                      const TargetRegisterInfo *TRI) const {
1201
1202   // Currently, this function only handles SVR4 32- and 64-bit ABIs.
1203   // Return false otherwise to maintain pre-existing behavior.
1204   if (!Subtarget.isSVR4ABI())
1205     return false;
1206
1207   MachineFunction *MF = MBB.getParent();
1208   const PPCInstrInfo &TII =
1209     *static_cast<const PPCInstrInfo*>(MF->getTarget().getInstrInfo());
1210   DebugLoc DL;
1211   bool CRSpilled = false;
1212   MachineInstrBuilder CRMIB;
1213
1214   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
1215     unsigned Reg = CSI[i].getReg();
1216     // Only Darwin actually uses the VRSAVE register, but it can still appear
1217     // here if, for example, @llvm.eh.unwind.init() is used.  If we're not on
1218     // Darwin, ignore it.
1219     if (Reg == PPC::VRSAVE && !Subtarget.isDarwinABI())
1220       continue;
1221
1222     // CR2 through CR4 are the nonvolatile CR fields.
1223     bool IsCRField = PPC::CR2 <= Reg && Reg <= PPC::CR4;
1224
1225     // Add the callee-saved register as live-in; it's killed at the spill.
1226     MBB.addLiveIn(Reg);
1227
1228     if (CRSpilled && IsCRField) {
1229       CRMIB.addReg(Reg, RegState::ImplicitKill);
1230       continue;
1231     }
1232
1233     // Insert the spill to the stack frame.
1234     if (IsCRField) {
1235       PPCFunctionInfo *FuncInfo = MF->getInfo<PPCFunctionInfo>();
1236       if (Subtarget.isPPC64()) {
1237         // The actual spill will happen at the start of the prologue.
1238         FuncInfo->addMustSaveCR(Reg);
1239       } else {
1240         CRSpilled = true;
1241         FuncInfo->setSpillsCR();
1242
1243         // 32-bit:  FP-relative.  Note that we made sure CR2-CR4 all have
1244         // the same frame index in PPCRegisterInfo::hasReservedSpillSlot.
1245         CRMIB = BuildMI(*MF, DL, TII.get(PPC::MFCR), PPC::R12)
1246                   .addReg(Reg, RegState::ImplicitKill);
1247
1248         MBB.insert(MI, CRMIB);
1249         MBB.insert(MI, addFrameReference(BuildMI(*MF, DL, TII.get(PPC::STW))
1250                                          .addReg(PPC::R12,
1251                                                  getKillRegState(true)),
1252                                          CSI[i].getFrameIdx()));
1253       }
1254     } else {
1255       const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
1256       TII.storeRegToStackSlot(MBB, MI, Reg, true,
1257                               CSI[i].getFrameIdx(), RC, TRI);
1258     }
1259   }
1260   return true;
1261 }
1262
1263 static void
1264 restoreCRs(bool isPPC64, bool is31,
1265            bool CR2Spilled, bool CR3Spilled, bool CR4Spilled,
1266            MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
1267            const std::vector<CalleeSavedInfo> &CSI, unsigned CSIIndex) {
1268
1269   MachineFunction *MF = MBB.getParent();
1270   const PPCInstrInfo &TII =
1271     *static_cast<const PPCInstrInfo*>(MF->getTarget().getInstrInfo());
1272   DebugLoc DL;
1273   unsigned RestoreOp, MoveReg;
1274
1275   if (isPPC64)
1276     // This is handled during epilogue generation.
1277     return;
1278   else {
1279     // 32-bit:  FP-relative
1280     MBB.insert(MI, addFrameReference(BuildMI(*MF, DL, TII.get(PPC::LWZ),
1281                                              PPC::R12),
1282                                      CSI[CSIIndex].getFrameIdx()));
1283     RestoreOp = PPC::MTOCRF;
1284     MoveReg = PPC::R12;
1285   }
1286
1287   if (CR2Spilled)
1288     MBB.insert(MI, BuildMI(*MF, DL, TII.get(RestoreOp), PPC::CR2)
1289                .addReg(MoveReg, getKillRegState(!CR3Spilled && !CR4Spilled)));
1290
1291   if (CR3Spilled)
1292     MBB.insert(MI, BuildMI(*MF, DL, TII.get(RestoreOp), PPC::CR3)
1293                .addReg(MoveReg, getKillRegState(!CR4Spilled)));
1294
1295   if (CR4Spilled)
1296     MBB.insert(MI, BuildMI(*MF, DL, TII.get(RestoreOp), PPC::CR4)
1297                .addReg(MoveReg, getKillRegState(true)));
1298 }
1299
1300 void PPCFrameLowering::
1301 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
1302                               MachineBasicBlock::iterator I) const {
1303   const PPCInstrInfo &TII =
1304     *static_cast<const PPCInstrInfo*>(MF.getTarget().getInstrInfo());
1305   if (MF.getTarget().Options.GuaranteedTailCallOpt &&
1306       I->getOpcode() == PPC::ADJCALLSTACKUP) {
1307     // Add (actually subtract) back the amount the callee popped on return.
1308     if (int CalleeAmt =  I->getOperand(1).getImm()) {
1309       bool is64Bit = Subtarget.isPPC64();
1310       CalleeAmt *= -1;
1311       unsigned StackReg = is64Bit ? PPC::X1 : PPC::R1;
1312       unsigned TmpReg = is64Bit ? PPC::X0 : PPC::R0;
1313       unsigned ADDIInstr = is64Bit ? PPC::ADDI8 : PPC::ADDI;
1314       unsigned ADDInstr = is64Bit ? PPC::ADD8 : PPC::ADD4;
1315       unsigned LISInstr = is64Bit ? PPC::LIS8 : PPC::LIS;
1316       unsigned ORIInstr = is64Bit ? PPC::ORI8 : PPC::ORI;
1317       MachineInstr *MI = I;
1318       DebugLoc dl = MI->getDebugLoc();
1319
1320       if (isInt<16>(CalleeAmt)) {
1321         BuildMI(MBB, I, dl, TII.get(ADDIInstr), StackReg)
1322           .addReg(StackReg, RegState::Kill)
1323           .addImm(CalleeAmt);
1324       } else {
1325         MachineBasicBlock::iterator MBBI = I;
1326         BuildMI(MBB, MBBI, dl, TII.get(LISInstr), TmpReg)
1327           .addImm(CalleeAmt >> 16);
1328         BuildMI(MBB, MBBI, dl, TII.get(ORIInstr), TmpReg)
1329           .addReg(TmpReg, RegState::Kill)
1330           .addImm(CalleeAmt & 0xFFFF);
1331         BuildMI(MBB, MBBI, dl, TII.get(ADDInstr), StackReg)
1332           .addReg(StackReg, RegState::Kill)
1333           .addReg(TmpReg);
1334       }
1335     }
1336   }
1337   // Simply discard ADJCALLSTACKDOWN, ADJCALLSTACKUP instructions.
1338   MBB.erase(I);
1339 }
1340
1341 bool
1342 PPCFrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
1343                                         MachineBasicBlock::iterator MI,
1344                                         const std::vector<CalleeSavedInfo> &CSI,
1345                                         const TargetRegisterInfo *TRI) const {
1346
1347   // Currently, this function only handles SVR4 32- and 64-bit ABIs.
1348   // Return false otherwise to maintain pre-existing behavior.
1349   if (!Subtarget.isSVR4ABI())
1350     return false;
1351
1352   MachineFunction *MF = MBB.getParent();
1353   const PPCInstrInfo &TII =
1354     *static_cast<const PPCInstrInfo*>(MF->getTarget().getInstrInfo());
1355   bool CR2Spilled = false;
1356   bool CR3Spilled = false;
1357   bool CR4Spilled = false;
1358   unsigned CSIIndex = 0;
1359
1360   // Initialize insertion-point logic; we will be restoring in reverse
1361   // order of spill.
1362   MachineBasicBlock::iterator I = MI, BeforeI = I;
1363   bool AtStart = I == MBB.begin();
1364
1365   if (!AtStart)
1366     --BeforeI;
1367
1368   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
1369     unsigned Reg = CSI[i].getReg();
1370
1371     // Only Darwin actually uses the VRSAVE register, but it can still appear
1372     // here if, for example, @llvm.eh.unwind.init() is used.  If we're not on
1373     // Darwin, ignore it.
1374     if (Reg == PPC::VRSAVE && !Subtarget.isDarwinABI())
1375       continue;
1376
1377     if (Reg == PPC::CR2) {
1378       CR2Spilled = true;
1379       // The spill slot is associated only with CR2, which is the
1380       // first nonvolatile spilled.  Save it here.
1381       CSIIndex = i;
1382       continue;
1383     } else if (Reg == PPC::CR3) {
1384       CR3Spilled = true;
1385       continue;
1386     } else if (Reg == PPC::CR4) {
1387       CR4Spilled = true;
1388       continue;
1389     } else {
1390       // When we first encounter a non-CR register after seeing at
1391       // least one CR register, restore all spilled CRs together.
1392       if ((CR2Spilled || CR3Spilled || CR4Spilled)
1393           && !(PPC::CR2 <= Reg && Reg <= PPC::CR4)) {
1394         bool is31 = needsFP(*MF);
1395         restoreCRs(Subtarget.isPPC64(), is31,
1396                    CR2Spilled, CR3Spilled, CR4Spilled,
1397                    MBB, I, CSI, CSIIndex);
1398         CR2Spilled = CR3Spilled = CR4Spilled = false;
1399       }
1400
1401       // Default behavior for non-CR saves.
1402       const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
1403       TII.loadRegFromStackSlot(MBB, I, Reg, CSI[i].getFrameIdx(),
1404                                RC, TRI);
1405       assert(I != MBB.begin() &&
1406              "loadRegFromStackSlot didn't insert any code!");
1407       }
1408
1409     // Insert in reverse order.
1410     if (AtStart)
1411       I = MBB.begin();
1412     else {
1413       I = BeforeI;
1414       ++I;
1415     }
1416   }
1417
1418   // If we haven't yet spilled the CRs, do so now.
1419   if (CR2Spilled || CR3Spilled || CR4Spilled) {
1420     bool is31 = needsFP(*MF);
1421     restoreCRs(Subtarget.isPPC64(), is31, CR2Spilled, CR3Spilled, CR4Spilled,
1422                MBB, I, CSI, CSIIndex);
1423   }
1424
1425   return true;
1426 }