[WIP] MSVC FPO debug information

[jrmuizel]

Summary

The basic approach is to add a FPO_INSTRUCTION during X86FrameLowering along
with some information in MachineModuleInfo. WinCodeViewLineTables then looks
for this instruction and pulls out the relevant information and emits the FPO
tables.

[majnemer]

include/llvm/CodeGen/MachineModuleInfo.h

51–53

Variable names should be upper case. Also, why not let the constructor take a const Twine & instead of SmallString?

include/llvm/Target/TargetOpcodes.h

125

FPO_INSTRUCTION is assigned the same value as STATEPOINT. Is this intentional?

lib/CodeGen/AsmPrinter/WinCodeViewLineTables.cpp

81–82

The curly bracne shouldn't be on its own line.

193–194

Please clang-format this.

197–222

These comments are very hard for me to parse. Can you have a single block comment?

226–227

Please clang-format this.

241–256

Variables start with a capital letter. Also, please avoid recalculating the end iterator on each iteration.

288

This change seems unrelated.

lib/CodeGen/AsmPrinter/WinCodeViewLineTables.h

41

Please have a space before the * token.

115

Please clang-format this line.

lib/MC/MCStreamer.cpp

23

Why did you have to make this change?

lib/Target/X86/X86FrameLowering.cpp

586

You never reassign to this variable.

1108

You never reassign to this variable.

[rnk]

I think you want to start by building this bottom up instead of starting all the way up at X86FrameLowering.

I'd take these steps:

1. Build out the MC streamer support for the masm .fpo directive. This seems to handle everything we need.
2. Take the assembler output of llc for about three interesting prologue types, manually annotate it with FPO directives, assemble it, and verify that it's debuggable.
3. Add X86 opcodes for these directives and move them through the AsmPrinter, similar to SEH_Prologue, pushreg, etc.

[rnk]

I implemented some FPO support here: D38776 I went a different way to try to make the assembly look nice at the cost of some flexibility. My goal wasn't to support the full generality of all possible FPO data, it was more to support realistic 32-bit x86 prologues, which tend to push one of the four CSRs at constant offsets from the initial SP value.

include/llvm/CodeGen/MachineInstr.h

public:
   bool isEHLabel() const { return getOpcode() == TargetOpcode::EH_LABEL; }
   bool isGCLabel() const { return getOpcode() == TargetOpcode::GC_LABEL; }
 
   /// Returns true if the MachineInstr represents a label.
   bool isLabel() const { return isEHLabel() || isGCLabel(); }
   bool isCFIInstruction() const {
     return getOpcode() == TargetOpcode::CFI_INSTRUCTION;
   }
+  bool isFPOInstruction() const {
+    return getOpcode() == TargetOpcode::FPO_INSTRUCTION;
+  }
+
 
   // True if the instruction represents a position in the function.
   bool isPosition() const { return isLabel() || isCFIInstruction(); }
 
   bool isDebugValue() const { return getOpcode() == TargetOpcode::DBG_VALUE; }
   /// A DBG_VALUE is indirect iff the first operand is a register and
   /// the second operand is an immediate.
   bool isIndirectDebugValue() const {

include/llvm/CodeGen/MachineModuleInfo.h

 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MachineLocation.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Dwarf.h"
 
 namespace llvm {
 
+struct MCWinFPOEntry {
+    MCWinFPOEntry(SmallString<64> str) : str(str) {
+    }
+    SmallString<64> str;
+    // XXX: If we move this out of here into the main function
+    // we can make this const and save space
+    MCSymbol *Label;
+};
+
+
 //===----------------------------------------------------------------------===//
 // Forward declarations.
 class Constant;
 class GlobalVariable;
 class BlockAddress;
 class MDNode;
 class MMIAddrLabelMap;
 class MachineBasicBlock;
class MachineModuleInfo : public ImmutablePass {
   /// MachineModuleInfoImpl, which lets targets accumulate whatever info they
   /// want.
   MachineModuleInfoImpl *ObjFileMMI;
 
   /// List of moves done by a function's prolog.  Used to construct frame maps
   /// by debug and exception handling consumers.
   std::vector<MCCFIInstruction> FrameInstructions;
 
+  std::vector<MCWinFPOEntry> FPOEntries;
+
   /// LandingPads - List of LandingPadInfo describing the landing pad
   /// information in the current function.
   std::vector<LandingPadInfo> LandingPads;
 
   /// LPadToCallSiteMap - Map a landing pad's EH symbol to the call site
   /// indexes.
   DenseMap<MCSymbol*, SmallVector<unsigned, 4> > LPadToCallSiteMap;
 
public:
   }
 
   unsigned LLVM_ATTRIBUTE_UNUSED_RESULT
   addFrameInst(const MCCFIInstruction &Inst) {
     FrameInstructions.push_back(Inst);
     return FrameInstructions.size() - 1;
   }
 
+  /// \brief Returns a reference to a list of fpo entries in the current
+  /// function.
+  std::vector<MCWinFPOEntry> &getFPOEntries() {
+    return FPOEntries;
+  }
+
+  unsigned LLVM_ATTRIBUTE_UNUSED_RESULT
+  addFPOEntry(const MCWinFPOEntry &FPOEntry) {
+    FPOEntries.push_back(FPOEntry);
+    return FPOEntries.size() - 1;
+  }
+
   /// getAddrLabelSymbol - Return the symbol to be used for the specified basic
   /// block when its address is taken.  This cannot be its normal LBB label
   /// because the block may be accessed outside its containing function.
   MCSymbol *getAddrLabelSymbol(const BasicBlock *BB);
 
   /// getAddrLabelSymbolToEmit - Return the symbol to be used for the specified
   /// basic block when its address is taken.  If other blocks were RAUW'd to
   /// this one, we may have to emit them as well, return the whole set.

include/llvm/MC/MCStreamer.h

 #define LLVM_MC_MCSTREAMER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCLinkerOptimizationHint.h"
 #include "llvm/MC/MCWinEH.h"
+#include "llvm/MC/MCWinFPO.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/SMLoc.h"
 #include <string>
 
 namespace llvm {
 class MCAsmBackend;
 class MCCodeEmitter;
 class MCContext;
class MCStreamer {
 
   std::vector<MCDwarfFrameInfo> DwarfFrameInfos;
   MCDwarfFrameInfo *getCurrentDwarfFrameInfo();
   void EnsureValidDwarfFrame();
 
   MCSymbol *EmitCFICommon();
 
   std::vector<WinEH::FrameInfo *> WinFrameInfos;
+  std::vector<WinFPO::FrameInfo *> WinFPOs;
   WinEH::FrameInfo *CurrentWinFrameInfo;
   void EnsureValidWinFrameInfo();
 
   /// \brief Tracks an index to represent the order a symbol was emitted in.
   /// Zero means we did not emit that symbol.
   DenseMap<const MCSymbol *, unsigned> SymbolOrdering;
 
   /// \brief This is stack of current and previous section values saved by
public:
   ArrayRef<MCDwarfFrameInfo> getDwarfFrameInfos() const {
     return DwarfFrameInfos;
   }
 
   unsigned getNumWinFrameInfos() { return WinFrameInfos.size(); }
   ArrayRef<WinEH::FrameInfo *> getWinFrameInfos() const {
     return WinFrameInfos;
   }
-
   void generateCompactUnwindEncodings(MCAsmBackend *MAB);
 
   /// \name Assembly File Formatting.
   /// @{
 
   /// \brief Return true if this streamer supports verbose assembly and if it is
   /// enabled.
   virtual bool isVerboseAsm() const { return false; }
public:
   virtual void EmitWinCFISaveReg(unsigned Register, unsigned Offset);
   virtual void EmitWinCFISaveXMM(unsigned Register, unsigned Offset);
   virtual void EmitWinCFIPushFrame(bool Code);
   virtual void EmitWinCFIEndProlog();
 
   virtual void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except);
   virtual void EmitWinEHHandlerData();
 
-  /// \brief Emit the given \p Instruction into the current section.
+  /// EmitInstruction - Emit the given @p Instruction into the current
+  /// section.
   virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
 
+  //virtual void EmitWinFPOInfo(int64_t FPOEntry);
+
   /// \brief Set the bundle alignment mode from now on in the section.
   /// The argument is the power of 2 to which the alignment is set. The
   /// value 0 means turn the bundle alignment off.
   virtual void EmitBundleAlignMode(unsigned AlignPow2);
 
   /// \brief The following instructions are a bundle-locked group.
   ///
   /// \param AlignToEnd - If true, the bundle-locked group will be aligned to

include/llvm/Support/COFF.h

namespace COFF {
   };
 
   enum CodeViewIdentifiers {
     DEBUG_SECTION_MAGIC = 0x4,
     DEBUG_SYMBOL_SUBSECTION = 0xF1,
     DEBUG_LINE_TABLE_SUBSECTION = 0xF2,
     DEBUG_STRING_TABLE_SUBSECTION = 0xF3,
     DEBUG_INDEX_SUBSECTION = 0xF4,
+    DEBUG_FPO_SUBSECTION = 0xF5,
 
     // Symbol subsections are split into records of different types.
     DEBUG_SYMBOL_TYPE_PROC_START = 0x1147,
     DEBUG_SYMBOL_TYPE_PROC_END = 0x114F
   };
 
   inline bool isReservedSectionNumber(int32_t SectionNumber) {
     return SectionNumber <= 0;
   }
 
 } // End namespace COFF.
 } // End namespace llvm.
 
 #endif

include/llvm/Target/Target.td

def FRAME_ALLOC : Instruction {
   // This instruction is really just a label. It has to be part of the chain so
   // that it doesn't get dropped from the DAG, but it produces nothing and has
   // no side effects.
   let OutOperandList = (outs);
   let InOperandList = (ins ptr_rc:$symbol, i32imm:$id);
   let hasSideEffects = 0;
   let hasCtrlDep = 1;
 }
+
+def FPO_INSTRUCTION : Instruction {
+  let OutOperandList = (outs);
+  let InOperandList = (ins i64imm:$id);
+  let AsmString = "";
+  let hasCtrlDep = 1;
+  let isNotDuplicable = 1;
+}
 }
 
 //===----------------------------------------------------------------------===//
 // AsmParser - This class can be implemented by targets that wish to implement
 // .s file parsing.
 //
 // Subtargets can have multiple different assembly parsers (e.g. AT&T vs Intel
 // syntax on X86 for example).

include/llvm/Target/TargetOpcodes.h

enum {
   /// intended to support garbage collection with fully precise relocating
   /// collectors and deoptimizations in either the callee or caller.
   STATEPOINT = 20,
 
   /// Instruction that records the offset of a function's frame allocation in a
   /// label. Created by the llvm.frameallocate intrinsic. It has two arguments:
   /// the symbol for the label and the frame index of the stack allocation.
   FRAME_ALLOC = 21,
+  FPO_INSTRUCTION = 20,
 };
 } // end namespace TargetOpcode
 } // end namespace llvm
 
 #endif

lib/CodeGen/AsmPrinter/WinCodeViewLineTables.h

class WinCodeViewLineTables : public AsmPrinterHandler {
   AsmPrinter *Asm;
   DebugLoc PrevInstLoc;
 
   // For each function, store a vector of labels to its instructions, as well as
   // to the end of the function.
   struct FunctionInfo {
     SmallVector<MCSymbol *, 10> Instrs;
     MCSymbol *End;
+    SmallVector<MCWinFPOEntry*, 10> FPOEntries;
     FunctionInfo() : End(nullptr) {}
   } *CurFn;
 
   typedef DenseMap<const Function *, FunctionInfo> FnDebugInfoTy;
   FnDebugInfoTy FnDebugInfo;
   // Store the functions we've visited in a vector so we can maintain a stable
   // order while emitting subsections.
   SmallVector<const Function *, 10> VisitedFunctions;
class WinCodeViewLineTables : public AsmPrinterHandler {
   void clear() {
     assert(CurFn == nullptr);
     FileNameRegistry.clear();
     InstrInfo.clear();
   }
 
   void emitDebugInfoForFunction(const Function *GV);
 
+  void emitFPOSegment(const MCWinFPOEntry *entry, bool entrypoint, const MCSymbol *Fn, const MCSymbol *From, const MCSymbol *To);
+  void emitFrameInfo(const MCSymbol *Fn, const FunctionInfo &FI);
+
+  void recordFPOEntry(MCWinFPOEntry *Entry);
 public:
   WinCodeViewLineTables(AsmPrinter *Asm);
 
   ~WinCodeViewLineTables() override {
     for (DirAndFilenameToFilepathMapTy::iterator
              I = DirAndFilenameToFilepathMap.begin(),
              E = DirAndFilenameToFilepathMap.end();
          I != E; ++I)

lib/CodeGen/AsmPrinter/WinCodeViewLineTables.cpp

StringRef WinCodeViewLineTables::getFullFilepath(const MDNode *S) {
   Cursor = 0;
   while ((Cursor = Filepath.find("\\\\", Cursor)) != std::string::npos)
     Filepath.erase(Cursor, 1);
 
   Result = strdup(Filepath.c_str());
   return StringRef(Result);
 }
 
+void WinCodeViewLineTables::recordFPOEntry(MCWinFPOEntry *Entry)
+{
+  assert(CurFn);
+  MCSymbol *MCL = Asm->MMI->getContext().createTempSymbol();
+  Asm->OutStreamer->EmitLabel(MCL);
+  Entry->Label = MCL;
+  CurFn->FPOEntries.push_back(Entry);
+  auto back = CurFn->FPOEntries.back();
+  FileNameRegistry.add(back->str);
+}
+
 void WinCodeViewLineTables::maybeRecordLocation(DebugLoc DL,
                                                 const MachineFunction *MF) {
   const MDNode *Scope = DL.getScope();
   if (!Scope)
     return;
   StringRef Filename = getFullFilepath(Scope);
 
   // Skip this instruction if it has the same file:line as the previous one.
static void EmitLabelDiff(MCStreamer &Streamer,
   MCContext &Context = Streamer.getContext();
   const MCExpr *FromRef = MCSymbolRefExpr::create(From, Variant, Context),
                *ToRef   = MCSymbolRefExpr::create(To, Variant, Context);
   const MCExpr *AddrDelta =
       MCBinaryExpr::create(MCBinaryExpr::Sub, ToRef, FromRef, Context);
   Streamer.EmitValue(AddrDelta, Size);
 }
 
+
+void WinCodeViewLineTables::emitFPOSegment(const MCWinFPOEntry *entry, bool entrypoint, const MCSymbol *Fn, const MCSymbol *From, const MCSymbol *To)
+{
+/* We should be able to set LocalsSize, ParamSize, MaxStackSize, SavedRegSize and PrologSize
+   all to 0 without any real problems. */
+    //FPOSegment [
+      //Start: 0x0
+      EmitLabelDiff(*Asm->OutStreamer, Fn, From);
+      //CodeSize: 0x14
+      EmitLabelDiff(*Asm->OutStreamer, From, To);
+      //LocalsSize: 0x0 // often 0 but not always
+      Asm->EmitInt32(0);
+      //ParamsSize: 0x0 //  ParamsSize stays the same for nested blocks
+      Asm->EmitInt32(0);
+      //MaxStackSize: 0x0 // always seems to be 0
+      Asm->EmitInt32(0);
+      //ProgramStr: $T0 $ebp = $eip $T0 4 + ^ = $ebp $T0 ^ = $esp $
+      //Asm->EmitInt32(0);
+      Asm->EmitInt32(FileNameRegistry.Infos[entry->str].StartOffset);
+// PrologSize is how much of the prolog is in the current block
+// i.e. if the PrologSize is 9 bytes and the second block begins at byte 5 it will have
+// a prolog size of 4 bytes
+      //PrologSize: 0x3
+      Asm->EmitInt16(0);
+      //SavedRegSize: 0x0 // This goes up predictably
+      Asm->EmitInt16(0);
+      /*Flags [ (0x4)
+        FPO_FUNCTION_ENTRY (0x4)
+      ]*/
+      Asm->EmitInt32(entrypoint ? 0x4 : 0);
+    //]
+}
+
+
+void WinCodeViewLineTables::emitFrameInfo(const MCSymbol *Fn, const FunctionInfo &FI)
+{
+  Asm->OutStreamer->AddComment("FPO subsection");
+  Asm->EmitInt32(COFF::DEBUG_FPO_SUBSECTION);
+  MCSymbol *FPOBegin = Asm->MMI->getContext().createTempSymbol(),
+           *FPOEnd = Asm->MMI->getContext().createTempSymbol();
+  EmitLabelDiff(*Asm->OutStreamer, FPOBegin, FPOEnd);
+  Asm->OutStreamer->EmitLabel(FPOBegin);
+
+  // Identify the function this subsection is for.
+/*
+  for (size_t I = 0, E = VisitedFunctions.size(); I != E; ++I)
+    emitDebugInfoForFunction(VisitedFunctions[I]);
+*/
+
+  bool start = true;
+  // Frame.begin is no good. We need the actual function
+  // Frame.begin just points to some random label
+  Asm->OutStreamer->EmitCOFFSecRel32(Fn);
+  for (auto entry = FI.FPOEntries.begin(); entry != FI.FPOEntries.end(); ) {
+      auto next = entry+1;
+      MCSymbol *end;
+      if (next == FI.FPOEntries.end()) {
+          end = FI.End;
+      } else {
+          end = (*next)->Label;
+      }
+      emitFPOSegment(*entry, start, Fn, (*entry)->Label, end);
+      start = false;
+      entry = next;
+  }
+
+  Asm->OutStreamer->EmitLabel(FPOEnd);
+  Asm->OutStreamer->AddComment("FPO end subsection");
+
+}
+
+
 void WinCodeViewLineTables::emitDebugInfoForFunction(const Function *GV) {
   // For each function there is a separate subsection
   // which holds the PC to file:line table.
   const MCSymbol *Fn = Asm->getSymbol(GV);
   assert(Fn);
 
   const FunctionInfo &FI = FnDebugInfo[GV];
   if (FI.Instrs.empty())
     return;
   assert(FI.End && "Don't know where the function ends?");
 
+  emitFrameInfo(Fn, FI);
+
   StringRef GVName = GV->getName();
   StringRef FuncName;
   if (auto *SP = getDISubprogram(GV))
     FuncName = SP->getDisplayName();
 
   // FIXME Clang currently sets DisplayName to "bar" for a C++
   // "namespace_foo::bar" function, see PR21528.  Luckily, dbghelp.dll is trying
   // to demangle display names anyways, so let's just put a mangled name into
   // the symbols subsection until Clang gives us what we need.
   if (GVName.startswith("\01?"))
     FuncName = GVName.substr(1);
+
   // Emit a symbol subsection, required by VS2012+ to find function boundaries.
   MCSymbol *SymbolsBegin = Asm->MMI->getContext().createTempSymbol(),
            *SymbolsEnd = Asm->MMI->getContext().createTempSymbol();
   Asm->OutStreamer->AddComment("Symbol subsection for " + Twine(FuncName));
   Asm->EmitInt32(COFF::DEBUG_SYMBOL_SUBSECTION);
   EmitLabelDiff(*Asm->OutStreamer, SymbolsBegin, SymbolsEnd);
   Asm->OutStreamer->EmitLabel(SymbolsBegin);
   {
if (CurFn->Instrs.empty()) {
     VisitedFunctions.pop_back();
   } else {
     CurFn->End = Asm->getFunctionEnd();
   }
   CurFn = nullptr;
 }
 
 void WinCodeViewLineTables::beginInstruction(const MachineInstr *MI) {
+  if (MI->isFPOInstruction()) {
+    auto &Entries = Asm->MMI->getFPOEntries();
+    int64_t FPOIndex = MI->getOperand(0).getImm();
+    recordFPOEntry(&Entries[FPOIndex]);
+    return;
+  }
   // Ignore DBG_VALUE locations and function prologue.
   if (!Asm || MI->isDebugValue() || MI->getFlag(MachineInstr::FrameSetup))
     return;
   DebugLoc DL = MI->getDebugLoc();
   if (DL == PrevInstLoc || !DL)
     return;
   maybeRecordLocation(DL, Asm->MF);
 }
 }

lib/MC/MCStreamer.cpp

 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCWin64EH.h"
+#include "llvm/MC/MCWinFPO.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 using namespace llvm;
 
 // Pin the vtables to this file.
 MCTargetStreamer::~MCTargetStreamer() {}

lib/Target/X86/X86FrameLowering.cpp

void X86FrameLowering::emitPrologue(MachineFunction &MF,
   bool HasFP = hasFP(MF);
   bool Is64Bit = STI.is64Bit();
   // standard x86_64 and NaCl use 64-bit frame/stack pointers, x32 - 32-bit.
   const bool Uses64BitFramePtr = STI.isTarget64BitLP64() || STI.isTargetNaCl64();
   bool IsWin64 = STI.isCallingConvWin64(Fn->getCallingConv());
   // Not necessarily synonymous with IsWin64.
   bool IsWinEH = MF.getTarget().getMCAsmInfo()->usesWindowsCFI();
   bool NeedsWinEH = IsWinEH && Fn->needsUnwindTableEntry();
+  bool NeedsWinFPO = true;
   bool NeedsDwarfCFI =
       !IsWinEH && (MMI.hasDebugInfo() || Fn->needsUnwindTableEntry());
   bool UseLEA = STI.useLeaForSP();
   unsigned SlotSize = RegInfo->getSlotSize();
   unsigned FramePtr = RegInfo->getFrameRegister(MF);
   const unsigned MachineFramePtr =
       STI.isTarget64BitILP32()
           ? getX86SubSuperRegister(FramePtr, MVT::i64, false)
if (HasFP) {
     if (RegInfo->needsStackRealignment(MF) && !IsWinEH)
       NumBytes = RoundUpToAlignment(NumBytes, MaxAlign);
 
     // Get the offset of the stack slot for the EBP register, which is
     // guaranteed to be the last slot by processFunctionBeforeFrameFinalized.
     // Update the frame offset adjustment.
     MFI->setOffsetAdjustment(-NumBytes);
 
+    if (NeedsWinFPO) {
+       int StringIndex = MMI.addFPOEntry(MCWinFPOEntry(SmallString<64>("$eip $esp ^ =")));
+
+       // XXX: we could use FPO_Push and FPO_Pop to get the stack like semantics
+       // that FPO instructions support
+       BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::FPO_INSTRUCTION))
+          .addImm(StringIndex)
+          .setMIFlag(MachineInstr::FrameSetup);
+    }
+
+
     // Save EBP/RBP into the appropriate stack slot.
     BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::PUSH64r : X86::PUSH32r))
       .addReg(MachineFramePtr, RegState::Kill)
       .setMIFlag(MachineInstr::FrameSetup);
 
+    if (NeedsWinFPO) {
+       int StringIndex = MMI.addFPOEntry(MCWinFPOEntry(SmallString<64>("$eip $esp 4 - ^ =")));
+
+       BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::FPO_INSTRUCTION))
+          .addImm(StringIndex)
+          .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);
       unsigned CFIIndex = MMI.addFrameInst(
           MCCFIInstruction::createDefCfaOffset(nullptr, 2 * stackGrowth));
       BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
           .addCFIIndex(CFIIndex);
if (!IsWinEH) {
       // Update EBP with the new base value.
       BuildMI(MBB, MBBI, DL,
               TII.get(Uses64BitFramePtr ? X86::MOV64rr : X86::MOV32rr),
               FramePtr)
           .addReg(StackPtr)
           .setMIFlag(MachineInstr::FrameSetup);
     }
 
+    if (NeedsWinFPO) {
+
+       int StringIndex = MMI.addFPOEntry(MCWinFPOEntry(SmallString<64>("$eip $ebp 4 - ^ =")));
+
+       BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::FPO_INSTRUCTION))
+          .addImm(StringIndex)
+          .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 = RegInfo->getDwarfRegNum(MachineFramePtr, true);
       unsigned CFIIndex = MMI.addFrameInst(
           MCCFIInstruction::createDefCfaRegister(nullptr, DwarfFramePtr));
       BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
           .addCFIIndex(CFIIndex);
if (!HasFP && NeedsDwarfCFI) {
       assert(StackSize);
       unsigned CFIIndex = MMI.addFrameInst(
           MCCFIInstruction::createDefCfaOffset(nullptr, StackOffset));
       BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
           .addCFIIndex(CFIIndex);
       StackOffset += stackGrowth;
     }
 
+    if (!HasFP && NeedsDwarfCFI) {
+      // Mark callee-saved push instruction.
+      // Define the current CFA rule to use the provided offset.
+      assert(StackSize);
+      unsigned CFIIndex = MMI.addFrameInst(
+          MCCFIInstruction::createDefCfaOffset(nullptr, StackOffset));
+      BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
+          .addCFIIndex(CFIIndex);
+      StackOffset += stackGrowth;
+    }
+
+    if (NeedsWinFPO) {
+       SmallString<64> Buffer;
+       llvm::raw_svector_ostream Stream(Buffer);
+       Stream << "$eip $ebp " << StackOffset << " - ^ =";
+
+       int StringIndex = MMI.addFPOEntry(MCWinFPOEntry(Buffer));
+
+       BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::FPO_INSTRUCTION))
+          .addImm(StringIndex)
+          .setMIFlag(MachineInstr::FrameSetup);
+    }
+
     if (NeedsWinEH) {
       BuildMI(MBB, MBBI, DL, TII.get(X86::SEH_PushReg)).addImm(Reg).setMIFlag(
           MachineInstr::FrameSetup);
     }
   }
 
   // Realign stack after we pushed callee-saved registers (so that we'll be
   // able to calculate their offsets from the frame pointer).
if (!HasFP && NumBytes) {
       BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
           .addCFIIndex(CFIIndex);
     }
 
     // Emit DWARF info specifying the offsets of the callee-saved registers.
     if (PushedRegs)
       emitCalleeSavedFrameMoves(MBB, MBBI, DL);
   }
+  if (((!HasFP && NumBytes) || PushedRegs) && NeedsWinFPO) {
+    // Mark end of stack pointer adjustment.
+    if (!HasFP && NumBytes) {
+      // Define the current CFA rule to use the provided offset.
+       SmallString<64> Buffer;
+       llvm::raw_svector_ostream Stream(Buffer);
+       Stream << "$eip $ebp " << (-StackSize + stackGrowth) << " - ^ =";
+
+       int StringIndex = MMI.addFPOEntry(MCWinFPOEntry(Buffer));
+
+       BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::FPO_INSTRUCTION))
+          .addImm(StringIndex)
+          .setMIFlag(MachineInstr::FrameSetup);
+    }
+  }
+
 }
 
 bool X86FrameLowering::canUseLEAForSPInEpilogue(
     const MachineFunction &MF) const {
   // We can't use LEA instructions for adjusting the stack pointer if this is a
   // leaf function 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:
if (BreakNext)
       break;
   }
   return false;
 }
 
 void X86FrameLowering::emitEpilogue(MachineFunction &MF,
                                     MachineBasicBlock &MBB) const {
   const MachineFrameInfo *MFI = MF.getFrameInfo();
+  MachineModuleInfo &MMI = MF.getMMI();
   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
   const X86Subtarget &STI = MF.getSubtarget<X86Subtarget>();
   const X86RegisterInfo *RegInfo = STI.getRegisterInfo();
   const TargetInstrInfo &TII = *STI.getInstrInfo();
   MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
   DebugLoc DL;
   if (MBBI != MBB.end())
     DL = MBBI->getDebugLoc();
void X86FrameLowering::emitEpilogue(MachineFunction &MF,
   // Alternatively, we could move the ADD, but this may not be possible
   // and is an optimization anyway.
   if (UseLEAForSP && !MF.getSubtarget<X86Subtarget>().useLeaForSP())
     UseLEAForSP = terminatorsNeedFlagsAsInput(MBB);
   // If that assert breaks, that means we do not do the right thing
   // in canUseAsEpilogue.
   assert((UseLEAForSP || !terminatorsNeedFlagsAsInput(MBB)) &&
          "We shouldn't have allowed this insertion point");
+  bool NeedsWinFPO = true;
 
   // Get the number of bytes to allocate from the FrameInfo.
   uint64_t StackSize = MFI->getStackSize();
   uint64_t MaxAlign = calculateMaxStackAlign(MF);
   unsigned CSSize = X86FI->getCalleeSavedFrameSize();
   uint64_t NumBytes = 0;
 
   if (hasFP(MF)) {
     // Calculate required stack adjustment.
     uint64_t FrameSize = StackSize - SlotSize;
     NumBytes = FrameSize - CSSize;
 
     // Callee-saved registers were pushed on stack before the stack was
     // realigned.
     if (RegInfo->needsStackRealignment(MF) && !IsWinEH)
       NumBytes = RoundUpToAlignment(FrameSize, MaxAlign);
 
     // Pop EBP.
     BuildMI(MBB, MBBI, DL,
             TII.get(Is64Bit ? X86::POP64r : X86::POP32r), MachineFramePtr);
+    unsigned DwarfStackPtr = RegInfo->getDwarfRegNum(StackPtr, true);
+    unsigned CFIIndex = MMI.addFrameInst(
+          MCCFIInstruction::createDefCfa(nullptr, DwarfStackPtr, NumBytes - (Is64Bit ? 8 : 4)));
+    BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
+          .addCFIIndex(CFIIndex);
+
+    if (NeedsWinFPO) {
+       int StringIndex = MMI.addFPOEntry(MCWinFPOEntry(SmallString<64>("$eip $esp ^ =")));
+
+       // XXX: we could use FPO_Push and FPO_Pop to get the stack like semantics
+       // that FPO instructions support
+       BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::FPO_INSTRUCTION))
+          .addImm(StringIndex)
+          .setMIFlag(MachineInstr::FrameSetup);
+    }
+
   } else {
     NumBytes = StackSize - CSSize;
   }
   uint64_t SEHStackAllocAmt = NumBytes;
 
   // Skip the callee-saved pop instructions.
   while (MBBI != MBB.begin()) {
     MachineBasicBlock::iterator PI = std::prev(MBBI);

utils/TableGen/CodeGenTarget.cpp

 void CodeGenTarget::ComputeInstrsByEnum() const {
   // The ordering here must match the ordering in TargetOpcodes.h.
   static const char *const FixedInstrs[] = {
       "PHI",          "INLINEASM",     "CFI_INSTRUCTION",  "EH_LABEL",
       "GC_LABEL",     "KILL",          "EXTRACT_SUBREG",   "INSERT_SUBREG",
       "IMPLICIT_DEF", "SUBREG_TO_REG", "COPY_TO_REGCLASS", "DBG_VALUE",
       "REG_SEQUENCE", "COPY",          "BUNDLE",           "LIFETIME_START",
       "LIFETIME_END", "STACKMAP",      "PATCHPOINT",       "LOAD_STACK_GUARD",
-      "STATEPOINT",   "FRAME_ALLOC",
+      "STATEPOINT",   "FRAME_ALLOC",   "FPO_INSTRUCTION",
       nullptr};
   const auto &Insts = getInstructions();
   for (const char *const *p = FixedInstrs; *p; ++p) {
     const CodeGenInstruction *Instr = GetInstByName(*p, Insts, Records);
     assert(Instr && "Missing target independent instruction");
     assert(Instr->Namespace == "TargetOpcode" && "Bad namespace");
     InstrsByEnum.push_back(Instr);
   }