[MC] Move .seh_ directive implementation to MCObjectStreamer

[rnk]

Summary

This suppresses the generation of .Lcfi labels in our textual assembler
output when targetting Win64. It was annoying that this generates
cascading .Lcfi labels:

llc foo.ll -o - | llvm-mc | llvm-mc

After three trips through MCAsmStreamer, we'd have three labels in the
output when none are necessary. We should only bother creating the
labels and frame data when making a real object file.

With this change, we will not check for mis-ordered .seh directives when
generating textual assembly. Personally, that seems like a reasonable
cost to pay to clean our assembly output.

This was a test before attempting to sink the generation of .Lcfi labels
for DWARF .cfi_ directives. If people like this, I will try that next.

[rnk]

• remove useless calls to MCStreamer::EmitWinCFI*

[majnemer]

llvm/include/llvm/MC/MCObjectStreamer.h

44

Should this be std::vector<std::unique_ptr<WinEH:FrameInfo>> ?

llvm/lib/MC/MCObjectStreamer.cpp

38–39

DeleteContainerPointers(WinFrameInfos)

78–80

Ditto.

[rnk]

Actually, I'm just going to sink EmitCFILabel into MCObjectStreamer and call it a day. That handles both .seh_ and .cfi_ directives. New patch soon.

llvm/include/llvm/MC/MCObjectStreamer.h

44

Done in rL315080.

llvm/include/llvm/MC/MCObjectStreamer.h

 //===- MCObjectStreamer.h - MCStreamer Object File Interface ----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCOBJECTSTREAMER_H
 #define LLVM_MC_MCOBJECTSTREAMER_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCWinEH.h"
 
 namespace llvm {
 class MCAssembler;
 class MCCodeEmitter;
 class MCSubtargetInfo;
 class MCExpr;
 class MCFragment;
 class MCDataFragment;

 /// implementation.
 class MCObjectStreamer : public MCStreamer {
   MCAssembler *Assembler;
   MCSection::iterator CurInsertionPoint;
   bool EmitEHFrame;
   bool EmitDebugFrame;
   SmallVector<MCSymbol *, 2> PendingLabels;
 
+  std::vector<WinEH::FrameInfo *> WinFrameInfos;
+  WinEH::FrameInfo *CurrentWinFrameInfo = nullptr;
+  void EnsureValidWinFrameInfo();
+
   virtual void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo&) = 0;
   void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
   void EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override;
 
 protected:
   MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB, raw_pwrite_stream &OS,
                    MCCodeEmitter *Emitter);
   ~MCObjectStreamer() override;
 
+  WinEH::FrameInfo *getCurrentWinFrameInfo() {
+    return CurrentWinFrameInfo;
+  }
+
 public:
   /// state management
   void reset() override;
 
   /// Object streamers require the integrated assembler.
   bool isIntegratedAssemblerRequired() const override { return true; }
 
   void EmitFrames(MCAsmBackend *MAB);
   void EmitCFISections(bool EH, bool Debug) override;
 
   MCFragment *getCurrentFragment() const;
 
   void insert(MCFragment *F) {
     flushPendingLabels(F);
     MCSection *CurSection = getCurrentSectionOnly();
     CurSection->getFragmentList().insert(CurInsertionPoint, F);
     F->setParent(CurSection);
   }
 
   /// Get a data fragment to write into, creating a new one if the current
   /// fragment is not a data fragment.
   MCDataFragment *getOrCreateDataFragment();
 
+  unsigned getNumWinFrameInfos() { return WinFrameInfos.size(); }
+  ArrayRef<WinEH::FrameInfo *> getWinFrameInfos() const {
+    return WinFrameInfos;
+  }
+
 protected:
   bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection);
 
   /// If any labels have been emitted but not assigned fragments, ensure that
   /// they get assigned, either to F if possible or to a new data fragment.
   /// Optionally, it is also possible to provide an offset \p FOffset, which
   /// will be used as a symbol offset within the fragment.
   void flushPendingLabels(MCFragment *F, uint64_t FOffset = 0);
public:
   /// compute it.  Currently, that requires that both symbols are in the same
   /// data fragment.  Otherwise, do nothing and return \c false.
   ///
   /// \pre Offset of \c Hi is greater than the offset \c Lo.
   void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
                               unsigned Size) override;
 
   bool mayHaveInstructions(MCSection &Sec) const override;
+
+  /// \name Unwind information directives
+  /// @{
+
+  void EmitWinCFIStartProc(const MCSymbol *Symbol) override;
+  void EmitWinCFIEndProc() override;
+  void EmitWinCFIStartChained() override;
+  void EmitWinCFIEndChained() override;
+  void EmitWinCFIPushReg(unsigned Register) override;
+  void EmitWinCFISetFrame(unsigned Register, unsigned Offset) override;
+  void EmitWinCFIAllocStack(unsigned Size) override;
+  void EmitWinCFISaveReg(unsigned Register, unsigned Offset) override;
+  void EmitWinCFISaveXMM(unsigned Register, unsigned Offset) override;
+  void EmitWinCFIPushFrame(bool Code) override;
+  void EmitWinCFIEndProlog() override;
+
+  void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except) override;
+  void EmitWinEHHandlerData() override;
+
+  /// @}
 };
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/MC/MCStreamer.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCLinkerOptimizationHint.h"
 #include "llvm/MC/MCSymbol.h"
-#include "llvm/MC/MCWinEH.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/TargetParser.h"
 #include <cassert>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>

 class MCStreamer {
   MCContext &Context;
   std::unique_ptr<MCTargetStreamer> TargetStreamer;
 
   std::vector<MCDwarfFrameInfo> DwarfFrameInfos;
   MCDwarfFrameInfo *getCurrentDwarfFrameInfo();
   void EnsureValidDwarfFrame();
 
-  MCSymbol *EmitCFILabel();
-  MCSymbol *EmitCFICommon();
-
-  std::vector<WinEH::FrameInfo *> WinFrameInfos;
-  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
   /// PushSection.
   SmallVector<std::pair<MCSectionSubPair, MCSectionSubPair>, 4> SectionStack;
 
   /// The next unique ID to use when creating a WinCFI-related section (.pdata
   /// or .xdata). This ID ensures that we have a one-to-one mapping from
   /// code section to unwind info section, which MSVC's incremental linker
   /// requires.
   unsigned NextWinCFIID = 0;
 
 protected:
   MCStreamer(MCContext &Ctx);
 
+  MCSymbol *EmitCFILabel();
+  MCSymbol *EmitCFICommon();
+
   virtual void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame);
   virtual void EmitCFIEndProcImpl(MCDwarfFrameInfo &CurFrame);
 
-  WinEH::FrameInfo *getCurrentWinFrameInfo() {
-    return CurrentWinFrameInfo;
-  }
-
   virtual void EmitWindowsUnwindTables();
 
   virtual void EmitRawTextImpl(StringRef String);
 
 public:
   MCStreamer(const MCStreamer &) = delete;
   MCStreamer &operator=(const MCStreamer &) = delete;
   virtual ~MCStreamer();
public:
 
   unsigned getNumFrameInfos() { return DwarfFrameInfos.size(); }
   ArrayRef<MCDwarfFrameInfo> getDwarfFrameInfos() const {
     return DwarfFrameInfos;
   }
 
   bool hasUnfinishedDwarfFrameInfo();
 
-  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 EmitCFIEscape(StringRef Values);
   virtual void EmitCFIReturnColumn(int64_t Register);
   virtual void EmitCFIGnuArgsSize(int64_t Size);
   virtual void EmitCFISignalFrame();
   virtual void EmitCFIUndefined(int64_t Register);
   virtual void EmitCFIRegister(int64_t Register1, int64_t Register2);
   virtual void EmitCFIWindowSave();
 
-  virtual void EmitWinCFIStartProc(const MCSymbol *Symbol);
-  virtual void EmitWinCFIEndProc();
-  virtual void EmitWinCFIStartChained();
-  virtual void EmitWinCFIEndChained();
-  virtual void EmitWinCFIPushReg(unsigned Register);
-  virtual void EmitWinCFISetFrame(unsigned Register, unsigned Offset);
-  virtual void EmitWinCFIAllocStack(unsigned Size);
-  virtual void EmitWinCFISaveReg(unsigned Register, unsigned Offset);
-  virtual void EmitWinCFISaveXMM(unsigned Register, unsigned Offset);
-  virtual void EmitWinCFIPushFrame(bool Code);
-  virtual void EmitWinCFIEndProlog();
+  virtual void EmitWinCFIStartProc(const MCSymbol *Symbol) {}
+  virtual void EmitWinCFIEndProc() {}
+  virtual void EmitWinCFIStartChained() {}
+  virtual void EmitWinCFIEndChained() {}
+  virtual void EmitWinCFIPushReg(unsigned Register) {}
+  virtual void EmitWinCFISetFrame(unsigned Register, unsigned Offset) {}
+  virtual void EmitWinCFIAllocStack(unsigned Size) {}
+  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();
+  virtual void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except) {}
+  virtual void EmitWinEHHandlerData() {}
 
   /// Get the .pdata section used for the given section. Typically the given
   /// section is either the main .text section or some other COMDAT .text
   /// section, but it may be any section containing code.
   MCSection *getAssociatedPDataSection(const MCSection *TextSec);
 
   /// Get the .xdata section used for the given section.
   MCSection *getAssociatedXDataSection(const MCSection *TextSec);

llvm/include/llvm/MC/MCWin64EH.h

 
 #ifndef LLVM_MC_MCWIN64EH_H
 #define LLVM_MC_MCWIN64EH_H
 
 #include "llvm/MC/MCWinEH.h"
 #include "llvm/Support/Win64EH.h"
 
 namespace llvm {
-class MCStreamer;
+class MCObjectStreamer;
 class MCSymbol;
 
 namespace Win64EH {
 struct Instruction {
   static WinEH::Instruction PushNonVol(MCSymbol *L, unsigned Reg) {
     return WinEH::Instruction(Win64EH::UOP_PushNonVol, L, Reg, -1);
   }
   static WinEH::Instruction Alloc(MCSymbol *L, unsigned Size) {
struct Instruction {
   }
   static WinEH::Instruction SetFPReg(MCSymbol *L, unsigned Reg, unsigned Off) {
     return WinEH::Instruction(UOP_SetFPReg, L, Reg, Off);
   }
 };
 
 class UnwindEmitter : public WinEH::UnwindEmitter {
 public:
-  void Emit(MCStreamer &Streamer) const override;
-  void EmitUnwindInfo(MCStreamer &Streamer, WinEH::FrameInfo *FI) const override;
+  void Emit(MCObjectStreamer &Streamer) const override;
+  void EmitUnwindInfo(MCObjectStreamer &Streamer,
+                      WinEH::FrameInfo *FI) const override;
 };
 }
 } // end namespace llvm
 
 #endif

llvm/include/llvm/MC/MCWinEH.h

 //===- MCWinEH.h - Windows Unwinding Support --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCWINEH_H
 #define LLVM_MC_MCWINEH_H
 
 #include <vector>
 
 namespace llvm {
 class MCSection;
-class MCStreamer;
+class MCObjectStreamer;
 class MCSymbol;
 
 namespace WinEH {
 struct Instruction {
   const MCSymbol *Label;
   const unsigned Offset;
   const unsigned Register;
   const unsigned Operation;
FrameInfo(const MCSymbol *Function, const MCSymbol *BeginFuncEHLabel,
         ChainedParent(ChainedParent) {}
 };
 
 class UnwindEmitter {
 public:
   virtual ~UnwindEmitter();
 
   /// This emits the unwind info sections (.pdata and .xdata in PE/COFF).
-  virtual void Emit(MCStreamer &Streamer) const = 0;
-  virtual void EmitUnwindInfo(MCStreamer &Streamer, FrameInfo *FI) const = 0;
+  virtual void Emit(MCObjectStreamer &Streamer) const = 0;
+  virtual void EmitUnwindInfo(MCObjectStreamer &Streamer,
+                              FrameInfo *FI) const = 0;
 };
 }
 }
 
 #endif

llvm/lib/MC/MCAsmStreamer.cpp

 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbolELF.h"
+#include "llvm/MC/MCWinEH.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include <cctype>

 
 void MCAsmStreamer::EmitCFIReturnColumn(int64_t Register) {
   MCStreamer::EmitCFIReturnColumn(Register);
   OS << "\t.cfi_return_column " << Register;
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol) {
-  MCStreamer::EmitWinCFIStartProc(Symbol);
-
   OS << ".seh_proc ";
   Symbol->print(OS, MAI);
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFIEndProc() {
-  MCStreamer::EmitWinCFIEndProc();
-
   OS << "\t.seh_endproc";
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFIStartChained() {
-  MCStreamer::EmitWinCFIStartChained();
-
   OS << "\t.seh_startchained";
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFIEndChained() {
-  MCStreamer::EmitWinCFIEndChained();
-
   OS << "\t.seh_endchained";
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind,
                                       bool Except) {
-  MCStreamer::EmitWinEHHandler(Sym, Unwind, Except);
-
   OS << "\t.seh_handler ";
   Sym->print(OS, MAI);
   if (Unwind)
     OS << ", @unwind";
   if (Except)
     OS << ", @except";
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinEHHandlerData() {
-  MCStreamer::EmitWinEHHandlerData();
-
-  // Switch sections. Don't call SwitchSection directly, because that will
-  // cause the section switch to be visible in the emitted assembly.
-  // We only do this so the section switch that terminates the handler
-  // data block is visible.
-  WinEH::FrameInfo *CurFrame = getCurrentWinFrameInfo();
-  MCSection *TextSec = &CurFrame->Function->getSection();
-  MCSection *XData = getAssociatedXDataSection(TextSec);
+  // Switch sections. Don't call SwitchSection directly, because that will cause
+  // the section switch to be visible in the emitted assembly.  We only do this
+  // so the section switch that terminates the handler data block is visible. We
+  // don't have to have precisely the right .xdata section when printing textual
+  // assembly.
+  MCSection *XData = getAssociatedXDataSection(getCurrentSectionOnly());
   SwitchSectionNoChange(XData);
 
   OS << "\t.seh_handlerdata";
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFIPushReg(unsigned Register) {
-  MCStreamer::EmitWinCFIPushReg(Register);
-
   OS << "\t.seh_pushreg " << Register;
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset) {
-  MCStreamer::EmitWinCFISetFrame(Register, Offset);
-
   OS << "\t.seh_setframe " << Register << ", " << Offset;
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFIAllocStack(unsigned Size) {
-  MCStreamer::EmitWinCFIAllocStack(Size);
-
   OS << "\t.seh_stackalloc " << Size;
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset) {
-  MCStreamer::EmitWinCFISaveReg(Register, Offset);
-
   OS << "\t.seh_savereg " << Register << ", " << Offset;
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset) {
-  MCStreamer::EmitWinCFISaveXMM(Register, Offset);
-
   OS << "\t.seh_savexmm " << Register << ", " << Offset;
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFIPushFrame(bool Code) {
-  MCStreamer::EmitWinCFIPushFrame(Code);
-
   OS << "\t.seh_pushframe";
   if (Code)
     OS << " @code";
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFIEndProlog() {
-  MCStreamer::EmitWinCFIEndProlog();
-
   OS << "\t.seh_endprologue";
   EmitEOL();
 }
 
 void MCAsmStreamer::AddEncodingComment(const MCInst &Inst,
                                        const MCSubtargetInfo &STI,
                                        bool PrintSchedInfo) {
   raw_ostream &OS = GetCommentOS();

llvm/lib/MC/MCObjectStreamer.cpp

 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCCodeView.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSymbol.h"
+#include "llvm/MC/MCWin64EH.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 using namespace llvm;
 
 MCObjectStreamer::MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB,
                                    raw_pwrite_stream &OS,
                                    MCCodeEmitter *Emitter_)
     : MCStreamer(Context),
       Assembler(new MCAssembler(Context, TAB, *Emitter_,
                                 *TAB.createObjectWriter(OS))),
       EmitEHFrame(true), EmitDebugFrame(false) {}
 
 MCObjectStreamer::~MCObjectStreamer() {
+  for (unsigned i = 0; i < getNumWinFrameInfos(); ++i)
+    delete WinFrameInfos[i];
   delete &Assembler->getBackend();
   delete &Assembler->getEmitter();
   delete &Assembler->getWriter();
   delete Assembler;
 }
 
 void MCObjectStreamer::flushPendingLabels(MCFragment *F, uint64_t FOffset) {
   if (PendingLabels.empty())
void MCObjectStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi,
   }
 
   EmitIntValue(Hi->getOffset() - Lo->getOffset(), Size);
 }
 
 void MCObjectStreamer::reset() {
   if (Assembler)
     Assembler->reset();
+  for (unsigned i = 0; i < getNumWinFrameInfos(); ++i)
+    delete WinFrameInfos[i];
+  WinFrameInfos.clear();
   CurInsertionPoint = MCSection::iterator();
+  CurrentWinFrameInfo = nullptr;
   EmitEHFrame = true;
   EmitDebugFrame = false;
   PendingLabels.clear();
   MCStreamer::reset();
 }
 
 void MCObjectStreamer::EmitFrames(MCAsmBackend *MAB) {
   if (!getNumFrameInfos())
void MCObjectStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
 
   MCStreamer::emitFill(IntNumValues, Size, Expr);
 }
 
 void MCObjectStreamer::EmitFileDirective(StringRef Filename) {
   getAssembler().addFileName(Filename);
 }
 
+void MCObjectStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol) {
+  const MCAsmInfo *MAI = getContext().getAsmInfo();
+  if (!MAI->usesWindowsCFI())
+    report_fatal_error(".seh_* directives are not supported on this target");
+  if (CurrentWinFrameInfo && !CurrentWinFrameInfo->End)
+    report_fatal_error("Starting a function before ending the previous one!");
+  MCSymbol *StartProc = EmitCFILabel();
+
+  WinFrameInfos.push_back(new WinEH::FrameInfo(Symbol, StartProc));
+  CurrentWinFrameInfo = WinFrameInfos.back();
+  CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
+}
+
+void MCObjectStreamer::EnsureValidWinFrameInfo() {
+  const MCAsmInfo *MAI = getContext().getAsmInfo();
+  if (!MAI->usesWindowsCFI())
+    report_fatal_error(".seh_* directives are not supported on this target");
+  if (!CurrentWinFrameInfo || CurrentWinFrameInfo->End)
+    report_fatal_error("No open Win64 EH frame function!");
+}
+
+void MCObjectStreamer::EmitWinCFIEndProc() {
+  EnsureValidWinFrameInfo();
+  if (CurrentWinFrameInfo->ChainedParent)
+    report_fatal_error("Not all chained regions terminated!");
+
+  MCSymbol *Label = EmitCFILabel();
+  CurrentWinFrameInfo->End = Label;
+}
+
+void MCObjectStreamer::EmitWinCFIStartChained() {
+  EnsureValidWinFrameInfo();
+
+  MCSymbol *StartProc = EmitCFILabel();
+
+  WinFrameInfos.push_back(new WinEH::FrameInfo(CurrentWinFrameInfo->Function,
+                                               StartProc, CurrentWinFrameInfo));
+  CurrentWinFrameInfo = WinFrameInfos.back();
+  CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
+}
+
+void MCObjectStreamer::EmitWinCFIEndChained() {
+  EnsureValidWinFrameInfo();
+  if (!CurrentWinFrameInfo->ChainedParent)
+    report_fatal_error("End of a chained region outside a chained region!");
+
+  MCSymbol *Label = EmitCFILabel();
+
+  CurrentWinFrameInfo->End = Label;
+  CurrentWinFrameInfo =
+      const_cast<WinEH::FrameInfo *>(CurrentWinFrameInfo->ChainedParent);
+}
+
+void MCObjectStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind,
+                                        bool Except) {
+  EnsureValidWinFrameInfo();
+  if (CurrentWinFrameInfo->ChainedParent)
+    report_fatal_error("Chained unwind areas can't have handlers!");
+  CurrentWinFrameInfo->ExceptionHandler = Sym;
+  if (!Except && !Unwind)
+    report_fatal_error("Don't know what kind of handler this is!");
+  if (Unwind)
+    CurrentWinFrameInfo->HandlesUnwind = true;
+  if (Except)
+    CurrentWinFrameInfo->HandlesExceptions = true;
+}
+
+void MCObjectStreamer::EmitWinEHHandlerData() {
+  EnsureValidWinFrameInfo();
+  if (CurrentWinFrameInfo->ChainedParent)
+    report_fatal_error("Chained unwind areas can't have handlers!");
+}
+
+void MCObjectStreamer::EmitWinCFIPushReg(unsigned Register) {
+  EnsureValidWinFrameInfo();
+
+  MCSymbol *Label = EmitCFILabel();
+
+  WinEH::Instruction Inst = Win64EH::Instruction::PushNonVol(Label, Register);
+  CurrentWinFrameInfo->Instructions.push_back(Inst);
+}
+
+void MCObjectStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset) {
+  EnsureValidWinFrameInfo();
+  if (CurrentWinFrameInfo->LastFrameInst >= 0)
+    report_fatal_error("Frame register and offset already specified!");
+  if (Offset & 0x0F)
+    report_fatal_error("Misaligned frame pointer offset!");
+  if (Offset > 240)
+    report_fatal_error("Frame offset must be less than or equal to 240!");
+
+  MCSymbol *Label = EmitCFILabel();
+
+  WinEH::Instruction Inst =
+      Win64EH::Instruction::SetFPReg(Label, Register, Offset);
+  CurrentWinFrameInfo->LastFrameInst = CurrentWinFrameInfo->Instructions.size();
+  CurrentWinFrameInfo->Instructions.push_back(Inst);
+}
+
+void MCObjectStreamer::EmitWinCFIAllocStack(unsigned Size) {
+  EnsureValidWinFrameInfo();
+  if (Size == 0)
+    report_fatal_error("Allocation size must be non-zero!");
+  if (Size & 7)
+    report_fatal_error("Misaligned stack allocation!");
+
+  MCSymbol *Label = EmitCFILabel();
+
+  WinEH::Instruction Inst = Win64EH::Instruction::Alloc(Label, Size);
+  CurrentWinFrameInfo->Instructions.push_back(Inst);
+}
+
+void MCObjectStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset) {
+  EnsureValidWinFrameInfo();
+  if (Offset & 7)
+    report_fatal_error("Misaligned saved register offset!");
+
+  MCSymbol *Label = EmitCFILabel();
+
+  WinEH::Instruction Inst =
+      Win64EH::Instruction::SaveNonVol(Label, Register, Offset);
+  CurrentWinFrameInfo->Instructions.push_back(Inst);
+}
+
+void MCObjectStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset) {
+  EnsureValidWinFrameInfo();
+  if (Offset & 0x0F)
+    report_fatal_error("Misaligned saved vector register offset!");
+
+  MCSymbol *Label = EmitCFILabel();
+
+  WinEH::Instruction Inst =
+      Win64EH::Instruction::SaveXMM(Label, Register, Offset);
+  CurrentWinFrameInfo->Instructions.push_back(Inst);
+}
+
+void MCObjectStreamer::EmitWinCFIPushFrame(bool Code) {
+  EnsureValidWinFrameInfo();
+  if (!CurrentWinFrameInfo->Instructions.empty())
+    report_fatal_error("If present, PushMachFrame must be the first UOP");
+
+  MCSymbol *Label = EmitCFILabel();
+
+  WinEH::Instruction Inst = Win64EH::Instruction::PushMachFrame(Label, Code);
+  CurrentWinFrameInfo->Instructions.push_back(Inst);
+}
+
+void MCObjectStreamer::EmitWinCFIEndProlog() {
+  EnsureValidWinFrameInfo();
+
+  MCSymbol *Label = EmitCFILabel();
+
+  CurrentWinFrameInfo->PrologEnd = Label;
+}
+
 void MCObjectStreamer::FinishImpl() {
   // If we are generating dwarf for assembly source files dump out the sections.
   if (getContext().getGenDwarfForAssembly())
     MCGenDwarfInfo::Emit(this);
 
   // Dump out the dwarf file & directory tables and line tables.
   MCDwarfLineTable::Emit(this, getAssembler().getDWARFLinetableParams());
 
   flushPendingLabels(nullptr);
   getAssembler().Finish();
 }

llvm/lib/MC/MCStreamer.cpp

 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSymbol.h"
-#include "llvm/MC/MCWin64EH.h"
-#include "llvm/MC/MCWinEH.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>

 MCTargetStreamer::~MCTargetStreamer() = default;
 
 void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {}
 
 void MCTargetStreamer::finish() {}
 
 void MCTargetStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {}
 
-MCStreamer::MCStreamer(MCContext &Ctx)
-    : Context(Ctx), CurrentWinFrameInfo(nullptr) {
+MCStreamer::MCStreamer(MCContext &Ctx) : Context(Ctx) {
   SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
 }
 
-MCStreamer::~MCStreamer() {
-  for (unsigned i = 0; i < getNumWinFrameInfos(); ++i)
-    delete WinFrameInfos[i];
-}
+MCStreamer::~MCStreamer() {}
 
 void MCStreamer::reset() {
   DwarfFrameInfos.clear();
-  for (unsigned i = 0; i < getNumWinFrameInfos(); ++i)
-    delete WinFrameInfos[i];
-  WinFrameInfos.clear();
-  CurrentWinFrameInfo = nullptr;
   SymbolOrdering.clear();
   SectionStack.clear();
   SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
 }
 
 raw_ostream &MCStreamer::GetCommentOS() {
   // By default, discard comments.
   return nulls();

 }
 
 void MCStreamer::EmitCFIReturnColumn(int64_t Register) {
   EnsureValidDwarfFrame();
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   CurFrame->RAReg = Register;
 }
 
-void MCStreamer::EnsureValidWinFrameInfo() {
-  const MCAsmInfo *MAI = Context.getAsmInfo();
-  if (!MAI->usesWindowsCFI())
-    report_fatal_error(".seh_* directives are not supported on this target");
-  if (!CurrentWinFrameInfo || CurrentWinFrameInfo->End)
-    report_fatal_error("No open Win64 EH frame function!");
-}
-
-void MCStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol) {
-  const MCAsmInfo *MAI = Context.getAsmInfo();
-  if (!MAI->usesWindowsCFI())
-    report_fatal_error(".seh_* directives are not supported on this target");
-  if (CurrentWinFrameInfo && !CurrentWinFrameInfo->End)
-    report_fatal_error("Starting a function before ending the previous one!");
-
-  MCSymbol *StartProc = EmitCFILabel();
-
-  WinFrameInfos.push_back(new WinEH::FrameInfo(Symbol, StartProc));
-  CurrentWinFrameInfo = WinFrameInfos.back();
-  CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
-}
-
-void MCStreamer::EmitWinCFIEndProc() {
-  EnsureValidWinFrameInfo();
-  if (CurrentWinFrameInfo->ChainedParent)
-    report_fatal_error("Not all chained regions terminated!");
-
-  MCSymbol *Label = EmitCFILabel();
-  CurrentWinFrameInfo->End = Label;
-}
-
-void MCStreamer::EmitWinCFIStartChained() {
-  EnsureValidWinFrameInfo();
-
-  MCSymbol *StartProc = EmitCFILabel();
-
-  WinFrameInfos.push_back(new WinEH::FrameInfo(CurrentWinFrameInfo->Function,
-                                               StartProc, CurrentWinFrameInfo));
-  CurrentWinFrameInfo = WinFrameInfos.back();
-  CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
-}
-
-void MCStreamer::EmitWinCFIEndChained() {
-  EnsureValidWinFrameInfo();
-  if (!CurrentWinFrameInfo->ChainedParent)
-    report_fatal_error("End of a chained region outside a chained region!");
-
-  MCSymbol *Label = EmitCFILabel();
-
-  CurrentWinFrameInfo->End = Label;
-  CurrentWinFrameInfo =
-      const_cast<WinEH::FrameInfo *>(CurrentWinFrameInfo->ChainedParent);
-}
-
-void MCStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind,
-                                  bool Except) {
-  EnsureValidWinFrameInfo();
-  if (CurrentWinFrameInfo->ChainedParent)
-    report_fatal_error("Chained unwind areas can't have handlers!");
-  CurrentWinFrameInfo->ExceptionHandler = Sym;
-  if (!Except && !Unwind)
-    report_fatal_error("Don't know what kind of handler this is!");
-  if (Unwind)
-    CurrentWinFrameInfo->HandlesUnwind = true;
-  if (Except)
-    CurrentWinFrameInfo->HandlesExceptions = true;
-}
-
-void MCStreamer::EmitWinEHHandlerData() {
-  EnsureValidWinFrameInfo();
-  if (CurrentWinFrameInfo->ChainedParent)
-    report_fatal_error("Chained unwind areas can't have handlers!");
-}
-
 static MCSection *getWinCFISection(MCContext &Context, unsigned *NextWinCFIID,
                                    MCSection *MainCFISec,
                                    const MCSection *TextSec) {
   // If this is the main .text section, use the main unwind info section.
   if (TextSec == Context.getObjectFileInfo()->getTextSection())
     return MainCFISec;
 
   const auto *TextSecCOFF = cast<MCSectionCOFF>(TextSec);

 MCSection *MCStreamer::getAssociatedXDataSection(const MCSection *TextSec) {
   return getWinCFISection(getContext(), &NextWinCFIID,
                           getContext().getObjectFileInfo()->getXDataSection(),
                           TextSec);
 }
 
 void MCStreamer::EmitSyntaxDirective() {}
 
-void MCStreamer::EmitWinCFIPushReg(unsigned Register) {
-  EnsureValidWinFrameInfo();
-
-  MCSymbol *Label = EmitCFILabel();
-
-  WinEH::Instruction Inst = Win64EH::Instruction::PushNonVol(Label, Register);
-  CurrentWinFrameInfo->Instructions.push_back(Inst);
-}
-
-void MCStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset) {
-  EnsureValidWinFrameInfo();
-  if (CurrentWinFrameInfo->LastFrameInst >= 0)
-    report_fatal_error("Frame register and offset already specified!");
-  if (Offset & 0x0F)
-    report_fatal_error("Misaligned frame pointer offset!");
-  if (Offset > 240)
-    report_fatal_error("Frame offset must be less than or equal to 240!");
-
-  MCSymbol *Label = EmitCFILabel();
-
-  WinEH::Instruction Inst =
-      Win64EH::Instruction::SetFPReg(Label, Register, Offset);
-  CurrentWinFrameInfo->LastFrameInst = CurrentWinFrameInfo->Instructions.size();
-  CurrentWinFrameInfo->Instructions.push_back(Inst);
-}
-
-void MCStreamer::EmitWinCFIAllocStack(unsigned Size) {
-  EnsureValidWinFrameInfo();
-  if (Size == 0)
-    report_fatal_error("Allocation size must be non-zero!");
-  if (Size & 7)
-    report_fatal_error("Misaligned stack allocation!");
-
-  MCSymbol *Label = EmitCFILabel();
-
-  WinEH::Instruction Inst = Win64EH::Instruction::Alloc(Label, Size);
-  CurrentWinFrameInfo->Instructions.push_back(Inst);
-}
-
-void MCStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset) {
-  EnsureValidWinFrameInfo();
-  if (Offset & 7)
-    report_fatal_error("Misaligned saved register offset!");
-
-  MCSymbol *Label = EmitCFILabel();
-
-  WinEH::Instruction Inst =
-      Win64EH::Instruction::SaveNonVol(Label, Register, Offset);
-  CurrentWinFrameInfo->Instructions.push_back(Inst);
-}
-
-void MCStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset) {
-  EnsureValidWinFrameInfo();
-  if (Offset & 0x0F)
-    report_fatal_error("Misaligned saved vector register offset!");
-
-  MCSymbol *Label = EmitCFILabel();
-
-  WinEH::Instruction Inst =
-      Win64EH::Instruction::SaveXMM(Label, Register, Offset);
-  CurrentWinFrameInfo->Instructions.push_back(Inst);
-}
-
-void MCStreamer::EmitWinCFIPushFrame(bool Code) {
-  EnsureValidWinFrameInfo();
-  if (!CurrentWinFrameInfo->Instructions.empty())
-    report_fatal_error("If present, PushMachFrame must be the first UOP");
-
-  MCSymbol *Label = EmitCFILabel();
-
-  WinEH::Instruction Inst = Win64EH::Instruction::PushMachFrame(Label, Code);
-  CurrentWinFrameInfo->Instructions.push_back(Inst);
-}
-
-void MCStreamer::EmitWinCFIEndProlog() {
-  EnsureValidWinFrameInfo();
-
-  MCSymbol *Label = EmitCFILabel();
-
-  CurrentWinFrameInfo->PrologEnd = Label;
-}
-
 void MCStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) {
 }
 
 void MCStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
 }
 
 void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) {}
 

llvm/lib/MC/MCWin64EH.cpp

 //===- lib/MC/MCWin64EH.cpp - MCWin64EH implementation --------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCWin64EH.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCSectionCOFF.h"
-#include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/Win64EH.h"
 
 using namespace llvm;
 
 // NOTE: All relocations generated here are 4-byte image-relative.
 
 static uint8_t CountOfUnwindCodes(std::vector<WinEH::Instruction> &Insns) {
for (const auto &I : Insns) {
     case Win64EH::UOP_AllocLarge:
       Count += (I.Offset > 512 * 1024 - 8) ? 3 : 2;
       break;
     }
   }
   return Count;
 }
 
-static void EmitAbsDifference(MCStreamer &Streamer, const MCSymbol *LHS,
+static void EmitAbsDifference(MCObjectStreamer &Streamer, const MCSymbol *LHS,
                               const MCSymbol *RHS) {
   MCContext &Context = Streamer.getContext();
   const MCExpr *Diff =
       MCBinaryExpr::createSub(MCSymbolRefExpr::create(LHS, Context),
                               MCSymbolRefExpr::create(RHS, Context), Context);
   Streamer.EmitValue(Diff, 1);
 }
 
-static void EmitUnwindCode(MCStreamer &streamer, const MCSymbol *begin,
+static void EmitUnwindCode(MCObjectStreamer &streamer, const MCSymbol *begin,
                            WinEH::Instruction &inst) {
   uint8_t b2;
   uint16_t w;
   b2 = (inst.Operation & 0x0F);
   switch (static_cast<Win64EH::UnwindOpcodes>(inst.Operation)) {
   case Win64EH::UOP_PushNonVol:
     EmitAbsDifference(streamer, inst.Label, begin);
     b2 |= (inst.Register & 0x0F) << 4;
case Win64EH::UOP_PushMachFrame:
     if (inst.Offset == 1)
       b2 |= 0x10;
     EmitAbsDifference(streamer, inst.Label, begin);
     streamer.EmitIntValue(b2, 1);
     break;
   }
 }
 
-static void EmitSymbolRefWithOfs(MCStreamer &streamer,
+static void EmitSymbolRefWithOfs(MCObjectStreamer &streamer,
                                  const MCSymbol *Base,
                                  const MCSymbol *Other) {
   MCContext &Context = streamer.getContext();
   const MCSymbolRefExpr *BaseRef = MCSymbolRefExpr::create(Base, Context);
   const MCSymbolRefExpr *OtherRef = MCSymbolRefExpr::create(Other, Context);
   const MCExpr *Ofs = MCBinaryExpr::createSub(OtherRef, BaseRef, Context);
   const MCSymbolRefExpr *BaseRefRel = MCSymbolRefExpr::create(Base,
                                               MCSymbolRefExpr::VK_COFF_IMGREL32,
                                               Context);
   streamer.EmitValue(MCBinaryExpr::createAdd(BaseRefRel, Ofs, Context), 4);
 }
 
-static void EmitRuntimeFunction(MCStreamer &streamer,
+static void EmitRuntimeFunction(MCObjectStreamer &streamer,
                                 const WinEH::FrameInfo *info) {
   MCContext &context = streamer.getContext();
 
   streamer.EmitValueToAlignment(4);
   EmitSymbolRefWithOfs(streamer, info->Function, info->Begin);
   EmitSymbolRefWithOfs(streamer, info->Function, info->End);
   streamer.EmitValue(MCSymbolRefExpr::create(info->Symbol,
                                              MCSymbolRefExpr::VK_COFF_IMGREL32,
                                              context), 4);
 }
 
-static void EmitUnwindInfo(MCStreamer &streamer, WinEH::FrameInfo *info) {
+static void EmitUnwindInfo(MCObjectStreamer &streamer, WinEH::FrameInfo *info) {
   // If this UNWIND_INFO already has a symbol, it's already been emitted.
   if (info->Symbol)
     return;
 
   MCContext &context = streamer.getContext();
   MCSymbol *Label = context.createTempSymbol();
 
   streamer.EmitValueToAlignment(4);
static void EmitUnwindInfo(MCObjectStreamer &streamer, WinEH::FrameInfo *info) {
   else if (numCodes == 0) {
     // The minimum size of an UNWIND_INFO struct is 8 bytes. If we're not
     // a chained unwind info, if there is no handler, and if there are fewer
     // than 2 slots used in the unwind code array, we have to pad to 8 bytes.
     streamer.EmitIntValue(0, 4);
   }
 }
 
-void llvm::Win64EH::UnwindEmitter::Emit(MCStreamer &Streamer) const {
+void llvm::Win64EH::UnwindEmitter::Emit(MCObjectStreamer &Streamer) const {
   // Emit the unwind info structs first.
   for (WinEH::FrameInfo *CFI : Streamer.getWinFrameInfos()) {
     MCSection *XData = Streamer.getAssociatedXDataSection(CFI->TextSection);
     Streamer.SwitchSection(XData);
     ::EmitUnwindInfo(Streamer, CFI);
   }
 
   // Now emit RUNTIME_FUNCTION entries.
   for (WinEH::FrameInfo *CFI : Streamer.getWinFrameInfos()) {
     MCSection *PData = Streamer.getAssociatedPDataSection(CFI->TextSection);
     Streamer.SwitchSection(PData);
     EmitRuntimeFunction(Streamer, CFI);
   }
 }
 
 void llvm::Win64EH::UnwindEmitter::EmitUnwindInfo(
-    MCStreamer &Streamer, WinEH::FrameInfo *info) const {
+    MCObjectStreamer &Streamer, WinEH::FrameInfo *info) const {
   // Switch sections (the static function above is meant to be called from
   // here and from Emit().
   MCSection *XData = Streamer.getAssociatedXDataSection(info->TextSection);
   Streamer.SwitchSection(XData);
 
   ::EmitUnwindInfo(Streamer, info);
 }
 

llvm/test/MC/AsmParser/directive_seh.s

# CHECK: .seh_pushreg 3
     .seh_handler __C_specific_handler, @except
     .seh_handlerdata
     .long 0
     .text
     .seh_startchained
     .seh_endprologue
     .seh_endchained
 # CHECK: .seh_setframe 3, 0
+# CHECK-NOT: .Lcfi
 # CHECK: .seh_endprologue
 # CHECK: .seh_handler __C_specific_handler, @except
 # CHECK-NOT: .section{{.*}}.xdata
 # CHECK: .seh_handlerdata
+# CHECK: .long 0
 # CHECK: .text
 # CHECK: .seh_startchained
 # CHECK: .seh_endprologue
 # CHECK: .seh_endchained
     lea (%rbx), %rsp
     pop %rbx
     addq $24, %rsp
     ret
     .seh_endproc
 # CHECK: .seh_endproc