DIEData, DIEWriter: introduce and begin migration.

[pcc]

Summary

This patch introduces the DIEData class, which stores a sequence of DWARF
DIEs directly in the format in which they will be emitted to the object file
(i.e. bytes and relocations), together with the DIEWriter class, which is
used to add DIEs to a DIEData. The goal is to decrease memory consumption
in the DWARF emitter by migrating all DIE emission to go through these
classes instead of the current memory-inefficient DIE and DIEValue classes
(see mailing list thread [1]).

This patch also takes the first step towards migrating the DWARF emitter. It
introduces the necessary scaffolding for the migration in the form of the
ability for a DIE to use a DIEData-based representation, and replaces the
existing DWARF emission code for base types with code that uses DIEData.
To avoid a regression in memory consumption, I coded my changes to DIE to
avoid increasing its size.

A few notes on this patch:

• This doesn't add any support for relocations (other than symbol relocations) or insertions as mentioned in the thread, because they aren't needed to emit base types, and I wanted to make this first patch as simple as possible. Future patches will add this as needed.

• The way that the current DWARF hasher code works is by walking DIE entries. This won't work in the new world, so I've added a new mechanism for generating a hash from metadata. To get from a DIE to metadata, I store a reference to the MDNode in the DIE. I reckon that hashes will eventually be computed by walking MDNodes directly starting at a compilation unit or type, perhaps supplemented by additional information collected by walking the IR, so you can see how the current code might evolve into that.
  
  This code isn't very DRY, but I think we can address this as needed as we migrate more tags to DIEData.

• The old and new abbreviation emitter code don't interact except by choosing to use different abbreviation numbers (the old code uses odd numbers, the new code uses even numbers).

[1] http://lists.llvm.org/pipermail/llvm-dev/2016-February/094974.html

[dblaikie]

The hashing stuff does seem a bit worrying - not sure how that'll end up looking.

The odd/even abbrev numbering seems a bit awkward - can we just build the new infrastructure closer to the old stuff, so they can pick numbers more closely? (have you done any size analysis of this change - I realize the numbering of DIEs is probably a small component of DWARF size, but this change sounds like it'd increase DWARF size a little?)

What do you have in mind for DIEs that are incomplete for most of DWARF emission? (user defined types (classes and structs), and subprogram/function descriptions are like this - as we were discussing in previous threads) The abbreviation won't be known until the end of DWARF emission, so it seems we'll want to keep around a representation of the abbreviation that's more like what we have today. It seems like this transition approach might result in more churn than would be necessary, prehaps? But maybe not - just wonedring/thinking about it.

I haven't looked at everything in detail - more review tomorrow, etc.

include/llvm/CodeGen/DIEData.h

153

else-after-return

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

685

Probably best not to name a function the same as a common library type. I think functions that use string as a verb usually end up named "stringify" or the like.. but that might not be what's being described here, not sure yet.

unittests/CodeGen/DIEDataTest.cpp

85

Use () rather than {}, this doesn't look like it should be an aggregate/implicit ctor (but we haven't really bothered to put 'explicit' on all the ctors that became implicit in C++11 with aggregate init)

[pcc]

The odd/even abbrev numbering seems a bit awkward - can we just build the new infrastructure closer to the old stuff, so they can pick numbers more closely?

Maybe, but I'd like to avoid having the new code and the old code interact where possible. In particular, I think the code would be a little harder to unit test if I use the old code for abbreviations.

(have you done any size analysis of this change - I realize the numbering of DIEs is probably a small component of DWARF size, but this change sounds like it'd increase DWARF size a little?)

I'll see what the impact is on Chromium.

The abbreviation won't be known until the end of DWARF emission

Is this true? Since the abbreviation depends only on the attribute names and forms, I suspect that in many cases we can compute an abbreviation up front and fill in attribute values later.

For example, the abstract origins for concrete variables added by DwarfDebug::finishVariableDefinitions. Since we know at DbgVariable creation time whether a variable is concrete or not, we can create an abstract origin attribute with some arbitrary value for concrete variables when we create them (in the equivalent of DwarfCompileUnit::constructVariableDIEImpl), store a reference to that attribute somewhere (which could just be a DIEData+offset pair), and use that in DwarfDebug::finishVariableDefinitions to fill in the value.

If there are cases where we truly cannot know about the existence of an attribute until later, then we can probably try something like maintaining a flag which would only be relevant for those DIE tags which can have attributes inserted dynamically, and have the code in DIEData::{prepareToEmit,emit} create abbreviations on demand for those specific tags, but I'd like to try to find a way to avoid that if possible.

[aprantl]

I'd be very interested in the size impact. Do you have access to a Darwin machine? Could you build something large and then run llvm-dsymutil with and without the patch on it and compare the differences?

include/llvm/CodeGen/DIEData.h

65

Certainly the most important part of the review :-)
We enable autobrief in Doxygen now. In most situations \brief is redundant now.

test/DebugInfo/X86/linkage-name.ll

7

If we're not checking the FORMs matching them just adds visual noise to the test. I would just delete everything after the TAG.
(this applies to all testcases)

[pcc]

• Address code review comments
• Restore sizeof(llvm::DIE) as intended. I misunderstood the code and thought that IntrusiveBackList was 2 pointers when in fact it is 1

include/llvm/CodeGen/DIEData.h

153

Fixed by removing the returns. I wanted to eventually make some of these functions return a reference to the attribute that could be filled in later, but that probably isn't appropriate for attributes like this one which need to know the value up front.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

685

Hm. I wanted to be concise with names in the new code, in order to distinguish visually from the old code. I think this naming might be okay if there are only a few weird cases like string.

[pcc]

Could you build something large and then run llvm-dsymutil with and without the patch on it and compare the differences?

I don't think this change will make a difference in llvm-dsymutil because it isn't using the data representation yet.

include/llvm/CodeGen/DIE.h

 
 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
 #define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
 
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/CodeGen/DwarfStringPoolEntry.h"
 #include "llvm/Support/Dwarf.h"
 #include <vector>
 
 namespace llvm {
 class AsmPrinter;
+class DIEData;
 class MCExpr;
 class MCSymbol;
 class raw_ostream;
 class DwarfTypeUnit;
 
 //===--------------------------------------------------------------------===//
 /// DIEAbbrevData - Dwarf abbreviation data, describes one attribute of a
 /// Dwarf abbreviation.
const_value_range values() const {
     return llvm::make_range(const_value_iterator(List.begin()),
                             const_value_iterator(List.end()));
   }
 };
 
 //===--------------------------------------------------------------------===//
 /// DIE - A structured debug information entry.  Has an abbreviation which
 /// describes its organization.
-class DIE : IntrusiveBackListNode, public DIEValueList {
+class DIE : IntrusiveBackListNode {
   friend class IntrusiveBackList<DIE>;
 
   /// Offset - Offset in debug info section.
   ///
   unsigned Offset;
 
   /// Size - Size of instance + children.
   ///
   unsigned Size;
 
+  // A DIE can have two possible representations. The explicit representation
+  // stores the DIE's attributes and children as lists of DIEValues and DIEs
+  // respectively, while the data representation uses the DIEData class to store
+  // attributes and children directly in DWARF format as a string of bytes and
+  // relocations. Eventually all DIEs will use the data representation and the
+  // DIE and DIEValue classes will be removed.
+
+  struct DIEExplicitRepr {
+    /// Children DIEs.
+    IntrusiveBackList<DIE> Children;
+
+    /// Attribute DIEValues.
+    DIEValueList Attrs;
+  };
+
+  struct DIEDataRepr {
+    /// The data underlying this DIE.
+    DIEData *Data = nullptr;
+
+    /// The DINode from which this DIE was created.
+    const DINode *MD = nullptr;
+  };
+
+  /// Abbreviation number. Unused in data representation DIEs.
   unsigned AbbrevNumber = ~0u;
 
-  /// Tag - Dwarf tag code.
+  /// Tag - Dwarf tag code. Data representation DIEs have this set to (dwarf::Tag)-1
+  /// and the tag code is available via DIEDataRepr::MD.
   ///
   dwarf::Tag Tag = (dwarf::Tag)0;
 
-  /// Children DIEs.
-  IntrusiveBackList<DIE> Children;
+  AlignedCharArrayUnion<DIEExplicitRepr, DIEDataRepr> Data;
+
+public:
+  bool isDIEData() const {
+    return Tag == (dwarf::Tag)-1;
+  }
+
+private:
+  DIEExplicitRepr &getDIEExplicitRepr() {
+    assert(!isDIEData());
+    return *reinterpret_cast<DIEExplicitRepr *>(Data.buffer);
+  }
+  const DIEExplicitRepr &getDIEExplicitRepr() const {
+    assert(!isDIEData());
+    return *reinterpret_cast<const DIEExplicitRepr *>(Data.buffer);
+  }
+
+  DIEDataRepr &getDIEDataRepr() {
+    assert(isDIEData());
+    return *reinterpret_cast<DIEDataRepr *>(Data.buffer);
+  }
+  const DIEDataRepr &getDIEDataRepr() const {
+    assert(isDIEData());
+    return *reinterpret_cast<const DIEDataRepr *>(Data.buffer);
+  }
 
   DIE *Parent = nullptr;
 
   DIE() = delete;
-  explicit DIE(dwarf::Tag Tag) : Offset(0), Size(0), Tag(Tag) {}
+  explicit DIE(dwarf::Tag Tag) : Offset(0), Size(0), Tag(Tag) {
+    new (Data.buffer) DIEExplicitRepr;
+  }
 
 public:
   static DIE *get(BumpPtrAllocator &Alloc, dwarf::Tag Tag) {
     return new (Alloc) DIE(Tag);
   }
 
   // Accessors.
-  unsigned getAbbrevNumber() const { return AbbrevNumber; }
-  dwarf::Tag getTag() const { return Tag; }
+  unsigned getAbbrevNumber() const {
+    assert(!isDIEData());
+    return AbbrevNumber;
+  }
+  dwarf::Tag getTag() const {
+    if (isDIEData())
+      return dwarf::Tag(getDIEDataRepr().MD->getTag());
+    return Tag;
+  }
+  DIEData *getDIEData() const {
+    return getDIEDataRepr().Data;
+  }
+  const DINode *getDINode() const {
+    return getDIEDataRepr().MD;
+  }
+  void setDIEData(DIEData *D, const DINode *MD) {
+    if (!isDIEData()) {
+      // Switch to the data representation.
+      getDIEExplicitRepr().~DIEExplicitRepr();
+      new (Data.buffer) DIEDataRepr;
+      Tag = (dwarf::Tag)-1;
+    }
+    getDIEDataRepr().Data = D;
+    getDIEDataRepr().MD = MD;
+  }
   unsigned getOffset() const { return Offset; }
   unsigned getSize() const { return Size; }
-  bool hasChildren() const { return !Children.empty(); }
+  bool hasChildren() const { return !getDIEExplicitRepr().Children.empty(); }
 
   typedef IntrusiveBackList<DIE>::iterator child_iterator;
   typedef IntrusiveBackList<DIE>::const_iterator const_child_iterator;
   typedef iterator_range<child_iterator> child_range;
   typedef iterator_range<const_child_iterator> const_child_range;
 
   child_range children() {
-    return llvm::make_range(Children.begin(), Children.end());
+    return llvm::make_range(getDIEExplicitRepr().Children.begin(),
+                            getDIEExplicitRepr().Children.end());
   }
   const_child_range children() const {
-    return llvm::make_range(Children.begin(), Children.end());
+    return llvm::make_range(getDIEExplicitRepr().Children.begin(),
+                            getDIEExplicitRepr().Children.end());
   }
 
   DIE *getParent() const { return Parent; }
 
   /// Generate the abbreviation for this DIE.
   ///
   /// Calculate the abbreviation for this, which should be uniqued and
   /// eventually used to call \a setAbbrevNumber().
   DIEAbbrev generateAbbrev() const;
 
   /// Set the abbreviation number for this DIE.
-  void setAbbrevNumber(unsigned I) { AbbrevNumber = I; }
+  void setAbbrevNumber(unsigned I) {
+    assert(!isDIEData());
+    AbbrevNumber = I;
+  }
 
   /// Climb up the parent chain to get the compile or type unit DIE this DIE
   /// belongs to.
   const DIE *getUnit() const;
   /// Similar to getUnit, returns null when DIE is not added to an
   /// owner yet.
   const DIE *getUnitOrNull() const;
   void setOffset(unsigned O) { Offset = O; }
   void setSize(unsigned S) { Size = S; }
 
   /// Add a child to the DIE.
   DIE &addChild(DIE *Child) {
     assert(!Child->getParent() && "Child should be orphaned");
     Child->Parent = this;
-    Children.push_back(*Child);
-    return Children.back();
+    getDIEExplicitRepr().Children.push_back(*Child);
+    return getDIEExplicitRepr().Children.back();
+  }
+
+  // Wrap DIEValueList member functions to provide representation checking.
+
+  operator DIEValueList&() {
+    return getDIEExplicitRepr().Attrs;
+  }
+
+  typedef DIEValueList::value_iterator value_iterator;
+  typedef DIEValueList::const_value_iterator const_value_iterator;
+
+  value_iterator addValue(BumpPtrAllocator &Alloc, DIEValue V) {
+    return getDIEExplicitRepr().Attrs.addValue(Alloc, V);
+  }
+  template <class T>
+  value_iterator addValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,
+                          dwarf::Form Form, T &&Value) {
+    return getDIEExplicitRepr().Attrs.addValue(Alloc, Attribute, Form,
+                                               std::forward<T>(Value));
+  }
+
+  typedef DIEValueList::value_range value_range;
+  typedef DIEValueList::const_value_range const_value_range;
+
+  value_range values() {
+    return getDIEExplicitRepr().Attrs.values();
+  }
+
+  const_value_range values() const {
+    return getDIEExplicitRepr().Attrs.values();
   }
 
   /// Find a value in the DIE with the attribute given.
   ///
   /// Returns a default-constructed DIEValue (where \a DIEValue::getType()
   /// gives \a DIEValue::isNone) if no such attribute exists.
   DIEValue findAttribute(dwarf::Attribute Attribute) const;
 

include/llvm/CodeGen/DIEData.h

+//===--- llvm/CodeGen/DIEData.h - DWARF Info Entries ------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Data structures for DWARF info entries.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_DIEDATA_H
+#define LLVM_CODEGEN_DIEDATA_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/Dwarf.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/LEB128.h"
+#include <map>
+#include <stdint.h>
+#include <utility>
+#include <vector>
+
+namespace llvm {
+
+class DIEData;
+class DIEWriter;
+class MCExpr;
+class MCStreamer;
+class MCSymbol;
+
+struct DIESymbolReloc {
+  uint8_t Size : 4;
+  uint64_t Offset : 60;
+  MCSymbol *Val;
+};
+
+// A block of debug information entries (DIEs). Clients add new DIEs to a
+// DIEData by creating a DIEWriter, adding attributes to it and calling the
+// write() function.
+class DIEData {
+  std::vector<char> Bytes;
+  std::vector<DIESymbolReloc> SymRelocs;
+
+public:
+  /// Prepare to emit this DIEData, and compute the offset of the end of
+  /// the DIEData given a start offset.
+  uint64_t prepareToEmit(uint64_t StartOffset);
+
+  /// Emit the DIEData to the given MCStreamer.
+  void emit(MCStreamer &S);
+
+  friend class DIEWriter;
+};
+
+class DWARFAbbrev {
+  std::vector<char> Data;
+  StringMap<uint64_t> AbbrevMap;
+
+public:
+  /// Get the bytes that need to be emitted to the DWARF abbreviation
+  /// section.
+  StringRef getAbbrevData() const { return {Data.data(), Data.size()}; }
+
+  /// Get an abbreviation number for the given attribute specification,
+  /// creating one if necessary.
+  size_t getAbbrevNo(StringRef AttrSpec);
+};
+
+class DIEWriter {
+  DWARFAbbrev *Abbrevs;
+  DIEData *Data;
+
+  SmallVector<char, 16> AttrSpec;
+  SmallVector<char, 16> Attrs;
+  SmallVector<DIESymbolReloc, 1> SymRelocs;
+
+  void attrSpec(dwarf::Attribute Attr, dwarf::Form Form) {
+    uint8_t AttrSpecULEB128[20];
+    unsigned AttrSize = encodeULEB128(Attr, AttrSpecULEB128);
+    unsigned FormSize = encodeULEB128(Form, AttrSpecULEB128 + AttrSize);
+    AttrSpec.append(AttrSpecULEB128, AttrSpecULEB128 + AttrSize + FormSize);
+  }
+
+public:
+  DIEWriter(DWARFAbbrev &Abbrevs, DIEData &Data, dwarf::Tag Tag,
+            bool HasChildren)
+      : Abbrevs(&Abbrevs), Data(&Data) {
+    uint8_t AttrSpecHeader[11];
+    unsigned TagSize = encodeULEB128(Tag, AttrSpecHeader);
+    AttrSpecHeader[TagSize] =
+        HasChildren ? dwarf::DW_CHILDREN_yes : dwarf::DW_CHILDREN_no;
+    AttrSpec.append(AttrSpecHeader, AttrSpecHeader + TagSize + 1);
+  }
+
+  /// Add an attribute of pure data.
+  void attr(dwarf::Attribute Attr, dwarf::Form Form, ArrayRef<char> Data) {
+    attrSpec(Attr, Form);
+    Attrs.append(Data.begin(), Data.end());
+  }
+
+  /// Add a single-byte integer attribute.
+  void attr1(dwarf::Attribute Attr, dwarf::Form Form, uint8_t Data) {
+    return attr(Attr, Form, {(char *)&Data, 1});
+  }
+
+  /// Add a 2-byte integer attribute with the given endianness.
+  void attr2(dwarf::Attribute Attr, dwarf::Form Form, uint16_t Data, bool BE) {
+    char Buf[2];
+    if (BE)
+      support::endian::write16be(Buf, Data);
+    else
+      support::endian::write16le(Buf, Data);
+    attr(Attr, Form, {Buf, 2});
+  }
+
+  /// Add a 4-byte integer attribute with the given endianness.
+  void attr4(dwarf::Attribute Attr, dwarf::Form Form, uint32_t Data, bool BE) {
+    char Buf[4];
+    if (BE)
+      support::endian::write32be(Buf, Data);
+    else
+      support::endian::write32le(Buf, Data);
+    attr(Attr, Form, {Buf, 4});
+  }
+
+  /// Add an 8-byte integer attribute with the given endianness.
+  void attr8(dwarf::Attribute Attr, dwarf::Form Form, uint64_t Data, bool BE) {
+    char Buf[8];
+    if (BE)
+      support::endian::write64be(Buf, Data);
+    else
+      support::endian::write64le(Buf, Data);
+    attr(Attr, Form, {Buf, 8});
+  }
+
+  /// Add an integer attribute using ULEB128 encoding.
+  void uleb128(dwarf::Attribute Attr, dwarf::Form Form, uint64_t Data) {
+    uint8_t DataULEB128[10];
+    unsigned Size = encodeULEB128(Data, DataULEB128);
+    attr(Attr, Form, {(char *)DataULEB128, Size});
+  }
+
+  /// Add an integer attribute using the most compact DW_FORM_data* form
+  /// possible.
+  void data(dwarf::Attribute Attr, uint64_t Data, bool BE) {
+    if (Data < (1ull << 8))
+      attr1(Attr, dwarf::DW_FORM_data1, Data);
+    else if (Data < (1ull << 16))
+      attr2(Attr, dwarf::DW_FORM_data2, Data, BE);
+    else if (Data < (1ull << 32))
+      attr4(Attr, dwarf::DW_FORM_data4, Data, BE);
+    else
+      attr8(Attr, dwarf::DW_FORM_data8, Data, BE);
+  }
+
+  /// Add an attribute that uses a symbol relocation.
+  void relocSym(dwarf::Attribute Attr, dwarf::Form Form, uint8_t Size,
+                MCSymbol *S) {
+    SymRelocs.push_back({Size, Attrs.size(), S});
+    Attrs.append(Size, 0);
+    attrSpec(Attr, Form);
+  }
+
+  /// Write the attribute to the DIEData passed at construction time.
+  void write();
+};
+
+}
+
+#endif

include/llvm/Support/Allocator.h

for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
       DestroyElements((char*)alignAddr(Ptr, alignOf<T>()), (char *)Ptr + Size);
     }
 
     Allocator.Reset();
   }
 
   /// \brief Allocate space for an array of objects without constructing them.
   T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
+
+  /// Construct an object with the specified constructor arguments.
+  template <typename ...Args>
+  T *Construct(Args &&...args) {
+    T *Obj = Allocate();
+    new (Obj) T(std::forward<T>(args)...);
+    return Obj;
+  }
 };
 
 }  // end namespace llvm
 
 template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold>
 void *operator new(size_t Size,
                    llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize,
                                               SizeThreshold> &Allocator) {

lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp

case MCCFIInstruction::OpGnuArgsSize:
     break;
   case MCCFIInstruction::OpEscape:
     OutStreamer->EmitCFIEscape(Inst.getValues());
     break;
   }
 }
 
 void AsmPrinter::emitDwarfDIE(const DIE &Die) const {
+  if (Die.isDIEData()) {
+    Die.getDIEData()->emit(*OutStreamer);
+    return;
+  }
+
   // Emit the code (index) for the abbreviation.
   if (isVerbose())
     OutStreamer->AddComment("Abbrev [" + Twine(Die.getAbbrevNumber()) + "] 0x" +
                             Twine::utohexstr(Die.getOffset()) + ":0x" +
                             Twine::utohexstr(Die.getSize()) + " " +
                             dwarf::TagString(Die.getTag()));
   EmitULEB128(Die.getAbbrevNumber());
 

lib/CodeGen/AsmPrinter/CMakeLists.txt

 add_llvm_library(LLVMAsmPrinter
   AddressPool.cpp
   ARMException.cpp
   AsmPrinter.cpp
   AsmPrinterDwarf.cpp
   AsmPrinterInlineAsm.cpp
   DbgValueHistoryCalculator.cpp
   DebugHandlerBase.cpp
   DebugLocStream.cpp
   DIE.cpp
+  DIEData.cpp
   DIEHash.cpp
   DwarfAccelTable.cpp
   DwarfCFIException.cpp
   DwarfCompileUnit.cpp
   DwarfDebug.cpp
   DwarfExpression.cpp
   DwarfFile.cpp
   DwarfStringPool.cpp

lib/CodeGen/AsmPrinter/DIE.cpp

O << "  "
       << '\n';
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEAbbrev::dump() { print(dbgs()); }
 
 DIEAbbrev DIE::generateAbbrev() const {
-  DIEAbbrev Abbrev(Tag, hasChildren());
+  DIEAbbrev Abbrev(getTag(), hasChildren());
   for (const DIEValue &V : values())
     Abbrev.AddAttribute(V.getAttribute(), V.getForm());
   return Abbrev;
 }
 
 /// Climb up the parent chain to get the unit DIE to which this DIE
 /// belongs.
 const DIE *DIE::getUnit() const {

lib/CodeGen/AsmPrinter/DIEData.cpp

+//===--- lib/CodeGen/DIEData.cpp - DWARF Info Entries ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Data structures for DWARF info entries.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/CodeGen/DIEData.h"
+#include "llvm/MC/MCStreamer.h"
+
+using namespace llvm;
+
+uint64_t DIEData::prepareToEmit(uint64_t StartOffset) {
+  // For now, just add the size of the Bytes array.
+  return StartOffset + Bytes.size();
+}
+
+void DIEData::emit(MCStreamer &S) {
+  size_t DataOffset = 0;
+
+  for (auto &R : SymRelocs) {
+    // Emit bytes until the next symbol relocation, then emit the symbol
+    // reference.
+    S.EmitBytes(StringRef(Bytes.data() + DataOffset,
+                          R.Offset - DataOffset));
+    S.EmitSymbolValue(R.Val, R.Size);
+    DataOffset = R.Offset + R.Size;
+  }
+
+  // Emit any remaining bytes.
+  S.EmitBytes(StringRef(Bytes.data() + DataOffset, Bytes.size() - DataOffset));
+}
+
+size_t DWARFAbbrev::getAbbrevNo(StringRef AttrSpec) {
+  // FIXME: in order that DIE abbreviations from DWARFAbbrev and from DwarfFile
+  // may coexist, DWARFAbbrev is made to produce even abbreviation numbers while
+  // DwarfFile produces odd numbers. Once DIE/DIEValue are removed, we can
+  // remove this hack. See DwarfFile::assignAbbrevNumber for the corresponding
+  // code in DwarfFile.
+  size_t AbbrevNo = AbbrevMap.size() * 2 + 2;
+  auto Ins = AbbrevMap.insert(std::make_pair(AttrSpec, AbbrevNo));
+  if (Ins.second) {
+    uint8_t AbbrevNoULEB128[10];
+    unsigned AbbrevNoSize = encodeULEB128(AbbrevNo, AbbrevNoULEB128);
+
+    size_t Pos = Data.size();
+    // Abbreviation number + abbreviation spec + 2 bytes for null terminator.
+    Data.insert(Data.end(), AbbrevNoSize + AttrSpec.size() + 2, 0);
+    memcpy(Data.data() + Pos, AbbrevNoULEB128, AbbrevNoSize);
+    memcpy(Data.data() + Pos + AbbrevNoSize, AttrSpec.data(), AttrSpec.size());
+  } else {
+    AbbrevNo = Ins.first->second;
+  }
+  return AbbrevNo;
+}
+
+void DIEWriter::write() {
+  size_t AbbrevNo =
+      Abbrevs->getAbbrevNo(StringRef(AttrSpec.data(), AttrSpec.size()));
+
+  uint8_t AbbrevNoULEB128[10];
+  unsigned AbbrevNoSize = encodeULEB128(AbbrevNo, AbbrevNoULEB128);
+
+  size_t Pos = Data->Bytes.size();
+  Data->Bytes.insert(Data->Bytes.end(), AbbrevNoSize + Attrs.size(), 0);
+  memcpy(Data->Bytes.data() + Pos, AbbrevNoULEB128, AbbrevNoSize);
+  memcpy(Data->Bytes.data() + Pos + AbbrevNoSize, Attrs.data(), Attrs.size());
+
+  for (auto R : SymRelocs)
+    Data->SymRelocs.push_back({R.Size, Pos + AbbrevNoSize + R.Offset, R.Val});
+}

lib/CodeGen/AsmPrinter/DIEHash.h

public:
   // Helper routines to process parts of a DIE.
 private:
   /// \brief Adds the parent context of \param Die to the hash.
   void addParentContext(const DIE &Die);
 
   /// \brief Adds the attributes of \param Die to the hash.
   void addAttributes(const DIE &Die);
 
+  /// Add the given string attribute to the hash.
+  void addStringAttr(dwarf::Attribute Attr, StringRef Str);
+
+  /// Add the given integer attribute to the hash.
+  void addIntAttr(dwarf::Attribute Attr, int64_t Value);
+
+  /// Computes the full DWARF4 7.27 hash of the DIE from metadata.
+  void computeHashFromMetadata(const MDNode *MD);
+
   /// \brief Computes the full DWARF4 7.27 hash of the DIE.
   void computeHash(const DIE &Die);
 
   // Routines that add DIEValues to the hash.
 public:
   /// \brief Adds \param Value to the hash.
   void update(uint8_t Value) { Hash.update(Value); }
 

lib/CodeGen/AsmPrinter/DIEHash.cpp

 
 #include "ByteStreamer.h"
 #include "DIEHash.h"
 #include "DwarfDebug.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/DIE.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
if ((Tag == dwarf::DW_TAG_pointer_type ||
        Tag == dwarf::DW_TAG_rvalue_reference_type ||
        Tag == dwarf::DW_TAG_ptr_to_member_type) &&
       // and the referenced type (via the [below attributes])
       // FIXME: This seems overly restrictive, and causes hash mismatches
       // there's a decl/def difference in the containing type of a
       // ptr_to_member_type, but it's what DWARF says, for some reason.
       Attribute == dwarf::DW_AT_type) {
     // ... has a DW_AT_name attribute,
-    StringRef Name = getDIEStringAttr(Entry, dwarf::DW_AT_name);
+    StringRef Name;
+    if (Entry.isDIEData())
+      Name = cast<DIType>(Entry.getDINode())->getName();
+    else
+      Name = getDIEStringAttr(Entry, dwarf::DW_AT_name);
     if (!Name.empty()) {
       hashShallowTypeReference(Attribute, Entry, Name);
       return;
     }
   }
 
   unsigned &DieNumber = Numbering[&Entry];
   if (DieNumber) {
case DIEValue::isNone:
 
     // 7.27 Step 3
     // ... An attribute that refers to another type entry T is processed as
     // follows:
   case DIEValue::isEntry:
     hashDIEEntry(Attribute, Tag, Value.getDIEEntry().getEntry());
     break;
   case DIEValue::isInteger: {
-    addULEB128('A');
-    addULEB128(Attribute);
     switch (Value.getForm()) {
     case dwarf::DW_FORM_data1:
     case dwarf::DW_FORM_data2:
     case dwarf::DW_FORM_data4:
     case dwarf::DW_FORM_data8:
     case dwarf::DW_FORM_udata:
     case dwarf::DW_FORM_sdata:
-      addULEB128(dwarf::DW_FORM_sdata);
-      addSLEB128((int64_t)Value.getDIEInteger().getValue());
+      addIntAttr(Attribute, (int64_t)Value.getDIEInteger().getValue());
       break;
     // DW_FORM_flag_present is just flag with a value of one. We still give it a
     // value so just use the value.
     case dwarf::DW_FORM_flag_present:
     case dwarf::DW_FORM_flag:
+      addULEB128('A');
+      addULEB128(Attribute);
       addULEB128(dwarf::DW_FORM_flag);
       addULEB128((int64_t)Value.getDIEInteger().getValue());
       break;
     default:
       llvm_unreachable("Unknown integer form!");
     }
     break;
   }
   case DIEValue::isString:
-    addULEB128('A');
-    addULEB128(Attribute);
-    addULEB128(dwarf::DW_FORM_string);
-    addString(Value.getDIEString().getString());
+    addStringAttr(Attribute, Value.getDIEString().getString());
     break;
   case DIEValue::isBlock:
   case DIEValue::isLoc:
   case DIEValue::isLocList:
     addULEB128('A');
     addULEB128(Attribute);
     addULEB128(dwarf::DW_FORM_block);
     if (Value.getType() == DIEValue::isBlock) {
void DIEHash::hashNestedType(const DIE &Die, StringRef Name) {
 
   // the tag of C,
   addULEB128(Die.getTag());
 
   // and the name.
   addString(Name);
 }
 
+void DIEHash::addStringAttr(dwarf::Attribute Attr, StringRef Str) {
+  addULEB128('A');
+  addULEB128(Attr);
+  addULEB128(dwarf::DW_FORM_string);
+  addString(Str);
+}
+
+void DIEHash::addIntAttr(dwarf::Attribute Attr, int64_t Value) {
+  addULEB128('A');
+  addULEB128(Attr);
+  addULEB128(dwarf::DW_FORM_sdata);
+  addSLEB128(Value);
+}
+
+void DIEHash::computeHashFromMetadata(const MDNode *MD) {
+  auto Ty = cast<DIBasicType>(MD);
+
+  addULEB128('D');
+  addULEB128(Ty->getTag());
+
+  if (!Ty->getName().empty())
+    addStringAttr(dwarf::DW_AT_name, Ty->getName());
+
+  if (Ty->getTag() != dwarf::DW_TAG_unspecified_type) {
+    addIntAttr(dwarf::DW_AT_byte_size, Ty->getSizeInBits() >> 3);
+    addIntAttr(dwarf::DW_AT_encoding, Ty->getEncoding());
+  }
+
+  Hash.update(makeArrayRef((uint8_t)'\0'));
+}
+
 // Compute the hash of a DIE. This is based on the type signature computation
 // given in section 7.27 of the DWARF4 standard. It is the md5 hash of a
 // flattened description of the DIE.
 void DIEHash::computeHash(const DIE &Die) {
+  if (Die.isDIEData()) {
+    computeHashFromMetadata(Die.getDINode());
+    return;
+  }
+
   // Append the letter 'D', followed by the DWARF tag of the DIE.
   addULEB128('D');
   addULEB128(Die.getTag());
 
   // Add each of the attributes of the DIE.
   addAttributes(Die);
 
   // Then hash each of the children of the DIE.
   for (auto &C : Die.children()) {
     // 7.27 Step 7
-    // If C is a nested type entry or a member function entry, ...
-    if (isType(C.getTag()) || C.getTag() == dwarf::DW_TAG_subprogram) {
+    // If C is a nested type entry or a member function entry, and has a
+    // DW_AT_name attribute
+    if (C.isDIEData()) {
+      auto Ty = cast<DIType>(C.getDINode());
+      StringRef Name = Ty->getName();
+      if (!Name.empty()) {
+        hashNestedType(C, Name);
+        continue;
+      }
+    } else if (isType(C.getTag()) || C.getTag() == dwarf::DW_TAG_subprogram) {
       StringRef Name = getDIEStringAttr(C, dwarf::DW_AT_name);
-      // ... and has a DW_AT_name attribute
       if (!Name.empty()) {
         hashNestedType(C, Name);
         continue;
       }
     }
     computeHash(C);
   }
 

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 
 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
                                                         const DIE *Die) {
   dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
 
   // We could have a specification DIE that has our most of our knowledge,
   // look for that now.
+  // FIXME: do something appropriate for data representation here.
+  if (!Die->isDIEData()) {
     if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
       DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
       if (SpecDIE.findAttribute(dwarf::DW_AT_external))
         Linkage = dwarf::GIEL_EXTERNAL;
     } else if (Die->findAttribute(dwarf::DW_AT_external))
       Linkage = dwarf::GIEL_EXTERNAL;
+  }
 
   switch (Die->getTag()) {
   case dwarf::DW_TAG_class_type:
   case dwarf::DW_TAG_structure_type:
   case dwarf::DW_TAG_union_type:
   case dwarf::DW_TAG_enumeration_type:
     return dwarf::PubIndexEntryDescriptor(
         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus

lib/CodeGen/AsmPrinter/DwarfFile.h

 #define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFFILE_H
 
 #include "AddressPool.h"
 #include "DwarfStringPool.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/CodeGen/DIEData.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/Allocator.h"
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace llvm {
 class AsmPrinter;
+class DWARFAbbrev;
 class DbgVariable;
 class DwarfCompileUnit;
 class DwarfUnit;
 class DIEAbbrev;
 class MCSymbol;
 class DIE;
 class LexicalScope;
 class StringRef;
 class DwarfDebug;
 class MCSection;
 class MDNode;
 class DwarfFile {
   // Target of Dwarf emission, used for sizing of abbreviations.
   AsmPrinter *Asm;
 
   BumpPtrAllocator AbbrevAllocator;
 
-  // Used to uniquely define abbreviations.
+  // Used to uniquely define abbreviations (DIE/DIEValue).
   FoldingSet<DIEAbbrev> AbbreviationsSet;
 
-  // A list of all the unique abbreviations in use.
+  // A list of all the unique abbreviations in use (DIE/DIEValue).
   std::vector<DIEAbbrev *> Abbreviations;
 
   // A pointer to all units in the section.
   SmallVector<std::unique_ptr<DwarfCompileUnit>, 1> CUs;
 
   DwarfStringPool StrPool;
 
   // Collection of dbg variables of a scope.
   DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8>> ScopeVariables;
 
   // Collection of abstract subprogram DIEs.
   DenseMap<const MDNode *, DIE *> AbstractSPDies;
 
   /// Maps MDNodes for type system with the corresponding DIEs. These DIEs can
   /// be shared across CUs, that is why we keep the map here instead
   /// of in DwarfCompileUnit.
   DenseMap<const MDNode *, DIE *> DITypeNodeToDieMap;
 
 public:
   DwarfFile(AsmPrinter *AP, StringRef Pref, BumpPtrAllocator &DA);
 
   ~DwarfFile();
 
+  // Abbreviations data structure (DIEData).
+  DWARFAbbrev Abbrevs;
+
   const SmallVectorImpl<std::unique_ptr<DwarfCompileUnit>> &getUnits() {
     return CUs;
   }
 
   /// \brief Compute the size and offset of a DIE given an incoming Offset.
   unsigned computeSizeAndOffset(DIE &Die, unsigned Offset);
 
   /// \brief Compute the size and offset of all the DIEs.

lib/CodeGen/AsmPrinter/DwarfFile.cpp

if (DIEAbbrev *Existing =
           AbbreviationsSet.FindNodeOrInsertPos(ID, InsertPos)) {
     Die.setAbbrevNumber(Existing->getNumber());
     return *Existing;
   }
 
   // Move the abbreviation to the heap and assign a number.
   DIEAbbrev *New = new (AbbrevAllocator) DIEAbbrev(std::move(Abbrev));
   Abbreviations.push_back(New);
-  New->setNumber(Abbreviations.size());
-  Die.setAbbrevNumber(Abbreviations.size());
+  // FIXME: in order that DIE abbreviations from DWARFAbbrev and from DwarfFile
+  // may coexist, DWARFAbbrev is made to produce even abbreviation numbers while
+  // DwarfFile produces odd numbers. Once DIE/DIEValue are removed, we can
+  // remove this hack. See DWARFAbbrev::getAbbrevNo for the corresponding code
+  // in DWARFAbbrev.
+  New->setNumber(Abbreviations.size() * 2 - 1);
+  Die.setAbbrevNumber(Abbreviations.size() * 2 - 1);
 
   // Store it for lookup.
   AbbreviationsSet.InsertNode(New, InsertPos);
   return *New;
 }
 
 void DwarfFile::addUnit(std::unique_ptr<DwarfCompileUnit> U) {
   CUs.push_back(std::move(U));
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) {
-  // Record the abbreviation.
-  const DIEAbbrev &Abbrev = assignAbbrevNumber(Die);
-
   // Set DIE offset
   Die.setOffset(Offset);
 
+  if (Die.isDIEData())
+    return Die.getDIEData()->prepareToEmit(Offset);
+
+  // Record the abbreviation.
+  const DIEAbbrev &Abbrev = assignAbbrevNumber(Die);
+
   // Start the size with the size of abbreviation code.
   Offset += getULEB128Size(Die.getAbbrevNumber());
 
   // Size the DIE attribute values.
   for (const auto &V : Die.values())
     // Size attribute value.
     Offset += V.SizeOf(Asm);
 
unsigned DwarfFile::computeSizeAndOffset(DIE &Die, unsigned Offset) {
   }
 
   Die.setSize(Offset - Die.getOffset());
   return Offset;
 }
 
 void DwarfFile::emitAbbrevs(MCSection *Section) {
   // Check to see if it is worth the effort.
-  if (!Abbreviations.empty()) {
+  if (!Abbreviations.empty() || !Abbrevs.getAbbrevData().empty()) {
     // Start the debug abbrev section.
     Asm->OutStreamer->SwitchSection(Section);
+    Asm->OutStreamer->EmitBytes(Abbrevs.getAbbrevData());
     Asm->emitDwarfAbbrevs(Abbreviations);
   }
 }
 
 // Emit strings into a string section.
 void DwarfFile::emitStrings(MCSection *StrSection, MCSection *OffsetSection) {
   StrPool.emit(*Asm, StrSection, OffsetSection);
 }

lib/CodeGen/AsmPrinter/DwarfUnit.h

 #define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFUNIT_H
 
 #include "DwarfDebug.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/DIE.h"
+#include "llvm/CodeGen/DIEData.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCSection.h"
 
 namespace llvm {
 

 class DwarfUnit {
 protected:
   /// MDNode for the compile unit.
   const DICompileUnit *CUNode;
 
   // All DIEValues are allocated through this allocator.
   BumpPtrAllocator DIEValueAllocator;
 
+  // All DIEDatas are allocated through this allocator.
+  SpecificBumpPtrAllocator<DIEData> DIEDataAlloc;
+
   /// Unit debug information entry.
   DIE &UnitDie;
 
   /// Target of Dwarf emission.
   AsmPrinter *Asm;
 
   // Holders for some common dwarf information.
   DwarfDebug *DD;
public:
 
   /// Add a new type attribute to the specified entity.
   ///
   /// This takes and attribute parameter because DW_AT_friend attributes are
   /// also type references.
   void addType(DIE &Entity, const DIType *Ty,
                dwarf::Attribute Attribute = dwarf::DW_AT_type);
 
+  /// Add a string to the specified DIEWriter.
+  void string(DIEWriter &W, dwarf::Attribute Attr, StringRef Str);
+
   DIE *getOrCreateNameSpace(const DINamespace *NS);
   DIE *getOrCreateModule(const DIModule *M);
   DIE *getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal = false);
 
   void applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
                                  bool Minimal = false);
 
   /// Find existing DIE or create new DIE for the given type.
protected:
   virtual unsigned getOrCreateSourceID(StringRef File, StringRef Directory) = 0;
 
   /// Look in the DwarfDebug map for the MDNode that corresponds to the
   /// reference.
   template <typename T> T *resolve(TypedDINodeRef<T> Ref) const {
     return DD->resolve(Ref);
   }
 
+  bool isBigEndian() const { return Asm->getDataLayout().isBigEndian(); }
+
 private:
-  void constructTypeDIE(DIE &Buffer, const DIBasicType *BTy);
+  void constructBasicType(DIEData &D, const DIBasicType *BTy);
   void constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy);
   void constructTypeDIE(DIE &Buffer, const DISubroutineType *DTy);
   void constructSubrangeDIE(DIE &Buffer, const DISubrange *SR, DIE *IndexTy);
   void constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy);
   void constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy);
   void constructMemberDIE(DIE &Buffer, const DIDerivedType *DT);
   void constructTemplateTypeParameterDIE(DIE &Buffer,
                                          const DITemplateTypeParameter *TP);

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
   for (const auto *Element : TParams) {
     if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
       constructTemplateTypeParameterDIE(Buffer, TTP);
     else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
       constructTemplateValueParameterDIE(Buffer, TVP);
   }
 }
 
+void DwarfUnit::string(DIEWriter &W, dwarf::Attribute Attr, StringRef Str) {
+  DwarfStringPool::EntryRef Entry = DU->getStringPool().getEntry(*Asm, Str);
+  if (isDwoUnit()) {
+    W.uleb128(Attr, dwarf::DW_FORM_GNU_str_index, Entry.getIndex());
+  } else if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
+    W.relocSym(Attr, dwarf::DW_FORM_strp, 4, Entry.getSymbol());
+  } else {
+    W.attr4(Attr, dwarf::DW_FORM_strp, Entry.getOffset(), isBigEndian());
+  }
+}
+
 DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
   if (!Context || isa<DIFile>(Context))
     return &getUnitDie();
   if (auto *T = dyn_cast<DIType>(Context))
     return getOrCreateTypeDIE(T);
   if (auto *NS = dyn_cast<DINamespace>(Context))
     return getOrCreateNameSpace(NS);
   if (auto *SP = dyn_cast<DISubprogram>(Context))
DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
   if (DIE *TyDIE = getDIE(Ty))
     return TyDIE;
 
   // Create new type.
   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
 
   updateAcceleratorTables(Context, Ty, TyDIE);
 
-  if (auto *BT = dyn_cast<DIBasicType>(Ty))
-    constructTypeDIE(TyDIE, BT);
-  else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
+  if (auto *BT = dyn_cast<DIBasicType>(Ty)) {
+    DIEData *Data = DIEDataAlloc.Construct();
+    constructBasicType(*Data, BT);
+    TyDIE.setDIEData(Data, BT);
+  } else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
     constructTypeDIE(TyDIE, STy);
   else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
     if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
       if (MDString *TypeId = CTy->getRawIdentifier()) {
         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
         // Skip updating the accelerator tables since this is not the full type.
         return &TyDIE;
       }
for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) {
     if (!Name.empty()) {
       CS += Name;
       CS += "::";
     }
   }
   return CS;
 }
 
-void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
+void DwarfUnit::constructBasicType(DIEData &D, const DIBasicType *BTy) {
+  DIEWriter W(DU->Abbrevs, D, dwarf::Tag(BTy->getTag()), false);
+
   // Get core information.
   StringRef Name = BTy->getName();
   // Add name if not anonymous or intermediate type.
   if (!Name.empty())
-    addString(Buffer, dwarf::DW_AT_name, Name);
+    string(W, dwarf::DW_AT_name, Name);
 
   // An unspecified type only has a name attribute.
   if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
-    return;
+    return W.write();
 
-  addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
-          BTy->getEncoding());
+  W.attr1(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, BTy->getEncoding());
 
   uint64_t Size = BTy->getSizeInBits() >> 3;
-  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
+  W.data(dwarf::DW_AT_byte_size, Size, isBigEndian());
+  W.write();
 }
 
 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
   // Get core information.
   StringRef Name = DTy->getName();
   uint64_t Size = DTy->getSizeInBits() >> 3;
   uint16_t Tag = Buffer.getTag();
 

test/DebugInfo/X86/enum-class.ll

 ; CHECK: DW_AT_enum_class [DW_FORM_flag_present] (true)
 ; CHECK: DW_AT_name [DW_FORM_strp]      ( .debug_str[{{.*}}] = "A")
 
 ; CHECK: DW_TAG_enumeration_type [{{.*}}] *
 ; CHECK: DW_AT_type [DW_FORM_ref4]
 ; CHECK: DW_AT_enum_class [DW_FORM_flag_present] (true)
 ; CHECK: DW_AT_name [DW_FORM_strp]          ( .debug_str[{{.*}}] = "B")
 
-; CHECK: DW_TAG_enumeration_type [6]
+; CHECK: DW_TAG_enumeration_type [{{.*}}]
 ; CHECK-NOT: DW_AT_enum_class
 ; CHECK: DW_AT_name [DW_FORM_strp]      ( .debug_str[{{.*}}] = "C")
 !23 = !{i32 1, !"Debug Info Version", i32 3}

test/DebugInfo/X86/fission-cu.ll

 ; CHECK: DW_AT_stmt_list DW_FORM_sec_offset
 ; CHECK: DW_AT_GNU_dwo_name      DW_FORM_strp
 ; CHECK: DW_AT_comp_dir  DW_FORM_strp
 ; CHECK: DW_AT_GNU_dwo_id        DW_FORM_data8
 
 ; Check that we're using the right forms.
 ; CHECK: .debug_abbrev.dwo contents:
 ; CHECK: Abbrev table for offset: 0x00000000
-; CHECK: [1] DW_TAG_compile_unit DW_CHILDREN_yes
+; CHECK: [{{.*}}] DW_TAG_base_type    DW_CHILDREN_no
+; CHECK: DW_AT_name      DW_FORM_GNU_str_index
+; CHECK: DW_AT_encoding  DW_FORM_data1
+; CHECK: DW_AT_byte_size DW_FORM_data1
+
+; CHECK: [{{.*}}] DW_TAG_compile_unit DW_CHILDREN_yes
 ; CHECK: DW_AT_producer  DW_FORM_GNU_str_index
 ; CHECK: DW_AT_language  DW_FORM_data2
 ; CHECK: DW_AT_name      DW_FORM_GNU_str_index
 ; CHECK-NOT: DW_AT_low_pc
 ; CHECK-NOT: DW_AT_stmt_list
 ; CHECK-NOT: DW_AT_comp_dir
 ; CHECK: DW_AT_GNU_dwo_id        DW_FORM_data8
 
-; CHECK: [2] DW_TAG_variable     DW_CHILDREN_no
+; CHECK: [{{.*}}] DW_TAG_variable     DW_CHILDREN_no
 ; CHECK: DW_AT_name      DW_FORM_GNU_str_index
 ; CHECK: DW_AT_type      DW_FORM_ref4
 ; CHECK: DW_AT_external  DW_FORM_flag_present
 ; CHECK: DW_AT_decl_file DW_FORM_data1
 ; CHECK: DW_AT_decl_line DW_FORM_data1
 ; CHECK: DW_AT_location  DW_FORM_exprloc
 
-; CHECK: [3] DW_TAG_base_type    DW_CHILDREN_no
-; CHECK: DW_AT_name      DW_FORM_GNU_str_index
-; CHECK: DW_AT_encoding  DW_FORM_data1
-; CHECK: DW_AT_byte_size DW_FORM_data1
-
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_compile_unit
 ; CHECK-NEXT: DW_AT_stmt_list [DW_FORM_sec_offset]   (0x00000000)
 ; CHECK-NEXT: DW_AT_GNU_dwo_name [DW_FORM_strp] ( .debug_str[0x00000000] = "baz.dwo")
 ; CHECK-NEXT: DW_AT_comp_dir [DW_FORM_strp]     ( .debug_str[0x00000008] = "/usr/local/google/home/echristo/tmp")
 ; CHECK-NEXT: DW_AT_GNU_dwo_id [DW_FORM_data8]  (0x1f1f859683d49324)
 
 ; Check that the rest of the compile units have information.

test/DebugInfo/X86/linkage-name.ll

 ; RUN: llc -mtriple=x86_64-macosx %s -o %t -filetype=obj
 ; RUN: llvm-dwarfdump -debug-dump=info %t | FileCheck %s
 
-; CHECK: DW_TAG_subprogram [9] *
+; CHECK: DW_TAG_class_type
+; CHECK: DW_TAG_subprogram
+
+; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_AT_{{(MIPS_)?}}linkage_name
 ; CHECK: DW_AT_specification
 
 %class.A = type { i8 }
 
 @a = global %class.A zeroinitializer, align 1
 
 define i32 @_ZN1A1aEi(%class.A* %this, i32 %b) nounwind uwtable ssp align 2 !dbg !5 {

test/DebugInfo/X86/low-pc-cu.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin -filetype=obj < %s \
 ; RUN:     | llvm-dwarfdump -debug-dump=info - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-V4
 ; RUN: llc -mtriple=x86_64-apple-darwin -filetype=obj -dwarf-version=3 < %s \
 ; RUN:     | llvm-dwarfdump -debug-dump=info - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-V3
 
 
 ; Check that we use DW_AT_low_pc and that it has the right encoding depending
 ; on dwarf version.
 
-; CHECK: DW_TAG_compile_unit [1]
+; CHECK: DW_TAG_compile_unit [
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_low_pc [DW_FORM_addr]       (0x0000000000000000)
 ; CHECK-NOT: DW_TAG
 ; CHECK-V3: DW_AT_high_pc [DW_FORM_addr]
 ; CHECK-V4: DW_AT_high_pc [DW_FORM_data4]
-; CHECK: DW_TAG_subprogram [2]
+; CHECK: DW_TAG_subprogram [
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_low_pc [DW_FORM_addr]
 ; CHECK-NOT: DW_TAG
 ; CHECK-V3: DW_AT_high_pc [DW_FORM_addr]
 ; CHECK-V4: DW_AT_high_pc [DW_FORM_data4]
 
 ; Function Attrs: nounwind uwtable
 define void @z() #0 !dbg !4 {

test/DebugInfo/X86/pieces-2.ll

 ;    } Outer;
 ;
 ;    int foo(Outer outer) {
 ;      Inner i1 = outer.inner[1];
 ;      return i1.a;
 ;    }
 ;
 ;
-; CHECK: DW_TAG_variable [4]
+; CHECK: DW_TAG_variable [
 ;                                                  rax, piece 0x00000004
 ; CHECK-NEXT: DW_AT_location [DW_FORM_block1]{{.*}}50 93 04
 ; CHECK-NEXT:  DW_AT_name {{.*}}"i1"
 ;
 ; ModuleID = '/Volumes/Data/llvm/test/DebugInfo/X86/sroasplit-1.ll'
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 

test/DebugInfo/X86/pieces-3.ll

 ;      Inner inner[2];
 ;    } Outer;
 ;
 ;    int foo(Outer outer) {
 ;      Inner i1 = outer.inner[1];
 ;      return i1.a;
 ;    }
 ;
-; CHECK: DW_TAG_formal_parameter [3]
+; CHECK: DW_TAG_formal_parameter [
 ; CHECK-NEXT:   DW_AT_location [DW_FORM_data4]        ([[LOC:.*]])
 ; CHECK-NEXT:   DW_AT_name {{.*}}"outer"
 ; CHECK: DW_TAG_variable
 ;                                                 rsi, piece 0x00000004
 ; CHECK-NEXT:   DW_AT_location [DW_FORM_block1]       {{.*}} 54 93 04
 ; CHECK-NEXT:   "i1"
 ;
 ; CHECK: .debug_loc

unittests/CodeGen/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
+  ${LLVM_TARGETS_TO_BUILD}
   AsmPrinter
   Support
   )
 
 set(CodeGenSources
+  DIEDataTest.cpp
   DIEHashTest.cpp
   )
 
 add_llvm_unittest(CodeGenTests
   ${CodeGenSources}
   )

unittests/CodeGen/DIEDataTest.cpp

+//===- llvm/unittests/CodeGen/DIEDataTest.cpp -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/CodeGen/DIEData.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCInstPrinter.h"
+#include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCObjectFileInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/Support/Dwarf.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Support/TargetSelect.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+struct TestMCContext {
+  const Target *TheTarget;
+  const char *TripleName = "x86_64-pc-linux";
+  MCObjectFileInfo MOFI;
+  std::unique_ptr<MCContext> MCCtx;
+  std::unique_ptr<MCRegisterInfo> MRI;
+  std::unique_ptr<MCAsmInfo> MAI;
+
+  TestMCContext() {
+    llvm::InitializeAllTargetInfos();
+    llvm::InitializeAllTargetMCs();
+    llvm::InitializeAllDisassemblers();
+
+    std::string Error;
+    TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
+    if (!TheTarget)
+      return;
+
+    MRI.reset(TheTarget->createMCRegInfo(TripleName));
+    MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName));
+
+    MCCtx = llvm::make_unique<MCContext>(MAI.get(), MRI.get(), &MOFI);
+    MOFI.InitMCObjectFileInfo(Triple(TripleName), Reloc::Default,
+                              CodeModel::Default, *MCCtx);
+  }
+};
+
+std::string dataToAsmString(TestMCContext &Ctx, DIEData *B) {
+  std::unique_ptr<MCInstrInfo> MCII(Ctx.TheTarget->createMCInstrInfo());
+  MCInstPrinter *IP = Ctx.TheTarget->createMCInstPrinter(
+      Triple(Ctx.TripleName), 0, *Ctx.MAI, *MCII, *Ctx.MRI);
+  std::string Result;
+  raw_string_ostream OS(Result);
+  auto FOS = new formatted_raw_ostream(OS);
+  std::unique_ptr<MCStreamer> S(Ctx.TheTarget->createAsmStreamer(
+      *Ctx.MCCtx, std::unique_ptr<formatted_raw_ostream>(FOS),
+      /*asmverbose*/ true,
+      /*useDwarfDirectory*/ true, IP, nullptr, nullptr, false));
+  S->InitSections(false);
+
+  B->prepareToEmit(/*Offset=*/0);
+  B->emit(*S);
+
+  FOS->flush();
+  OS.flush();
+  return Result;
+}
+
+TEST(DIEData, Basic) {
+  TestMCContext Ctx;
+  if (!Ctx.TheTarget)
+    return;
+
+  DWARFAbbrev Abbrevs;
+  DIEData Data;
+
+  {
+    DIEWriter W(Abbrevs, Data, dwarf::DW_TAG_subprogram, false);
+    W.attr4(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, 1, false);
+    W.write();
+  }
+
+  {
+    DIEWriter W(Abbrevs, Data, dwarf::DW_TAG_subprogram, false);
+    W.attr4(dwarf::DW_AT_name, dwarf::DW_FORM_ref4, 1, false);
+    W.write();
+  }
+
+  EXPECT_EQ(R"(  .text
+  .asciz  "\002\001\000\000\000\004\001\000\000"
+)",
+            dataToAsmString(Ctx, &Data));
+  EXPECT_EQ(
+      (std::string({2, dwarf::DW_TAG_subprogram, 0, dwarf::DW_AT_type,
+                    dwarf::DW_FORM_ref4, 0, 0, 4, dwarf::DW_TAG_subprogram, 0,
+                    dwarf::DW_AT_name, dwarf::DW_FORM_ref4, 0, 0})),
+      Abbrevs.getAbbrevData());
+}
+
+TEST(DIEData, MCReloc) {
+  TestMCContext Ctx;
+  if (!Ctx.TheTarget)
+    return;
+
+  MCSymbol *Sym1 = Ctx.MCCtx->getOrCreateSymbol("sym1");
+  MCSymbol *Sym2 = Ctx.MCCtx->getOrCreateSymbol("sym2");
+
+  DWARFAbbrev Abbrevs;
+  DIEData Data;
+
+  {
+    DIEWriter W(Abbrevs, Data, dwarf::DW_TAG_subprogram, false);
+    W.relocSym(dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 4, Sym1);
+    W.write();
+  }
+
+  {
+    DIEWriter W(Abbrevs, Data, dwarf::DW_TAG_subprogram, false);
+    W.relocSym(dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 8, Sym2);
+    W.write();
+  }
+
+  EXPECT_EQ(R"(  .text
+  .byte 2
+  .long sym1
+  .byte 2
+  .quad sym2
+)",
+            dataToAsmString(Ctx, &Data));
+  EXPECT_EQ((std::string({2, dwarf::DW_TAG_subprogram, 0, dwarf::DW_AT_low_pc,
+                          dwarf::DW_FORM_addr, 0, 0})),
+            Abbrevs.getAbbrevData());
+}