lib/Target/X86/X86FrameLowering.cpp

   1 //===-- X86FrameLowering.cpp - X86 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 X86 implementation of TargetFrameLowering class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "X86FrameLowering.h"
  15 #include "X86InstrBuilder.h"
  16 #include "X86InstrInfo.h"
  17 #include "X86MachineFunctionInfo.h"
  18 #include "X86Subtarget.h"
  19 #include "X86TargetMachine.h"
  20 #include "llvm/ADT/SmallSet.h"
  21 #include "llvm/Analysis/EHPersonalities.h"
  22 #include "llvm/CodeGen/MachineFrameInfo.h"
  23 #include "llvm/CodeGen/MachineFunction.h"
  24 #include "llvm/CodeGen/MachineInstrBuilder.h"
  25 #include "llvm/CodeGen/MachineModuleInfo.h"
  26 #include "llvm/CodeGen/MachineRegisterInfo.h"
  27 #include "llvm/CodeGen/WinEHFuncInfo.h"
  28 #include "llvm/IR/DataLayout.h"
  29 #include "llvm/IR/Function.h"
  30 #include "llvm/MC/MCAsmInfo.h"
  31 #include "llvm/MC/MCSymbol.h"
  32 #include "llvm/Target/TargetOptions.h"
  33 #include "llvm/Support/Debug.h"
  34 #include <cstdlib>
  35
  36 using namespace llvm;
  37
  38 X86FrameLowering::X86FrameLowering(const X86Subtarget &STI,
  39                                    unsigned StackAlignOverride)
  40     : TargetFrameLowering(StackGrowsDown, StackAlignOverride,
  41                           STI.is64Bit() ? -8 : -4),
  42       STI(STI), TII(*STI.getInstrInfo()), TRI(STI.getRegisterInfo()) {
  43   // Cache a bunch of frame-related predicates for this subtarget.
  44   SlotSize = TRI->getSlotSize();
  45   Is64Bit = STI.is64Bit();
  46   IsLP64 = STI.isTarget64BitLP64();
  47   // standard x86_64 and NaCl use 64-bit frame/stack pointers, x32 - 32-bit.
  48   Uses64BitFramePtr = STI.isTarget64BitLP64() || STI.isTargetNaCl64();
  49   StackPtr = TRI->getStackRegister();
  50 }
  51
  52 bool X86FrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
  53   return !MF.getFrameInfo()->hasVarSizedObjects() &&
  54          !MF.getInfo<X86MachineFunctionInfo>()->getHasPushSequences();
  55 }
  56
  57 /// canSimplifyCallFramePseudos - If there is a reserved call frame, the
  58 /// call frame pseudos can be simplified.  Having a FP, as in the default
  59 /// implementation, is not sufficient here since we can't always use it.
  60 /// Use a more nuanced condition.
  61 bool
  62 X86FrameLowering::canSimplifyCallFramePseudos(const MachineFunction &MF) const {
  63   return hasReservedCallFrame(MF) ||
  64          (hasFP(MF) && !TRI->needsStackRealignment(MF)) ||
  65          TRI->hasBasePointer(MF);
  66 }
  67
  68 // needsFrameIndexResolution - Do we need to perform FI resolution for
  69 // this function. Normally, this is required only when the function
  70 // has any stack objects. However, FI resolution actually has another job,
  71 // not apparent from the title - it resolves callframesetup/destroy
  72 // that were not simplified earlier.
  73 // So, this is required for x86 functions that have push sequences even
  74 // when there are no stack objects.
  75 bool
  76 X86FrameLowering::needsFrameIndexResolution(const MachineFunction &MF) const {
  77   return MF.getFrameInfo()->hasStackObjects() ||
  78          MF.getInfo<X86MachineFunctionInfo>()->getHasPushSequences();
  79 }
  80
  81 /// hasFP - Return true if the specified function should have a dedicated frame
  82 /// pointer register.  This is true if the function has variable sized allocas
  83 /// or if frame pointer elimination is disabled.
  84 bool X86FrameLowering::hasFP(const MachineFunction &MF) const {
  85   const MachineFrameInfo *MFI = MF.getFrameInfo();
  86   const MachineModuleInfo &MMI = MF.getMMI();
  87
  88   return (MF.getTarget().Options.DisableFramePointerElim(MF) ||
  89           TRI->needsStackRealignment(MF) ||
  90           MFI->hasVarSizedObjects() ||
  91           MFI->isFrameAddressTaken() || MFI->hasOpaqueSPAdjustment() ||
  92           MF.getInfo<X86MachineFunctionInfo>()->getForceFramePointer() ||
  93           MMI.callsUnwindInit() || MMI.hasEHFunclets() || MMI.callsEHReturn() ||
  94           MFI->hasStackMap() || MFI->hasPatchPoint());
  95 }
  96
  97 static unsigned getSUBriOpcode(unsigned IsLP64, int64_t Imm) {
  98   if (IsLP64) {
  99     if (isInt<8>(Imm))
 100       return X86::SUB64ri8;
 101     return X86::SUB64ri32;
 102   } else {
 103     if (isInt<8>(Imm))
 104       return X86::SUB32ri8;
 105     return X86::SUB32ri;
 106   }
 107 }
 108
 109 static unsigned getADDriOpcode(unsigned IsLP64, int64_t Imm) {
 110   if (IsLP64) {
 111     if (isInt<8>(Imm))
 112       return X86::ADD64ri8;
 113     return X86::ADD64ri32;
 114   } else {
 115     if (isInt<8>(Imm))
 116       return X86::ADD32ri8;
 117     return X86::ADD32ri;
 118   }
 119 }
 120
 121 static unsigned getSUBrrOpcode(unsigned isLP64) {
 122   return isLP64 ? X86::SUB64rr : X86::SUB32rr;
 123 }
 124
 125 static unsigned getADDrrOpcode(unsigned isLP64) {
 126   return isLP64 ? X86::ADD64rr : X86::ADD32rr;
 127 }
 128
 129 static unsigned getANDriOpcode(bool IsLP64, int64_t Imm) {
 130   if (IsLP64) {
 131     if (isInt<8>(Imm))
 132       return X86::AND64ri8;
 133     return X86::AND64ri32;
 134   }
 135   if (isInt<8>(Imm))
 136     return X86::AND32ri8;
 137   return X86::AND32ri;
 138 }
 139
 140 static unsigned getLEArOpcode(unsigned IsLP64) {
 141   return IsLP64 ? X86::LEA64r : X86::LEA32r;
 142 }
 143
 144 /// findDeadCallerSavedReg - Return a caller-saved register that isn't live
 145 /// when it reaches the "return" instruction. We can then pop a stack object
 146 /// to this register without worry about clobbering it.
 147 static unsigned findDeadCallerSavedReg(MachineBasicBlock &MBB,
 148                                        MachineBasicBlock::iterator &MBBI,
 149                                        const X86RegisterInfo *TRI,
 150                                        bool Is64Bit) {
 151   const MachineFunction *MF = MBB.getParent();
 152   const Function *F = MF->getFunction();
 153   if (!F || MF->getMMI().callsEHReturn())
 154     return 0;
 155
 156   const TargetRegisterClass &AvailableRegs = *TRI->getGPRsForTailCall(*MF);
 157
 158   unsigned Opc = MBBI->getOpcode();
 159   switch (Opc) {
 160   default: return 0;
 161   case X86::RETL:
 162   case X86::RETQ:
 163   case X86::RETIL:
 164   case X86::RETIQ:
 165   case X86::TCRETURNdi:
 166   case X86::TCRETURNri:
 167   case X86::TCRETURNmi:
 168   case X86::TCRETURNdi64:
 169   case X86::TCRETURNri64:
 170   case X86::TCRETURNmi64:
 171   case X86::EH_RETURN:
 172   case X86::EH_RETURN64: {
 173     SmallSet<uint16_t, 8> Uses;
 174     for (unsigned i = 0, e = MBBI->getNumOperands(); i != e; ++i) {
 175       MachineOperand &MO = MBBI->getOperand(i);
 176       if (!MO.isReg() || MO.isDef())
 177         continue;
 178       unsigned Reg = MO.getReg();
 179       if (!Reg)
 180         continue;
 181       for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
 182         Uses.insert(*AI);
 183     }
 184
 185     for (auto CS : AvailableRegs)
 186       if (!Uses.count(CS) && CS != X86::RIP)
 187         return CS;
 188   }
 189   }
 190
 191   return 0;
 192 }
 193
 194 static bool isEAXLiveIn(MachineFunction &MF) {
 195   for (MachineRegisterInfo::livein_iterator II = MF.getRegInfo().livein_begin(),
 196        EE = MF.getRegInfo().livein_end(); II != EE; ++II) {
 197     unsigned Reg = II->first;
 198
 199     if (Reg == X86::RAX || Reg == X86::EAX || Reg == X86::AX ||
 200         Reg == X86::AH || Reg == X86::AL)
 201       return true;
 202   }
 203
 204   return false;
 205 }
 206
 207 /// Check if the flags need to be preserved before the terminators.
 208 /// This would be the case, if the eflags is live-in of the region
 209 /// composed by the terminators or live-out of that region, without
 210 /// being defined by a terminator.
 211 static bool
 212 flagsNeedToBePreservedBeforeTheTerminators(const MachineBasicBlock &MBB) {
 213   for (const MachineInstr &MI : MBB.terminators()) {
 214     bool BreakNext = false;
 215     for (const MachineOperand &MO : MI.operands()) {
 216       if (!MO.isReg())
 217         continue;
 218       unsigned Reg = MO.getReg();
 219       if (Reg != X86::EFLAGS)
 220         continue;
 221
 222       // This terminator needs an eflags that is not defined
 223       // by a previous another terminator:
 224       // EFLAGS is live-in of the region composed by the terminators.
 225       if (!MO.isDef())
 226         return true;
 227       // This terminator defines the eflags, i.e., we don't need to preserve it.
 228       // However, we still need to check this specific terminator does not
 229       // read a live-in value.
 230       BreakNext = true;
 231     }
 232     // We found a definition of the eflags, no need to preserve them.
 233     if (BreakNext)
 234       return false;
 235   }
 236
 237   // None of the terminators use or define the eflags.
 238   // Check if they are live-out, that would imply we need to preserve them.
 239   for (const MachineBasicBlock *Succ : MBB.successors())
 240     if (Succ->isLiveIn(X86::EFLAGS))
 241       return true;
 242
 243   return false;
 244 }
 245
 246 /// emitSPUpdate - Emit a series of instructions to increment / decrement the
 247 /// stack pointer by a constant value.
 248 void X86FrameLowering::emitSPUpdate(MachineBasicBlock &MBB,
 249                                     MachineBasicBlock::iterator &MBBI,
 250                                     int64_t NumBytes, bool InEpilogue) const {
 251   bool isSub = NumBytes < 0;
 252   uint64_t Offset = isSub ? -NumBytes : NumBytes;
 253
 254   uint64_t Chunk = (1LL << 31) - 1;
 255   DebugLoc DL = MBB.findDebugLoc(MBBI);
 256
 257   while (Offset) {
 258     if (Offset > Chunk) {
 259       // Rather than emit a long series of instructions for large offsets,
 260       // load the offset into a register and do one sub/add
 261       unsigned Reg = 0;
 262
 263       if (isSub && !isEAXLiveIn(*MBB.getParent()))
 264         Reg = (unsigned)(Is64Bit ? X86::RAX : X86::EAX);
 265       else
 266         Reg = findDeadCallerSavedReg(MBB, MBBI, TRI, Is64Bit);
 267
 268       if (Reg) {
 269         unsigned Opc = Is64Bit ? X86::MOV64ri : X86::MOV32ri;
 270         BuildMI(MBB, MBBI, DL, TII.get(Opc), Reg)
 271           .addImm(Offset);
 272         Opc = isSub
 273           ? getSUBrrOpcode(Is64Bit)
 274           : getADDrrOpcode(Is64Bit);
 275         MachineInstr *MI = BuildMI(MBB, MBBI, DL, TII.get(Opc), StackPtr)
 276           .addReg(StackPtr)
 277           .addReg(Reg);
 278         MI->getOperand(3).setIsDead(); // The EFLAGS implicit def is dead.
 279         Offset = 0;
 280         continue;
 281       }
 282     }
 283
 284     uint64_t ThisVal = std::min(Offset, Chunk);
 285     if (ThisVal == (Is64Bit ? 8 : 4)) {
 286       // Use push / pop instead.
 287       unsigned Reg = isSub
 288         ? (unsigned)(Is64Bit ? X86::RAX : X86::EAX)
 289         : findDeadCallerSavedReg(MBB, MBBI, TRI, Is64Bit);
 290       if (Reg) {
 291         unsigned Opc = isSub
 292           ? (Is64Bit ? X86::PUSH64r : X86::PUSH32r)
 293           : (Is64Bit ? X86::POP64r  : X86::POP32r);
 294         MachineInstr *MI = BuildMI(MBB, MBBI, DL, TII.get(Opc))
 295           .addReg(Reg, getDefRegState(!isSub) | getUndefRegState(isSub));
 296         if (isSub)
 297           MI->setFlag(MachineInstr::FrameSetup);
 298         else
 299           MI->setFlag(MachineInstr::FrameDestroy);
 300         Offset -= ThisVal;
 301         continue;
 302       }
 303     }
 304
 305     MachineInstrBuilder MI = BuildStackAdjustment(
 306         MBB, MBBI, DL, isSub ? -ThisVal : ThisVal, InEpilogue);
 307     if (isSub)
 308       MI.setMIFlag(MachineInstr::FrameSetup);
 309     else
 310       MI.setMIFlag(MachineInstr::FrameDestroy);
 311
 312     Offset -= ThisVal;
 313   }
 314 }
 315
 316 MachineInstrBuilder X86FrameLowering::BuildStackAdjustment(
 317     MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, DebugLoc DL,
 318     int64_t Offset, bool InEpilogue) const {
 319   assert(Offset != 0 && "zero offset stack adjustment requested");
 320
 321   // On Atom, using LEA to adjust SP is preferred, but using it in the epilogue
 322   // is tricky.
 323   bool UseLEA;
 324   if (!InEpilogue) {
 325     // Check if inserting the prologue at the beginning
 326     // of MBB would require to use LEA operations.
 327     // We need to use LEA operations if EFLAGS is live in, because
 328     // it means an instruction will read it before it gets defined.
 329     UseLEA = STI.useLeaForSP() || MBB.isLiveIn(X86::EFLAGS);
 330   } else {
 331     // If we can use LEA for SP but we shouldn't, check that none
 332     // of the terminators uses the eflags. Otherwise we will insert
 333     // a ADD that will redefine the eflags and break the condition.
 334     // Alternatively, we could move the ADD, but this may not be possible
 335     // and is an optimization anyway.
 336     UseLEA = canUseLEAForSPInEpilogue(*MBB.getParent());
 337     if (UseLEA && !STI.useLeaForSP())
 338       UseLEA = flagsNeedToBePreservedBeforeTheTerminators(MBB);
 339     // If that assert breaks, that means we do not do the right thing
 340     // in canUseAsEpilogue.
 341     assert((UseLEA || !flagsNeedToBePreservedBeforeTheTerminators(MBB)) &&
 342            "We shouldn't have allowed this insertion point");
 343   }
 344
 345   MachineInstrBuilder MI;
 346   if (UseLEA) {
 347     MI = addRegOffset(BuildMI(MBB, MBBI, DL,
 348                               TII.get(getLEArOpcode(Uses64BitFramePtr)),
 349                               StackPtr),
 350                       StackPtr, false, Offset);
 351   } else {
 352     bool IsSub = Offset < 0;
 353     uint64_t AbsOffset = IsSub ? -Offset : Offset;
 354     unsigned Opc = IsSub ? getSUBriOpcode(Uses64BitFramePtr, AbsOffset)
 355                          : getADDriOpcode(Uses64BitFramePtr, AbsOffset);
 356     MI = BuildMI(MBB, MBBI, DL, TII.get(Opc), StackPtr)
 357              .addReg(StackPtr)
 358              .addImm(AbsOffset);
 359     MI->getOperand(3).setIsDead(); // The EFLAGS implicit def is dead.
 360   }
 361   return MI;
 362 }
 363
 364 int X86FrameLowering::mergeSPUpdates(MachineBasicBlock &MBB,
 365                                      MachineBasicBlock::iterator &MBBI,
 366                                      bool doMergeWithPrevious) const {
 367   if ((doMergeWithPrevious && MBBI == MBB.begin()) ||
 368       (!doMergeWithPrevious && MBBI == MBB.end()))
 369     return 0;
 370
 371   MachineBasicBlock::iterator PI = doMergeWithPrevious ? std::prev(MBBI) : MBBI;
 372   MachineBasicBlock::iterator NI = doMergeWithPrevious ? nullptr
 373                                                        : std::next(MBBI);
 374   unsigned Opc = PI->getOpcode();
 375   int Offset = 0;
 376
 377   if ((Opc == X86::ADD64ri32 || Opc == X86::ADD64ri8 ||
 378        Opc == X86::ADD32ri || Opc == X86::ADD32ri8 ||
 379        Opc == X86::LEA32r || Opc == X86::LEA64_32r) &&
 380       PI->getOperand(0).getReg() == StackPtr){
 381     Offset += PI->getOperand(2).getImm();
 382     MBB.erase(PI);
 383     if (!doMergeWithPrevious) MBBI = NI;
 384   } else if ((Opc == X86::SUB64ri32 || Opc == X86::SUB64ri8 ||
 385               Opc == X86::SUB32ri || Opc == X86::SUB32ri8) &&
 386              PI->getOperand(0).getReg() == StackPtr) {
 387     Offset -= PI->getOperand(2).getImm();
 388     MBB.erase(PI);
 389     if (!doMergeWithPrevious) MBBI = NI;
 390   }
 391
 392   return Offset;
 393 }
 394
 395 void X86FrameLowering::BuildCFI(MachineBasicBlock &MBB,
 396                                 MachineBasicBlock::iterator MBBI, DebugLoc DL,
 397                                 MCCFIInstruction CFIInst) const {
 398   MachineFunction &MF = *MBB.getParent();
 399   unsigned CFIIndex = MF.getMMI().addFrameInst(CFIInst);
 400   BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
 401       .addCFIIndex(CFIIndex);
 402 }
 403
 404 void
 405 X86FrameLowering::emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
 406                                             MachineBasicBlock::iterator MBBI,
 407                                             DebugLoc DL) const {
 408   MachineFunction &MF = *MBB.getParent();
 409   MachineFrameInfo *MFI = MF.getFrameInfo();
 410   MachineModuleInfo &MMI = MF.getMMI();
 411   const MCRegisterInfo *MRI = MMI.getContext().getRegisterInfo();
 412
 413   // Add callee saved registers to move list.
 414   const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
 415   if (CSI.empty()) return;
 416
 417   // Calculate offsets.
 418   for (std::vector<CalleeSavedInfo>::const_iterator
 419          I = CSI.begin(), E = CSI.end(); I != E; ++I) {
 420     int64_t Offset = MFI->getObjectOffset(I->getFrameIdx());
 421     unsigned Reg = I->getReg();
 422
 423     unsigned DwarfReg = MRI->getDwarfRegNum(Reg, true);
 424     BuildCFI(MBB, MBBI, DL,
 425              MCCFIInstruction::createOffset(nullptr, DwarfReg, Offset));
 426   }
 427 }
 428
 429 /// usesTheStack - This function checks if any of the users of EFLAGS
 430 /// copies the EFLAGS. We know that the code that lowers COPY of EFLAGS has
 431 /// to use the stack, and if we don't adjust the stack we clobber the first
 432 /// frame index.
 433 /// See X86InstrInfo::copyPhysReg.
 434 static bool usesTheStack(const MachineFunction &MF) {
 435   const MachineRegisterInfo &MRI = MF.getRegInfo();
 436
 437   for (MachineRegisterInfo::reg_instr_iterator
 438        ri = MRI.reg_instr_begin(X86::EFLAGS), re = MRI.reg_instr_end();
 439        ri != re; ++ri)
 440     if (ri->isCopy())
 441       return true;
 442
 443   return false;
 444 }
 445
 446 MachineInstr *X86FrameLowering::emitStackProbe(MachineFunction &MF,
 447                                                MachineBasicBlock &MBB,
 448                                                MachineBasicBlock::iterator MBBI,
 449                                                DebugLoc DL,
 450                                                bool InProlog) const {
 451   const X86Subtarget &STI = MF.getSubtarget<X86Subtarget>();
 452   if (STI.isTargetWindowsCoreCLR()) {
 453     if (InProlog) {
 454       return emitStackProbeInlineStub(MF, MBB, MBBI, DL, true);
 455     } else {
 456       return emitStackProbeInline(MF, MBB, MBBI, DL, false);
 457     }
 458   } else {
 459     return emitStackProbeCall(MF, MBB, MBBI, DL, InProlog);
 460   }
 461 }
 462
 463 void X86FrameLowering::inlineStackProbe(MachineFunction &MF,
 464                                         MachineBasicBlock &PrologMBB) const {
 465   const StringRef ChkStkStubSymbol = "__chkstk_stub";
 466   MachineInstr *ChkStkStub = nullptr;
 467
 468   for (MachineInstr &MI : PrologMBB) {
 469     if (MI.isCall() && MI.getOperand(0).isSymbol() &&
 470         ChkStkStubSymbol == MI.getOperand(0).getSymbolName()) {
 471       ChkStkStub = &MI;
 472       break;
 473     }
 474   }
 475
 476   if (ChkStkStub != nullptr) {
 477     MachineBasicBlock::iterator MBBI = std::next(ChkStkStub->getIterator());
 478     assert(std::prev(MBBI).operator==(ChkStkStub) &&
 479       "MBBI expected after __chkstk_stub.");
 480     DebugLoc DL = PrologMBB.findDebugLoc(MBBI);
 481     emitStackProbeInline(MF, PrologMBB, MBBI, DL, true);
 482     ChkStkStub->eraseFromParent();
 483   }
 484 }
 485
 486 MachineInstr *X86FrameLowering::emitStackProbeInline(
 487   MachineFunction &MF, MachineBasicBlock &MBB,
 488   MachineBasicBlock::iterator MBBI, DebugLoc DL, bool InProlog) const {
 489   const X86Subtarget &STI = MF.getSubtarget<X86Subtarget>();
 490   assert(STI.is64Bit() && "different expansion needed for 32 bit");
 491   assert(STI.isTargetWindowsCoreCLR() && "custom expansion expects CoreCLR");
 492   const TargetInstrInfo &TII = *STI.getInstrInfo();
 493   const BasicBlock *LLVM_BB = MBB.getBasicBlock();
 494
 495   // RAX contains the number of bytes of desired stack adjustment.
 496   // The handling here assumes this value has already been updated so as to
 497   // maintain stack alignment.
 498   //
 499   // We need to exit with RSP modified by this amount and execute suitable
 500   // page touches to notify the OS that we're growing the stack responsibly.
 501   // All stack probing must be done without modifying RSP.
 502   //
 503   // MBB:
 504   //    SizeReg = RAX;
 505   //    ZeroReg = 0
 506   //    CopyReg = RSP
 507   //    Flags, TestReg = CopyReg - SizeReg
 508   //    FinalReg = !Flags.Ovf ? TestReg : ZeroReg
 509   //    LimitReg = gs magic thread env access
 510   //    if FinalReg >= LimitReg goto ContinueMBB
 511   // RoundBB:
 512   //    RoundReg = page address of FinalReg
 513   // LoopMBB:
 514   //    LoopReg = PHI(LimitReg,ProbeReg)
 515   //    ProbeReg = LoopReg - PageSize
 516   //    [ProbeReg] = 0
 517   //    if (ProbeReg > RoundReg) goto LoopMBB
 518   // ContinueMBB:
 519   //    RSP = RSP - RAX
 520   //    [rest of original MBB]
 521
 522   // Set up the new basic blocks
 523   MachineBasicBlock *RoundMBB = MF.CreateMachineBasicBlock(LLVM_BB);
 524   MachineBasicBlock *LoopMBB = MF.CreateMachineBasicBlock(LLVM_BB);
 525   MachineBasicBlock *ContinueMBB = MF.CreateMachineBasicBlock(LLVM_BB);
 526
 527   MachineFunction::iterator MBBIter = std::next(MBB.getIterator());
 528   MF.insert(MBBIter, RoundMBB);
 529   MF.insert(MBBIter, LoopMBB);
 530   MF.insert(MBBIter, ContinueMBB);
 531
 532   // Split MBB and move the tail portion down to ContinueMBB.
 533   MachineBasicBlock::iterator BeforeMBBI = std::prev(MBBI);
 534   ContinueMBB->splice(ContinueMBB->begin(), &MBB, MBBI, MBB.end());
 535   ContinueMBB->transferSuccessorsAndUpdatePHIs(&MBB);
 536
 537   // Some useful constants
 538   const int64_t ThreadEnvironmentStackLimit = 0x10;
 539   const int64_t PageSize = 0x1000;
 540   const int64_t PageMask = ~(PageSize - 1);
 541
 542   // Registers we need. For the normal case we use virtual
 543   // registers. For the prolog expansion we use RAX, RCX and RDX.
 544   MachineRegisterInfo &MRI = MF.getRegInfo();
 545   const TargetRegisterClass *RegClass = &X86::GR64RegClass;
 546   const unsigned SizeReg = InProlog ? (unsigned)X86::RAX
 547                                     : MRI.createVirtualRegister(RegClass),
 548                  ZeroReg = InProlog ? (unsigned)X86::RCX
 549                                     : MRI.createVirtualRegister(RegClass),
 550                  CopyReg = InProlog ? (unsigned)X86::RDX
 551                                     : MRI.createVirtualRegister(RegClass),
 552                  TestReg = InProlog ? (unsigned)X86::RDX
 553                                     : MRI.createVirtualRegister(RegClass),
 554                  FinalReg = InProlog ? (unsigned)X86::RDX
 555                                      : MRI.createVirtualRegister(RegClass),
 556                  RoundedReg = InProlog ? (unsigned)X86::RDX
 557                                        : MRI.createVirtualRegister(RegClass),
 558                  LimitReg = InProlog ? (unsigned)X86::RCX
 559                                      : MRI.createVirtualRegister(RegClass),
 560                  JoinReg = InProlog ? (unsigned)X86::RCX
 561                                     : MRI.createVirtualRegister(RegClass),
 562                  ProbeReg = InProlog ? (unsigned)X86::RCX
 563                                      : MRI.createVirtualRegister(RegClass);
 564
 565   // SP-relative offsets where we can save RCX and RDX.
 566   int64_t RCXShadowSlot = 0;
 567   int64_t RDXShadowSlot = 0;
 568
 569   // If inlining in the prolog, save RCX and RDX.
 570   // Future optimization: don't save or restore if not live in.
 571   if (InProlog) {
 572     // Compute the offsets. We need to account for things already
 573     // pushed onto the stack at this point: return address, frame
 574     // pointer (if used), and callee saves.
 575     X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
 576     const int64_t CalleeSaveSize = X86FI->getCalleeSavedFrameSize();
 577     const bool HasFP = hasFP(MF);
 578     RCXShadowSlot = 8 + CalleeSaveSize + (HasFP ? 8 : 0);
 579     RDXShadowSlot = RCXShadowSlot + 8;
 580     // Emit the saves.
 581     addRegOffset(BuildMI(&MBB, DL, TII.get(X86::MOV64mr)), X86::RSP, false,
 582                  RCXShadowSlot)
 583         .addReg(X86::RCX);
 584     addRegOffset(BuildMI(&MBB, DL, TII.get(X86::MOV64mr)), X86::RSP, false,
 585                  RDXShadowSlot)
 586         .addReg(X86::RDX);
 587   } else {
 588     // Not in the prolog. Copy RAX to a virtual reg.
 589     BuildMI(&MBB, DL, TII.get(X86::MOV64rr), SizeReg).addReg(X86::RAX);
 590   }
 591
 592   // Add code to MBB to check for overflow and set the new target stack pointer
 593   // to zero if so.
 594   BuildMI(&MBB, DL, TII.get(X86::XOR64rr), ZeroReg)
 595       .addReg(ZeroReg, RegState::Undef)
 596       .addReg(ZeroReg, RegState::Undef);
 597   BuildMI(&MBB, DL, TII.get(X86::MOV64rr), CopyReg).addReg(X86::RSP);
 598   BuildMI(&MBB, DL, TII.get(X86::SUB64rr), TestReg)
 599       .addReg(CopyReg)
 600       .addReg(SizeReg);
 601   BuildMI(&MBB, DL, TII.get(X86::CMOVB64rr), FinalReg)
 602       .addReg(TestReg)
 603       .addReg(ZeroReg);
 604
 605   // FinalReg now holds final stack pointer value, or zero if
 606   // allocation would overflow. Compare against the current stack
 607   // limit from the thread environment block. Note this limit is the
 608   // lowest touched page on the stack, not the point at which the OS
 609   // will cause an overflow exception, so this is just an optimization
 610   // to avoid unnecessarily touching pages that are below the current
 611   // SP but already commited to the stack by the OS.
 612   BuildMI(&MBB, DL, TII.get(X86::MOV64rm), LimitReg)
 613       .addReg(0)
 614       .addImm(1)
 615       .addReg(0)
 616       .addImm(ThreadEnvironmentStackLimit)
 617       .addReg(X86::GS);
 618   BuildMI(&MBB, DL, TII.get(X86::CMP64rr)).addReg(FinalReg).addReg(LimitReg);
 619   // Jump if the desired stack pointer is at or above the stack limit.
 620   BuildMI(&MBB, DL, TII.get(X86::JAE_1)).addMBB(ContinueMBB);
 621
 622   // Add code to roundMBB to round the final stack pointer to a page boundary.
 623   BuildMI(RoundMBB, DL, TII.get(X86::AND64ri32), RoundedReg)
 624       .addReg(FinalReg)
 625       .addImm(PageMask);
 626   BuildMI(RoundMBB, DL, TII.get(X86::JMP_1)).addMBB(LoopMBB);
 627
 628   // LimitReg now holds the current stack limit, RoundedReg page-rounded
 629   // final RSP value. Add code to loopMBB to decrement LimitReg page-by-page
 630   // and probe until we reach RoundedReg.
 631   if (!InProlog) {
 632     BuildMI(LoopMBB, DL, TII.get(X86::PHI), JoinReg)
 633         .addReg(LimitReg)
 634         .addMBB(RoundMBB)
 635         .addReg(ProbeReg)
 636         .addMBB(LoopMBB);
 637   }
 638
 639   addRegOffset(BuildMI(LoopMBB, DL, TII.get(X86::LEA64r), ProbeReg), JoinReg,
 640                false, -PageSize);
 641
 642   // Probe by storing a byte onto the stack.
 643   BuildMI(LoopMBB, DL, TII.get(X86::MOV8mi))
 644       .addReg(ProbeReg)
 645       .addImm(1)
 646       .addReg(0)
 647       .addImm(0)
 648       .addReg(0)
 649       .addImm(0);
 650   BuildMI(LoopMBB, DL, TII.get(X86::CMP64rr))
 651       .addReg(RoundedReg)
 652       .addReg(ProbeReg);
 653   BuildMI(LoopMBB, DL, TII.get(X86::JNE_1)).addMBB(LoopMBB);
 654
 655   MachineBasicBlock::iterator ContinueMBBI = ContinueMBB->getFirstNonPHI();
 656
 657   // If in prolog, restore RDX and RCX.
 658   if (InProlog) {
 659     addRegOffset(BuildMI(*ContinueMBB, ContinueMBBI, DL, TII.get(X86::MOV64rm),
 660                          X86::RCX),
 661                  X86::RSP, false, RCXShadowSlot);
 662     addRegOffset(BuildMI(*ContinueMBB, ContinueMBBI, DL, TII.get(X86::MOV64rm),
 663                          X86::RDX),
 664                  X86::RSP, false, RDXShadowSlot);
 665   }
 666
 667   // Now that the probing is done, add code to continueMBB to update
 668   // the stack pointer for real.
 669   BuildMI(*ContinueMBB, ContinueMBBI, DL, TII.get(X86::SUB64rr), X86::RSP)
 670       .addReg(X86::RSP)
 671       .addReg(SizeReg);
 672
 673   // Add the control flow edges we need.
 674   MBB.addSuccessor(ContinueMBB);
 675   MBB.addSuccessor(RoundMBB);
 676   RoundMBB->addSuccessor(LoopMBB);
 677   LoopMBB->addSuccessor(ContinueMBB);
 678   LoopMBB->addSuccessor(LoopMBB);
 679
 680   // Mark all the instructions added to the prolog as frame setup.
 681   if (InProlog) {
 682     for (++BeforeMBBI; BeforeMBBI != MBB.end(); ++BeforeMBBI) {
 683       BeforeMBBI->setFlag(MachineInstr::FrameSetup);
 684     }
 685     for (MachineInstr &MI : *RoundMBB) {
 686       MI.setFlag(MachineInstr::FrameSetup);
 687     }
 688     for (MachineInstr &MI : *LoopMBB) {
 689       MI.setFlag(MachineInstr::FrameSetup);
 690     }
 691     for (MachineBasicBlock::iterator CMBBI = ContinueMBB->begin();
 692          CMBBI != ContinueMBBI; ++CMBBI) {
 693       CMBBI->setFlag(MachineInstr::FrameSetup);
 694     }
 695   }
 696
 697   // Possible TODO: physreg liveness for InProlog case.
 698
 699   return ContinueMBBI;
 700 }
 701
 702 MachineInstr *X86FrameLowering::emitStackProbeCall(
 703     MachineFunction &MF, MachineBasicBlock &MBB,
 704     MachineBasicBlock::iterator MBBI, DebugLoc DL, bool InProlog) const {
 705   bool IsLargeCodeModel = MF.getTarget().getCodeModel() == CodeModel::Large;
 706
 707   unsigned CallOp;
 708   if (Is64Bit)
 709     CallOp = IsLargeCodeModel ? X86::CALL64r : X86::CALL64pcrel32;
 710   else
 711     CallOp = X86::CALLpcrel32;
 712
 713   const char *Symbol;
 714   if (Is64Bit) {
 715     if (STI.isTargetCygMing()) {
 716       Symbol = "___chkstk_ms";
 717     } else {
 718       Symbol = "__chkstk";
 719     }
 720   } else if (STI.isTargetCygMing())
 721     Symbol = "_alloca";
 722   else
 723     Symbol = "_chkstk";
 724
 725   MachineInstrBuilder CI;
 726   MachineBasicBlock::iterator ExpansionMBBI = std::prev(MBBI);
 727
 728   // All current stack probes take AX and SP as input, clobber flags, and
 729   // preserve all registers. x86_64 probes leave RSP unmodified.
 730   if (Is64Bit && MF.getTarget().getCodeModel() == CodeModel::Large) {
 731     // For the large code model, we have to call through a register. Use R11,
 732     // as it is scratch in all supported calling conventions.
 733     BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64ri), X86::R11)
 734         .addExternalSymbol(Symbol);
 735     CI = BuildMI(MBB, MBBI, DL, TII.get(CallOp)).addReg(X86::R11);
 736   } else {
 737     CI = BuildMI(MBB, MBBI, DL, TII.get(CallOp)).addExternalSymbol(Symbol);
 738   }
 739
 740   unsigned AX = Is64Bit ? X86::RAX : X86::EAX;
 741   unsigned SP = Is64Bit ? X86::RSP : X86::ESP;
 742   CI.addReg(AX, RegState::Implicit)
 743       .addReg(SP, RegState::Implicit)
 744       .addReg(AX, RegState::Define | RegState::Implicit)
 745       .addReg(SP, RegState::Define | RegState::Implicit)
 746       .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
 747
 748   if (Is64Bit) {
 749     // MSVC x64's __chkstk and cygwin/mingw's ___chkstk_ms do not adjust %rsp
 750     // themselves. It also does not clobber %rax so we can reuse it when
 751     // adjusting %rsp.
 752     BuildMI(MBB, MBBI, DL, TII.get(X86::SUB64rr), X86::RSP)
 753         .addReg(X86::RSP)
 754         .addReg(X86::RAX);
 755   }
 756
 757   if (InProlog) {
 758     // Apply the frame setup flag to all inserted instrs.
 759     for (++ExpansionMBBI; ExpansionMBBI != MBBI; ++ExpansionMBBI)
 760       ExpansionMBBI->setFlag(MachineInstr::FrameSetup);
 761   }
 762
 763   return MBBI;
 764 }
 765
 766 MachineInstr *X86FrameLowering::emitStackProbeInlineStub(
 767     MachineFunction &MF, MachineBasicBlock &MBB,
 768     MachineBasicBlock::iterator MBBI, DebugLoc DL, bool InProlog) const {
 769
 770   assert(InProlog && "ChkStkStub called outside prolog!");
 771
 772   BuildMI(MBB, MBBI, DL, TII.get(X86::CALLpcrel32))
 773       .addExternalSymbol("__chkstk_stub");
 774
 775   return MBBI;
 776 }
 777
 778 static unsigned calculateSetFPREG(uint64_t SPAdjust) {
 779   // Win64 ABI has a less restrictive limitation of 240; 128 works equally well
 780   // and might require smaller successive adjustments.
 781   const uint64_t Win64MaxSEHOffset = 128;
 782   uint64_t SEHFrameOffset = std::min(SPAdjust, Win64MaxSEHOffset);
 783   // Win64 ABI requires 16-byte alignment for the UWOP_SET_FPREG opcode.
 784   return SEHFrameOffset & -16;
 785 }
 786
 787 // If we're forcing a stack realignment we can't rely on just the frame
 788 // info, we need to know the ABI stack alignment as well in case we
 789 // have a call out.  Otherwise just make sure we have some alignment - we'll
 790 // go with the minimum SlotSize.
 791 uint64_t X86FrameLowering::calculateMaxStackAlign(const MachineFunction &MF) const {
 792   const MachineFrameInfo *MFI = MF.getFrameInfo();
 793   uint64_t MaxAlign = MFI->getMaxAlignment(); // Desired stack alignment.
 794   unsigned StackAlign = getStackAlignment();
 795   if (MF.getFunction()->hasFnAttribute("stackrealign")) {
 796     if (MFI->hasCalls())
 797       MaxAlign = (StackAlign > MaxAlign) ? StackAlign : MaxAlign;
 798     else if (MaxAlign < SlotSize)
 799       MaxAlign = SlotSize;
 800   }
 801   return MaxAlign;
 802 }
 803
 804 void X86FrameLowering::BuildStackAlignAND(MachineBasicBlock &MBB,
 805                                           MachineBasicBlock::iterator MBBI,
 806                                           DebugLoc DL, unsigned Reg,
 807                                           uint64_t MaxAlign) const {
 808   uint64_t Val = -MaxAlign;
 809   unsigned AndOp = getANDriOpcode(Uses64BitFramePtr, Val);
 810   MachineInstr *MI = BuildMI(MBB, MBBI, DL, TII.get(AndOp), Reg)
 811                          .addReg(Reg)
 812                          .addImm(Val)
 813                          .setMIFlag(MachineInstr::FrameSetup);
 814
 815   // The EFLAGS implicit def is dead.
 816   MI->getOperand(3).setIsDead();
 817 }
 818
 819 /// emitPrologue - Push callee-saved registers onto the stack, which
 820 /// automatically adjust the stack pointer. Adjust the stack pointer to allocate
 821 /// space for local variables. Also emit labels used by the exception handler to
 822 /// generate the exception handling frames.
 823
 824 /*
 825   Here's a gist of what gets emitted:
 826
 827   ; Establish frame pointer, if needed
 828   [if needs FP]
 829       push  %rbp
 830       .cfi_def_cfa_offset 16
 831       .cfi_offset %rbp, -16
 832       .seh_pushreg %rpb
 833       mov  %rsp, %rbp
 834       .cfi_def_cfa_register %rbp
 835
 836   ; Spill general-purpose registers
 837   [for all callee-saved GPRs]
 838       pushq %<reg>
 839       [if not needs FP]
 840          .cfi_def_cfa_offset (offset from RETADDR)
 841       .seh_pushreg %<reg>
 842
 843   ; If the required stack alignment > default stack alignment
 844   ; rsp needs to be re-aligned.  This creates a "re-alignment gap"
 845   ; of unknown size in the stack frame.
 846   [if stack needs re-alignment]
 847       and  $MASK, %rsp
 848
 849   ; Allocate space for locals
 850   [if target is Windows and allocated space > 4096 bytes]
 851       ; Windows needs special care for allocations larger
 852       ; than one page.
 853       mov $NNN, %rax
 854       call ___chkstk_ms/___chkstk
 855       sub  %rax, %rsp
 856   [else]
 857       sub  $NNN, %rsp
 858
 859   [if needs FP]
 860       .seh_stackalloc (size of XMM spill slots)
 861       .seh_setframe %rbp, SEHFrameOffset ; = size of all spill slots
 862   [else]
 863       .seh_stackalloc NNN
 864
 865   ; Spill XMMs
 866   ; Note, that while only Windows 64 ABI specifies XMMs as callee-preserved,
 867   ; they may get spilled on any platform, if the current function
 868   ; calls @llvm.eh.unwind.init
 869   [if needs FP]
 870       [for all callee-saved XMM registers]
 871           movaps  %<xmm reg>, -MMM(%rbp)
 872       [for all callee-saved XMM registers]
 873           .seh_savexmm %<xmm reg>, (-MMM + SEHFrameOffset)
 874               ; i.e. the offset relative to (%rbp - SEHFrameOffset)
 875   [else]
 876       [for all callee-saved XMM registers]
 877           movaps  %<xmm reg>, KKK(%rsp)
 878       [for all callee-saved XMM registers]
 879           .seh_savexmm %<xmm reg>, KKK
 880
 881   .seh_endprologue
 882
 883   [if needs base pointer]
 884       mov  %rsp, %rbx
 885       [if needs to restore base pointer]
 886           mov %rsp, -MMM(%rbp)
 887
 888   ; Emit CFI info
 889   [if needs FP]
 890       [for all callee-saved registers]
 891           .cfi_offset %<reg>, (offset from %rbp)
 892   [else]
 893        .cfi_def_cfa_offset (offset from RETADDR)
 894       [for all callee-saved registers]
 895           .cfi_offset %<reg>, (offset from %rsp)
 896
 897   Notes:
 898   - .seh directives are emitted only for Windows 64 ABI
 899   - .cfi directives are emitted for all other ABIs
 900   - for 32-bit code, substitute %e?? registers for %r??
 901 */
 902
 903 void X86FrameLowering::emitPrologue(MachineFunction &MF,
 904                                     MachineBasicBlock &MBB) const {
 905   assert(&STI == &MF.getSubtarget<X86Subtarget>() &&
 906          "MF used frame lowering for wrong subtarget");
 907   MachineBasicBlock::iterator MBBI = MBB.begin();
 908   MachineFrameInfo *MFI = MF.getFrameInfo();
 909   const Function *Fn = MF.getFunction();
 910   MachineModuleInfo &MMI = MF.getMMI();
 911   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
 912   uint64_t MaxAlign = calculateMaxStackAlign(MF); // Desired stack alignment.
 913   uint64_t StackSize = MFI->getStackSize();    // Number of bytes to allocate.
 914   bool IsFunclet = MBB.isEHFuncletEntry();
 915   EHPersonality Personality = EHPersonality::Unknown;
 916   if (Fn->hasPersonalityFn())
 917     Personality = classifyEHPersonality(Fn->getPersonalityFn());
 918   bool FnHasClrFunclet =
 919       MMI.hasEHFunclets() && Personality == EHPersonality::CoreCLR;
 920   bool IsClrFunclet = IsFunclet && FnHasClrFunclet;
 921   bool HasFP = hasFP(MF);
 922   bool IsWin64CC = STI.isCallingConvWin64(Fn->getCallingConv());
 923   bool IsWin64Prologue = MF.getTarget().getMCAsmInfo()->usesWindowsCFI();
 924   bool NeedsWinCFI = IsWin64Prologue && Fn->needsUnwindTableEntry();
 925   bool NeedsDwarfCFI =
 926       !IsWin64Prologue && (MMI.hasDebugInfo() || Fn->needsUnwindTableEntry());
 927   unsigned FramePtr = TRI->getFrameRegister(MF);
 928   const unsigned MachineFramePtr =
 929       STI.isTarget64BitILP32()
 930           ? getX86SubSuperRegister(FramePtr, MVT::i64, false)
 931           : FramePtr;
 932   unsigned BasePtr = TRI->getBaseRegister();
 933
 934   // Debug location must be unknown since the first debug location is used
 935   // to determine the end of the prologue.
 936   DebugLoc DL;
 937
 938   // Add RETADDR move area to callee saved frame size.
 939   int TailCallReturnAddrDelta = X86FI->getTCReturnAddrDelta();
 940   if (TailCallReturnAddrDelta && IsWin64Prologue)
 941     report_fatal_error("Can't handle guaranteed tail call under win64 yet");
 942
 943   if (TailCallReturnAddrDelta < 0)
 944     X86FI->setCalleeSavedFrameSize(
 945       X86FI->getCalleeSavedFrameSize() - TailCallReturnAddrDelta);
 946
 947   bool UseStackProbe = (STI.isOSWindows() && !STI.isTargetMachO());
 948
 949   // The default stack probe size is 4096 if the function has no stackprobesize
 950   // attribute.
 951   unsigned StackProbeSize = 4096;
 952   if (Fn->hasFnAttribute("stack-probe-size"))
 953     Fn->getFnAttribute("stack-probe-size")
 954         .getValueAsString()
 955         .getAsInteger(0, StackProbeSize);
 956
 957   // If this is x86-64 and the Red Zone is not disabled, if we are a leaf
 958   // function, and use up to 128 bytes of stack space, don't have a frame
 959   // pointer, calls, or dynamic alloca then we do not need to adjust the
 960   // stack pointer (we fit in the Red Zone). We also check that we don't
 961   // push and pop from the stack.
 962   if (Is64Bit && !Fn->hasFnAttribute(Attribute::NoRedZone) &&
 963       !TRI->needsStackRealignment(MF) &&
 964       !MFI->hasVarSizedObjects() && // No dynamic alloca.
 965       !MFI->adjustsStack() &&       // No calls.
 966       !IsWin64CC &&                 // Win64 has no Red Zone
 967       !usesTheStack(MF) &&          // Don't push and pop.
 968       !MF.shouldSplitStack()) {     // Regular stack
 969     uint64_t MinSize = X86FI->getCalleeSavedFrameSize();
 970     if (HasFP) MinSize += SlotSize;
 971     StackSize = std::max(MinSize, StackSize > 128 ? StackSize - 128 : 0);
 972     MFI->setStackSize(StackSize);
 973   }
 974
 975   // Insert stack pointer adjustment for later moving of return addr.  Only
 976   // applies to tail call optimized functions where the callee argument stack
 977   // size is bigger than the callers.
 978   if (TailCallReturnAddrDelta < 0) {
 979     BuildStackAdjustment(MBB, MBBI, DL, TailCallReturnAddrDelta,
 980                          /*InEpilogue=*/false)
 981         .setMIFlag(MachineInstr::FrameSetup);
 982   }
 983
 984   // Mapping for machine moves:
 985   //
 986   //   DST: VirtualFP AND
 987   //        SRC: VirtualFP              => DW_CFA_def_cfa_offset
 988   //        ELSE                        => DW_CFA_def_cfa
 989   //
 990   //   SRC: VirtualFP AND
 991   //        DST: Register               => DW_CFA_def_cfa_register
 992   //
 993   //   ELSE
 994   //        OFFSET < 0                  => DW_CFA_offset_extended_sf
 995   //        REG < 64                    => DW_CFA_offset + Reg
 996   //        ELSE                        => DW_CFA_offset_extended
 997
 998   uint64_t NumBytes = 0;
 999   int stackGrowth = -SlotSize;
1000
1001   // Find the funclet establisher parameter
1002   unsigned Establisher = X86::NoRegister;
1003   if (IsClrFunclet)
1004     Establisher = Uses64BitFramePtr ? X86::RCX : X86::ECX;
1005   else if (IsFunclet)
1006     Establisher = Uses64BitFramePtr ? X86::RDX : X86::EDX;
1007
1008   if (IsWin64Prologue && IsFunclet && !IsClrFunclet) {
1009     // Immediately spill establisher into the home slot.
1010     // The runtime cares about this.
1011     // MOV64mr %rdx, 16(%rsp)
1012     unsigned MOVmr = Uses64BitFramePtr ? X86::MOV64mr : X86::MOV32mr;
1013     addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(MOVmr)), StackPtr, true, 16)
1014         .addReg(Establisher)
1015         .setMIFlag(MachineInstr::FrameSetup);
1016     MBB.addLiveIn(Establisher);
1017   }
1018
1019   if (HasFP) {
1020     // Calculate required stack adjustment.
1021     uint64_t FrameSize = StackSize - SlotSize;
1022     // If required, include space for extra hidden slot for stashing base pointer.
1023     if (X86FI->getRestoreBasePointer())
1024       FrameSize += SlotSize;
1025
1026     NumBytes = FrameSize - X86FI->getCalleeSavedFrameSize();
1027
1028     // Callee-saved registers are pushed on stack before the stack is realigned.
1029     if (TRI->needsStackRealignment(MF) && !IsWin64Prologue)
1030       NumBytes = RoundUpToAlignment(NumBytes, MaxAlign);
1031
1032     // Get the offset of the stack slot for the EBP register, which is
1033     // guaranteed to be the last slot by processFunctionBeforeFrameFinalized.
1034     // Update the frame offset adjustment.
1035     if (!IsFunclet)
1036       MFI->setOffsetAdjustment(-NumBytes);
1037     else
1038       assert(MFI->getOffsetAdjustment() == -(int)NumBytes &&
1039              "should calculate same local variable offset for funclets");
1040
1041     // Save EBP/RBP into the appropriate stack slot.
1042     BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::PUSH64r : X86::PUSH32r))
1043       .addReg(MachineFramePtr, RegState::Kill)
1044       .setMIFlag(MachineInstr::FrameSetup);
1045
1046     if (NeedsDwarfCFI) {
1047       // Mark the place where EBP/RBP was saved.
1048       // Define the current CFA rule to use the provided offset.
1049       assert(StackSize);
1050       BuildCFI(MBB, MBBI, DL,
1051                MCCFIInstruction::createDefCfaOffset(nullptr, 2 * stackGrowth));
1052
1053       // Change the rule for the FramePtr to be an "offset" rule.
1054       unsigned DwarfFramePtr = TRI->getDwarfRegNum(MachineFramePtr, true);
1055       BuildCFI(MBB, MBBI, DL, MCCFIInstruction::createOffset(
1056                                   nullptr, DwarfFramePtr, 2 * stackGrowth));
1057     }
1058
1059     if (NeedsWinCFI) {
1060       BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_PushReg))
1061           .addImm(FramePtr)
1062           .setMIFlag(MachineInstr::FrameSetup);
1063     }
1064
1065     if (!IsWin64Prologue && !IsFunclet) {
1066       // Update EBP with the new base value.
1067       BuildMI(MBB, MBBI, DL,
1068               TII.get(Uses64BitFramePtr ? X86::MOV64rr : X86::MOV32rr),
1069               FramePtr)
1070           .addReg(StackPtr)
1071           .setMIFlag(MachineInstr::FrameSetup);
1072
1073       if (NeedsDwarfCFI) {
1074         // Mark effective beginning of when frame pointer becomes valid.
1075         // Define the current CFA to use the EBP/RBP register.
1076         unsigned DwarfFramePtr = TRI->getDwarfRegNum(MachineFramePtr, true);
1077         BuildCFI(MBB, MBBI, DL, MCCFIInstruction::createDefCfaRegister(
1078                                     nullptr, DwarfFramePtr));
1079       }
1080     }
1081
1082     // Mark the FramePtr as live-in in every block. Don't do this again for
1083     // funclet prologues.
1084     if (!IsFunclet) {
1085       for (MachineBasicBlock &EveryMBB : MF)
1086         EveryMBB.addLiveIn(MachineFramePtr);
1087     }
1088   } else {
1089     assert(!IsFunclet && "funclets without FPs not yet implemented");
1090     NumBytes = StackSize - X86FI->getCalleeSavedFrameSize();
1091   }
1092
1093   // For EH funclets, only allocate enough space for outgoing calls. Save the
1094   // NumBytes value that we would've used for the parent frame.
1095   unsigned ParentFrameNumBytes = NumBytes;
1096   if (IsFunclet)
1097     NumBytes = getWinEHFuncletFrameSize(MF);
1098
1099   // Skip the callee-saved push instructions.
1100   bool PushedRegs = false;
1101   int StackOffset = 2 * stackGrowth;
1102
1103   while (MBBI != MBB.end() &&
1104          MBBI->getFlag(MachineInstr::FrameSetup) &&
1105          (MBBI->getOpcode() == X86::PUSH32r ||
1106           MBBI->getOpcode() == X86::PUSH64r)) {
1107     PushedRegs = true;
1108     unsigned Reg = MBBI->getOperand(0).getReg();
1109     ++MBBI;
1110
1111     if (!HasFP && NeedsDwarfCFI) {
1112       // Mark callee-saved push instruction.
1113       // Define the current CFA rule to use the provided offset.
1114       assert(StackSize);
1115       BuildCFI(MBB, MBBI, DL,
1116                MCCFIInstruction::createDefCfaOffset(nullptr, StackOffset));
1117       StackOffset += stackGrowth;
1118     }
1119
1120     if (NeedsWinCFI) {
1121       BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_PushReg)).addImm(Reg).setMIFlag(
1122           MachineInstr::FrameSetup);
1123     }
1124   }
1125
1126   // Realign stack after we pushed callee-saved registers (so that we'll be
1127   // able to calculate their offsets from the frame pointer).
1128   // Don't do this for Win64, it needs to realign the stack after the prologue.
1129   if (!IsWin64Prologue && !IsFunclet && TRI->needsStackRealignment(MF)) {
1130     assert(HasFP && "There should be a frame pointer if stack is realigned.");
1131     BuildStackAlignAND(MBB, MBBI, DL, StackPtr, MaxAlign);
1132   }
1133
1134   // If there is an SUB32ri of ESP immediately before this instruction, merge
1135   // the two. This can be the case when tail call elimination is enabled and
1136   // the callee has more arguments then the caller.
1137   NumBytes -= mergeSPUpdates(MBB, MBBI, true);
1138
1139   // Adjust stack pointer: ESP -= numbytes.
1140
1141   // Windows and cygwin/mingw require a prologue helper routine when allocating
1142   // more than 4K bytes on the stack.  Windows uses __chkstk and cygwin/mingw
1143   // uses __alloca.  __alloca and the 32-bit version of __chkstk will probe the
1144   // stack and adjust the stack pointer in one go.  The 64-bit version of
1145   // __chkstk is only responsible for probing the stack.  The 64-bit prologue is
1146   // responsible for adjusting the stack pointer.  Touching the stack at 4K
1147   // increments is necessary to ensure that the guard pages used by the OS
1148   // virtual memory manager are allocated in correct sequence.
1149   uint64_t AlignedNumBytes = NumBytes;
1150   if (IsWin64Prologue && !IsFunclet && TRI->needsStackRealignment(MF))
1151     AlignedNumBytes = RoundUpToAlignment(AlignedNumBytes, MaxAlign);
1152   if (AlignedNumBytes >= StackProbeSize && UseStackProbe) {
1153     // Check whether EAX is livein for this function.
1154     bool isEAXAlive = isEAXLiveIn(MF);
1155
1156     if (isEAXAlive) {
1157       // Sanity check that EAX is not livein for this function.
1158       // It should not be, so throw an assert.
1159       assert(!Is64Bit && "EAX is livein in x64 case!");
1160
1161       // Save EAX
1162       BuildMI(MBB, MBBI, DL, TII.get(X86::PUSH32r))
1163         .addReg(X86::EAX, RegState::Kill)
1164         .setMIFlag(MachineInstr::FrameSetup);
1165     }
1166
1167     if (Is64Bit) {
1168       // Handle the 64-bit Windows ABI case where we need to call __chkstk.
1169       // Function prologue is responsible for adjusting the stack pointer.
1170       if (isUInt<32>(NumBytes)) {
1171         BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32ri), X86::EAX)
1172             .addImm(NumBytes)
1173             .setMIFlag(MachineInstr::FrameSetup);
1174       } else if (isInt<32>(NumBytes)) {
1175         BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64ri32), X86::RAX)
1176             .addImm(NumBytes)
1177             .setMIFlag(MachineInstr::FrameSetup);
1178       } else {
1179         BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64ri), X86::RAX)
1180             .addImm(NumBytes)
1181             .setMIFlag(MachineInstr::FrameSetup);
1182       }
1183     } else {
1184       // Allocate NumBytes-4 bytes on stack in case of isEAXAlive.
1185       // We'll also use 4 already allocated bytes for EAX.
1186       BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32ri), X86::EAX)
1187           .addImm(isEAXAlive ? NumBytes - 4 : NumBytes)
1188           .setMIFlag(MachineInstr::FrameSetup);
1189     }
1190
1191     // Call __chkstk, __chkstk_ms, or __alloca.
1192     emitStackProbe(MF, MBB, MBBI, DL, true);
1193
1194     if (isEAXAlive) {
1195       // Restore EAX
1196       MachineInstr *MI =
1197           addRegOffset(BuildMI(MF, DL, TII.get(X86::MOV32rm), X86::EAX),
1198                        StackPtr, false, NumBytes - 4);
1199       MI->setFlag(MachineInstr::FrameSetup);
1200       MBB.insert(MBBI, MI);
1201     }
1202   } else if (NumBytes) {
1203     emitSPUpdate(MBB, MBBI, -(int64_t)NumBytes, /*InEpilogue=*/false);
1204   }
1205
1206   if (NeedsWinCFI && NumBytes)
1207     BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_StackAlloc))
1208         .addImm(NumBytes)
1209         .setMIFlag(MachineInstr::FrameSetup);
1210
1211   int SEHFrameOffset = 0;
1212   unsigned SPOrEstablisher;
1213   if (IsFunclet) {
1214     if (IsClrFunclet) {
1215       // The establisher parameter passed to a CLR funclet is actually a pointer
1216       // to the (mostly empty) frame of its nearest enclosing funclet; we have
1217       // to find the root function establisher frame by loading the PSPSym from
1218       // the intermediate frame.
1219       unsigned PSPSlotOffset = getPSPSlotOffsetFromSP(MF);
1220       MachinePointerInfo NoInfo;
1221       MBB.addLiveIn(Establisher);
1222       addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64rm), Establisher),
1223                    Establisher, false, PSPSlotOffset)
1224           .addMemOperand(MF.getMachineMemOperand(
1225               NoInfo, MachineMemOperand::MOLoad, SlotSize, SlotSize));
1226       ;
1227       // Save the root establisher back into the current funclet's (mostly
1228       // empty) frame, in case a sub-funclet or the GC needs it.
1229       addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64mr)), StackPtr,
1230                    false, PSPSlotOffset)
1231           .addReg(Establisher)
1232           .addMemOperand(
1233               MF.getMachineMemOperand(NoInfo, MachineMemOperand::MOStore |
1234                                                   MachineMemOperand::MOVolatile,
1235                                       SlotSize, SlotSize));
1236     }
1237     SPOrEstablisher = Establisher;
1238   } else {
1239     SPOrEstablisher = StackPtr;
1240   }
1241
1242   if (IsWin64Prologue && HasFP) {
1243     // Set RBP to a small fixed offset from RSP. In the funclet case, we base
1244     // this calculation on the incoming establisher, which holds the value of
1245     // RSP from the parent frame at the end of the prologue.
1246     SEHFrameOffset = calculateSetFPREG(ParentFrameNumBytes);
1247     if (SEHFrameOffset)
1248       addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::LEA64r), FramePtr),
1249                    SPOrEstablisher, false, SEHFrameOffset);
1250     else
1251       BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64rr), FramePtr)
1252           .addReg(SPOrEstablisher);
1253
1254     // If this is not a funclet, emit the CFI describing our frame pointer.
1255     if (NeedsWinCFI && !IsFunclet) {
1256       BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_SetFrame))
1257           .addImm(FramePtr)
1258           .addImm(SEHFrameOffset)
1259           .setMIFlag(MachineInstr::FrameSetup);
1260       if (isAsynchronousEHPersonality(Personality))
1261         MF.getWinEHFuncInfo()->SEHSetFrameOffset = SEHFrameOffset;
1262     }
1263   } else if (IsFunclet && STI.is32Bit()) {
1264     // Reset EBP / ESI to something good for funclets.
1265     MBBI = restoreWin32EHStackPointers(MBB, MBBI, DL);
1266     // If we're a catch funclet, we can be returned to via catchret. Save ESP
1267     // into the registration node so that the runtime will restore it for us.
1268     if (!MBB.isCleanupFuncletEntry()) {
1269       assert(Personality == EHPersonality::MSVC_CXX);
1270       unsigned FrameReg;
1271       int FI = MF.getWinEHFuncInfo()->EHRegNodeFrameIndex;
1272       int64_t EHRegOffset = getFrameIndexReference(MF, FI, FrameReg);
1273       // ESP is the first field, so no extra displacement is needed.
1274       addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32mr)), FrameReg,
1275                    false, EHRegOffset)
1276           .addReg(X86::ESP);
1277     }
1278   }
1279
1280   while (MBBI != MBB.end() && MBBI->getFlag(MachineInstr::FrameSetup)) {
1281     const MachineInstr *FrameInstr = &*MBBI;
1282     ++MBBI;
1283
1284     if (NeedsWinCFI) {
1285       int FI;
1286       if (unsigned Reg = TII.isStoreToStackSlot(FrameInstr, FI)) {
1287         if (X86::FR64RegClass.contains(Reg)) {
1288           unsigned IgnoredFrameReg;
1289           int Offset = getFrameIndexReference(MF, FI, IgnoredFrameReg);
1290           Offset += SEHFrameOffset;
1291
1292           BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_SaveXMM))
1293               .addImm(Reg)
1294               .addImm(Offset)
1295               .setMIFlag(MachineInstr::FrameSetup);
1296         }
1297       }
1298     }
1299   }
1300
1301   if (NeedsWinCFI)
1302     BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_EndPrologue))
1303         .setMIFlag(MachineInstr::FrameSetup);
1304
1305   if (FnHasClrFunclet && !IsFunclet) {
1306     // Save the so-called Initial-SP (i.e. the value of the stack pointer
1307     // immediately after the prolog)  into the PSPSlot so that funclets
1308     // and the GC can recover it.
1309     unsigned PSPSlotOffset = getPSPSlotOffsetFromSP(MF);
1310     auto PSPInfo = MachinePointerInfo::getFixedStack(
1311         MF, MF.getWinEHFuncInfo()->PSPSymFrameIdx);
1312     addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64mr)), StackPtr, false,
1313                  PSPSlotOffset)
1314         .addReg(StackPtr)
1315         .addMemOperand(MF.getMachineMemOperand(
1316             PSPInfo, MachineMemOperand::MOStore | MachineMemOperand::MOVolatile,
1317             SlotSize, SlotSize));
1318   }
1319
1320   // Realign stack after we spilled callee-saved registers (so that we'll be
1321   // able to calculate their offsets from the frame pointer).
1322   // Win64 requires aligning the stack after the prologue.
1323   if (IsWin64Prologue && TRI->needsStackRealignment(MF)) {
1324     assert(HasFP && "There should be a frame pointer if stack is realigned.");
1325     BuildStackAlignAND(MBB, MBBI, DL, SPOrEstablisher, MaxAlign);
1326   }
1327
1328   // We already dealt with stack realignment and funclets above.
1329   if (IsFunclet && STI.is32Bit())
1330     return;
1331
1332   // If we need a base pointer, set it up here. It's whatever the value
1333   // of the stack pointer is at this point. Any variable size objects
1334   // will be allocated after this, so we can still use the base pointer
1335   // to reference locals.
1336   if (TRI->hasBasePointer(MF)) {
1337     // Update the base pointer with the current stack pointer.
1338     unsigned Opc = Uses64BitFramePtr ? X86::MOV64rr : X86::MOV32rr;
1339     BuildMI(MBB, MBBI, DL, TII.get(Opc), BasePtr)
1340       .addReg(SPOrEstablisher)
1341       .setMIFlag(MachineInstr::FrameSetup);
1342     if (X86FI->getRestoreBasePointer()) {
1343       // Stash value of base pointer.  Saving RSP instead of EBP shortens
1344       // dependence chain. Used by SjLj EH.
1345       unsigned Opm = Uses64BitFramePtr ? X86::MOV64mr : X86::MOV32mr;
1346       addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(Opm)),
1347                    FramePtr, true, X86FI->getRestoreBasePointerOffset())
1348         .addReg(SPOrEstablisher)
1349         .setMIFlag(MachineInstr::FrameSetup);
1350     }
1351
1352     if (X86FI->getHasSEHFramePtrSave() && !IsFunclet) {
1353       // Stash the value of the frame pointer relative to the base pointer for
1354       // Win32 EH. This supports Win32 EH, which does the inverse of the above:
1355       // it recovers the frame pointer from the base pointer rather than the
1356       // other way around.
1357       unsigned Opm = Uses64BitFramePtr ? X86::MOV64mr : X86::MOV32mr;
1358       unsigned UsedReg;
1359       int Offset =
1360           getFrameIndexReference(MF, X86FI->getSEHFramePtrSaveIndex(), UsedReg);
1361       assert(UsedReg == BasePtr);
1362       addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(Opm)), UsedReg, true, Offset)
1363           .addReg(FramePtr)
1364           .setMIFlag(MachineInstr::FrameSetup);
1365     }
1366   }
1367
1368   if (((!HasFP && NumBytes) || PushedRegs) && NeedsDwarfCFI) {
1369     // Mark end of stack pointer adjustment.
1370     if (!HasFP && NumBytes) {
1371       // Define the current CFA rule to use the provided offset.
1372       assert(StackSize);
1373       BuildCFI(MBB, MBBI, DL, MCCFIInstruction::createDefCfaOffset(
1374                                   nullptr, -StackSize + stackGrowth));
1375     }
1376
1377     // Emit DWARF info specifying the offsets of the callee-saved registers.
1378     if (PushedRegs)
1379       emitCalleeSavedFrameMoves(MBB, MBBI, DL);
1380   }
1381 }
1382
1383 bool X86FrameLowering::canUseLEAForSPInEpilogue(
1384     const MachineFunction &MF) const {
1385   // We can't use LEA instructions for adjusting the stack pointer if this is a
1386   // leaf function in the Win64 ABI.  Only ADD instructions may be used to
1387   // deallocate the stack.
1388   // This means that we can use LEA for SP in two situations:
1389   // 1. We *aren't* using the Win64 ABI which means we are free to use LEA.
1390   // 2. We *have* a frame pointer which means we are permitted to use LEA.
1391   return !MF.getTarget().getMCAsmInfo()->usesWindowsCFI() || hasFP(MF);
1392 }
1393
1394 static bool isFuncletReturnInstr(MachineInstr *MI) {
1395   switch (MI->getOpcode()) {
1396   case X86::CATCHRET:
1397   case X86::CLEANUPRET:
1398     return true;
1399   default:
1400     return false;
1401   }
1402   llvm_unreachable("impossible");
1403 }
1404
1405 // CLR funclets use a special "Previous Stack Pointer Symbol" slot on the
1406 // stack. It holds a pointer to the bottom of the root function frame.  The
1407 // establisher frame pointer passed to a nested funclet may point to the
1408 // (mostly empty) frame of its parent funclet, but it will need to find
1409 // the frame of the root function to access locals.  To facilitate this,
1410 // every funclet copies the pointer to the bottom of the root function
1411 // frame into a PSPSym slot in its own (mostly empty) stack frame. Using the
1412 // same offset for the PSPSym in the root function frame that's used in the
1413 // funclets' frames allows each funclet to dynamically accept any ancestor
1414 // frame as its establisher argument (the runtime doesn't guarantee the
1415 // immediate parent for some reason lost to history), and also allows the GC,
1416 // which uses the PSPSym for some bookkeeping, to find it in any funclet's
1417 // frame with only a single offset reported for the entire method.
1418 unsigned
1419 X86FrameLowering::getPSPSlotOffsetFromSP(const MachineFunction &MF) const {
1420   const WinEHFuncInfo &Info = *MF.getWinEHFuncInfo();
1421   // getFrameIndexReferenceFromSP has an out ref parameter for the stack
1422   // pointer register; pass a dummy that we ignore
1423   unsigned SPReg;
1424   int Offset = getFrameIndexReferenceFromSP(MF, Info.PSPSymFrameIdx, SPReg);
1425   assert(Offset >= 0);
1426   return static_cast<unsigned>(Offset);
1427 }
1428
1429 unsigned
1430 X86FrameLowering::getWinEHFuncletFrameSize(const MachineFunction &MF) const {
1431   // This is the size of the pushed CSRs.
1432   unsigned CSSize =
1433       MF.getInfo<X86MachineFunctionInfo>()->getCalleeSavedFrameSize();
1434   // This is the amount of stack a funclet needs to allocate.
1435   unsigned UsedSize;
1436   EHPersonality Personality =
1437       classifyEHPersonality(MF.getFunction()->getPersonalityFn());
1438   if (Personality == EHPersonality::CoreCLR) {
1439     // CLR funclets need to hold enough space to include the PSPSym, at the
1440     // same offset from the stack pointer (immediately after the prolog) as it
1441     // resides at in the main function.
1442     UsedSize = getPSPSlotOffsetFromSP(MF) + SlotSize;
1443   } else {
1444     // Other funclets just need enough stack for outgoing call arguments.
1445     UsedSize = MF.getFrameInfo()->getMaxCallFrameSize();
1446   }
1447   // RBP is not included in the callee saved register block. After pushing RBP,
1448   // everything is 16 byte aligned. Everything we allocate before an outgoing
1449   // call must also be 16 byte aligned.
1450   unsigned FrameSizeMinusRBP =
1451       RoundUpToAlignment(CSSize + UsedSize, getStackAlignment());
1452   // Subtract out the size of the callee saved registers. This is how much stack
1453   // each funclet will allocate.
1454   return FrameSizeMinusRBP - CSSize;
1455 }
1456
1457 void X86FrameLowering::emitEpilogue(MachineFunction &MF,
1458                                     MachineBasicBlock &MBB) const {
1459   const MachineFrameInfo *MFI = MF.getFrameInfo();
1460   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
1461   MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
1462   DebugLoc DL;
1463   if (MBBI != MBB.end())
1464     DL = MBBI->getDebugLoc();
1465   // standard x86_64 and NaCl use 64-bit frame/stack pointers, x32 - 32-bit.
1466   const bool Is64BitILP32 = STI.isTarget64BitILP32();
1467   unsigned FramePtr = TRI->getFrameRegister(MF);
1468   unsigned MachineFramePtr =
1469       Is64BitILP32 ? getX86SubSuperRegister(FramePtr, MVT::i64, false)
1470                    : FramePtr;
1471
1472   bool IsWin64Prologue = MF.getTarget().getMCAsmInfo()->usesWindowsCFI();
1473   bool NeedsWinCFI =
1474       IsWin64Prologue && MF.getFunction()->needsUnwindTableEntry();
1475   bool IsFunclet = isFuncletReturnInstr(MBBI);
1476   MachineBasicBlock *TargetMBB = nullptr;
1477
1478   // Get the number of bytes to allocate from the FrameInfo.
1479   uint64_t StackSize = MFI->getStackSize();
1480   uint64_t MaxAlign = calculateMaxStackAlign(MF);
1481   unsigned CSSize = X86FI->getCalleeSavedFrameSize();
1482   uint64_t NumBytes = 0;
1483
1484   if (MBBI->getOpcode() == X86::CATCHRET) {
1485     // SEH shouldn't use catchret.
1486     assert(!isAsynchronousEHPersonality(
1487                classifyEHPersonality(MF.getFunction()->getPersonalityFn())) &&
1488            "SEH should not use CATCHRET");
1489
1490     NumBytes = getWinEHFuncletFrameSize(MF);
1491     assert(hasFP(MF) && "EH funclets without FP not yet implemented");
1492     TargetMBB = MBBI->getOperand(0).getMBB();
1493
1494     // Pop EBP.
1495     BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::POP64r : X86::POP32r),
1496             MachineFramePtr)
1497         .setMIFlag(MachineInstr::FrameDestroy);
1498   } else if (MBBI->getOpcode() == X86::CLEANUPRET) {
1499     NumBytes = getWinEHFuncletFrameSize(MF);
1500     assert(hasFP(MF) && "EH funclets without FP not yet implemented");
1501     BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::POP64r : X86::POP32r),
1502             MachineFramePtr)
1503         .setMIFlag(MachineInstr::FrameDestroy);
1504   } else if (hasFP(MF)) {
1505     // Calculate required stack adjustment.
1506     uint64_t FrameSize = StackSize - SlotSize;
1507     NumBytes = FrameSize - CSSize;
1508
1509     // Callee-saved registers were pushed on stack before the stack was
1510     // realigned.
1511     if (TRI->needsStackRealignment(MF) && !IsWin64Prologue)
1512       NumBytes = RoundUpToAlignment(FrameSize, MaxAlign);
1513
1514     // Pop EBP.
1515     BuildMI(MBB, MBBI, DL,
1516             TII.get(Is64Bit ? X86::POP64r : X86::POP32r), MachineFramePtr)
1517         .setMIFlag(MachineInstr::FrameDestroy);
1518   } else {
1519     NumBytes = StackSize - CSSize;
1520   }
1521   uint64_t SEHStackAllocAmt = NumBytes;
1522
1523   // Skip the callee-saved pop instructions.
1524   while (MBBI != MBB.begin()) {
1525     MachineBasicBlock::iterator PI = std::prev(MBBI);
1526     unsigned Opc = PI->getOpcode();
1527
1528     if ((Opc != X86::POP32r || !PI->getFlag(MachineInstr::FrameDestroy)) &&
1529         (Opc != X86::POP64r || !PI->getFlag(MachineInstr::FrameDestroy)) &&
1530         Opc != X86::DBG_VALUE && !PI->isTerminator())
1531       break;
1532
1533     --MBBI;
1534   }
1535   MachineBasicBlock::iterator FirstCSPop = MBBI;
1536
1537   if (TargetMBB) {
1538     // Fill EAX/RAX with the address of the target block.
1539     unsigned ReturnReg = STI.is64Bit() ? X86::RAX : X86::EAX;
1540     if (STI.is64Bit()) {
1541       // LEA64r TargetMBB(%rip), %rax
1542       BuildMI(MBB, FirstCSPop, DL, TII.get(X86::LEA64r), ReturnReg)
1543           .addReg(X86::RIP)
1544           .addImm(0)
1545           .addReg(0)
1546           .addMBB(TargetMBB)
1547           .addReg(0);
1548     } else {
1549       // MOV32ri $TargetMBB, %eax
1550       BuildMI(MBB, FirstCSPop, DL, TII.get(X86::MOV32ri), ReturnReg)
1551           .addMBB(TargetMBB);
1552     }
1553     // Record that we've taken the address of TargetMBB and no longer just
1554     // reference it in a terminator.
1555     TargetMBB->setHasAddressTaken();
1556   }
1557
1558   if (MBBI != MBB.end())
1559     DL = MBBI->getDebugLoc();
1560
1561   // If there is an ADD32ri or SUB32ri of ESP immediately before this
1562   // instruction, merge the two instructions.
1563   if (NumBytes || MFI->hasVarSizedObjects())
1564     NumBytes += mergeSPUpdates(MBB, MBBI, true);
1565
1566   // If dynamic alloca is used, then reset esp to point to the last callee-saved
1567   // slot before popping them off! Same applies for the case, when stack was
1568   // realigned. Don't do this if this was a funclet epilogue, since the funclets
1569   // will not do realignment or dynamic stack allocation.
1570   if ((TRI->needsStackRealignment(MF) || MFI->hasVarSizedObjects()) &&
1571       !IsFunclet) {
1572     if (TRI->needsStackRealignment(MF))
1573       MBBI = FirstCSPop;
1574     unsigned SEHFrameOffset = calculateSetFPREG(SEHStackAllocAmt);
1575     uint64_t LEAAmount =
1576         IsWin64Prologue ? SEHStackAllocAmt - SEHFrameOffset : -CSSize;
1577
1578     // There are only two legal forms of epilogue:
1579     // - add SEHAllocationSize, %rsp
1580     // - lea SEHAllocationSize(%FramePtr), %rsp
1581     //
1582     // 'mov %FramePtr, %rsp' will not be recognized as an epilogue sequence.
1583     // However, we may use this sequence if we have a frame pointer because the
1584     // effects of the prologue can safely be undone.
1585     if (LEAAmount != 0) {
1586       unsigned Opc = getLEArOpcode(Uses64BitFramePtr);
1587       addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(Opc), StackPtr),
1588                    FramePtr, false, LEAAmount);
1589       --MBBI;
1590     } else {
1591       unsigned Opc = (Uses64BitFramePtr ? X86::MOV64rr : X86::MOV32rr);
1592       BuildMI(MBB, MBBI, DL, TII.get(Opc), StackPtr)
1593         .addReg(FramePtr);
1594       --MBBI;
1595     }
1596   } else if (NumBytes) {
1597     // Adjust stack pointer back: ESP += numbytes.
1598     emitSPUpdate(MBB, MBBI, NumBytes, /*InEpilogue=*/true);
1599     --MBBI;
1600   }
1601
1602   // Windows unwinder will not invoke function's exception handler if IP is
1603   // either in prologue or in epilogue.  This behavior causes a problem when a
1604   // call immediately precedes an epilogue, because the return address points
1605   // into the epilogue.  To cope with that, we insert an epilogue marker here,
1606   // then replace it with a 'nop' if it ends up immediately after a CALL in the
1607   // final emitted code.
1608   if (NeedsWinCFI)
1609     BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_Epilogue));
1610
1611   // Add the return addr area delta back since we are not tail calling.
1612   int Offset = -1 * X86FI->getTCReturnAddrDelta();
1613   assert(Offset >= 0 && "TCDelta should never be positive");
1614   if (Offset) {
1615     MBBI = MBB.getFirstTerminator();
1616
1617     // Check for possible merge with preceding ADD instruction.
1618     Offset += mergeSPUpdates(MBB, MBBI, true);
1619     emitSPUpdate(MBB, MBBI, Offset, /*InEpilogue=*/true);
1620   }
1621 }
1622
1623 // NOTE: this only has a subset of the full frame index logic. In
1624 // particular, the FI < 0 and AfterFPPop logic is handled in
1625 // X86RegisterInfo::eliminateFrameIndex, but not here. Possibly
1626 // (probably?) it should be moved into here.
1627 int X86FrameLowering::getFrameIndexReference(const MachineFunction &MF, int FI,
1628                                              unsigned &FrameReg) const {
1629   const MachineFrameInfo *MFI = MF.getFrameInfo();
1630
1631   // We can't calculate offset from frame pointer if the stack is realigned,
1632   // so enforce usage of stack/base pointer.  The base pointer is used when we
1633   // have dynamic allocas in addition to dynamic realignment.
1634   if (TRI->hasBasePointer(MF))
1635     FrameReg = TRI->getBaseRegister();
1636   else if (TRI->needsStackRealignment(MF))
1637     FrameReg = TRI->getStackRegister();
1638   else
1639     FrameReg = TRI->getFrameRegister(MF);
1640
1641   // Offset will hold the offset from the stack pointer at function entry to the
1642   // object.
1643   // We need to factor in additional offsets applied during the prologue to the
1644   // frame, base, and stack pointer depending on which is used.
1645   int Offset = MFI->getObjectOffset(FI) - getOffsetOfLocalArea();
1646   const X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
1647   unsigned CSSize = X86FI->getCalleeSavedFrameSize();
1648   uint64_t StackSize = MFI->getStackSize();
1649   bool HasFP = hasFP(MF);
1650   bool IsWin64Prologue = MF.getTarget().getMCAsmInfo()->usesWindowsCFI();
1651   int64_t FPDelta = 0;
1652
1653   if (IsWin64Prologue) {
1654     assert(!MFI->hasCalls() || (StackSize % 16) == 8);
1655
1656     // Calculate required stack adjustment.
1657     uint64_t FrameSize = StackSize - SlotSize;
1658     // If required, include space for extra hidden slot for stashing base pointer.
1659     if (X86FI->getRestoreBasePointer())
1660       FrameSize += SlotSize;
1661     uint64_t NumBytes = FrameSize - CSSize;
1662
1663     uint64_t SEHFrameOffset = calculateSetFPREG(NumBytes);
1664     if (FI && FI == X86FI->getFAIndex())
1665       return -SEHFrameOffset;
1666
1667     // FPDelta is the offset from the "traditional" FP location of the old base
1668     // pointer followed by return address and the location required by the
1669     // restricted Win64 prologue.
1670     // Add FPDelta to all offsets below that go through the frame pointer.
1671     FPDelta = FrameSize - SEHFrameOffset;
1672     assert((!MFI->hasCalls() || (FPDelta % 16) == 0) &&
1673            "FPDelta isn't aligned per the Win64 ABI!");
1674   }
1675
1676
1677   if (TRI->hasBasePointer(MF)) {
1678     assert(HasFP && "VLAs and dynamic stack realign, but no FP?!");
1679     if (FI < 0) {
1680       // Skip the saved EBP.
1681       return Offset + SlotSize + FPDelta;
1682     } else {
1683       assert((-(Offset + StackSize)) % MFI->getObjectAlignment(FI) == 0);
1684       return Offset + StackSize;
1685     }
1686   } else if (TRI->needsStackRealignment(MF)) {
1687     if (FI < 0) {
1688       // Skip the saved EBP.
1689       return Offset + SlotSize + FPDelta;
1690     } else {
1691       assert((-(Offset + StackSize)) % MFI->getObjectAlignment(FI) == 0);
1692       return Offset + StackSize;
1693     }
1694     // FIXME: Support tail calls
1695   } else {
1696     if (!HasFP)
1697       return Offset + StackSize;
1698
1699     // Skip the saved EBP.
1700     Offset += SlotSize;
1701
1702     // Skip the RETADDR move area
1703     int TailCallReturnAddrDelta = X86FI->getTCReturnAddrDelta();
1704     if (TailCallReturnAddrDelta < 0)
1705       Offset -= TailCallReturnAddrDelta;
1706   }
1707
1708   return Offset + FPDelta;
1709 }
1710
1711 // Simplified from getFrameIndexReference keeping only StackPointer cases
1712 int X86FrameLowering::getFrameIndexReferenceFromSP(const MachineFunction &MF,
1713                                                    int FI,
1714                                                    unsigned &FrameReg) const {
1715   const MachineFrameInfo *MFI = MF.getFrameInfo();
1716   // Does not include any dynamic realign.
1717   const uint64_t StackSize = MFI->getStackSize();
1718   {
1719 #ifndef NDEBUG
1720     // LLVM arranges the stack as follows:
1721     //   ...
1722     //   ARG2
1723     //   ARG1
1724     //   RETADDR
1725     //   PUSH RBP   <-- RBP points here
1726     //   PUSH CSRs
1727     //   ~~~~~~~    <-- possible stack realignment (non-win64)
1728     //   ...
1729     //   STACK OBJECTS
1730     //   ...        <-- RSP after prologue points here
1731     //   ~~~~~~~    <-- possible stack realignment (win64)
1732     //
1733     // if (hasVarSizedObjects()):
1734     //   ...        <-- "base pointer" (ESI/RBX) points here
1735     //   DYNAMIC ALLOCAS
1736     //   ...        <-- RSP points here
1737     //
1738     // Case 1: In the simple case of no stack realignment and no dynamic
1739     // allocas, both "fixed" stack objects (arguments and CSRs) are addressable
1740     // with fixed offsets from RSP.
1741     //
1742     // Case 2: In the case of stack realignment with no dynamic allocas, fixed
1743     // stack objects are addressed with RBP and regular stack objects with RSP.
1744     //
1745     // Case 3: In the case of dynamic allocas and stack realignment, RSP is used
1746     // to address stack arguments for outgoing calls and nothing else. The "base
1747     // pointer" points to local variables, and RBP points to fixed objects.
1748     //
1749     // In cases 2 and 3, we can only answer for non-fixed stack objects, and the
1750     // answer we give is relative to the SP after the prologue, and not the
1751     // SP in the middle of the function.
1752
1753     assert((!MFI->isFixedObjectIndex(FI) || !TRI->needsStackRealignment(MF) ||
1754             STI.isTargetWin64()) &&
1755            "offset from fixed object to SP is not static");
1756
1757     // We don't handle tail calls, and shouldn't be seeing them either.
1758     int TailCallReturnAddrDelta =
1759         MF.getInfo<X86MachineFunctionInfo>()->getTCReturnAddrDelta();
1760     assert(!(TailCallReturnAddrDelta < 0) && "we don't handle this case!");
1761 #endif
1762   }
1763
1764   // Fill in FrameReg output argument.
1765   FrameReg = TRI->getStackRegister();
1766
1767   // This is how the math works out:
1768   //
1769   //  %rsp grows (i.e. gets lower) left to right. Each box below is
1770   //  one word (eight bytes).  Obj0 is the stack slot we're trying to
1771   //  get to.
1772   //
1773   //    ----------------------------------
1774   //    | BP | Obj0 | Obj1 | ... | ObjN |
1775   //    ----------------------------------
1776   //    ^    ^      ^                   ^
1777   //    A    B      C                   E
1778   //
1779   // A is the incoming stack pointer.
1780   // (B - A) is the local area offset (-8 for x86-64) [1]
1781   // (C - A) is the Offset returned by MFI->getObjectOffset for Obj0 [2]
1782   //
1783   // |(E - B)| is the StackSize (absolute value, positive).  For a
1784   // stack that grown down, this works out to be (B - E). [3]
1785   //
1786   // E is also the value of %rsp after stack has been set up, and we
1787   // want (C - E) -- the value we can add to %rsp to get to Obj0.  Now
1788   // (C - E) == (C - A) - (B - A) + (B - E)
1789   //            { Using [1], [2] and [3] above }
1790   //         == getObjectOffset - LocalAreaOffset + StackSize
1791   //
1792
1793   // Get the Offset from the StackPointer
1794   int Offset = MFI->getObjectOffset(FI) - getOffsetOfLocalArea();
1795
1796   return Offset + StackSize;
1797 }
1798
1799 bool X86FrameLowering::assignCalleeSavedSpillSlots(
1800     MachineFunction &MF, const TargetRegisterInfo *TRI,
1801     std::vector<CalleeSavedInfo> &CSI) const {
1802   MachineFrameInfo *MFI = MF.getFrameInfo();
1803   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
1804
1805   unsigned CalleeSavedFrameSize = 0;
1806   int SpillSlotOffset = getOffsetOfLocalArea() + X86FI->getTCReturnAddrDelta();
1807
1808   if (hasFP(MF)) {
1809     // emitPrologue always spills frame register the first thing.
1810     SpillSlotOffset -= SlotSize;
1811     MFI->CreateFixedSpillStackObject(SlotSize, SpillSlotOffset);
1812
1813     // Since emitPrologue and emitEpilogue will handle spilling and restoring of
1814     // the frame register, we can delete it from CSI list and not have to worry
1815     // about avoiding it later.
1816     unsigned FPReg = TRI->getFrameRegister(MF);
1817     for (unsigned i = 0; i < CSI.size(); ++i) {
1818       if (TRI->regsOverlap(CSI[i].getReg(),FPReg)) {
1819         CSI.erase(CSI.begin() + i);
1820         break;
1821       }
1822     }
1823   }
1824
1825   // Assign slots for GPRs. It increases frame size.
1826   for (unsigned i = CSI.size(); i != 0; --i) {
1827     unsigned Reg = CSI[i - 1].getReg();
1828
1829     if (!X86::GR64RegClass.contains(Reg) && !X86::GR32RegClass.contains(Reg))
1830       continue;
1831
1832     SpillSlotOffset -= SlotSize;
1833     CalleeSavedFrameSize += SlotSize;
1834
1835     int SlotIndex = MFI->CreateFixedSpillStackObject(SlotSize, SpillSlotOffset);
1836     CSI[i - 1].setFrameIdx(SlotIndex);
1837   }
1838
1839   X86FI->setCalleeSavedFrameSize(CalleeSavedFrameSize);
1840
1841   // Assign slots for XMMs.
1842   for (unsigned i = CSI.size(); i != 0; --i) {
1843     unsigned Reg = CSI[i - 1].getReg();
1844     if (X86::GR64RegClass.contains(Reg) || X86::GR32RegClass.contains(Reg))
1845       continue;
1846
1847     const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
1848     // ensure alignment
1849     SpillSlotOffset -= std::abs(SpillSlotOffset) % RC->getAlignment();
1850     // spill into slot
1851     SpillSlotOffset -= RC->getSize();
1852     int SlotIndex =
1853         MFI->CreateFixedSpillStackObject(RC->getSize(), SpillSlotOffset);
1854     CSI[i - 1].setFrameIdx(SlotIndex);
1855     MFI->ensureMaxAlignment(RC->getAlignment());
1856   }
1857
1858   return true;
1859 }
1860
1861 bool X86FrameLowering::spillCalleeSavedRegisters(
1862     MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
1863     const std::vector<CalleeSavedInfo> &CSI,
1864     const TargetRegisterInfo *TRI) const {
1865   DebugLoc DL = MBB.findDebugLoc(MI);
1866
1867   // Don't save CSRs in 32-bit EH funclets. The caller saves EBX, EBP, ESI, EDI
1868   // for us, and there are no XMM CSRs on Win32.
1869   if (MBB.isEHFuncletEntry() && STI.is32Bit() && STI.isOSWindows())
1870     return true;
1871
1872   // Push GPRs. It increases frame size.
1873   unsigned Opc = STI.is64Bit() ? X86::PUSH64r : X86::PUSH32r;
1874   for (unsigned i = CSI.size(); i != 0; --i) {
1875     unsigned Reg = CSI[i - 1].getReg();
1876
1877     if (!X86::GR64RegClass.contains(Reg) && !X86::GR32RegClass.contains(Reg))
1878       continue;
1879     // Add the callee-saved register as live-in. It's killed at the spill.
1880     MBB.addLiveIn(Reg);
1881
1882     BuildMI(MBB, MI, DL, TII.get(Opc)).addReg(Reg, RegState::Kill)
1883       .setMIFlag(MachineInstr::FrameSetup);
1884   }
1885
1886   // Make XMM regs spilled. X86 does not have ability of push/pop XMM.
1887   // It can be done by spilling XMMs to stack frame.
1888   for (unsigned i = CSI.size(); i != 0; --i) {
1889     unsigned Reg = CSI[i-1].getReg();
1890     if (X86::GR64RegClass.contains(Reg) || X86::GR32RegClass.contains(Reg))
1891       continue;
1892     // Add the callee-saved register as live-in. It's killed at the spill.
1893     MBB.addLiveIn(Reg);
1894     const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
1895
1896     TII.storeRegToStackSlot(MBB, MI, Reg, true, CSI[i - 1].getFrameIdx(), RC,
1897                             TRI);
1898     --MI;
1899     MI->setFlag(MachineInstr::FrameSetup);
1900     ++MI;
1901   }
1902
1903   return true;
1904 }
1905
1906 bool X86FrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
1907                                                MachineBasicBlock::iterator MI,
1908                                         const std::vector<CalleeSavedInfo> &CSI,
1909                                           const TargetRegisterInfo *TRI) const {
1910   if (CSI.empty())
1911     return false;
1912
1913   if (isFuncletReturnInstr(MI) && STI.isOSWindows()) {
1914     // Don't restore CSRs in 32-bit EH funclets. Matches
1915     // spillCalleeSavedRegisters.
1916     if (STI.is32Bit())
1917       return true;
1918     // Don't restore CSRs before an SEH catchret. SEH except blocks do not form
1919     // funclets. emitEpilogue transforms these to normal jumps.
1920     if (MI->getOpcode() == X86::CATCHRET) {
1921       const Function *Func = MBB.getParent()->getFunction();
1922       bool IsSEH = isAsynchronousEHPersonality(
1923           classifyEHPersonality(Func->getPersonalityFn()));
1924       if (IsSEH)
1925         return true;
1926     }
1927   }
1928
1929   DebugLoc DL = MBB.findDebugLoc(MI);
1930
1931   // Reload XMMs from stack frame.
1932   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
1933     unsigned Reg = CSI[i].getReg();
1934     if (X86::GR64RegClass.contains(Reg) ||
1935         X86::GR32RegClass.contains(Reg))
1936       continue;
1937
1938     const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
1939     TII.loadRegFromStackSlot(MBB, MI, Reg, CSI[i].getFrameIdx(), RC, TRI);
1940   }
1941
1942   // POP GPRs.
1943   unsigned Opc = STI.is64Bit() ? X86::POP64r : X86::POP32r;
1944   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
1945     unsigned Reg = CSI[i].getReg();
1946     if (!X86::GR64RegClass.contains(Reg) &&
1947         !X86::GR32RegClass.contains(Reg))
1948       continue;
1949
1950     BuildMI(MBB, MI, DL, TII.get(Opc), Reg)
1951         .setMIFlag(MachineInstr::FrameDestroy);
1952   }
1953   return true;
1954 }
1955
1956 void X86FrameLowering::determineCalleeSaves(MachineFunction &MF,
1957                                             BitVector &SavedRegs,
1958                                             RegScavenger *RS) const {
1959   TargetFrameLowering::determineCalleeSaves(MF, SavedRegs, RS);
1960
1961   MachineFrameInfo *MFI = MF.getFrameInfo();
1962
1963   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
1964   int64_t TailCallReturnAddrDelta = X86FI->getTCReturnAddrDelta();
1965
1966   if (TailCallReturnAddrDelta < 0) {
1967     // create RETURNADDR area
1968     //   arg
1969     //   arg
1970     //   RETADDR
1971     //   { ...
1972     //     RETADDR area
1973     //     ...
1974     //   }
1975     //   [EBP]
1976     MFI->CreateFixedObject(-TailCallReturnAddrDelta,
1977                            TailCallReturnAddrDelta - SlotSize, true);
1978   }
1979
1980   // Spill the BasePtr if it's used.
1981   if (TRI->hasBasePointer(MF)) {
1982     SavedRegs.set(TRI->getBaseRegister());
1983
1984     // Allocate a spill slot for EBP if we have a base pointer and EH funclets.
1985     if (MF.getMMI().hasEHFunclets()) {
1986       int FI = MFI->CreateSpillStackObject(SlotSize, SlotSize);
1987       X86FI->setHasSEHFramePtrSave(true);
1988       X86FI->setSEHFramePtrSaveIndex(FI);
1989     }
1990   }
1991 }
1992
1993 static bool
1994 HasNestArgument(const MachineFunction *MF) {
1995   const Function *F = MF->getFunction();
1996   for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
1997        I != E; I++) {
1998     if (I->hasNestAttr())
1999       return true;
2000   }
2001   return false;
2002 }
2003
2004 /// GetScratchRegister - Get a temp register for performing work in the
2005 /// segmented stack and the Erlang/HiPE stack prologue. Depending on platform
2006 /// and the properties of the function either one or two registers will be
2007 /// needed. Set primary to true for the first register, false for the second.
2008 static unsigned
2009 GetScratchRegister(bool Is64Bit, bool IsLP64, const MachineFunction &MF, bool Primary) {
2010   CallingConv::ID CallingConvention = MF.getFunction()->getCallingConv();
2011
2012   // Erlang stuff.
2013   if (CallingConvention == CallingConv::HiPE) {
2014     if (Is64Bit)
2015       return Primary ? X86::R14 : X86::R13;
2016     else
2017       return Primary ? X86::EBX : X86::EDI;
2018   }
2019
2020   if (Is64Bit) {
2021     if (IsLP64)
2022       return Primary ? X86::R11 : X86::R12;
2023     else
2024       return Primary ? X86::R11D : X86::R12D;
2025   }
2026
2027   bool IsNested = HasNestArgument(&MF);
2028
2029   if (CallingConvention == CallingConv::X86_FastCall ||
2030       CallingConvention == CallingConv::Fast) {
2031     if (IsNested)
2032       report_fatal_error("Segmented stacks does not support fastcall with "
2033                          "nested function.");
2034     return Primary ? X86::EAX : X86::ECX;
2035   }
2036   if (IsNested)
2037     return Primary ? X86::EDX : X86::EAX;
2038   return Primary ? X86::ECX : X86::EAX;
2039 }
2040
2041 // The stack limit in the TCB is set to this many bytes above the actual stack
2042 // limit.
2043 static const uint64_t kSplitStackAvailable = 256;
2044
2045 void X86FrameLowering::adjustForSegmentedStacks(
2046     MachineFunction &MF, MachineBasicBlock &PrologueMBB) const {
2047   MachineFrameInfo *MFI = MF.getFrameInfo();
2048   uint64_t StackSize;
2049   unsigned TlsReg, TlsOffset;
2050   DebugLoc DL;
2051
2052   unsigned ScratchReg = GetScratchRegister(Is64Bit, IsLP64, MF, true);
2053   assert(!MF.getRegInfo().isLiveIn(ScratchReg) &&
2054          "Scratch register is live-in");
2055
2056   if (MF.getFunction()->isVarArg())
2057     report_fatal_error("Segmented stacks do not support vararg functions.");
2058   if (!STI.isTargetLinux() && !STI.isTargetDarwin() && !STI.isTargetWin32() &&
2059       !STI.isTargetWin64() && !STI.isTargetFreeBSD() &&
2060       !STI.isTargetDragonFly())
2061     report_fatal_error("Segmented stacks not supported on this platform.");
2062
2063   // Eventually StackSize will be calculated by a link-time pass; which will
2064   // also decide whether checking code needs to be injected into this particular
2065   // prologue.
2066   StackSize = MFI->getStackSize();
2067
2068   // Do not generate a prologue for functions with a stack of size zero
2069   if (StackSize == 0)
2070     return;
2071
2072   MachineBasicBlock *allocMBB = MF.CreateMachineBasicBlock();
2073   MachineBasicBlock *checkMBB = MF.CreateMachineBasicBlock();
2074   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
2075   bool IsNested = false;
2076
2077   // We need to know if the function has a nest argument only in 64 bit mode.
2078   if (Is64Bit)
2079     IsNested = HasNestArgument(&MF);
2080
2081   // The MOV R10, RAX needs to be in a different block, since the RET we emit in
2082   // allocMBB needs to be last (terminating) instruction.
2083
2084   for (const auto &LI : PrologueMBB.liveins()) {
2085     allocMBB->addLiveIn(LI);
2086     checkMBB->addLiveIn(LI);
2087   }
2088
2089   if (IsNested)
2090     allocMBB->addLiveIn(IsLP64 ? X86::R10 : X86::R10D);
2091
2092   MF.push_front(allocMBB);
2093   MF.push_front(checkMBB);
2094
2095   // When the frame size is less than 256 we just compare the stack
2096   // boundary directly to the value of the stack pointer, per gcc.
2097   bool CompareStackPointer = StackSize < kSplitStackAvailable;
2098
2099   // Read the limit off the current stacklet off the stack_guard location.
2100   if (Is64Bit) {
2101     if (STI.isTargetLinux()) {
2102       TlsReg = X86::FS;
2103       TlsOffset = IsLP64 ? 0x70 : 0x40;
2104     } else if (STI.isTargetDarwin()) {
2105       TlsReg = X86::GS;
2106       TlsOffset = 0x60 + 90*8; // See pthread_machdep.h. Steal TLS slot 90.
2107     } else if (STI.isTargetWin64()) {
2108       TlsReg = X86::GS;
2109       TlsOffset = 0x28; // pvArbitrary, reserved for application use
2110     } else if (STI.isTargetFreeBSD()) {
2111       TlsReg = X86::FS;
2112       TlsOffset = 0x18;
2113     } else if (STI.isTargetDragonFly()) {
2114       TlsReg = X86::FS;
2115       TlsOffset = 0x20; // use tls_tcb.tcb_segstack
2116     } else {
2117       report_fatal_error("Segmented stacks not supported on this platform.");
2118     }
2119
2120     if (CompareStackPointer)
2121       ScratchReg = IsLP64 ? X86::RSP : X86::ESP;
2122     else
2123       BuildMI(checkMBB, DL, TII.get(IsLP64 ? X86::LEA64r : X86::LEA64_32r), ScratchReg).addReg(X86::RSP)
2124         .addImm(1).addReg(0).addImm(-StackSize).addReg(0);
2125
2126     BuildMI(checkMBB, DL, TII.get(IsLP64 ? X86::CMP64rm : X86::CMP32rm)).addReg(ScratchReg)
2127       .addReg(0).addImm(1).addReg(0).addImm(TlsOffset).addReg(TlsReg);
2128   } else {
2129     if (STI.isTargetLinux()) {
2130       TlsReg = X86::GS;
2131       TlsOffset = 0x30;
2132     } else if (STI.isTargetDarwin()) {
2133       TlsReg = X86::GS;
2134       TlsOffset = 0x48 + 90*4;
2135     } else if (STI.isTargetWin32()) {
2136       TlsReg = X86::FS;
2137       TlsOffset = 0x14; // pvArbitrary, reserved for application use
2138     } else if (STI.isTargetDragonFly()) {
2139       TlsReg = X86::FS;
2140       TlsOffset = 0x10; // use tls_tcb.tcb_segstack
2141     } else if (STI.isTargetFreeBSD()) {
2142       report_fatal_error("Segmented stacks not supported on FreeBSD i386.");
2143     } else {
2144       report_fatal_error("Segmented stacks not supported on this platform.");
2145     }
2146
2147     if (CompareStackPointer)
2148       ScratchReg = X86::ESP;
2149     else
2150       BuildMI(checkMBB, DL, TII.get(X86::LEA32r), ScratchReg).addReg(X86::ESP)
2151         .addImm(1).addReg(0).addImm(-StackSize).addReg(0);
2152
2153     if (STI.isTargetLinux() || STI.isTargetWin32() || STI.isTargetWin64() ||
2154         STI.isTargetDragonFly()) {
2155       BuildMI(checkMBB, DL, TII.get(X86::CMP32rm)).addReg(ScratchReg)
2156         .addReg(0).addImm(0).addReg(0).addImm(TlsOffset).addReg(TlsReg);
2157     } else if (STI.isTargetDarwin()) {
2158
2159       // TlsOffset doesn't fit into a mod r/m byte so we need an extra register.
2160       unsigned ScratchReg2;
2161       bool SaveScratch2;
2162       if (CompareStackPointer) {
2163         // The primary scratch register is available for holding the TLS offset.
2164         ScratchReg2 = GetScratchRegister(Is64Bit, IsLP64, MF, true);
2165         SaveScratch2 = false;
2166       } else {
2167         // Need to use a second register to hold the TLS offset
2168         ScratchReg2 = GetScratchRegister(Is64Bit, IsLP64, MF, false);
2169
2170         // Unfortunately, with fastcc the second scratch register may hold an
2171         // argument.
2172         SaveScratch2 = MF.getRegInfo().isLiveIn(ScratchReg2);
2173       }
2174
2175       // If Scratch2 is live-in then it needs to be saved.
2176       assert((!MF.getRegInfo().isLiveIn(ScratchReg2) || SaveScratch2) &&
2177              "Scratch register is live-in and not saved");
2178
2179       if (SaveScratch2)
2180         BuildMI(checkMBB, DL, TII.get(X86::PUSH32r))
2181           .addReg(ScratchReg2, RegState::Kill);
2182
2183       BuildMI(checkMBB, DL, TII.get(X86::MOV32ri), ScratchReg2)
2184         .addImm(TlsOffset);
2185       BuildMI(checkMBB, DL, TII.get(X86::CMP32rm))
2186         .addReg(ScratchReg)
2187         .addReg(ScratchReg2).addImm(1).addReg(0)
2188         .addImm(0)
2189         .addReg(TlsReg);
2190
2191       if (SaveScratch2)
2192         BuildMI(checkMBB, DL, TII.get(X86::POP32r), ScratchReg2);
2193     }
2194   }
2195
2196   // This jump is taken if SP >= (Stacklet Limit + Stack Space required).
2197   // It jumps to normal execution of the function body.
2198   BuildMI(checkMBB, DL, TII.get(X86::JA_1)).addMBB(&PrologueMBB);
2199
2200   // On 32 bit we first push the arguments size and then the frame size. On 64
2201   // bit, we pass the stack frame size in r10 and the argument size in r11.
2202   if (Is64Bit) {
2203     // Functions with nested arguments use R10, so it needs to be saved across
2204     // the call to _morestack
2205
2206     const unsigned RegAX = IsLP64 ? X86::RAX : X86::EAX;
2207     const unsigned Reg10 = IsLP64 ? X86::R10 : X86::R10D;
2208     const unsigned Reg11 = IsLP64 ? X86::R11 : X86::R11D;
2209     const unsigned MOVrr = IsLP64 ? X86::MOV64rr : X86::MOV32rr;
2210     const unsigned MOVri = IsLP64 ? X86::MOV64ri : X86::MOV32ri;
2211
2212     if (IsNested)
2213       BuildMI(allocMBB, DL, TII.get(MOVrr), RegAX).addReg(Reg10);
2214
2215     BuildMI(allocMBB, DL, TII.get(MOVri), Reg10)
2216       .addImm(StackSize);
2217     BuildMI(allocMBB, DL, TII.get(MOVri), Reg11)
2218       .addImm(X86FI->getArgumentStackSize());
2219   } else {
2220     BuildMI(allocMBB, DL, TII.get(X86::PUSHi32))
2221       .addImm(X86FI->getArgumentStackSize());
2222     BuildMI(allocMBB, DL, TII.get(X86::PUSHi32))
2223       .addImm(StackSize);
2224   }
2225
2226   // __morestack is in libgcc
2227   if (Is64Bit && MF.getTarget().getCodeModel() == CodeModel::Large) {
2228     // Under the large code model, we cannot assume that __morestack lives
2229     // within 2^31 bytes of the call site, so we cannot use pc-relative
2230     // addressing. We cannot perform the call via a temporary register,
2231     // as the rax register may be used to store the static chain, and all
2232     // other suitable registers may be either callee-save or used for
2233     // parameter passing. We cannot use the stack at this point either
2234     // because __morestack manipulates the stack directly.
2235     //
2236     // To avoid these issues, perform an indirect call via a read-only memory
2237     // location containing the address.
2238     //
2239     // This solution is not perfect, as it assumes that the .rodata section
2240     // is laid out within 2^31 bytes of each function body, but this seems
2241     // to be sufficient for JIT.
2242     BuildMI(allocMBB, DL, TII.get(X86::CALL64m))
2243         .addReg(X86::RIP)
2244         .addImm(0)
2245         .addReg(0)
2246         .addExternalSymbol("__morestack_addr")
2247         .addReg(0);
2248     MF.getMMI().setUsesMorestackAddr(true);
2249   } else {
2250     if (Is64Bit)
2251       BuildMI(allocMBB, DL, TII.get(X86::CALL64pcrel32))
2252         .addExternalSymbol("__morestack");
2253     else
2254       BuildMI(allocMBB, DL, TII.get(X86::CALLpcrel32))
2255         .addExternalSymbol("__morestack");
2256   }
2257
2258   if (IsNested)
2259     BuildMI(allocMBB, DL, TII.get(X86::MORESTACK_RET_RESTORE_R10));
2260   else
2261     BuildMI(allocMBB, DL, TII.get(X86::MORESTACK_RET));
2262
2263   allocMBB->addSuccessor(&PrologueMBB);
2264
2265   checkMBB->addSuccessor(allocMBB);
2266   checkMBB->addSuccessor(&PrologueMBB);
2267
2268 #ifdef XDEBUG
2269   MF.verify();
2270 #endif
2271 }
2272
2273 /// Erlang programs may need a special prologue to handle the stack size they
2274 /// might need at runtime. That is because Erlang/OTP does not implement a C
2275 /// stack but uses a custom implementation of hybrid stack/heap architecture.
2276 /// (for more information see Eric Stenman's Ph.D. thesis:
2277 /// http://publications.uu.se/uu/fulltext/nbn_se_uu_diva-2688.pdf)
2278 ///
2279 /// CheckStack:
2280 ///       temp0 = sp - MaxStack
2281 ///       if( temp0 < SP_LIMIT(P) ) goto IncStack else goto OldStart
2282 /// OldStart:
2283 ///       ...
2284 /// IncStack:
2285 ///       call inc_stack   # doubles the stack space
2286 ///       temp0 = sp - MaxStack
2287 ///       if( temp0 < SP_LIMIT(P) ) goto IncStack else goto OldStart
2288 void X86FrameLowering::adjustForHiPEPrologue(
2289     MachineFunction &MF, MachineBasicBlock &PrologueMBB) const {
2290   MachineFrameInfo *MFI = MF.getFrameInfo();
2291   DebugLoc DL;
2292   // HiPE-specific values
2293   const unsigned HipeLeafWords = 24;
2294   const unsigned CCRegisteredArgs = Is64Bit ? 6 : 5;
2295   const unsigned Guaranteed = HipeLeafWords * SlotSize;
2296   unsigned CallerStkArity = MF.getFunction()->arg_size() > CCRegisteredArgs ?
2297                             MF.getFunction()->arg_size() - CCRegisteredArgs : 0;
2298   unsigned MaxStack = MFI->getStackSize() + CallerStkArity*SlotSize + SlotSize;
2299
2300   assert(STI.isTargetLinux() &&
2301          "HiPE prologue is only supported on Linux operating systems.");
2302
2303   // Compute the largest caller's frame that is needed to fit the callees'
2304   // frames. This 'MaxStack' is computed from:
2305   //
2306   // a) the fixed frame size, which is the space needed for all spilled temps,
2307   // b) outgoing on-stack parameter areas, and
2308   // c) the minimum stack space this function needs to make available for the
2309   //    functions it calls (a tunable ABI property).
2310   if (MFI->hasCalls()) {
2311     unsigned MoreStackForCalls = 0;
2312
2313     for (MachineFunction::iterator MBBI = MF.begin(), MBBE = MF.end();
2314          MBBI != MBBE; ++MBBI)
2315       for (MachineBasicBlock::iterator MI = MBBI->begin(), ME = MBBI->end();
2316            MI != ME; ++MI) {
2317         if (!MI->isCall())
2318           continue;
2319
2320         // Get callee operand.
2321         const MachineOperand &MO = MI->getOperand(0);
2322
2323         // Only take account of global function calls (no closures etc.).
2324         if (!MO.isGlobal())
2325           continue;
2326
2327         const Function *F = dyn_cast<Function>(MO.getGlobal());
2328         if (!F)
2329           continue;
2330
2331         // Do not update 'MaxStack' for primitive and built-in functions
2332         // (encoded with names either starting with "erlang."/"bif_" or not
2333         // having a ".", such as a simple <Module>.<Function>.<Arity>, or an
2334         // "_", such as the BIF "suspend_0") as they are executed on another
2335         // stack.
2336         if (F->getName().find("erlang.") != StringRef::npos ||
2337             F->getName().find("bif_") != StringRef::npos ||
2338             F->getName().find_first_of("._") == StringRef::npos)
2339           continue;
2340
2341         unsigned CalleeStkArity =
2342           F->arg_size() > CCRegisteredArgs ? F->arg_size()-CCRegisteredArgs : 0;
2343         if (HipeLeafWords - 1 > CalleeStkArity)
2344           MoreStackForCalls = std::max(MoreStackForCalls,
2345                                (HipeLeafWords - 1 - CalleeStkArity) * SlotSize);
2346       }
2347     MaxStack += MoreStackForCalls;
2348   }
2349
2350   // If the stack frame needed is larger than the guaranteed then runtime checks
2351   // and calls to "inc_stack_0" BIF should be inserted in the assembly prologue.
2352   if (MaxStack > Guaranteed) {
2353     MachineBasicBlock *stackCheckMBB = MF.CreateMachineBasicBlock();
2354     MachineBasicBlock *incStackMBB = MF.CreateMachineBasicBlock();
2355
2356     for (const auto &LI : PrologueMBB.liveins()) {
2357       stackCheckMBB->addLiveIn(LI);
2358       incStackMBB->addLiveIn(LI);
2359     }
2360
2361     MF.push_front(incStackMBB);
2362     MF.push_front(stackCheckMBB);
2363
2364     unsigned ScratchReg, SPReg, PReg, SPLimitOffset;
2365     unsigned LEAop, CMPop, CALLop;
2366     if (Is64Bit) {
2367       SPReg = X86::RSP;
2368       PReg  = X86::RBP;
2369       LEAop = X86::LEA64r;
2370       CMPop = X86::CMP64rm;
2371       CALLop = X86::CALL64pcrel32;
2372       SPLimitOffset = 0x90;
2373     } else {
2374       SPReg = X86::ESP;
2375       PReg  = X86::EBP;
2376       LEAop = X86::LEA32r;
2377       CMPop = X86::CMP32rm;
2378       CALLop = X86::CALLpcrel32;
2379       SPLimitOffset = 0x4c;
2380     }
2381
2382     ScratchReg = GetScratchRegister(Is64Bit, IsLP64, MF, true);
2383     assert(!MF.getRegInfo().isLiveIn(ScratchReg) &&
2384            "HiPE prologue scratch register is live-in");
2385
2386     // Create new MBB for StackCheck:
2387     addRegOffset(BuildMI(stackCheckMBB, DL, TII.get(LEAop), ScratchReg),
2388                  SPReg, false, -MaxStack);
2389     // SPLimitOffset is in a fixed heap location (pointed by BP).
2390     addRegOffset(BuildMI(stackCheckMBB, DL, TII.get(CMPop))
2391                  .addReg(ScratchReg), PReg, false, SPLimitOffset);
2392     BuildMI(stackCheckMBB, DL, TII.get(X86::JAE_1)).addMBB(&PrologueMBB);
2393
2394     // Create new MBB for IncStack:
2395     BuildMI(incStackMBB, DL, TII.get(CALLop)).
2396       addExternalSymbol("inc_stack_0");
2397     addRegOffset(BuildMI(incStackMBB, DL, TII.get(LEAop), ScratchReg),
2398                  SPReg, false, -MaxStack);
2399     addRegOffset(BuildMI(incStackMBB, DL, TII.get(CMPop))
2400                  .addReg(ScratchReg), PReg, false, SPLimitOffset);
2401     BuildMI(incStackMBB, DL, TII.get(X86::JLE_1)).addMBB(incStackMBB);
2402
2403     stackCheckMBB->addSuccessor(&PrologueMBB, {99, 100});
2404     stackCheckMBB->addSuccessor(incStackMBB, {1, 100});
2405     incStackMBB->addSuccessor(&PrologueMBB, {99, 100});
2406     incStackMBB->addSuccessor(incStackMBB, {1, 100});
2407   }
2408 #ifdef XDEBUG
2409   MF.verify();
2410 #endif
2411 }
2412
2413 bool X86FrameLowering::adjustStackWithPops(MachineBasicBlock &MBB,
2414     MachineBasicBlock::iterator MBBI, DebugLoc DL, int Offset) const {
2415
2416   if (Offset <= 0)
2417     return false;
2418
2419   if (Offset % SlotSize)
2420     return false;
2421
2422   int NumPops = Offset / SlotSize;
2423   // This is only worth it if we have at most 2 pops.
2424   if (NumPops != 1 && NumPops != 2)
2425     return false;
2426
2427   // Handle only the trivial case where the adjustment directly follows
2428   // a call. This is the most common one, anyway.
2429   if (MBBI == MBB.begin())
2430     return false;
2431   MachineBasicBlock::iterator Prev = std::prev(MBBI);
2432   if (!Prev->isCall() || !Prev->getOperand(1).isRegMask())
2433     return false;
2434
2435   unsigned Regs[2];
2436   unsigned FoundRegs = 0;
2437
2438   auto RegMask = Prev->getOperand(1);
2439
2440   auto &RegClass =
2441       Is64Bit ? X86::GR64_NOREX_NOSPRegClass : X86::GR32_NOREX_NOSPRegClass;
2442   // Try to find up to NumPops free registers.
2443   for (auto Candidate : RegClass) {
2444
2445     // Poor man's liveness:
2446     // Since we're immediately after a call, any register that is clobbered
2447     // by the call and not defined by it can be considered dead.
2448     if (!RegMask.clobbersPhysReg(Candidate))
2449       continue;
2450
2451     bool IsDef = false;
2452     for (const MachineOperand &MO : Prev->implicit_operands()) {
2453       if (MO.isReg() && MO.isDef() && MO.getReg() == Candidate) {
2454         IsDef = true;
2455         break;
2456       }
2457     }
2458
2459     if (IsDef)
2460       continue;
2461
2462     Regs[FoundRegs++] = Candidate;
2463     if (FoundRegs == (unsigned)NumPops)
2464       break;
2465   }
2466
2467   if (FoundRegs == 0)
2468     return false;
2469
2470   // If we found only one free register, but need two, reuse the same one twice.
2471   while (FoundRegs < (unsigned)NumPops)
2472     Regs[FoundRegs++] = Regs[0];
2473
2474   for (int i = 0; i < NumPops; ++i)
2475     BuildMI(MBB, MBBI, DL,
2476             TII.get(STI.is64Bit() ? X86::POP64r : X86::POP32r), Regs[i]);
2477
2478   return true;
2479 }
2480
2481 void X86FrameLowering::
2482 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
2483                               MachineBasicBlock::iterator I) const {
2484   bool reserveCallFrame = hasReservedCallFrame(MF);
2485   unsigned Opcode = I->getOpcode();
2486   bool isDestroy = Opcode == TII.getCallFrameDestroyOpcode();
2487   DebugLoc DL = I->getDebugLoc();
2488   uint64_t Amount = !reserveCallFrame ? I->getOperand(0).getImm() : 0;
2489   uint64_t InternalAmt = (isDestroy || Amount) ? I->getOperand(1).getImm() : 0;
2490   I = MBB.erase(I);
2491
2492   if (!reserveCallFrame) {
2493     // If the stack pointer can be changed after prologue, turn the
2494     // adjcallstackup instruction into a 'sub ESP, <amt>' and the
2495     // adjcallstackdown instruction into 'add ESP, <amt>'
2496
2497     // We need to keep the stack aligned properly.  To do this, we round the
2498     // amount of space needed for the outgoing arguments up to the next
2499     // alignment boundary.
2500     unsigned StackAlign = getStackAlignment();
2501     Amount = RoundUpToAlignment(Amount, StackAlign);
2502
2503     MachineModuleInfo &MMI = MF.getMMI();
2504     const Function *Fn = MF.getFunction();
2505     bool WindowsCFI = MF.getTarget().getMCAsmInfo()->usesWindowsCFI();
2506     bool DwarfCFI = !WindowsCFI &&
2507                     (MMI.hasDebugInfo() || Fn->needsUnwindTableEntry());
2508
2509     // If we have any exception handlers in this function, and we adjust
2510     // the SP before calls, we may need to indicate this to the unwinder
2511     // using GNU_ARGS_SIZE. Note that this may be necessary even when
2512     // Amount == 0, because the preceding function may have set a non-0
2513     // GNU_ARGS_SIZE.
2514     // TODO: We don't need to reset this between subsequent functions,
2515     // if it didn't change.
2516     bool HasDwarfEHHandlers = !WindowsCFI &&
2517                               !MF.getMMI().getLandingPads().empty();
2518
2519     if (HasDwarfEHHandlers && !isDestroy &&
2520         MF.getInfo<X86MachineFunctionInfo>()->getHasPushSequences())
2521       BuildCFI(MBB, I, DL,
2522                MCCFIInstruction::createGnuArgsSize(nullptr, Amount));
2523
2524     if (Amount == 0)
2525       return;
2526
2527     // Factor out the amount that gets handled inside the sequence
2528     // (Pushes of argument for frame setup, callee pops for frame destroy)
2529     Amount -= InternalAmt;
2530
2531     // TODO: This is needed only if we require precise CFA.
2532     // If this is a callee-pop calling convention, emit a CFA adjust for
2533     // the amount the callee popped.
2534     if (isDestroy && InternalAmt && DwarfCFI && !hasFP(MF))
2535       BuildCFI(MBB, I, DL,
2536                MCCFIInstruction::createAdjustCfaOffset(nullptr, -InternalAmt));
2537
2538     if (Amount) {
2539       // Add Amount to SP to destroy a frame, and subtract to setup.
2540       int Offset = isDestroy ? Amount : -Amount;
2541
2542       if (!(Fn->optForMinSize() &&
2543             adjustStackWithPops(MBB, I, DL, Offset)))
2544         BuildStackAdjustment(MBB, I, DL, Offset, /*InEpilogue=*/false);
2545     }
2546
2547     if (DwarfCFI && !hasFP(MF)) {
2548       // If we don't have FP, but need to generate unwind information,
2549       // we need to set the correct CFA offset after the stack adjustment.
2550       // How much we adjust the CFA offset depends on whether we're emitting
2551       // CFI only for EH purposes or for debugging. EH only requires the CFA
2552       // offset to be correct at each call site, while for debugging we want
2553       // it to be more precise.
2554       int CFAOffset = Amount;
2555       // TODO: When not using precise CFA, we also need to adjust for the
2556       // InternalAmt here.
2557
2558       if (CFAOffset) {
2559         CFAOffset = isDestroy ? -CFAOffset : CFAOffset;
2560         BuildCFI(MBB, I, DL,
2561                  MCCFIInstruction::createAdjustCfaOffset(nullptr, CFAOffset));
2562       }
2563     }
2564
2565     return;
2566   }
2567
2568   if (isDestroy && InternalAmt) {
2569     // If we are performing frame pointer elimination and if the callee pops
2570     // something off the stack pointer, add it back.  We do this until we have
2571     // more advanced stack pointer tracking ability.
2572     // We are not tracking the stack pointer adjustment by the callee, so make
2573     // sure we restore the stack pointer immediately after the call, there may
2574     // be spill code inserted between the CALL and ADJCALLSTACKUP instructions.
2575     MachineBasicBlock::iterator B = MBB.begin();
2576     while (I != B && !std::prev(I)->isCall())
2577       --I;
2578     BuildStackAdjustment(MBB, I, DL, -InternalAmt, /*InEpilogue=*/false);
2579   }
2580 }
2581
2582 bool X86FrameLowering::canUseAsEpilogue(const MachineBasicBlock &MBB) const {
2583   assert(MBB.getParent() && "Block is not attached to a function!");
2584
2585   // Win64 has strict requirements in terms of epilogue and we are
2586   // not taking a chance at messing with them.
2587   // I.e., unless this block is already an exit block, we can't use
2588   // it as an epilogue.
2589   if (STI.isTargetWin64() && !MBB.succ_empty() && !MBB.isReturnBlock())
2590     return false;
2591
2592   if (canUseLEAForSPInEpilogue(*MBB.getParent()))
2593     return true;
2594
2595   // If we cannot use LEA to adjust SP, we may need to use ADD, which
2596   // clobbers the EFLAGS. Check that we do not need to preserve it,
2597   // otherwise, conservatively assume this is not
2598   // safe to insert the epilogue here.
2599   return !flagsNeedToBePreservedBeforeTheTerminators(MBB);
2600 }
2601
2602 bool X86FrameLowering::enableShrinkWrapping(const MachineFunction &MF) const {
2603   // If we may need to emit frameless compact unwind information, give
2604   // up as this is currently broken: PR25614.
2605   return MF.getFunction()->hasFnAttribute(Attribute::NoUnwind) || hasFP(MF);
2606 }
2607
2608 MachineBasicBlock::iterator X86FrameLowering::restoreWin32EHStackPointers(
2609     MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
2610     DebugLoc DL, bool RestoreSP) const {
2611   assert(STI.isTargetWindowsMSVC() && "funclets only supported in MSVC env");
2612   assert(STI.isTargetWin32() && "EBP/ESI restoration only required on win32");
2613   assert(STI.is32Bit() && !Uses64BitFramePtr &&
2614          "restoring EBP/ESI on non-32-bit target");
2615
2616   MachineFunction &MF = *MBB.getParent();
2617   unsigned FramePtr = TRI->getFrameRegister(MF);
2618   unsigned BasePtr = TRI->getBaseRegister();
2619   WinEHFuncInfo &FuncInfo = *MF.getWinEHFuncInfo();
2620   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
2621   MachineFrameInfo *MFI = MF.getFrameInfo();
2622
2623   // FIXME: Don't set FrameSetup flag in catchret case.
2624
2625   int FI = FuncInfo.EHRegNodeFrameIndex;
2626   int EHRegSize = MFI->getObjectSize(FI);
2627
2628   if (RestoreSP) {
2629     // MOV32rm -EHRegSize(%ebp), %esp
2630     addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32rm), X86::ESP),
2631                  X86::EBP, true, -EHRegSize)
2632         .setMIFlag(MachineInstr::FrameSetup);
2633   }
2634
2635   unsigned UsedReg;
2636   int EHRegOffset = getFrameIndexReference(MF, FI, UsedReg);
2637   int EndOffset = -EHRegOffset - EHRegSize;
2638   FuncInfo.EHRegNodeEndOffset = EndOffset;
2639
2640   if (UsedReg == FramePtr) {
2641     // ADD $offset, %ebp
2642     unsigned ADDri = getADDriOpcode(false, EndOffset);
2643     BuildMI(MBB, MBBI, DL, TII.get(ADDri), FramePtr)
2644         .addReg(FramePtr)
2645         .addImm(EndOffset)
2646         .setMIFlag(MachineInstr::FrameSetup)
2647         ->getOperand(3)
2648         .setIsDead();
2649     assert(EndOffset >= 0 &&
2650            "end of registration object above normal EBP position!");
2651   } else if (UsedReg == BasePtr) {
2652     // LEA offset(%ebp), %esi
2653     addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::LEA32r), BasePtr),
2654                  FramePtr, false, EndOffset)
2655         .setMIFlag(MachineInstr::FrameSetup);
2656     // MOV32rm SavedEBPOffset(%esi), %ebp
2657     assert(X86FI->getHasSEHFramePtrSave());
2658     int Offset =
2659         getFrameIndexReference(MF, X86FI->getSEHFramePtrSaveIndex(), UsedReg);
2660     assert(UsedReg == BasePtr);
2661     addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32rm), FramePtr),
2662                  UsedReg, true, Offset)
2663         .setMIFlag(MachineInstr::FrameSetup);
2664   } else {
2665     llvm_unreachable("32-bit frames with WinEH must use FramePtr or BasePtr");
2666   }
2667   return MBBI;
2668 }
2669
2670 unsigned X86FrameLowering::getWinEHParentFrameOffset(const MachineFunction &MF) const {
2671   // RDX, the parent frame pointer, is homed into 16(%rsp) in the prologue.
2672   unsigned Offset = 16;
2673   // RBP is immediately pushed.
2674   Offset += SlotSize;
2675   // All callee-saved registers are then pushed.
2676   Offset += MF.getInfo<X86MachineFunctionInfo>()->getCalleeSavedFrameSize();
2677   // Every funclet allocates enough stack space for the largest outgoing call.
2678   Offset += getWinEHFuncletFrameSize(MF);
2679   return Offset;
2680 }
2681
2682 void X86FrameLowering::processFunctionBeforeFrameFinalized(
2683     MachineFunction &MF, RegScavenger *RS) const {
2684   // If this function isn't doing Win64-style C++ EH, we don't need to do
2685   // anything.
2686   const Function *Fn = MF.getFunction();
2687   if (!STI.is64Bit() || !MF.getMMI().hasEHFunclets() ||
2688       classifyEHPersonality(Fn->getPersonalityFn()) != EHPersonality::MSVC_CXX)
2689     return;
2690
2691   // Win64 C++ EH needs to allocate the UnwindHelp object at some fixed offset
2692   // relative to RSP after the prologue.  Find the offset of the last fixed
2693   // object, so that we can allocate a slot immediately following it. If there
2694   // were no fixed objects, use offset -SlotSize, which is immediately after the
2695   // return address. Fixed objects have negative frame indices.
2696   MachineFrameInfo *MFI = MF.getFrameInfo();
2697   int64_t MinFixedObjOffset = -SlotSize;
2698   for (int I = MFI->getObjectIndexBegin(); I < 0; ++I)
2699     MinFixedObjOffset = std::min(MinFixedObjOffset, MFI->getObjectOffset(I));
2700
2701   int64_t UnwindHelpOffset = MinFixedObjOffset - SlotSize;
2702   int UnwindHelpFI =
2703       MFI->CreateFixedObject(SlotSize, UnwindHelpOffset, /*Immutable=*/false);
2704   MF.getWinEHFuncInfo()->UnwindHelpFrameIdx = UnwindHelpFI;
2705
2706   // Store -2 into UnwindHelp on function entry. We have to scan forwards past
2707   // other frame setup instructions.
2708   MachineBasicBlock &MBB = MF.front();
2709   auto MBBI = MBB.begin();
2710   while (MBBI != MBB.end() && MBBI->getFlag(MachineInstr::FrameSetup))
2711     ++MBBI;
2712
2713   DebugLoc DL = MBB.findDebugLoc(MBBI);
2714   addFrameReference(BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64mi32)),
2715                     UnwindHelpFI)
2716       .addImm(-2);
2717 }