[WIP][DebugInfo] refactor DIE classes. Remove dependency on AsmPrinter.

[avl]

Summary

Remove dependency of DWARF generation code on AsmPrinter.

This patch is not for integration. I want to consult whether it is going
in the right direction. It demonstrates the possible variant of refactoring.
Not all cases/problems are resolved in this patch currently.

During work on "Remove obsolete debug info in lld" I need to generate
DWARF without using AsmPrinter(To not to add extra libraries to lld).
The current implementation of DWARF generation is heavily depends on
using AsmPrinter. F.e. CodeGen/DIE.h

class DIEInteger {

void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;

}

I think it would be a bad idea to write a new set of DWARF generating
classes, not depending on AsmPrinter. Instead, it would be better
to reduce dependence on AsmPrinter for current structures.
It would allow for reusing existed implementation.

There is already a place which implements such separation :

AsmPrinter/ByteStreamer.h:ByteStreamer
AsmPrinter/DwarfDebug.h:DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer)

But it is used locally. I think the same idea could be implemented
in a more general way:

There should be a class that allows writing byte data in the dwarf section: DwarfDebugSection.
DwarfDebugSection would have two descendands: DwarfDebugSectionAsm, DwarfDebugSectionBin.
There should be a class that allows writing DWARF constructions(units, line tables,
address ranges) to DwarfDebugSection: DwarfDebugFile.
DIE* classes from CodeGen/DIE.h should be moved into DebugInfoDWARF library.
DwarfDebugSection & DwarfDebugFile should be put into DebugInfoDWARF library.
In a far perspective: DwarfDebugFile could replace AsmPrinter/DwarfFile,
other classes would be moved into DebugInfoDWARF library(DwarfStringPool...).
The above changes would allow generating DWARF without AsmPrinter.
Also, this implementation could probably be reused by debug info tools(dsymutil,
llvm-gsymutil, llvm-dwp...).

This patch presents some changes which show the direction of the refactoring.

What do you think? Would this refactoring be useful?
Is it OK to do things in this manner?

If that idea is OK, then changes could be done incrementally,
moving code(currently located in AsmPrinter) into DebugInfoDWARF library.

[clayborg]

I too ran into the AsmPrinter being a bit overkill for writing simple data. GSYM has a simple file writer class that just uses llvm::raw_pwrite_stream:

llvm/include/llvm/DebugInfo/GSYM/FileWriter.h
llvm/lib/DebugInfo/GSYM/FileWriter.cpp

Not sure if this would be worth improving and moving to a more generic location so that everyone can use it? It is a very simple class right now, no labels or sections, but these features could be added if needed. GSYM files are currently stand alone files, but in the future we will want GSYM to be a section within a file.

[dblaikie]

During work on "Remove obsolete debug info in lld" I need to generate DWARF without using AsmPrinter(To not to add extra libraries to lld).

Could you point to where this is a requirement? (has this already been discussed in review/found to be an unacceptable dependency? llvm-dsymutil uses the existing AsmPrinter-based APIs to write the output, yes?)

I think it would be a bad idea to write a new set of DWARF generating classes, not depending on AsmPrinter.

Agreed

Instead, it would be better to reduce dependence on AsmPrinter for current structures.

Agreed, if the dependency is unacceptable.

There is already a place which implements such separation :

AsmPrinter/ByteStreamer.h:ByteStreamer
AsmPrinter/DwarfDebug.h:DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer)

For historics: That API was added by @echristo to allow both emitting the bytes and hashing the bytes of a location - so it does represent a small instance of the abstraction you're looking for, yes.

But it is used locally. I think the same idea could be implemented in a more general way:

There should be a class that allows writing byte data in the dwarf section: DwarfDebugSection. DwarfDebugSection would have two descendands: DwarfDebugSectionAsm, DwarfDebugSectionBin.

I'd expect it, perhaps, to be more like ByteStreamer - which has a hashing and an AsmPrinter implementation. Though in this case we'd start with only an AsmPrinter implementation (AsmPrinter already abstracts over the asm/binary distinction, so there's hopefully no need to float that up/duplicate that in the DwarfDebugSection abstraction).

(I'm leaving naming mostly aside here for now - that'll have to be iterated on at some point)

There should be a class that allows writing DWARF constructions(units, line tables, address ranges) to DwarfDebugSection: DwarfDebugFile.

Not quite sure what you're picturing with DwarfDebugFile - I guess you mean an abstraction over a collection of DwarfDebugSections related to a particular file (eg: one for a .o file, one for a .dwo file, perhaps).

Though looking at the API for DwarfDebugFile in your proposed patch, it seems to have features I'd consider too high level for that abstraction - like writeCompileUnitHeader etc - anything that is higher level than assembly (so ulebs, ints, relocations, labels) seems inappropriate for the abstraction. AsmPrinter should be the first/trivially wrapped in this abstraction, I think. (I wouldn't mind something less stateful, though - as you say, the section V file abstraction, though that might lead to some confusing assembly - since AsmPrinter is a streaming abstraction, so if you have a stateful section then the usage code might end up thinking it's totally fine to write a few things to one section, then a few things to another section - which creates for less-than-ideal assembly (fragmented sections) & so I think that'd be unfortunate)

DIE* classes from CodeGen/DIE.h should be moved into DebugInfoDWARF library.

I'd say it'd be best to not move it into the DebugInfoDWARF library - that'd have the reverse effect, then LLVM's code generation would end up depending on DWARF parsing code it has no need for... - so I guess this'd need to go in a separate library.

The general idea of making these APIs independent of AsmPrinter - yeah, seems plausible, if it's especially necessary/useful - see the first questions.

[avl]

Could you point to where this is a requirement? (has this already been discussed in review/found to be an unacceptable dependency?

Actually, I did not discuss it with LLD folks.
It looked obvious from the LLD code structure.
But, that my assumption could be wrong. I`ve asked now in D74169.

So I will wait for feedback from them. If AsmPrinter is OK - then no need to do refactoring now.

llvm-dsymutil uses the existing AsmPrinter-based APIs to write the output, yes?)

yes.

[avl]

Could you point to where this is a requirement? (has this already been discussed in review/found to be an unacceptable dependency? llvm-dsymutil uses the existing AsmPrinter-based APIs to write the output, yes?)

So far, LLD folks generally do not object adding AsmPrinter if overall impact would be acceptable.

I think I could continue with AsmPrinter for now. Though it looks a bit overcomplicated solution. Simple writer like llvm/include/llvm/DebugInfo/GSYM/FileWriter.h would be more appropriate solution generally.

[avl]

Such a refactoring could make sense in the future. Currently it would be OK to use AsmPrinter, thus I abandon the review.

llvm/include/llvm/CodeGen/AsmPrinter.h

 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/CodeGen/AsmPrinterHandler.h"
 #include "llvm/CodeGen/DwarfStringPoolEntry.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugSection.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SourceMgr.h"
 #include <cstdint>
 #include <memory>
 #include <utility>
 #include <vector>

 class StackMaps;
 class TargetLoweringObjectFile;
 class TargetMachine;
 
 namespace remarks {
 class RemarkStreamer;
 }
 
+class DwarfDebugSectionImpl : public DwarfDebugSectionAsm {
+public:
+  DwarfDebugSectionImpl(AsmPrinter *AP, MCStreamer *OutStreamer,
+                        TargetMachine *TM, const MCAsmInfo *MAI, bool IsVerbose)
+      : AP(AP), OutStreamer(OutStreamer), TM(TM), MAI(MAI),
+        IsVerbose(IsVerbose) {}
+
+  uint16_t getDwarfVersion() const override;
+
+  void setDwarfVersion(uint16_t Version) override;
+
+  unsigned getAddressSize() const override;
+
+  /// Emit a byte directive and value.
+  void writeInt8(int Value) override;
+
+  /// Emit a short directive and value.
+  void writeInt16(int Value) override;
+
+  /// Emit a long directive and value.
+  void writeInt32(int Value) override;
+
+  /// Emit a long long directive and value.
+  void writeInt64(uint64_t Value) override;
+
+  /// Emit the specified signed leb128 value.
+  void writeSLEB128(int64_t Value, const char *Desc = nullptr) override;
+
+  /// Emit the specified unsigned leb128 value.
+  void writeULEB128(uint64_t Value, const char *Desc = nullptr,
+                    unsigned PadTo = 0) override;
+
+  bool isAsm() const override { return true; }
+
+  dwarf::DwarfFormat getDwarfFormat() const override;
+
+  void writeIntValue(uint64_t Value, unsigned Size) override;
+
+  bool doesDwarfUseRelocationsAcrossSections() const override;
+
+  void writeBytes(StringRef Data) override;
+
+  AsmPrinter *getAsmPrinter() { return AP; }
+
+  void addBlankLine() override;
+
+  void writeDebugValue(const MCExpr *Value, unsigned Size) override;
+
+  void writeLabelReference(const MCSymbol *Label, unsigned Size,
+                           bool IsSectionRelative = false) override;
+
+  void writeLabelPlusOffset(const MCSymbol *Label, uint64_t Offset,
+                            unsigned Size, bool IsSectionRelative) override;
+
+  void writeLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
+                            unsigned Size) override;
+
+  void writeDwarfSymbolReference(const MCSymbol *Label,
+                                 bool ForceOffset = false) override;
+
+private:
+  AsmPrinter *AP;
+  MCStreamer *OutStreamer;
+  TargetMachine *TM;
+  const MCAsmInfo *MAI;
+  bool IsVerbose;
+};
+
 /// This class is intended to be used as a driving class for all asm writers.
 class AsmPrinter : public MachineFunctionPass {
 public:
   /// Target machine description.
   TargetMachine &TM;
 
   /// Target Asm Printer information.
   const MCAsmInfo *MAI;
private:
   mutable std::unique_ptr<SrcMgrDiagInfo> DiagInfo;
 
   /// If the target supports dwarf debug info, this pointer is non-null.
   DwarfDebug *DD = nullptr;
 
   /// If the current module uses dwarf CFI annotations strictly for debugging.
   bool isCFIMoveForDebugging = false;
 
+  std::unique_ptr<DwarfDebugSectionImpl> DebugSection;
+
 protected:
   explicit AsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer);
 
 public:
   ~AsmPrinter() override;
 
   DwarfDebug *getDwarfDebug() { return DD; }
   DwarfDebug *getDwarfDebug() const { return DD; }
+  DwarfDebugSection *getCurDwarfDebugSection() const {
+    return DebugSection.get();
+  }
 
   uint16_t getDwarfVersion() const;
   void setDwarfVersion(uint16_t Version);
 
   bool isPositionIndependent() const;
 
   /// Return true if assembly output should contain comments.
   bool isVerbose() const { return VerboseAsm; }
public:
   void emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo,
                           unsigned Encoding) const;
   /// Emit an integer value corresponding to the call site encoding
   void emitCallSiteValue(uint64_t Value, unsigned Encoding) const;
 
   /// Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
   virtual unsigned getISAEncoding() { return 0; }
 
-  /// Emit the directive and value for debug thread local expression
-  ///
-  /// \p Value - The value to emit.
-  /// \p Size - The size of the integer (in bytes) to emit.
-  virtual void emitDebugValue(const MCExpr *Value, unsigned Size) const;
-
   //===------------------------------------------------------------------===//
   // Dwarf Lowering Routines
   //===------------------------------------------------------------------===//
 
   /// Emit frame instruction to describe the layout of the frame.
   void emitCFIInstruction(const MCCFIInstruction &Inst) const;
 
   /// Emit Dwarf abbreviation table.
   template <typename T> void emitDwarfAbbrevs(const T &Abbrevs) const {
     // For each abbreviation.
     for (const auto &Abbrev : Abbrevs)
       emitDwarfAbbrev(*Abbrev);
 
     // Mark end of abbreviations.
-    emitULEB128(0, "EOM(3)");
+    getCurDwarfDebugSection()->writeULEB128(0, "EOM(3)");
   }
 
   void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const;
 
   /// Recursively emit Dwarf DIE tree.
   void emitDwarfDIE(const DIE &Die) const;
 
   //===------------------------------------------------------------------===//

llvm/include/llvm/CodeGen/DIE.h

 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/CodeGen/DwarfStringPoolEntry.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugSection.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Allocator.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 #include <new>
 #include <type_traits>
public:
   void AddImplicitConstAttribute(dwarf::Attribute Attribute, int64_t Value) {
     Data.push_back(DIEAbbrevData(Attribute, Value));
   }
 
   /// Used to gather unique data for the abbreviation folding set.
   void Profile(FoldingSetNodeID &ID) const;
 
   /// Print the abbreviation using the specified asm printer.
-  void Emit(const AsmPrinter *AP) const;
+  void Emit(DwarfDebugSection *Dwarf) const;
 
   void print(raw_ostream &O) const;
   void dump() const;
 };
 
 //===--------------------------------------------------------------------===//
 /// Helps unique DIEAbbrev objects and assigns abbreviation numbers.
 ///
if (IsSigned) {
         return dwarf::DW_FORM_data4;
     }
     return dwarf::DW_FORM_data8;
   }
 
   uint64_t getValue() const { return Integer; }
   void setValue(uint64_t Val) { Integer = Val; }
 
-  void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const;
+  unsigned SizeOf(const DwarfDebugSection *Dwarf, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// An expression DIE.
 class DIEExpr {
   const MCExpr *Expr;
 
 public:
   explicit DIEExpr(const MCExpr *E) : Expr(E) {}
 
   /// Get MCExpr.
   const MCExpr *getValue() const { return Expr; }
 
-  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const;
+  unsigned SizeOf(const DwarfDebugSection *Dwarf, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A label DIE.
 class DIELabel {
   const MCSymbol *Label;
 
 public:
   explicit DIELabel(const MCSymbol *L) : Label(L) {}
 
   /// Get MCSymbol.
   const MCSymbol *getValue() const { return Label; }
 
-  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const;
+  unsigned SizeOf(const DwarfDebugSection *Dwarf, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A BaseTypeRef DIE.
 class DIEBaseTypeRef {
   const DwarfCompileUnit *CU;
   const uint64_t Index;
   static constexpr unsigned ULEB128PadSize = 4;
 
 public:
   explicit DIEBaseTypeRef(const DwarfCompileUnit *TheCU, uint64_t Idx)
     : CU(TheCU), Index(Idx) {}
 
   /// EmitValue - Emit base type reference.
-  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const;
   /// SizeOf - Determine size of the base type reference in bytes.
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOf(const DwarfDebugSection *Dwarf, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A simple label difference DIE.
 ///
 class DIEDelta {
   const MCSymbol *LabelHi;
   const MCSymbol *LabelLo;
 
 public:
   DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) : LabelHi(Hi), LabelLo(Lo) {}
 
-  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const;
+  unsigned SizeOf(const DwarfDebugSection *Dwarf, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A container for string pool string values.
 ///
 /// This class is used with the DW_FORM_strp and DW_FORM_GNU_str_index forms.
 class DIEString {
   DwarfStringPoolEntryRef S;
 
 public:
   DIEString(DwarfStringPoolEntryRef S) : S(S) {}
 
   /// Grab the string out of the object.
   StringRef getString() const { return S.getString(); }
 
-  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const;
+  unsigned SizeOf(const DwarfDebugSection *Dwarf, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A container for inline string values.
 ///
 /// This class is used with the DW_FORM_string form.
 class DIEInlineString {
   StringRef S;
 
 public:
   template <typename Allocator>
   explicit DIEInlineString(StringRef Str, Allocator &A) : S(Str.copy(A)) {}
 
   ~DIEInlineString() = default;
 
   /// Grab the string out of the object.
   StringRef getString() const { return S; }
 
-  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const;
+  unsigned SizeOf(const DwarfDebugSection *Dwarf, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A pointer to another debug information entry.  An instance of this class can
 /// also be used as a proxy for a debug information entry not yet defined
 /// (ie. types.)
 class DIEEntry {
   DIE *Entry;
 
 public:
   DIEEntry() = delete;
   explicit DIEEntry(DIE &E) : Entry(&E) {}
 
   DIE &getEntry() const { return *Entry; }
 
-  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const;
+  unsigned SizeOf(const DwarfDebugSection *Dwarf, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// Represents a pointer to a location list in the debug_loc
 /// section.
 class DIELocList {
   /// Index into the .debug_loc vector.
   size_t Index;
 
 public:
   DIELocList(size_t I) : Index(I) {}
 
   /// Grab the current index out.
   size_t getValue() const { return Index; }
 
-  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const;
+  unsigned SizeOf(const DwarfDebugSection *Dwarf, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A debug information entry value. Some of these roughly correlate
 /// to DWARF attribute classes.
 class DIEBlock;

 #define HANDLE_DIEVALUE_LARGE(T)                                               \
   const DIE##T &getDIE##T() const {                                            \
     assert(getType() == is##T && "Expected " #T);                              \
     return **get<const DIE##T *>();                                            \
   }
 #include "llvm/CodeGen/DIEValue.def"
 
   /// Emit value via the Dwarf writer.
-  void emitValue(const AsmPrinter *AP) const;
+  void emitValue(DwarfDebugSection *Dwarf) const;
 
   /// Return the size of a value in bytes.
-  unsigned SizeOf(const AsmPrinter *AP) const;
+  unsigned SizeOf(const DwarfDebugSection *Dwarf) const;
 
   void print(raw_ostream &O) const;
   void dump() const;
 };
 
 struct IntrusiveBackListNode {
   PointerIntPair<IntrusiveBackListNode *, 1> Next;
 
public:
   /// information and gives each DIE a chance to figure out its CU relative DIE
   /// offset, unique its abbreviation and fill in the abbreviation code, and
   /// return the unit offset that points to where the next DIE will be emitted
   /// within the debug unit section. After this function has been called for all
   /// DIE objects, the DWARF can be generated since all DIEs will be able to
   /// properly refer to other DIE objects since all DIEs have calculated their
   /// offsets.
   ///
-  /// \param AP AsmPrinter to use when calculating sizes.
+  /// \param Dwarf DwarfDebugStream to use when calculating sizes.
   /// \param AbbrevSet the abbreviation used to unique DIE abbreviations.
   /// \param CUOffset the compile/type unit relative offset in bytes.
   /// \returns the offset for the DIE that follows this DIE within the
   /// current compile/type unit.
-  unsigned computeOffsetsAndAbbrevs(const AsmPrinter *AP,
+  unsigned computeOffsetsAndAbbrevs(DwarfDebugSection *Dwarf,
                                     DIEAbbrevSet &AbbrevSet, unsigned CUOffset);
 
   /// Climb up the parent chain to get the compile unit or type unit DIE that
   /// this DIE belongs to.
   ///
   /// \returns the compile or type unit DIE that owns this DIE, or NULL if
   /// this DIE hasn't been added to a unit DIE.
   const DIE *getUnitDie() const;

 class DIELoc : public DIEValueList {
   mutable unsigned Size = 0; // Size in bytes excluding size header.
 
 public:
   DIELoc() = default;
 
   /// ComputeSize - Calculate the size of the location expression.
   ///
-  unsigned ComputeSize(const AsmPrinter *AP) const;
+  unsigned ComputeSize(const DwarfDebugSection *AP) const;
 
   // TODO: move setSize() and Size to DIEValueList.
   void setSize(unsigned size) { Size = size; }
 
   /// BestForm - Choose the best form for data.
   ///
   dwarf::Form BestForm(unsigned DwarfVersion) const {
     if (DwarfVersion > 3)
       return dwarf::DW_FORM_exprloc;
     // Pre-DWARF4 location expressions were blocks and not exprloc.
     if ((unsigned char)Size == Size)
       return dwarf::DW_FORM_block1;
     if ((unsigned short)Size == Size)
       return dwarf::DW_FORM_block2;
     if ((unsigned int)Size == Size)
       return dwarf::DW_FORM_block4;
     return dwarf::DW_FORM_block;
   }
 
-  void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const;
+  unsigned SizeOf(const DwarfDebugSection *Dwarf, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// DIEBlock - Represents a block of values.
 //
 class DIEBlock : public DIEValueList {
   mutable unsigned Size = 0; // Size in bytes excluding size header.
 
 public:
   DIEBlock() = default;
 
   /// ComputeSize - Calculate the size of the location expression.
   ///
-  unsigned ComputeSize(const AsmPrinter *AP) const;
+  unsigned ComputeSize(const DwarfDebugSection *Dwarf) const;
 
   // TODO: move setSize() and Size to DIEValueList.
   void setSize(unsigned size) { Size = size; }
 
   /// BestForm - Choose the best form for data.
   ///
   dwarf::Form BestForm() const {
     if ((unsigned char)Size == Size)
       return dwarf::DW_FORM_block1;
     if ((unsigned short)Size == Size)
       return dwarf::DW_FORM_block2;
     if ((unsigned int)Size == Size)
       return dwarf::DW_FORM_block4;
     return dwarf::DW_FORM_block;
   }
 
-  void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  void emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const;
+  unsigned SizeOf(const DwarfDebugSection *Dwarf, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFile.h

+//===- DWARFDebugFile.h -------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_DWARF_DWARFDEBUGFILE_H
+#define LLVM_DEBUGINFO_DWARF_DWARFDEBUGFILE_H
+
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/CodeGen/DIE.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugSection.h"
+#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
+#include <cstdint>
+
+namespace llvm {
+
+/// This class writes DWARF constructions into
+class DwarfDebugFile {
+public:
+  virtual ~DwarfDebugFile() {}
+
+  /// Set of methods writing DWARF constructions:
+
+  /// Writes compile unit header.
+  virtual void writeCompileUnitHeader(DIEUnit &Unit) = 0;
+
+  /// Writes compile units address ranges.
+  virtual void writeUnitRangesEntries(DIEUnit &Unit) = 0;
+
+  /// Recursively write Dwarf DIE tree.
+  virtual void writeDwarfDIE(const DIE &Die) = 0;
+
+  /// Set of methods returning DWARF sections:
+
+  virtual DwarfDebugSection *getLocSection() = 0;
+  virtual DwarfDebugSection *getLoclistsSection() = 0;
+  virtual DwarfDebugSection *getArangesSection() = 0;
+  virtual DwarfDebugSection *getFrameSection() = 0;
+  virtual DwarfDebugSection *getEHFrameSection() = 0;
+  virtual DwarfDebugSection *getLineSection() = 0;
+  virtual DwarfDebugSection *getLineStrSection() = 0;
+  virtual DwarfDebugSection *getStrSection() = 0;
+  virtual DwarfDebugSection *getRangesSection() = 0;
+  virtual DwarfDebugSection *getRnglistsSection() = 0;
+  virtual DwarfDebugSection *getMacinfoSection() = 0;
+  virtual DwarfDebugSection *getMacinfoDWOSection() = 0;
+  virtual DwarfDebugSection *getPubnamesSection() = 0;
+  virtual DwarfDebugSection *getPubtypesSection() = 0;
+  virtual DwarfDebugSection *getGnuPubnamesSection() = 0;
+  virtual DwarfDebugSection *getGnuPubtypesSection() = 0;
+  virtual DwarfDebugSection *getStrOffsetsSection() = 0;
+  virtual void
+  forEachInfoDWOSections(function_ref<void(DwarfDebugSection *)> F) = 0;
+  virtual void
+  forEachTypesDWOSections(function_ref<void(DwarfDebugSection *)> F) = 0;
+  virtual DwarfDebugSection *getAbbrevDWOSection() = 0;
+  virtual DwarfDebugSection *getLineDWOSection() = 0;
+  virtual DwarfDebugSection *getLocDWOSection() = 0;
+  virtual DwarfDebugSection *getLoclistsDWOSection() = 0;
+  virtual DwarfDebugSection *getStrDWOSection() = 0;
+  virtual DwarfDebugSection *getStrOffsetsDWOSection() = 0;
+  virtual DwarfDebugSection *getRangesDWOSection() = 0;
+  virtual DwarfDebugSection *getRnglistsDWOSection() = 0;
+  virtual DwarfDebugSection *getAddrSection() = 0;
+  virtual DwarfDebugSection *getAppleNamesSection() = 0;
+  virtual DwarfDebugSection *getAppleTypesSection() = 0;
+  virtual DwarfDebugSection *getAppleNamespacesSection() = 0;
+  virtual DwarfDebugSection *getNamesSection() = 0;
+  virtual DwarfDebugSection *getAppleObjCSection() = 0;
+  virtual DwarfDebugSection *getCUIndexSection() = 0;
+  virtual DwarfDebugSection *getGdbIndexSection() = 0;
+  virtual DwarfDebugSection *getTUIndexSection() = 0;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGFILE_H

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugSection.h

+//===- DWARFDebugSection.h ------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_DWARF_DWARFDEBUGSECTION_H
+#define LLVM_DEBUGINFO_DWARF_DWARFDEBUGSECTION_H
+
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCSymbol.h"
+#include <cstdint>
+
+namespace llvm {
+
+/// This class represents routines to write unstructured data
+/// into debug section.
+class DwarfDebugSection {
+public:
+  virtual ~DwarfDebugSection() {}
+
+  /// Returns true if the destination is an assembler.
+  virtual bool isAsm() const = 0;
+
+  /// Set of methods describing state of debug stream.
+
+  /// Returns Dwarf format(32 bit/64 bit).
+  virtual dwarf::DwarfFormat getDwarfFormat() const = 0;
+
+  /// Returns current address size.
+  virtual unsigned getAddressSize() const = 0;
+
+  /// Set current address size.
+  virtual void setAddressSize(unsigned Size) {}
+
+  /// Returns current Dwarf version number.
+  virtual uint16_t getDwarfVersion() const = 0;
+
+  /// Set current Dwarf version.
+  virtual void setDwarfVersion(uint16_t Version) = 0;
+
+  /// True if Dwarf2 output generally uses relocations for references to other
+  /// .debug_* sections.
+  virtual bool doesDwarfUseRelocationsAcrossSections() const = 0;
+
+  /// Special case of EmitValue that avoids the client
+  /// to call concrete sized method.
+  virtual void writeIntValue(uint64_t Value, unsigned Size) = 0;
+
+  /// Write a byte directive and value.
+  virtual void writeInt8(int Value) = 0;
+
+  /// Write a short directive and value.
+  virtual void writeInt16(int Value) = 0;
+
+  /// Write a long directive and value.
+  virtual void writeInt32(int Value) = 0;
+
+  /// Write a long long directive and value.
+  virtual void writeInt64(uint64_t Value) = 0;
+
+  /// Write the specified signed leb128 value.
+  virtual void writeSLEB128(int64_t Value, const char *Desc = nullptr) = 0;
+
+  /// Write the specified unsigned leb128 value.
+  virtual void writeULEB128(uint64_t Value, const char *Desc = nullptr,
+                            unsigned PadTo = 0) = 0;
+
+  /// Write the specified bytes.
+  virtual void writeBytes(StringRef Data) = 0;
+};
+
+class DwarfDebugSectionAsm : public DwarfDebugSection {
+public:
+  bool isAsm() const override { return true; }
+
+  /// Write the directive and value for debug thread local expression
+  ///
+  /// \p Value - The value to write.
+  /// \p Size - The size of the integer (in bytes) to write.
+  virtual void writeDebugValue(const MCExpr *Value, unsigned Size) = 0;
+
+  /// Write something like ".long Label" where the size in bytes of the
+  /// directive is specified by Size and Label specifies the label.
+  virtual void writeLabelReference(const MCSymbol *Label, unsigned Size,
+                                   bool IsSectionRelative = false) = 0;
+
+  /// Write something like ".long Label+Offset" where the size in bytes of the
+  /// directive is specified by Size and Label specifies the label.  This
+  /// implicitly uses .set if it is available.
+  virtual void writeLabelPlusOffset(const MCSymbol *Label, uint64_t Offset,
+                                    unsigned Size,
+                                    bool IsSectionRelative = false) = 0;
+
+  /// Write something like ".long Hi-Lo" where the size in bytes of the
+  /// directive is specified by Size and Hi/Lo specify the labels.  This
+  /// implicitly uses .set if it is available.
+  virtual void writeLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
+                                    unsigned Size) = 0;
+
+  /// Write a reference to a symbol for use in dwarf. Different object formats
+  /// represent this in different ways. Some use a relocation others encode
+  /// the label offset in its section.
+  virtual void writeDwarfSymbolReference(const MCSymbol *Label,
+                                         bool ForceOffset = false) = 0;
+
+  /// Emit a blank line to a .s file to pretty it up.
+  virtual void addBlankLine() = 0;
+};
+
+class DwarfDebugSectionBin : public DwarfDebugSection {
+public:
+  bool isAsm() const override { return false; }
+
+  /// returns current section size.
+  virtual uint64_t getSize() const = 0;
+
+  /// Fixup a uint64_t value at the specified offset in the section. This
+  /// function will save the current section position, seek to the specified
+  /// offset, overwrite the data using Value, and then restore the section
+  /// position to the previous section position.
+  ///
+  /// \param   Value The value to write into the section.
+  /// \param   Offset The offset at which to write the Value within the section.
+  void fixup32(uint32_t Value, uint64_t Offset);
+
+  /// Fixup a uint64_t value at the specified offset in the section. This
+  /// function will save the current section position, seek to the specified
+  /// section, overwrite the data using Value, and then restore the section
+  /// position to the previous section position.
+  ///
+  /// \param   Value The value to write into the section.
+  /// \param   Offset The offset at which to write the Value within the section.
+  void fixup64(uint64_t Value, uint64_t Offset);
+
+  /// Pad with zeroes at the current section position until the current section
+  /// position matches the specified alignment.
+  ///
+  /// \param  Align An integer speciying the desired alignment. This does not
+  ///         need to be a power of two.
+  void alignTo(size_t Align);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGSECTION_H

llvm/lib/CodeGen/AsmPrinter/AccelTable.cpp

assert(AbbrevIt != Abbreviations.end() &&
          "Why wasn't this abbrev generated?");
 
   Asm->emitULEB128(AbbrevIt->first, "Abbreviation code");
   for (const auto &AttrEnc : AbbrevIt->second) {
     Asm->OutStreamer->AddComment(dwarf::IndexString(AttrEnc.Index));
     switch (AttrEnc.Index) {
     case dwarf::DW_IDX_compile_unit: {
       DIEInteger ID(getCUIndexForEntry(Entry));
-      ID.emitValue(Asm, AttrEnc.Form);
+      ID.emitValue(Asm->getCurDwarfDebugSection(), AttrEnc.Form);
       break;
     }
     case dwarf::DW_IDX_die_offset:
       assert(AttrEnc.Form == dwarf::DW_FORM_ref4);
       Asm->emitInt32(Entry.getDieOffset());
       break;
     default:
       llvm_unreachable("Unexpected index attribute!");

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (*GVAlign > Alignment || GV->hasSection())
     Alignment = *GVAlign;
   return Alignment;
 }
 
 AsmPrinter::AsmPrinter(TargetMachine &tm, std::unique_ptr<MCStreamer> Streamer)
     : MachineFunctionPass(ID), TM(tm), MAI(tm.getMCAsmInfo()),
       OutContext(Streamer->getContext()), OutStreamer(std::move(Streamer)) {
   VerboseAsm = OutStreamer->isVerboseAsm();
+  DebugSection = std::make_unique<DwarfDebugSectionImpl>(
+      this, OutStreamer.get(), &TM, MAI, isVerbose());
 }
 
 AsmPrinter::~AsmPrinter() {
   assert(!DD && Handlers.empty() && "Debug/EH info didn't get finalized");
 
   if (GCMetadataPrinters) {
     gcp_map_type &GCMap = getGCMap(GCMetadataPrinters);
 
void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
   if (MAI->hasDotTypeDotSizeDirective())
     // .size foo, 42
     OutStreamer->emitELFSize(EmittedInitSym,
                              MCConstantExpr::create(Size, OutContext));
 
   OutStreamer->AddBlankLine();
 }
 
-/// Emit the directive and value for debug thread local expression
-///
-/// \p Value - The value to emit.
-/// \p Size - The size of the integer (in bytes) to emit.
-void AsmPrinter::emitDebugValue(const MCExpr *Value, unsigned Size) const {
-  OutStreamer->emitValue(Value, Size);
-}
-
 /// EmitFunctionHeader - This method emits the header for the current
 /// function.
 void AsmPrinter::emitFunctionHeader() {
   const Function &F = MF->getFunction();
 
   if (isVerbose())
     OutStreamer->GetCommentOS()
         << "-- Begin function "

 
 uint16_t AsmPrinter::getDwarfVersion() const {
   return OutStreamer->getContext().getDwarfVersion();
 }
 
 void AsmPrinter::setDwarfVersion(uint16_t Version) {
   OutStreamer->getContext().setDwarfVersion(Version);
 }
+
+uint16_t DwarfDebugSectionImpl::getDwarfVersion() const {
+  return OutStreamer->getContext().getDwarfVersion();
+}
+
+void DwarfDebugSectionImpl::setDwarfVersion(uint16_t Version) {
+  OutStreamer->getContext().setDwarfVersion(Version);
+}
+
+unsigned DwarfDebugSectionImpl::getAddressSize() const {
+  return TM->getPointerSize(0); // FIXME: Default address space
+}
+
+/// Emit a byte directive and value.
+///
+void DwarfDebugSectionImpl::writeInt8(int Value) {
+  OutStreamer->emitInt8(Value);
+}
+
+/// Emit a short directive and value.
+void DwarfDebugSectionImpl::writeInt16(int Value) {
+  OutStreamer->emitInt16(Value);
+}
+
+/// Emit a long directive and value.
+void DwarfDebugSectionImpl::writeInt32(int Value) {
+  OutStreamer->emitInt32(Value);
+}
+
+/// Emit a long long directive and value.
+void DwarfDebugSectionImpl::writeInt64(uint64_t Value) {
+  OutStreamer->emitInt64(Value);
+}
+
+/// EmitSLEB128 - emit the specified signed leb128 value.
+void DwarfDebugSectionImpl::writeSLEB128(int64_t Value, const char *Desc) {
+  if (IsVerbose && Desc)
+    OutStreamer->AddComment(Desc);
+
+  OutStreamer->emitSLEB128IntValue(Value);
+}
+
+void DwarfDebugSectionImpl::writeULEB128(uint64_t Value, const char *Desc,
+                                         unsigned PadTo) {
+  if (IsVerbose && Desc)
+    OutStreamer->AddComment(Desc);
+
+  OutStreamer->emitULEB128IntValue(Value, PadTo);
+}
+
+void DwarfDebugSectionImpl::writeBytes(StringRef Data) {
+  OutStreamer->emitBytes(Data);
+}
+
+dwarf::DwarfFormat DwarfDebugSectionImpl::getDwarfFormat() const {
+  return OutStreamer->getContext().getDwarfFormat();
+}
+
+void DwarfDebugSectionImpl::writeIntValue(uint64_t Value, unsigned Size) {
+  OutStreamer->emitIntValue(Value, Size);
+}
+
+bool DwarfDebugSectionImpl::doesDwarfUseRelocationsAcrossSections() const {
+  return MAI->doesDwarfUseRelocationsAcrossSections();
+}
+
+void DwarfDebugSectionImpl::addBlankLine() { OutStreamer->AddBlankLine(); }
+
+void DwarfDebugSectionImpl::writeDebugValue(const MCExpr *Value,
+                                            unsigned Size) {
+  OutStreamer->emitValue(Value, Size);
+}
+
+void DwarfDebugSectionImpl::writeLabelPlusOffset(const MCSymbol *Label,
+                                                 uint64_t Offset, unsigned Size,
+                                                 bool IsSectionRelative) {
+  if (MAI->needsDwarfSectionOffsetDirective() && IsSectionRelative) {
+    OutStreamer->EmitCOFFSecRel32(Label, Offset);
+    if (Size > 4)
+      OutStreamer->emitZeros(Size - 4);
+    return;
+  }
+
+  // Emit Label+Offset (or just Label if Offset is zero)
+  const MCExpr *Expr = MCSymbolRefExpr::create(Label, AP->OutContext);
+  if (Offset)
+    Expr = MCBinaryExpr::createAdd(
+        Expr, MCConstantExpr::create(Offset, AP->OutContext), AP->OutContext);
+
+  OutStreamer->emitValue(Expr, Size);
+}
+
+void DwarfDebugSectionImpl::writeLabelReference(const MCSymbol *Label,
+                                                unsigned Size,
+                                                bool IsSectionRelative) {
+  writeLabelPlusOffset(Label, 0, Size, IsSectionRelative);
+}
+
+void DwarfDebugSectionImpl::writeLabelDifference(const MCSymbol *Hi,
+                                                 const MCSymbol *Lo,
+                                                 unsigned Size) {
+  OutStreamer->emitAbsoluteSymbolDiff(Hi, Lo, Size);
+}
+
+void DwarfDebugSectionImpl::writeDwarfSymbolReference(const MCSymbol *Label,
+                                                      bool ForceOffset) {
+  if (!ForceOffset) {
+    // On COFF targets, we have to emit the special .secrel32 directive.
+    if (MAI->needsDwarfSectionOffsetDirective()) {
+      OutStreamer->EmitCOFFSecRel32(Label, /*Offset=*/0);
+      return;
+    }
+
+    // If the format uses relocations with dwarf, refer to the symbol directly.
+    if (MAI->doesDwarfUseRelocationsAcrossSections()) {
+      OutStreamer->emitSymbolValue(Label, 4);
+      return;
+    }
+  }
+
+  // Otherwise, emit it as a label difference from the start of the section.
+  writeLabelDifference(Label, Label->getSection().getBeginSymbol(), 4);
+}

llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp

 void AsmPrinter::emitDwarfStringOffset(DwarfStringPoolEntry S) const {
   if (MAI->doesDwarfUseRelocationsAcrossSections()) {
     assert(S.Symbol && "No symbol available");
     emitDwarfSymbolReference(S.Symbol);
     return;
   }
 
   // Just emit the offset directly; no need for symbol math.
-  emitInt32(S.Offset);
+  getCurDwarfDebugSection()->writeInt32(S.Offset);
 }
 
 void AsmPrinter::emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const {
   emitLabelPlusOffset(Label, Offset, MAI->getCodePointerSize());
 }
 
 void AsmPrinter::emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo,
                                     unsigned Encoding) const {
   // The least significant 3 bits specify the width of the encoding
   if ((Encoding & 0x7) == dwarf::DW_EH_PE_uleb128)
     emitLabelDifferenceAsULEB128(Hi, Lo);
   else
     emitLabelDifference(Hi, Lo, GetSizeOfEncodedValue(Encoding));
 }
 
 void AsmPrinter::emitCallSiteValue(uint64_t Value, unsigned Encoding) const {
   // The least significant 3 bits specify the width of the encoding
   if ((Encoding & 0x7) == dwarf::DW_EH_PE_uleb128)
-    emitULEB128(Value);
+    getCurDwarfDebugSection()->writeULEB128(Value);
   else
     OutStreamer->emitIntValue(Value, GetSizeOfEncodedValue(Encoding));
 }
 
 //===----------------------------------------------------------------------===//
 // Dwarf Lowering Routines
 //===----------------------------------------------------------------------===//
 
for (const auto &V : Die.values()) {
     if (isVerbose()) {
       OutStreamer->AddComment(dwarf::AttributeString(Attr));
       if (Attr == dwarf::DW_AT_accessibility)
         OutStreamer->AddComment(
             dwarf::AccessibilityString(V.getDIEInteger().getValue()));
     }
 
     // Emit an attribute using the defined form.
-    V.emitValue(this);
+    V.emitValue(getCurDwarfDebugSection());
   }
 
   // Emit the DIE children if any.
   if (Die.hasChildren()) {
     for (auto &Child : Die.children())
       emitDwarfDIE(Child);
 
     OutStreamer->AddComment("End Of Children Mark");
-    emitInt8(0);
+    getCurDwarfDebugSection()->writeInt8(0);
   }
 }
 
 void AsmPrinter::emitDwarfAbbrev(const DIEAbbrev &Abbrev) const {
   // Emit the abbreviations code (base 1 index.)
-  emitULEB128(Abbrev.getNumber(), "Abbreviation Code");
+  const_cast<AsmPrinter *>(this)->emitULEB128(Abbrev.getNumber(),
+                                              "Abbreviation Code");
 
   // Emit the abbreviations data.
-  Abbrev.Emit(this);
+  Abbrev.Emit(getCurDwarfDebugSection());
 }

llvm/lib/CodeGen/AsmPrinter/DIE.cpp

void DIEAbbrev::Profile(FoldingSetNodeID &ID) const {
 
   // For each attribute description.
   for (unsigned i = 0, N = Data.size(); i < N; ++i)
     Data[i].Profile(ID);
 }
 
 /// Emit - Print the abbreviation using the specified asm printer.
 ///
-void DIEAbbrev::Emit(const AsmPrinter *AP) const {
+void DIEAbbrev::Emit(DwarfDebugSection *Dwarf) const {
   // Emit its Dwarf tag type.
-  AP->emitULEB128(Tag, dwarf::TagString(Tag).data());
+  Dwarf->writeULEB128(Tag, dwarf::TagString(Tag).data());
 
   // Emit whether it has children DIEs.
-  AP->emitULEB128((unsigned)Children, dwarf::ChildrenString(Children).data());
+  Dwarf->writeULEB128((unsigned)Children,
+                      dwarf::ChildrenString(Children).data());
 
   // For each attribute description.
   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
     const DIEAbbrevData &AttrData = Data[i];
 
     // Emit attribute type.
-    AP->emitULEB128(AttrData.getAttribute(),
+    Dwarf->writeULEB128(AttrData.getAttribute(),
                         dwarf::AttributeString(AttrData.getAttribute()).data());
 
     // Emit form type.
 #ifndef NDEBUG
     // Could be an assertion, but this way we can see the failing form code
     // easily, which helps track down where it came from.
     if (!dwarf::isValidFormForVersion(AttrData.getForm(),
-                                      AP->getDwarfVersion())) {
+                                      Dwarf->getDwarfVersion())) {
       LLVM_DEBUG(dbgs() << "Invalid form " << format("0x%x", AttrData.getForm())
-                        << " for DWARF version " << AP->getDwarfVersion()
+                        << " for DWARF version " << Dwarf->getDwarfVersion()
                         << "\n");
       llvm_unreachable("Invalid form for specified DWARF version");
     }
 #endif
-    AP->emitULEB128(AttrData.getForm(),
+    Dwarf->writeULEB128(AttrData.getForm(),
                         dwarf::FormEncodingString(AttrData.getForm()).data());
 
     // Emit value for DW_FORM_implicit_const.
     if (AttrData.getForm() == dwarf::DW_FORM_implicit_const)
-      AP->emitSLEB128(AttrData.getValue());
+      Dwarf->writeSLEB128(AttrData.getValue());
   }
 
   // Mark end of abbreviation.
-  AP->emitULEB128(0, "EOM(1)");
-  AP->emitULEB128(0, "EOM(2)");
+  Dwarf->writeULEB128(0, "EOM(1)");
+  Dwarf->writeULEB128(0, "EOM(2)");
 }
 
 LLVM_DUMP_METHOD
 void DIEAbbrev::print(raw_ostream &O) const {
   O << "Abbreviation @"
     << format("0x%lx", (long)(intptr_t)this)
     << "  "
     << dwarf::TagString(Tag)

 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void DIE::dump() const {
   print(dbgs());
 }
 #endif
 
-unsigned DIE::computeOffsetsAndAbbrevs(const AsmPrinter *AP,
+unsigned DIE::computeOffsetsAndAbbrevs(DwarfDebugSection *Dwarf,
                                        DIEAbbrevSet &AbbrevSet,
                                        unsigned CUOffset) {
   // Unique the abbreviation and fill in the abbreviation number so this DIE
   // can be emitted.
   const DIEAbbrev &Abbrev = AbbrevSet.uniqueAbbreviation(*this);
 
   // Set compile/type unit relative offset of this DIE.
   setOffset(CUOffset);
 
   // Add the byte size of the abbreviation code.
   CUOffset += getULEB128Size(getAbbrevNumber());
 
   // Add the byte size of all the DIE attribute values.
   for (const auto &V : values())
-    CUOffset += V.SizeOf(AP);
+    CUOffset += V.SizeOf(Dwarf);
 
   // Let the children compute their offsets and abbreviation numbers.
   if (hasChildren()) {
     (void)Abbrev;
     assert(Abbrev.hasChildren() && "Children flag not set");
 
     for (auto &Child : children())
-      CUOffset = Child.computeOffsetsAndAbbrevs(AP, AbbrevSet, CUOffset);
+      CUOffset = Child.computeOffsetsAndAbbrevs(Dwarf, AbbrevSet, CUOffset);
 
     // Each child chain is terminated with a zero byte, adjust the offset.
     CUOffset += sizeof(int8_t);
   }
 
   // Compute the byte size of this DIE and all of its children correctly. This
   // is needed so that top level DIE can help the compile unit set its length
   // correctly.
DIEUnit::DIEUnit(uint16_t V, uint8_t A, dwarf::Tag UnitTag)
   Die.Owner = this;
   assert((UnitTag == dwarf::DW_TAG_compile_unit ||
           UnitTag == dwarf::DW_TAG_skeleton_unit ||
           UnitTag == dwarf::DW_TAG_type_unit ||
           UnitTag == dwarf::DW_TAG_partial_unit) &&
          "expected a unit TAG");
 }
 
-void DIEValue::emitValue(const AsmPrinter *AP) const {
+void DIEValue::emitValue(DwarfDebugSection *Dwarf) const {
   switch (Ty) {
   case isNone:
     llvm_unreachable("Expected valid DIEValue");
 #define HANDLE_DIEVALUE(T)                                                     \
   case is##T:                                                                  \
-    getDIE##T().emitValue(AP, Form);                                           \
+    getDIE##T().emitValue(Dwarf, Form);                                        \
     break;
 #include "llvm/CodeGen/DIEValue.def"
   }
 }
 
-unsigned DIEValue::SizeOf(const AsmPrinter *AP) const {
+unsigned DIEValue::SizeOf(const DwarfDebugSection *Dwarf) const {
   switch (Ty) {
   case isNone:
     llvm_unreachable("Expected valid DIEValue");
 #define HANDLE_DIEVALUE(T)                                                     \
   case is##T:                                                                  \
-    return getDIE##T().SizeOf(AP, Form);
+    return getDIE##T().SizeOf(Dwarf, Form);
 #include "llvm/CodeGen/DIEValue.def"
   }
   llvm_unreachable("Unknown DIE kind");
 }
 
 LLVM_DUMP_METHOD
 void DIEValue::print(raw_ostream &O) const {
   switch (Ty) {

 #endif
 
 //===----------------------------------------------------------------------===//
 // DIEInteger Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit integer of appropriate size.
 ///
-void DIEInteger::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
+void DIEInteger::emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_implicit_const:
   case dwarf::DW_FORM_flag_present:
     // Emit something to keep the lines and comments in sync.
     // FIXME: Is there a better way to do this?
-    Asm->OutStreamer->AddBlankLine();
+    if (Dwarf->isAsm())
+      static_cast<DwarfDebugSectionAsm *>(Dwarf)->addBlankLine();
     return;
   case dwarf::DW_FORM_flag:
   case dwarf::DW_FORM_ref1:
   case dwarf::DW_FORM_data1:
   case dwarf::DW_FORM_strx1:
   case dwarf::DW_FORM_addrx1:
   case dwarf::DW_FORM_ref2:
   case dwarf::DW_FORM_data2:
void DIEInteger::emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const {
   case dwarf::DW_FORM_ref_sup8:
   case dwarf::DW_FORM_GNU_ref_alt:
   case dwarf::DW_FORM_GNU_strp_alt:
   case dwarf::DW_FORM_line_strp:
   case dwarf::DW_FORM_sec_offset:
   case dwarf::DW_FORM_strp_sup:
   case dwarf::DW_FORM_addr:
   case dwarf::DW_FORM_ref_addr:
-    Asm->OutStreamer->emitIntValue(Integer, SizeOf(Asm, Form));
+    Dwarf->writeIntValue(Integer, SizeOf(Dwarf, Form));
     return;
   case dwarf::DW_FORM_GNU_str_index:
   case dwarf::DW_FORM_GNU_addr_index:
   case dwarf::DW_FORM_ref_udata:
   case dwarf::DW_FORM_strx:
   case dwarf::DW_FORM_addrx:
   case dwarf::DW_FORM_rnglistx:
   case dwarf::DW_FORM_udata:
-    Asm->emitULEB128(Integer);
+    Dwarf->writeULEB128(Integer);
     return;
   case dwarf::DW_FORM_sdata:
-    Asm->emitSLEB128(Integer);
+    Dwarf->writeSLEB128(Integer);
     return;
-  default: llvm_unreachable("DIE Value form not supported yet");
+  default:
+    llvm_unreachable("DIE Value form not supported yet");
   }
 }
 
 /// SizeOf - Determine size of integer value in bytes.
 ///
-unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEInteger::SizeOf(const DwarfDebugSection *Dwarf,
+                            dwarf::Form Form) const {
   dwarf::FormParams Params = {0, 0, dwarf::DWARF32};
-  if (AP)
-    Params = {AP->getDwarfVersion(), uint8_t(AP->getPointerSize()),
-              AP->OutStreamer->getContext().getDwarfFormat()};
+  if (Dwarf)
+    Params = {Dwarf->getDwarfVersion(), uint8_t(Dwarf->getAddressSize()),
+              Dwarf->getDwarfFormat()};
 
   if (Optional<uint8_t> FixedSize = dwarf::getFixedFormByteSize(Form, Params))
     return *FixedSize;
 
   switch (Form) {
   case dwarf::DW_FORM_GNU_str_index:
   case dwarf::DW_FORM_GNU_addr_index:
   case dwarf::DW_FORM_ref_udata:

 }
 
 //===----------------------------------------------------------------------===//
 // DIEExpr Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit expression value.
 ///
-void DIEExpr::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
-  AP->emitDebugValue(Expr, SizeOf(AP, Form));
+void DIEExpr::emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const {
+  if (Dwarf->isAsm()) {
+    static_cast<DwarfDebugSectionAsm *>(Dwarf)->writeDebugValue(
+        Expr, SizeOf(Dwarf, Form));
+  } else {
+    llvm_unreachable(
+        "DIEExpr::emitValue for DwarfDebugSectionBin is not implemented yet.");
+  }
 }
 
 /// SizeOf - Determine size of expression value in bytes.
 ///
-unsigned DIEExpr::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEExpr::SizeOf(const DwarfDebugSection *Dwarf,
+                         dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_data4) return 4;
   if (Form == dwarf::DW_FORM_sec_offset) return 4;
   if (Form == dwarf::DW_FORM_strp) return 4;
-  return AP->getPointerSize();
+  return Dwarf->getAddressSize();
 }
 
 LLVM_DUMP_METHOD
 void DIEExpr::print(raw_ostream &O) const { O << "Expr: " << *Expr; }
 
 //===----------------------------------------------------------------------===//
 // DIELabel Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit label value.
 ///
-void DIELabel::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
-  AP->emitLabelReference(
-      Label, SizeOf(AP, Form),
+void DIELabel::emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const {
+  if (Dwarf->isAsm()) {
+    static_cast<DwarfDebugSectionAsm *>(Dwarf)->writeLabelReference(
+        Label, SizeOf(Dwarf, Form),
         Form == dwarf::DW_FORM_strp || Form == dwarf::DW_FORM_sec_offset ||
             Form == dwarf::DW_FORM_ref_addr || Form == dwarf::DW_FORM_data4);
+  } else {
+    llvm_unreachable(
+        "DIELabel::emitValue for DwarfDebugSectionBin is not implemented yet.");
+  }
 }
 
 /// SizeOf - Determine size of label value in bytes.
 ///
-unsigned DIELabel::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIELabel::SizeOf(const DwarfDebugSection *Dwarf,
+                          dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_data4) return 4;
   if (Form == dwarf::DW_FORM_sec_offset) return 4;
   if (Form == dwarf::DW_FORM_strp) return 4;
-  return AP->MAI->getCodePointerSize();
+  return Dwarf->getAddressSize();
 }
 
 LLVM_DUMP_METHOD
 void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); }
 
 //===----------------------------------------------------------------------===//
 // DIEBaseTypeRef Implementation
 //===----------------------------------------------------------------------===//
 
-void DIEBaseTypeRef::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+void DIEBaseTypeRef::emitValue(DwarfDebugSection *Dwarf, dwarf::Form) const {
   uint64_t Offset = CU->ExprRefedBaseTypes[Index].Die->getOffset();
   assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
-  AP->emitULEB128(Offset, nullptr, ULEB128PadSize);
+  Dwarf->writeULEB128(Offset, nullptr, ULEB128PadSize);
 }
 
-unsigned DIEBaseTypeRef::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEBaseTypeRef::SizeOf(const DwarfDebugSection *, dwarf::Form) const {
   return ULEB128PadSize;
 }
 
 LLVM_DUMP_METHOD
 void DIEBaseTypeRef::print(raw_ostream &O) const { O << "BaseTypeRef: " << Index; }
 
 //===----------------------------------------------------------------------===//
 // DIEDelta Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit delta value.
 ///
-void DIEDelta::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
-  AP->emitLabelDifference(LabelHi, LabelLo, SizeOf(AP, Form));
+void DIEDelta::emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const {
+  if (Dwarf->isAsm()) {
+    static_cast<DwarfDebugSectionAsm *>(Dwarf)->writeLabelDifference(
+        LabelHi, LabelLo, SizeOf(Dwarf, Form));
+  } else {
+    llvm_unreachable(
+        "DIEDelta::emitValue for DwarfDebugSectionBin is not implemented yet.");
+  }
 }
 
 /// SizeOf - Determine size of delta value in bytes.
 ///
-unsigned DIEDelta::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEDelta::SizeOf(const DwarfDebugSection *Dwarf,
+                          dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_data4) return 4;
   if (Form == dwarf::DW_FORM_sec_offset) return 4;
   if (Form == dwarf::DW_FORM_strp) return 4;
-  return AP->MAI->getCodePointerSize();
+  return Dwarf->getAddressSize();
 }
 
 LLVM_DUMP_METHOD
 void DIEDelta::print(raw_ostream &O) const {
   O << "Del: " << LabelHi->getName() << "-" << LabelLo->getName();
 }
 
 //===----------------------------------------------------------------------===//
 // DIEString Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit string value.
 ///
-void DIEString::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+void DIEString::emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const {
   // Index of string in symbol table.
   switch (Form) {
   case dwarf::DW_FORM_GNU_str_index:
   case dwarf::DW_FORM_strx:
   case dwarf::DW_FORM_strx1:
   case dwarf::DW_FORM_strx2:
   case dwarf::DW_FORM_strx3:
   case dwarf::DW_FORM_strx4:
-    DIEInteger(S.getIndex()).emitValue(AP, Form);
+    DIEInteger(S.getIndex()).emitValue(Dwarf, Form);
     return;
   case dwarf::DW_FORM_strp:
-    if (AP->MAI->doesDwarfUseRelocationsAcrossSections())
-      DIELabel(S.getSymbol()).emitValue(AP, Form);
+    if (Dwarf->doesDwarfUseRelocationsAcrossSections())
+      DIELabel(S.getSymbol()).emitValue(Dwarf, Form);
     else
-      DIEInteger(S.getOffset()).emitValue(AP, Form);
+      DIEInteger(S.getOffset()).emitValue(Dwarf, Form);
     return;
   default:
     llvm_unreachable("Expected valid string form");
   }
 }
 
 /// SizeOf - Determine size of delta value in bytes.
 ///
-unsigned DIEString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEString::SizeOf(const DwarfDebugSection *Dwarf,
+                           dwarf::Form Form) const {
   // Index of string in symbol table.
   switch (Form) {
   case dwarf::DW_FORM_GNU_str_index:
   case dwarf::DW_FORM_strx:
   case dwarf::DW_FORM_strx1:
   case dwarf::DW_FORM_strx2:
   case dwarf::DW_FORM_strx3:
   case dwarf::DW_FORM_strx4:
-    return DIEInteger(S.getIndex()).SizeOf(AP, Form);
+    return DIEInteger(S.getIndex()).SizeOf(Dwarf, Form);
   case dwarf::DW_FORM_strp:
-    if (AP->MAI->doesDwarfUseRelocationsAcrossSections())
-      return DIELabel(S.getSymbol()).SizeOf(AP, Form);
-    return DIEInteger(S.getOffset()).SizeOf(AP, Form);
+    if (Dwarf->doesDwarfUseRelocationsAcrossSections())
+      return DIELabel(S.getSymbol()).SizeOf(Dwarf, Form);
+    return DIEInteger(S.getOffset()).SizeOf(Dwarf, Form);
   default:
     llvm_unreachable("Expected valid string form");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEString::print(raw_ostream &O) const {
   O << "String: " << S.getString();
 }
 
 //===----------------------------------------------------------------------===//
 // DIEInlineString Implementation
 //===----------------------------------------------------------------------===//
-void DIEInlineString::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+void DIEInlineString::emitValue(DwarfDebugSection *Dwarf,
+                                dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_string) {
-    AP->OutStreamer->emitBytes(S);
-    AP->emitInt8(0);
+    Dwarf->writeBytes(S);
+    Dwarf->writeInt8(0);
     return;
   }
   llvm_unreachable("Expected valid string form");
 }
 
-unsigned DIEInlineString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEInlineString::SizeOf(const DwarfDebugSection *, dwarf::Form) const {
   // Emit string bytes + NULL byte.
   return S.size() + 1;
 }
 
 LLVM_DUMP_METHOD
 void DIEInlineString::print(raw_ostream &O) const {
   O << "InlineString: " << S;
 }
 
 //===----------------------------------------------------------------------===//
 // DIEEntry Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit debug information entry offset.
 ///
-void DIEEntry::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+void DIEEntry::emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const {
 
   switch (Form) {
   case dwarf::DW_FORM_ref1:
   case dwarf::DW_FORM_ref2:
   case dwarf::DW_FORM_ref4:
   case dwarf::DW_FORM_ref8:
-    AP->OutStreamer->emitIntValue(Entry->getOffset(), SizeOf(AP, Form));
+    Dwarf->writeIntValue(Entry->getOffset(), SizeOf(Dwarf, Form));
     return;
 
   case dwarf::DW_FORM_ref_udata:
-    AP->emitULEB128(Entry->getOffset());
+    Dwarf->writeULEB128(Entry->getOffset());
     return;
 
   case dwarf::DW_FORM_ref_addr: {
     // Get the absolute offset for this DIE within the debug info/types section.
     unsigned Addr = Entry->getDebugSectionOffset();
     if (const MCSymbol *SectionSym =
             Entry->getUnit()->getCrossSectionRelativeBaseAddress()) {
-      AP->emitLabelPlusOffset(SectionSym, Addr, SizeOf(AP, Form), true);
+      if (Dwarf->isAsm()) {
+        static_cast<DwarfDebugSectionAsm *>(Dwarf)->writeLabelPlusOffset(
+            SectionSym, Addr, SizeOf(Dwarf, Form), true);
+      } else {
+        llvm_unreachable("DIEDelta::emitValue for DwarfDebugSectionBin is not "
+                         "implemented yet.");
+      }
+
       return;
     }
 
-    AP->OutStreamer->emitIntValue(Addr, SizeOf(AP, Form));
+    Dwarf->writeIntValue(Addr, SizeOf(Dwarf, Form));
     return;
   }
   default:
     llvm_unreachable("Improper form for DIE reference");
   }
 }
 
-unsigned DIEEntry::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEEntry::SizeOf(const DwarfDebugSection *Dwarf,
+                          dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_ref1:
     return 1;
   case dwarf::DW_FORM_ref2:
     return 2;
   case dwarf::DW_FORM_ref4:
     return 4;
   case dwarf::DW_FORM_ref8:
     return 8;
   case dwarf::DW_FORM_ref_udata:
     return getULEB128Size(Entry->getOffset());
   case dwarf::DW_FORM_ref_addr:
-    if (AP->getDwarfVersion() == 2)
-      return AP->MAI->getCodePointerSize();
-    switch (AP->OutStreamer->getContext().getDwarfFormat()) {
+    if (Dwarf->getDwarfVersion() == 2)
+      return Dwarf->getAddressSize();
+    switch (Dwarf->getDwarfFormat()) {
     case dwarf::DWARF32:
       return 4;
     case dwarf::DWARF64:
       return 8;
     }
     llvm_unreachable("Invalid DWARF format");
 
   default:
     llvm_unreachable("Improper form for DIE reference");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEEntry::print(raw_ostream &O) const {
   O << format("Die: 0x%lx", (long)(intptr_t)&Entry);
 }
 
 //===----------------------------------------------------------------------===//
 // DIELoc Implementation
 //===----------------------------------------------------------------------===//
 
 /// ComputeSize - calculate the size of the location expression.
 ///
-unsigned DIELoc::ComputeSize(const AsmPrinter *AP) const {
+unsigned DIELoc::ComputeSize(const DwarfDebugSection *Dwarf) const {
   if (!Size) {
     for (const auto &V : values())
-      Size += V.SizeOf(AP);
+      Size += V.SizeOf(Dwarf);
   }
 
   return Size;
 }
 
 /// EmitValue - Emit location data.
 ///
-void DIELoc::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
+void DIELoc::emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const {
   switch (Form) {
   default: llvm_unreachable("Improper form for block");
-  case dwarf::DW_FORM_block1: Asm->emitInt8(Size);    break;
-  case dwarf::DW_FORM_block2: Asm->emitInt16(Size);   break;
-  case dwarf::DW_FORM_block4: Asm->emitInt32(Size);   break;
+  case dwarf::DW_FORM_block1:
+    Dwarf->writeInt8(Size);
+    break;
+  case dwarf::DW_FORM_block2:
+    Dwarf->writeInt16(Size);
+    break;
+  case dwarf::DW_FORM_block4:
+    Dwarf->writeInt32(Size);
+    break;
   case dwarf::DW_FORM_block:
   case dwarf::DW_FORM_exprloc:
-    Asm->emitULEB128(Size);
+    Dwarf->writeULEB128(Size);
     break;
   }
 
   for (const auto &V : values())
-    V.emitValue(Asm);
+    V.emitValue(Dwarf);
 }
 
 /// SizeOf - Determine size of location data in bytes.
 ///
-unsigned DIELoc::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIELoc::SizeOf(const DwarfDebugSection *, dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
   case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
   case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
   case dwarf::DW_FORM_block:
   case dwarf::DW_FORM_exprloc:
     return Size + getULEB128Size(Size);
   default: llvm_unreachable("Improper form for block");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIELoc::print(raw_ostream &O) const {
   printValues(O, *this, "ExprLoc", Size, 5);
 }
 
 //===----------------------------------------------------------------------===//
 // DIEBlock Implementation
 //===----------------------------------------------------------------------===//
 
 /// ComputeSize - calculate the size of the block.
 ///
-unsigned DIEBlock::ComputeSize(const AsmPrinter *AP) const {
+unsigned DIEBlock::ComputeSize(const DwarfDebugSection *Dwarf) const {
   if (!Size) {
     for (const auto &V : values())
-      Size += V.SizeOf(AP);
+      Size += V.SizeOf(Dwarf);
   }
 
   return Size;
 }
 
 /// EmitValue - Emit block data.
 ///
-void DIEBlock::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
+void DIEBlock::emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const {
   switch (Form) {
   default: llvm_unreachable("Improper form for block");
-  case dwarf::DW_FORM_block1: Asm->emitInt8(Size);    break;
-  case dwarf::DW_FORM_block2: Asm->emitInt16(Size);   break;
-  case dwarf::DW_FORM_block4: Asm->emitInt32(Size);   break;
+  case dwarf::DW_FORM_block1:
+    Dwarf->writeInt8(Size);
+    break;
+  case dwarf::DW_FORM_block2:
+    Dwarf->writeInt16(Size);
+    break;
+  case dwarf::DW_FORM_block4:
+    Dwarf->writeInt32(Size);
+    break;
   case dwarf::DW_FORM_block:
-    Asm->emitULEB128(Size);
+    Dwarf->writeULEB128(Size);
     break;
   case dwarf::DW_FORM_string: break;
   case dwarf::DW_FORM_data16: break;
   }
 
   for (const auto &V : values())
-    V.emitValue(Asm);
+    V.emitValue(Dwarf);
 }
 
 /// SizeOf - Determine size of block data in bytes.
 ///
-unsigned DIEBlock::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEBlock::SizeOf(const DwarfDebugSection *, dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
   case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
   case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
   case dwarf::DW_FORM_block:  return Size + getULEB128Size(Size);
   case dwarf::DW_FORM_data16: return 16;
   default: llvm_unreachable("Improper form for block");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEBlock::print(raw_ostream &O) const {
   printValues(O, *this, "Blk", Size, 5);
 }
 
 //===----------------------------------------------------------------------===//
 // DIELocList Implementation
 //===----------------------------------------------------------------------===//
 
-unsigned DIELocList::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIELocList::SizeOf(const DwarfDebugSection *Dwarf,
+                            dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_loclistx)
     return getULEB128Size(Index);
   if (Form == dwarf::DW_FORM_data4)
     return 4;
   if (Form == dwarf::DW_FORM_sec_offset)
     return 4;
-  return AP->MAI->getCodePointerSize();
+  return Dwarf->getAddressSize();
 }
 
 /// EmitValue - Emit label value.
 ///
-void DIELocList::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+void DIELocList::emitValue(DwarfDebugSection *Dwarf, dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_loclistx) {
-    AP->emitULEB128(Index);
+    Dwarf->writeULEB128(Index);
     return;
   }
-  DwarfDebug *DD = AP->getDwarfDebug();
+
+  if (Dwarf->isAsm()) {
+    DwarfDebug *DD = static_cast<DwarfDebugSectionImpl *>(Dwarf)
+                         ->getAsmPrinter()
+                         ->getDwarfDebug();
     MCSymbol *Label = DD->getDebugLocs().getList(Index).Label;
-  AP->emitDwarfSymbolReference(Label, /*ForceOffset*/ DD->useSplitDwarf());
+    static_cast<DwarfDebugSectionAsm *>(Dwarf)->writeDwarfSymbolReference(
+        Label,
+        /*ForceOffset*/ DD->useSplitDwarf());
+  } else {
+    llvm_unreachable("DIELocList::emitValue for DwarfDebugSectionBin is not "
+                     "implemented yet.");
+  }
 }
 
 LLVM_DUMP_METHOD
 void DIELocList::print(raw_ostream &O) const { O << "LocList: " << Index; }

llvm/lib/CodeGen/AsmPrinter/DIEHash.cpp

case DIEValue::isInlineString:
     break;
   case DIEValue::isBlock:
   case DIEValue::isLoc:
   case DIEValue::isLocList:
     addULEB128('A');
     addULEB128(Attribute);
     addULEB128(dwarf::DW_FORM_block);
     if (Value.getType() == DIEValue::isBlock) {
-      addULEB128(Value.getDIEBlock().ComputeSize(AP));
+      addULEB128(Value.getDIEBlock().ComputeSize(
+          AP ? AP->getCurDwarfDebugSection() : nullptr));
       hashBlockData(Value.getDIEBlock().values());
     } else if (Value.getType() == DIEValue::isLoc) {
-      addULEB128(Value.getDIELoc().ComputeSize(AP));
+      addULEB128(Value.getDIELoc().ComputeSize(
+          AP ? AP->getCurDwarfDebugSection() : nullptr));
       hashBlockData(Value.getDIELoc().values());
     } else {
       // We could add the block length, but that would take
       // a bit of work and not add a lot of uniqueness
       // to the hash in some way we could test.
       hashLocList(Value.getDIELocList());
     }
     break;

llvm/lib/CodeGen/AsmPrinter/DwarfFile.cpp

unsigned DwarfFile::computeSizeAndOffsetsForUnit(DwarfUnit *TheU) {
   // The return value here is CU-relative, after laying out
   // all of the CU DIE.
   return computeSizeAndOffset(TheU->getUnitDie(), Offset);
 }
 
 // Compute the size and offset of a DIE. The offset is relative to start of the
 // CU. It returns the offset after laying out the DIE.
 unsigned DwarfFile::computeSizeAndOffset(DIE &Die, unsigned Offset) {
-  return Die.computeOffsetsAndAbbrevs(Asm, Abbrevs, Offset);
+  return Die.computeOffsetsAndAbbrevs(Asm->getCurDwarfDebugSection(), Abbrevs,
+                                      Offset);
 }
 
 void DwarfFile::emitAbbrevs(MCSection *Section) { Abbrevs.Emit(Asm, Section); }
 
 // Emit strings into a string section.
 void DwarfFile::emitStrings(MCSection *StrSection, MCSection *OffsetSection,
                             bool UseRelativeOffsets) {
   StrPool.emit(*Asm, StrSection, OffsetSection, UseRelativeOffsets);

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 void DIEDwarfExpression::enableTemporaryBuffer() {
   assert(!IsBuffering && "Already buffering?");
   IsBuffering = true;
 }
 
 void DIEDwarfExpression::disableTemporaryBuffer() { IsBuffering = false; }
 
 unsigned DIEDwarfExpression::getTemporaryBufferSize() {
-  return TmpDIE.ComputeSize(&AP);
+  return TmpDIE.ComputeSize(AP.getCurDwarfDebugSection());
 }
 
 void DIEDwarfExpression::commitTemporaryBuffer() { OutDIE.takeValues(TmpDIE); }
 
 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
                                          unsigned MachineReg) {
   return MachineReg == TRI.getFrameRegister(*AP.MF);
 }

 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
   DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
   if (N)
     insertDIE(N, &Die);
   return Die;
 }
 
 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
-  Loc->ComputeSize(Asm);
+  Loc->ComputeSize(Asm->getCurDwarfDebugSection());
   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
   Die.addValue(DIEValueAllocator, Attribute,
                Loc->BestForm(DD->getDwarfVersion()), Loc);
 }
 
 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
                          DIEBlock *Block) {
-  Block->ComputeSize(Asm);
+  Block->ComputeSize(Asm->getCurDwarfDebugSection());
   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
   Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block);
 }
 
 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
   if (Line == 0)
     return;
 

llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp

 
 namespace {} // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 /// dwarfgen::DIE implementation.
 //===----------------------------------------------------------------------===//
 unsigned dwarfgen::DIE::computeSizeAndOffsets(unsigned Offset) {
   auto &DG = CU->getGenerator();
-  return Die->computeOffsetsAndAbbrevs(DG.getAsmPrinter(), DG.getAbbrevSet(),
-                                       Offset);
+  return Die->computeOffsetsAndAbbrevs(
+      DG.getAsmPrinter()->getCurDwarfDebugSection(), DG.getAbbrevSet(), Offset);
 }
 
 void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form, uint64_t U) {
   auto &DG = CU->getGenerator();
   Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
                 DIEInteger(U));
 }
 
void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form, const void *P,
   auto &DG = CU->getGenerator();
   DIEBlock *Block = new (DG.getAllocator()) DIEBlock;
   for (size_t I = 0; I < S; ++I)
     Block->addValue(
         DG.getAllocator(), (dwarf::Attribute)0, dwarf::DW_FORM_data1,
         DIEInteger(
             (const_cast<uint8_t *>(static_cast<const uint8_t *>(P)))[I]));
 
-  Block->ComputeSize(DG.getAsmPrinter());
+  Block->ComputeSize(DG.getAsmPrinter()->getCurDwarfDebugSection());
   Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
                 Block);
 }
 
 void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form) {
   auto &DG = CU->getGenerator();
   assert(Form == DW_FORM_flag_present);
   Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,