X86: introduce a new `FrameBuilder` type

[compnerd]

Summary

This introduces a new FrameBuilder type to try to reduce the
complexity in the PEI handling in the frame lowering. This is
currently a small added complexity for incrementally migrating
the implementation to this type which can be shared across the
prologue and epilogue emission as they both recompute a shared
set of information. It should allow for the prologue emission
to become a dispatch over the format - funclet, windows 32/64,
or Unix.

[rnk]

Looks good to me!

llvm/lib/Target/X86/X86FrameLowering.cpp

1786

As future work, you could probably add FrameBuilder::BuildMI methods that return a MachineInstrBuilder and fill in the standard insertion point and debug location, and which perhaps include the TII.get() opcode lookup.

llvm/lib/Target/X86/X86FrameLowering.cpp

 bool X86FrameLowering::isWin64Prologue(const MachineFunction &MF) const {
   return MF.getTarget().getMCAsmInfo()->usesWindowsCFI();
 }
 
 bool X86FrameLowering::needsDwarfCFI(const MachineFunction &MF) const {
   return !isWin64Prologue(MF) && MF.needsFrameMoves();
 }
 
+namespace {
+class FrameBuilder final {
+  const Function &F;
+
+  MachineFunction &MF;
+  MachineBasicBlock &MBB;
+  MachineModuleInfo &MMI;
+
+  const X86Subtarget &STI;
+  const X86InstrInfo &TII;
+
+  // Indicates if the target uses Windows CFI directives.
+  bool TargetUsesWinCFI;
+
+  // Indiciates if we are building the frame for a funclet.
+  bool IsFunclet;
+
+  // Indicates if the frame needs CFI directives to be emitted for FPO.
+  bool ShouldEmitWinFPO;
+
+  // Indicates if the frame needs CFI directives to be emitted.
+  bool ShouldEmitWinCFI;
+
+  // The insertion point for the basic block.
+  MachineBasicBlock::iterator MBBI;
+
+  // The debug location associated with any instruction emitted.  This should be
+  // the unknown value for the prologue as the first debug instruction
+  // establishes the end of the prologue.
+  DebugLoc DL;
+
+  // Indicates if the frame has any Windows CFI directives.
+  bool HasWinCFI = false;
+
+  // NOTE: Temporarily friend the emission function until the entire function is
+  // migrated to the builder.
+  friend void X86FrameLowering::emitPrologue(MachineFunction &,
+                                             MachineBasicBlock &) const;
+
+public:
+  FrameBuilder(MachineFunction &MF, MachineBasicBlock &MBB)
+      : F(MF.getFunction()), MF(MF), MBB(MBB), MMI(MF.getMMI()),
+        STI(MF.getSubtarget<X86Subtarget>()), TII(*STI.getInstrInfo()),
+        MBBI(MBB.begin()) {
+    TargetUsesWinCFI = MF.getTarget().getMCAsmInfo()->usesWindowsCFI();
+
+    IsFunclet = MBB.isEHFuncletEntry();
+
+    // FIXME: we should emit FPO data for funclets as well.
+    ShouldEmitWinFPO =
+        STI.isTargetWin32() && MMI.getModule()->getCodeViewFlag() && !IsFunclet;
+
+    // Emit CFI directives if the the frame needs to support unwinding or if we
+    // need to emit FPO data.
+    ShouldEmitWinCFI =
+        (TargetUsesWinCFI && F.needsUnwindTableEntry()) || ShouldEmitWinFPO;
+  }
+
+private:
+  void EmitWinCFI(unsigned CFI, std::initializer_list<int64_t> Args = {}) {
+    if (!ShouldEmitWinCFI)
+      return;
+
+    MachineInstrBuilder MIB = BuildMI(MBB, MBBI, DL, TII.get(CFI));
+    for (int64_t Imm : Args)
+      MIB.addImm(Imm);
+    MIB.setMIFlag(MachineInstr::FrameSetup);
+
+    HasWinCFI = true;
+  }
+};
+}
+
 /// emitPrologue - Push callee-saved registers onto the stack, which
 /// automatically adjust the stack pointer. Adjust the stack pointer to allocate
 /// space for local variables. Also emit labels used by the exception handler to
 /// generate the exception handling frames.
 
 /*
   Here's a gist of what gets emitted:
 

   - .cfi directives are emitted for all other ABIs
   - for 32-bit code, substitute %e?? registers for %r??
 */
 
 void X86FrameLowering::emitPrologue(MachineFunction &MF,
                                     MachineBasicBlock &MBB) const {
   assert(&STI == &MF.getSubtarget<X86Subtarget>() &&
          "MF used frame lowering for wrong subtarget");
-  MachineBasicBlock::iterator MBBI = MBB.begin();
+
   MachineFrameInfo &MFI = MF.getFrameInfo();
   const Function &Fn = MF.getFunction();
-  MachineModuleInfo &MMI = MF.getMMI();
   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
   uint64_t MaxAlign = calculateMaxStackAlign(MF); // Desired stack alignment.
   uint64_t StackSize = MFI.getStackSize();    // Number of bytes to allocate.
   bool IsFunclet = MBB.isEHFuncletEntry();
   EHPersonality Personality = EHPersonality::Unknown;
   if (Fn.hasPersonalityFn())
     Personality = classifyEHPersonality(Fn.getPersonalityFn());
   bool FnHasClrFunclet =
       MF.hasEHFunclets() && Personality == EHPersonality::CoreCLR;
   bool IsClrFunclet = IsFunclet && FnHasClrFunclet;
   bool HasFP = hasFP(MF);
   bool IsWin64Prologue = isWin64Prologue(MF);
-  bool NeedsWin64CFI = IsWin64Prologue && Fn.needsUnwindTableEntry();
-  // FIXME: Emit FPO data for EH funclets.
-  bool NeedsWinFPO =
-      !IsFunclet && STI.isTargetWin32() && MMI.getModule()->getCodeViewFlag();
-  bool NeedsWinCFI = NeedsWin64CFI || NeedsWinFPO;
   bool NeedsDwarfCFI = needsDwarfCFI(MF);
   Register FramePtr = TRI->getFrameRegister(MF);
   const Register MachineFramePtr =
       STI.isTarget64BitILP32()
           ? Register(getX86SubSuperRegister(FramePtr, 64)) : FramePtr;
   Register BasePtr = TRI->getBaseRegister();
-  bool HasWinCFI = false;
 
-  // Debug location must be unknown since the first debug location is used
-  // to determine the end of the prologue.
-  DebugLoc DL;
+  FrameBuilder FB(MF, MBB);
 
   // Add RETADDR move area to callee saved frame size.
   int TailCallReturnAddrDelta = X86FI->getTCReturnAddrDelta();
   if (TailCallReturnAddrDelta && IsWin64Prologue)
     report_fatal_error("Can't handle guaranteed tail call under win64 yet");
 
   if (TailCallReturnAddrDelta < 0)
     X86FI->setCalleeSavedFrameSize(
       X86FI->getCalleeSavedFrameSize() - TailCallReturnAddrDelta);
 
   const bool EmitStackProbeCall =
       STI.getTargetLowering()->hasStackProbeSymbol(MF);
   unsigned StackProbeSize = STI.getTargetLowering()->getStackProbeSize(MF);
 
   if (HasFP && X86FI->hasSwiftAsyncContext()) {
-    BuildMI(MBB, MBBI, DL, TII.get(X86::BTS64ri8),
+    BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::BTS64ri8),
             MachineFramePtr)
         .addUse(MachineFramePtr)
         .addImm(60)
         .setMIFlag(MachineInstr::FrameSetup);
   }
 
   // Re-align the stack on 64-bit if the x86-interrupt calling convention is
   // used and an error code was pushed, since the x86-64 ABI requires a 16-byte
   // stack alignment.
   if (Fn.getCallingConv() == CallingConv::X86_INTR && Is64Bit &&
       Fn.arg_size() == 2) {
     StackSize += 8;
     MFI.setStackSize(StackSize);
-    emitSPUpdate(MBB, MBBI, DL, -8, /*InEpilogue=*/false);
+    emitSPUpdate(MBB, FB.MBBI, FB.DL, -8, /*InEpilogue=*/false);
   }
 
   // If this is x86-64 and the Red Zone is not disabled, if we are a leaf
   // function, and use up to 128 bytes of stack space, don't have a frame
   // pointer, calls, or dynamic alloca then we do not need to adjust the
   // stack pointer (we fit in the Red Zone). We also check that we don't
   // push and pop from the stack.
   if (has128ByteRedZone(MF) && !TRI->hasStackRealignment(MF) &&
       !MFI.hasVarSizedObjects() &&             // No dynamic alloca.
       !MFI.adjustsStack() &&                   // No calls.
       !EmitStackProbeCall &&                   // No stack probes.
       !MFI.hasCopyImplyingStackAdjustment() && // Don't push and pop.
       !MF.shouldSplitStack()) {                // Regular stack
     uint64_t MinSize = X86FI->getCalleeSavedFrameSize();
     if (HasFP) MinSize += SlotSize;
     X86FI->setUsesRedZone(MinSize > 0 || StackSize > 0);
     StackSize = std::max(MinSize, StackSize > 128 ? StackSize - 128 : 0);
     MFI.setStackSize(StackSize);
   }
 
   // Insert stack pointer adjustment for later moving of return addr.  Only
   // applies to tail call optimized functions where the callee argument stack
   // size is bigger than the callers.
   if (TailCallReturnAddrDelta < 0) {
-    BuildStackAdjustment(MBB, MBBI, DL, TailCallReturnAddrDelta,
+    BuildStackAdjustment(MBB, FB.MBBI, FB.DL, TailCallReturnAddrDelta,
                          /*InEpilogue=*/false)
         .setMIFlag(MachineInstr::FrameSetup);
   }
 
   // Mapping for machine moves:
   //
   //   DST: VirtualFP AND
   //        SRC: VirtualFP              => DW_CFA_def_cfa_offset

   else if (IsFunclet)
     Establisher = Uses64BitFramePtr ? X86::RDX : X86::EDX;
 
   if (IsWin64Prologue && IsFunclet && !IsClrFunclet) {
     // Immediately spill establisher into the home slot.
     // The runtime cares about this.
     // MOV64mr %rdx, 16(%rsp)
     unsigned MOVmr = Uses64BitFramePtr ? X86::MOV64mr : X86::MOV32mr;
-    addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(MOVmr)), StackPtr, true, 16)
+    addRegOffset(BuildMI(MBB, FB.MBBI, FB.DL, TII.get(MOVmr)), StackPtr, true,
+                 16)
         .addReg(Establisher)
         .setMIFlag(MachineInstr::FrameSetup);
     MBB.addLiveIn(Establisher);
   }
 
   if (HasFP) {
     assert(MF.getRegInfo().isReserved(MachineFramePtr) && "FP reserved");
 
     // Calculate required stack adjustment.
     uint64_t FrameSize = StackSize - SlotSize;
-    // If required, include space for extra hidden slot for stashing base pointer.
+    // If required, include space for extra hidden slot for stashing base
+    // pointer.
     if (X86FI->getRestoreBasePointer())
       FrameSize += SlotSize;
 
     NumBytes = FrameSize - X86FI->getCalleeSavedFrameSize();
 
     // Callee-saved registers are pushed on stack before the stack is realigned.
     if (TRI->hasStackRealignment(MF) && !IsWin64Prologue)
       NumBytes = alignTo(NumBytes, MaxAlign);
 
     // Save EBP/RBP into the appropriate stack slot.
-    BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::PUSH64r : X86::PUSH32r))
+    BuildMI(MBB, FB.MBBI, FB.DL, TII.get(Is64Bit ? X86::PUSH64r : X86::PUSH32r))
         .addReg(MachineFramePtr, RegState::Kill)
         .setMIFlag(MachineInstr::FrameSetup);
 
     if (NeedsDwarfCFI) {
       // Mark the place where EBP/RBP was saved.
       // Define the current CFA rule to use the provided offset.
       assert(StackSize);
-      BuildCFI(MBB, MBBI, DL,
+      BuildCFI(MBB, FB.MBBI, FB.DL,
                MCCFIInstruction::cfiDefCfaOffset(nullptr, -2 * stackGrowth));
 
       // Change the rule for the FramePtr to be an "offset" rule.
       unsigned DwarfFramePtr = TRI->getDwarfRegNum(MachineFramePtr, true);
-      BuildCFI(MBB, MBBI, DL, MCCFIInstruction::createOffset(
+      BuildCFI(MBB, FB.MBBI, FB.DL, MCCFIInstruction::createOffset(
                                   nullptr, DwarfFramePtr, 2 * stackGrowth));
     }
 
-    if (NeedsWinCFI) {
-      HasWinCFI = true;
-      BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_PushReg))
-          .addImm(FramePtr)
-          .setMIFlag(MachineInstr::FrameSetup);
-    }
+    FB.EmitWinCFI(X86::SEH_PushReg, {FramePtr});
 
     if (!IsFunclet) {
       if (X86FI->hasSwiftAsyncContext()) {
         const auto &Attrs = MF.getFunction().getAttributes();
 
         // Before we update the live frame pointer we have to ensure there's a
         // valid (or null) asynchronous context in its slot just before FP in
         // the frame record, so store it now.
         if (Attrs.hasAttrSomewhere(Attribute::SwiftAsync)) {
           // We have an initial context in r14, store it just before the frame
           // pointer.
           MBB.addLiveIn(X86::R14);
-          BuildMI(MBB, MBBI, DL, TII.get(X86::PUSH64r))
+          BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::PUSH64r))
               .addReg(X86::R14)
               .setMIFlag(MachineInstr::FrameSetup);
         } else {
           // No initial context, store null so that there's no pointer that
           // could be misused.
-          BuildMI(MBB, MBBI, DL, TII.get(X86::PUSH64i8))
+          BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::PUSH64i8))
               .addImm(0)
               .setMIFlag(MachineInstr::FrameSetup);
         }
 
-        if (NeedsWinCFI) {
-          HasWinCFI = true;
-          BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_PushReg))
-              .addImm(X86::R14)
-              .setMIFlag(MachineInstr::FrameSetup);
-        }
+        FB.EmitWinCFI(X86::SEH_PushReg, {X86::R14});
 
-        BuildMI(MBB, MBBI, DL, TII.get(X86::LEA64r), FramePtr)
+        BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::LEA64r), FramePtr)
             .addUse(X86::RSP)
             .addImm(1)
             .addUse(X86::NoRegister)
             .addImm(8)
             .addUse(X86::NoRegister)
             .setMIFlag(MachineInstr::FrameSetup);
-        BuildMI(MBB, MBBI, DL, TII.get(X86::SUB64ri8), X86::RSP)
+        BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::SUB64ri8), X86::RSP)
             .addUse(X86::RSP)
             .addImm(8)
             .setMIFlag(MachineInstr::FrameSetup);
       }
 
       if (!IsWin64Prologue && !IsFunclet) {
         // Update EBP with the new base value.
         if (!X86FI->hasSwiftAsyncContext())
-          BuildMI(MBB, MBBI, DL,
+          BuildMI(MBB, FB.MBBI, FB.DL,
                   TII.get(Uses64BitFramePtr ? X86::MOV64rr : X86::MOV32rr),
                   FramePtr)
               .addReg(StackPtr)
               .setMIFlag(MachineInstr::FrameSetup);
 
         if (NeedsDwarfCFI) {
           // Mark effective beginning of when frame pointer becomes valid.
           // Define the current CFA to use the EBP/RBP register.
           unsigned DwarfFramePtr = TRI->getDwarfRegNum(MachineFramePtr, true);
           BuildCFI(
-              MBB, MBBI, DL,
+              MBB, FB.MBBI, FB.DL,
               MCCFIInstruction::createDefCfaRegister(nullptr, DwarfFramePtr));
         }
 
-        if (NeedsWinFPO) {
-          // .cv_fpo_setframe $FramePtr
-          HasWinCFI = true;
-          BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_SetFrame))
-              .addImm(FramePtr)
-              .addImm(0)
-              .setMIFlag(MachineInstr::FrameSetup);
-        }
+        // .cv_fpo_setframe $FramePtr
+        if (FB.ShouldEmitWinFPO)
+          FB.EmitWinCFI(X86::SEH_SetFrame, {FramePtr, 0});
       }
     }
   } else {
     assert(!IsFunclet && "funclets without FPs not yet implemented");
     NumBytes = StackSize - X86FI->getCalleeSavedFrameSize();
   }
 
   // Update the offset adjustment, which is mainly used by codeview to translate

   unsigned ParentFrameNumBytes = NumBytes;
   if (IsFunclet)
     NumBytes = getWinEHFuncletFrameSize(MF);
 
   // Skip the callee-saved push instructions.
   bool PushedRegs = false;
   int StackOffset = 2 * stackGrowth;
 
-  while (MBBI != MBB.end() &&
-         MBBI->getFlag(MachineInstr::FrameSetup) &&
-         (MBBI->getOpcode() == X86::PUSH32r ||
-          MBBI->getOpcode() == X86::PUSH64r)) {
+  while (FB.MBBI != MBB.end() &&
+         FB.MBBI->getFlag(MachineInstr::FrameSetup) &&
+         (FB.MBBI->getOpcode() == X86::PUSH32r ||
+          FB.MBBI->getOpcode() == X86::PUSH64r)) {
     PushedRegs = true;
-    Register Reg = MBBI->getOperand(0).getReg();
-    ++MBBI;
+    Register Reg = FB.MBBI->getOperand(0).getReg();
+    ++FB.MBBI;
 
     if (!HasFP && NeedsDwarfCFI) {
       // Mark callee-saved push instruction.
       // Define the current CFA rule to use the provided offset.
       assert(StackSize);
-      BuildCFI(MBB, MBBI, DL,
+      BuildCFI(MBB, FB.MBBI, FB.DL,
                MCCFIInstruction::cfiDefCfaOffset(nullptr, -StackOffset));
       StackOffset += stackGrowth;
     }
 
-    if (NeedsWinCFI) {
-      HasWinCFI = true;
-      BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_PushReg))
-          .addImm(Reg)
-          .setMIFlag(MachineInstr::FrameSetup);
-    }
+    FB.EmitWinCFI(X86::SEH_PushReg, {Reg});
   }
 
   // Realign stack after we pushed callee-saved registers (so that we'll be
   // able to calculate their offsets from the frame pointer).
   // Don't do this for Win64, it needs to realign the stack after the prologue.
   if (!IsWin64Prologue && !IsFunclet && TRI->hasStackRealignment(MF)) {
     assert(HasFP && "There should be a frame pointer if stack is realigned.");
-    BuildStackAlignAND(MBB, MBBI, DL, StackPtr, MaxAlign);
-
-    if (NeedsWinCFI) {
-      HasWinCFI = true;
-      BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_StackAlign))
-          .addImm(MaxAlign)
-          .setMIFlag(MachineInstr::FrameSetup);
-    }
+    BuildStackAlignAND(MBB, FB.MBBI, FB.DL, StackPtr, MaxAlign);
+    FB.EmitWinCFI(X86::SEH_StackAlign, {static_cast<int64_t>(MaxAlign)});
   }
 
   // If there is an SUB32ri of ESP immediately before this instruction, merge
   // the two. This can be the case when tail call elimination is enabled and
   // the callee has more arguments then the caller.
-  NumBytes -= mergeSPUpdates(MBB, MBBI, true);
+  NumBytes -= mergeSPUpdates(MBB, FB.MBBI, true);
 
   // Adjust stack pointer: ESP -= numbytes.
 
   // Windows and cygwin/mingw require a prologue helper routine when allocating
   // more than 4K bytes on the stack.  Windows uses __chkstk and cygwin/mingw
   // uses __alloca.  __alloca and the 32-bit version of __chkstk will probe the
   // stack and adjust the stack pointer in one go.  The 64-bit version of
   // __chkstk is only responsible for probing the stack.  The 64-bit prologue is
   // responsible for adjusting the stack pointer.  Touching the stack at 4K
   // increments is necessary to ensure that the guard pages used by the OS
   // virtual memory manager are allocated in correct sequence.
   uint64_t AlignedNumBytes = NumBytes;
   if (IsWin64Prologue && !IsFunclet && TRI->hasStackRealignment(MF))
     AlignedNumBytes = alignTo(AlignedNumBytes, MaxAlign);
   if (AlignedNumBytes >= StackProbeSize && EmitStackProbeCall) {
     assert(!X86FI->getUsesRedZone() &&
            "The Red Zone is not accounted for in stack probes");
 
     // Check whether EAX is livein for this block.
     bool isEAXAlive = isEAXLiveIn(MBB);
 
     if (isEAXAlive) {
       if (Is64Bit) {
         // Save RAX
-        BuildMI(MBB, MBBI, DL, TII.get(X86::PUSH64r))
+        BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::PUSH64r))
             .addReg(X86::RAX, RegState::Kill)
             .setMIFlag(MachineInstr::FrameSetup);
       } else {
         // Save EAX
-        BuildMI(MBB, MBBI, DL, TII.get(X86::PUSH32r))
+        BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::PUSH32r))
             .addReg(X86::EAX, RegState::Kill)
             .setMIFlag(MachineInstr::FrameSetup);
       }
     }
 
     if (Is64Bit) {
       // Handle the 64-bit Windows ABI case where we need to call __chkstk.
       // Function prologue is responsible for adjusting the stack pointer.
       int64_t Alloc = isEAXAlive ? NumBytes - 8 : NumBytes;
       if (isUInt<32>(Alloc)) {
-        BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32ri), X86::EAX)
+        BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::MOV32ri), X86::EAX)
             .addImm(Alloc)
             .setMIFlag(MachineInstr::FrameSetup);
       } else if (isInt<32>(Alloc)) {
-        BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64ri32), X86::RAX)
+        BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::MOV64ri32), X86::RAX)
             .addImm(Alloc)
             .setMIFlag(MachineInstr::FrameSetup);
       } else {
-        BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64ri), X86::RAX)
+        BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::MOV64ri), X86::RAX)
             .addImm(Alloc)
             .setMIFlag(MachineInstr::FrameSetup);
       }
     } else {
       // Allocate NumBytes-4 bytes on stack in case of isEAXAlive.
       // We'll also use 4 already allocated bytes for EAX.
-      BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32ri), X86::EAX)
+      BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::MOV32ri), X86::EAX)
           .addImm(isEAXAlive ? NumBytes - 4 : NumBytes)
           .setMIFlag(MachineInstr::FrameSetup);
     }
 
     // Call __chkstk, __chkstk_ms, or __alloca.
-    emitStackProbe(MF, MBB, MBBI, DL, true);
+    emitStackProbe(MF, MBB, FB.MBBI, FB.DL, true);
 
     if (isEAXAlive) {
       // Restore RAX/EAX
       MachineInstr *MI;
       if (Is64Bit)
-        MI = addRegOffset(BuildMI(MF, DL, TII.get(X86::MOV64rm), X86::RAX),
+        MI = addRegOffset(BuildMI(MF, FB.DL, TII.get(X86::MOV64rm), X86::RAX),
                           StackPtr, false, NumBytes - 8);
       else
-        MI = addRegOffset(BuildMI(MF, DL, TII.get(X86::MOV32rm), X86::EAX),
+        MI = addRegOffset(BuildMI(MF, FB.DL, TII.get(X86::MOV32rm), X86::EAX),
                           StackPtr, false, NumBytes - 4);
       MI->setFlag(MachineInstr::FrameSetup);
-      MBB.insert(MBBI, MI);
+      MBB.insert(FB.MBBI, MI);
     }
   } else if (NumBytes) {
-    emitSPUpdate(MBB, MBBI, DL, -(int64_t)NumBytes, /*InEpilogue=*/false);
+    emitSPUpdate(MBB, FB.MBBI, FB.DL, -(int64_t)NumBytes, /*InEpilogue=*/false);
   }
 
-  if (NeedsWinCFI && NumBytes) {
-    HasWinCFI = true;
-    BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_StackAlloc))
-        .addImm(NumBytes)
-        .setMIFlag(MachineInstr::FrameSetup);
-  }
+  if (NumBytes)
+    FB.EmitWinCFI(X86::SEH_StackAlloc, {static_cast<int64_t>(NumBytes)});
 
   int SEHFrameOffset = 0;
   unsigned SPOrEstablisher;
   if (IsFunclet) {
     if (IsClrFunclet) {
       // The establisher parameter passed to a CLR funclet is actually a pointer
       // to the (mostly empty) frame of its nearest enclosing funclet; we have
       // to find the root function establisher frame by loading the PSPSym from
       // the intermediate frame.
       unsigned PSPSlotOffset = getPSPSlotOffsetFromSP(MF);
       MachinePointerInfo NoInfo;
       MBB.addLiveIn(Establisher);
-      addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64rm), Establisher),
-                   Establisher, false, PSPSlotOffset)
+      addRegOffset(
+          BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::MOV64rm), Establisher),
+          Establisher, false, PSPSlotOffset)
           .addMemOperand(MF.getMachineMemOperand(
               NoInfo, MachineMemOperand::MOLoad, SlotSize, Align(SlotSize)));
       ;
       // Save the root establisher back into the current funclet's (mostly
       // empty) frame, in case a sub-funclet or the GC needs it.
-      addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64mr)), StackPtr,
-                   false, PSPSlotOffset)
+      addRegOffset(BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::MOV64mr)),
+                   StackPtr, false, PSPSlotOffset)
           .addReg(Establisher)
           .addMemOperand(MF.getMachineMemOperand(
               NoInfo,
               MachineMemOperand::MOStore | MachineMemOperand::MOVolatile,
               SlotSize, Align(SlotSize)));
     }
     SPOrEstablisher = Establisher;
   } else {
     SPOrEstablisher = StackPtr;
   }
 
   if (IsWin64Prologue && HasFP) {
     // Set RBP to a small fixed offset from RSP. In the funclet case, we base
     // this calculation on the incoming establisher, which holds the value of
     // RSP from the parent frame at the end of the prologue.
     SEHFrameOffset = calculateSetFPREG(ParentFrameNumBytes);
     if (SEHFrameOffset)
-      addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::LEA64r), FramePtr),
+      addRegOffset(BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::LEA64r), FramePtr),
                    SPOrEstablisher, false, SEHFrameOffset);
     else
-      BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64rr), FramePtr)
+      BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::MOV64rr), FramePtr)
           .addReg(SPOrEstablisher);
 
     // If this is not a funclet, emit the CFI describing our frame pointer.
-    if (NeedsWinCFI && !IsFunclet) {
+    if (!IsFunclet) {
       assert(!NeedsWinFPO && "this setframe incompatible with FPO data");
-      HasWinCFI = true;
-      BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_SetFrame))
-          .addImm(FramePtr)
-          .addImm(SEHFrameOffset)
-          .setMIFlag(MachineInstr::FrameSetup);
+      FB.EmitWinCFI(X86::SEH_SetFrame, {FramePtr, SEHFrameOffset});
       if (isAsynchronousEHPersonality(Personality))
         MF.getWinEHFuncInfo()->SEHSetFrameOffset = SEHFrameOffset;
     }
   } else if (IsFunclet && STI.is32Bit()) {
     // Reset EBP / ESI to something good for funclets.
-    MBBI = restoreWin32EHStackPointers(MBB, MBBI, DL);
+    FB.MBBI = restoreWin32EHStackPointers(MBB, FB.MBBI, FB.DL);
     // If we're a catch funclet, we can be returned to via catchret. Save ESP
     // into the registration node so that the runtime will restore it for us.
     if (!MBB.isCleanupFuncletEntry()) {
       assert(Personality == EHPersonality::MSVC_CXX);
       Register FrameReg;
       int FI = MF.getWinEHFuncInfo()->EHRegNodeFrameIndex;
       int64_t EHRegOffset = getFrameIndexReference(MF, FI, FrameReg).getFixed();
       // ESP is the first field, so no extra displacement is needed.
-      addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32mr)), FrameReg,
+      addRegOffset(BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::MOV32mr)), FrameReg,
                    false, EHRegOffset)
           .addReg(X86::ESP);
     }
   }
 
-  while (MBBI != MBB.end() && MBBI->getFlag(MachineInstr::FrameSetup)) {
-    const MachineInstr &FrameInstr = *MBBI;
-    ++MBBI;
-
-    if (NeedsWinCFI) {
-      int FI;
-      if (unsigned Reg = TII.isStoreToStackSlot(FrameInstr, FI)) {
-        if (X86::FR64RegClass.contains(Reg)) {
-          int Offset;
-          Register IgnoredFrameReg;
-          if (IsWin64Prologue && IsFunclet)
-            Offset = getWin64EHFrameIndexRef(MF, FI, IgnoredFrameReg);
-          else
-            Offset =
-                getFrameIndexReference(MF, FI, IgnoredFrameReg).getFixed() +
-                SEHFrameOffset;
-
-          HasWinCFI = true;
-          assert(!NeedsWinFPO && "SEH_SaveXMM incompatible with FPO data");
-          BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_SaveXMM))
-              .addImm(Reg)
-              .addImm(Offset)
-              .setMIFlag(MachineInstr::FrameSetup);
-        }
+  while (FB.MBBI != MBB.end() && FB.MBBI->getFlag(MachineInstr::FrameSetup)) {
+    const MachineInstr &FrameInstr = *FB.MBBI;
+    ++FB.MBBI;
+
+    int FI;
+    if (unsigned Reg = TII.isStoreToStackSlot(FrameInstr, FI)) {
+      if (X86::FR64RegClass.contains(Reg)) {
+        int Offset;
+        Register IgnoredFrameReg;
+        if (IsWin64Prologue && IsFunclet)
+          Offset = getWin64EHFrameIndexRef(MF, FI, IgnoredFrameReg);
+        else
+          Offset =
+              getFrameIndexReference(MF, FI, IgnoredFrameReg).getFixed() +
+              SEHFrameOffset;
+
+        assert(!NeedsWinFPO && "SEH_SaveXMM incompatible with FPO data");
+        FB.EmitWinCFI(X86::SEH_SaveXMM, {Reg, Offset});
       }
     }
   }
 
-  if (NeedsWinCFI && HasWinCFI)
-    BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_EndPrologue))
-        .setMIFlag(MachineInstr::FrameSetup);
+  if (FB.HasWinCFI)
+    FB.EmitWinCFI(X86::SEH_EndPrologue);
 
   if (FnHasClrFunclet && !IsFunclet) {
     // Save the so-called Initial-SP (i.e. the value of the stack pointer
     // immediately after the prolog)  into the PSPSlot so that funclets
     // and the GC can recover it.
     unsigned PSPSlotOffset = getPSPSlotOffsetFromSP(MF);
     auto PSPInfo = MachinePointerInfo::getFixedStack(
         MF, MF.getWinEHFuncInfo()->PSPSymFrameIdx);
-    addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64mr)), StackPtr, false,
+    addRegOffset(BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::MOV64mr)), StackPtr, false,
                  PSPSlotOffset)
         .addReg(StackPtr)
         .addMemOperand(MF.getMachineMemOperand(
             PSPInfo, MachineMemOperand::MOStore | MachineMemOperand::MOVolatile,
             SlotSize, Align(SlotSize)));
   }
 
   // Realign stack after we spilled callee-saved registers (so that we'll be
   // able to calculate their offsets from the frame pointer).
   // Win64 requires aligning the stack after the prologue.
   if (IsWin64Prologue && TRI->hasStackRealignment(MF)) {
     assert(HasFP && "There should be a frame pointer if stack is realigned.");
-    BuildStackAlignAND(MBB, MBBI, DL, SPOrEstablisher, MaxAlign);
+    BuildStackAlignAND(MBB, FB.MBBI, FB.DL, SPOrEstablisher, MaxAlign);
   }
 
   // We already dealt with stack realignment and funclets above.
   if (IsFunclet && STI.is32Bit())
     return;
 
   // If we need a base pointer, set it up here. It's whatever the value
   // of the stack pointer is at this point. Any variable size objects
   // will be allocated after this, so we can still use the base pointer
   // to reference locals.
   if (TRI->hasBasePointer(MF)) {
     // Update the base pointer with the current stack pointer.
     unsigned Opc = Uses64BitFramePtr ? X86::MOV64rr : X86::MOV32rr;
-    BuildMI(MBB, MBBI, DL, TII.get(Opc), BasePtr)
+    BuildMI(MBB, FB.MBBI, FB.DL, TII.get(Opc), BasePtr)
       .addReg(SPOrEstablisher)
       .setMIFlag(MachineInstr::FrameSetup);
     if (X86FI->getRestoreBasePointer()) {
       // Stash value of base pointer.  Saving RSP instead of EBP shortens
       // dependence chain. Used by SjLj EH.
       unsigned Opm = Uses64BitFramePtr ? X86::MOV64mr : X86::MOV32mr;
-      addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(Opm)),
+      addRegOffset(BuildMI(MBB, FB.MBBI, FB.DL, TII.get(Opm)),
                    FramePtr, true, X86FI->getRestoreBasePointerOffset())
         .addReg(SPOrEstablisher)
         .setMIFlag(MachineInstr::FrameSetup);
     }
 
     if (X86FI->getHasSEHFramePtrSave() && !IsFunclet) {
       // Stash the value of the frame pointer relative to the base pointer for
       // Win32 EH. This supports Win32 EH, which does the inverse of the above:
       // it recovers the frame pointer from the base pointer rather than the
       // other way around.
       unsigned Opm = Uses64BitFramePtr ? X86::MOV64mr : X86::MOV32mr;
       Register UsedReg;
       int Offset =
           getFrameIndexReference(MF, X86FI->getSEHFramePtrSaveIndex(), UsedReg)
               .getFixed();
       assert(UsedReg == BasePtr);
-      addRegOffset(BuildMI(MBB, MBBI, DL, TII.get(Opm)), UsedReg, true, Offset)
+      addRegOffset(BuildMI(MBB, FB.MBBI, FB.DL, TII.get(Opm)), UsedReg, true, Offset)
           .addReg(FramePtr)
           .setMIFlag(MachineInstr::FrameSetup);
     }
   }
 
   if (((!HasFP && NumBytes) || PushedRegs) && NeedsDwarfCFI) {
     // Mark end of stack pointer adjustment.
     if (!HasFP && NumBytes) {
       // Define the current CFA rule to use the provided offset.
       assert(StackSize);
       BuildCFI(
-          MBB, MBBI, DL,
+          MBB, FB.MBBI, FB.DL,
           MCCFIInstruction::cfiDefCfaOffset(nullptr, StackSize - stackGrowth));
     }
 
     // Emit DWARF info specifying the offsets of the callee-saved registers.
-    emitCalleeSavedFrameMoves(MBB, MBBI, DL, true);
+    emitCalleeSavedFrameMoves(MBB, FB.MBBI, FB.DL, true);
   }
 
   // X86 Interrupt handling function cannot assume anything about the direction
   // flag (DF in EFLAGS register). Clear this flag by creating "cld" instruction
   // in each prologue of interrupt handler function.
   //
   // FIXME: Create "cld" instruction only in these cases:
   // 1. The interrupt handling function uses any of the "rep" instructions.
   // 2. Interrupt handling function calls another function.
   //
   if (Fn.getCallingConv() == CallingConv::X86_INTR)
-    BuildMI(MBB, MBBI, DL, TII.get(X86::CLD))
+    BuildMI(MBB, FB.MBBI, FB.DL, TII.get(X86::CLD))
         .setMIFlag(MachineInstr::FrameSetup);
 
   // At this point we know if the function has WinCFI or not.
-  MF.setHasWinCFI(HasWinCFI);
+  MF.setHasWinCFI(FB.HasWinCFI);
 }
 
 bool X86FrameLowering::canUseLEAForSPInEpilogue(
     const MachineFunction &MF) const {
   // We can't use LEA instructions for adjusting the stack pointer if we don't
   // have a frame pointer in the Win64 ABI.  Only ADD instructions may be used
   // to deallocate the stack.
   // This means that we can use LEA for SP in two situations: