Make a DWARF generator so we can unit test DWARF APIs with gtest.

[clayborg]

Summary

The only tests we have for the DWARF parser are the tests that use llvm-dwarfdump and expect output from textual dumps.

More DWARF parser modification are coming in the next few weeks and I wanted to add tests that can verify that we can encode and decode all form types, as well as test some other basic DWARF APIs where we ask DIE objects for their children and siblings.

DwarfGenerator.cpp was added in the lib/CodeGen directory. This file contains the code necessary to easily create DWARF for tests:

dwarfgen::Generator DG;
Triple Triple("x86_64--");
bool success = DG.init(Triple, Version);
if (!success)
  return;
dwarfgen::CompileUnit &CU = DG.addCompileUnit();
dwarfgen::DIE CUDie = CU.getUnitDIE();

CUDie.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/main.c");
CUDie.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C);

dwarfgen::DIE SubprogramDie = CUDie.addChild(DW_TAG_subprogram);
SubprogramDie.addAttribute(DW_AT_name, DW_FORM_strp, "main");
SubprogramDie.addAttribute(DW_AT_low_pc, DW_FORM_addr, 0x1000U);
SubprogramDie.addAttribute(DW_AT_high_pc, DW_FORM_addr, 0x2000U);

dwarfgen::DIE IntDie = CUDie.addChild(DW_TAG_base_type);
IntDie.addAttribute(DW_AT_name, DW_FORM_strp, "int");
IntDie.addAttribute(DW_AT_encoding, DW_FORM_data1, DW_ATE_signed);
IntDie.addAttribute(DW_AT_byte_size, DW_FORM_data1, 4);

dwarfgen::DIE ArgcDie = SubprogramDie.addChild(DW_TAG_formal_parameter);
ArgcDie.addAttribute(DW_AT_name, DW_FORM_strp, "argc");
// ArgcDie.addAttribute(DW_AT_type, DW_FORM_ref4, IntDie);
ArgcDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, IntDie);

StringRef FileBytes = DG.generate();
MemoryBufferRef FileBuffer(FileBytes, "dwarf");
auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
EXPECT_TRUE((bool)Obj);
DWARFContextInMemory DwarfContext(*Obj.get());

This code is backed by the AsmPrinter code that emits DWARF for the actual compiler.

While adding unit tests it was discovered that DIEValue that used DIEEntry as their values had bugs where DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref8, and DW_FORM_ref_udata forms were not supported. These are all now supported. Added support for DW_FORM_string so we can emit inlined C strings.

Centralized the code to unique abbreviations into a new DIEAbbrevSet class and made both the dwarfgen::Generator and the llvm::DwarfFile classes use the new class.

Fixed comments in the llvm::DIE class so that the Offset is known to be the compile/type unit offset.

DIEInteger now supports more DW_FORM values.

There are also unit tests that cover:

• Encoding and decoding all form types and values
• Encoding and decoding all reference types (DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref4, DW_FORM_ref8, DW_FORM_ref_udata, DW_FORM_ref_addr) including cross compile unit references with that go forward one compile unit and backward on compile unit.

[clayborg]

Added an inline comment about triples required to created the dwarfgen::Generator since it requires us to use the triple to get all the right classes for the AsmPrinter and all the associated classes that go with it.

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

63–66 ↗

(On Diff #80002)

Is there a better way to ensure we get a 32 and 64 bit target we can use for generating DWARF? This is my only issue with the patch that I know of. This triple code is repeated 3 times in this file. What happens if we aren't able to get these architectures?

[aprantl]

Couple of inline comments.

include/llvm/CodeGen/DIE.h

122 ↗

(On Diff #80002)

The extra newline could defeat doxygen..

129 ↗

(On Diff #80002)

///

lib/CodeGen/AsmPrinter/DIE.cpp

388 ↗

(On Diff #80002)

LLVM_FALLTHROUGH *and* break?

389 ↗

(On Diff #80002)

I think we might as well move the
Asm->OutStreamer->EmitIntValue(Integer, Size);
up here and return since it is only reachable from this case?

437 ↗

(On Diff #80002)

maybe add a getPointerSize method somewhere and hardcode it there?

593 ↗

(On Diff #80002)

better write
assert(Form == dwarf::DW_FORM_string && "Expected valid string form")`
and get rid of the extra indentation. I don't think there's a good reason for being defensive here, is there?

603 ↗

(On Diff #80002)

-Wpedantic: I think the coding guide lines prefer the commont on a separate line.

620 ↗

(On Diff #80002)

move to bottom to match other switch-stmts in this file?

674 ↗

(On Diff #80002)

see my other comment

lib/CodeGen/DwarfGenerator.cpp

122 ↗

(On Diff #80002)

inline in the header?

124 ↗

(On Diff #80002)

should we use any of the new error handling mechanisms here instead of returning a bool?

lib/CodeGen/DwarfGenerator.h

170 ↗

(On Diff #80002)

can this be a nullptr? Should it be a reference?

unittests/DebugInfo/DWARF/CMakeLists.txt

9 ↗

(On Diff #80002)

Are we 100% sure that all users of libDebugInfoDWARF want to link agains all of these extra libraries all the time? If not, we may need to layer this differently.

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

63–66 ↗

(On Diff #80002)

This definitely looks like it would break on the bots that build only an arm backend.

774 ↗

(On Diff #80002)

Thanks for add all these tests!

[clayborg]

Fixed Adrian's issues. Big changes include:

• Added llvm::Expected support to the dwarfgen::Generator
• Handle errors if any arise
• Get host triple and get its 32 and 64 bits variants for 4 byte and 8 byte addresses and bail out if targets are not available without breaking the gtest.

[clayborg]

Marked things as done and commented where things weren't changed.

lib/CodeGen/AsmPrinter/DIE.cpp

593 ↗

(On Diff #80340)

If we use an assert and they aren't enabled, we want to crash, so I used llvm_unreachable below.

lib/CodeGen/DwarfGenerator.cpp

123 ↗

(On Diff #80340)

Can't inline the destructor as the headers must be included so that the std::unique_ptr member variables and properly destruct themselves.

lib/CodeGen/DwarfGenerator.h

170 ↗

(On Diff #80002)

It is returned as a pointer from the place we get it from (TheTarget->createMCAsmBackend(...)) so this should stay a pointer.

unittests/DebugInfo/DWARF/CMakeLists.txt

4–9 ↗

(On Diff #80002)

This is only for this unit test executable, not for libDebugInfoDWARF.

[clayborg]

Friendly ping.

[clayborg]

Would love to get this in if anyone has time for a review.

[aprantl]

Thanks, I think this looks good now!
Please be sure to test this with '-DLLVM_TARGETS_TO_BUILD=ARM' to make sure this works even if the X86 target isn't present before committing.

lib/CodeGen/DwarfGenerator.h

52 ↗

(On Diff #80340)

I would remove this line.

59 ↗

(On Diff #80340)

please remove this line, I think it conflicts with Doxygen's parser.

llvm/trunk/include/llvm/CodeGen/DIE.h

 // Data structures for DWARF info entries.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
 #define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
 
 #include "llvm/ADT/FoldingSet.h"
-#include "llvm/ADT/iterator.h"
-#include "llvm/ADT/iterator_range.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/CodeGen/DwarfStringPoolEntry.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Dwarf.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 #include <new>
 #include <type_traits>
+#include <vector>
 
 namespace llvm {
 
 class AsmPrinter;
 class DIE;
 class DIEUnit;
 class MCExpr;
 class MCSection;
public:
   /// Print the abbreviation using the specified asm printer.
   void Emit(const AsmPrinter *AP) const;
 
   void print(raw_ostream &O);
   void dump();
 };
 
 //===--------------------------------------------------------------------===//
+/// Helps unique DIEAbbrev objects and assigns abbreviation numbers.
+///
+/// This class will unique the DIE abbreviations for a llvm::DIE object and
+/// assign a unique abbreviation number to each unique DIEAbbrev object it
+/// finds. The resulting collection of DIEAbbrev objects can then be emitted
+/// into the .debug_abbrev section.
+class DIEAbbrevSet {
+  /// The bump allocator to use when creating DIEAbbrev objects in the uniqued
+  /// storage container.
+  BumpPtrAllocator &Alloc;
+  /// \brief FoldingSet that uniques the abbreviations.
+  llvm::FoldingSet<DIEAbbrev> AbbreviationsSet;
+  /// A list of all the unique abbreviations in use.
+  std::vector<DIEAbbrev *> Abbreviations;
+
+public:
+  DIEAbbrevSet(BumpPtrAllocator &A) : Alloc(A) {}
+  ~DIEAbbrevSet();
+  /// Generate the abbreviation declaration for a DIE and return a pointer to
+  /// the generated abbreviation.
+  ///
+  /// \param DIE the debug info entry to generate the abbreviation for.
+  /// \returns A reference to the uniqued abbreviation declaration that is
+  /// owned by this class.
+  DIEAbbrev &uniqueAbbreviation(DIE &Die);
+
+  /// Print all abbreviations using the specified asm printer.
+  void Emit(const AsmPrinter *AP, MCSection *Section) const;
+};
+
+//===--------------------------------------------------------------------===//
 /// An integer value DIE.
 ///
 class DIEInteger {
   uint64_t Integer;
 
 public:
   explicit DIEInteger(uint64_t I) : Integer(I) {}
 
public:
 
   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
-/// A container for string values.
+/// 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 print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
+/// A container for inline string values.
+///
+/// This class is used with the DW_FORM_string form.
+class DIEInlineString {
+  std::string S;
+
+public:
+  explicit DIEInlineString(StringRef Str) : S(Str.str()) {}
+
+  ~DIEInlineString() = default;
+
+  /// Grab the string out of the object.
+  StringRef getString() const { return StringRef(S); }
+
+  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOf(const AsmPrinter *AP, 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 DIE;
 class DIEEntry {
   DIE *Entry;
 
   DIEEntry() = delete;
 
 public:
   explicit DIEEntry(DIE &E) : Entry(&E) {}
 
   DIE &getEntry() const { return *Entry; }
 
-  /// Returns size of a ref_addr entry.
-  static unsigned getRefAddrSize(const AsmPrinter *AP);
-
   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
-    return Form == dwarf::DW_FORM_ref_addr ? getRefAddrSize(AP)
-                                           : sizeof(int32_t);
-  }
+  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// Represents a pointer to a location list in the debug_loc
 /// section.
 class DIELocList {

 
 //===--------------------------------------------------------------------===//
 /// A structured debug information entry.  Has an abbreviation which
 /// describes its organization.
 class DIE : IntrusiveBackListNode, public DIEValueList {
   friend class IntrusiveBackList<DIE>;
   friend class DIEUnit;
 
-  /// Offset - Dwarf unit relative offset.
-  ///
+  /// Dwarf unit relative offset.
   unsigned Offset;
-
-  /// Size - Size of instance + children.
-  ///
+  /// Size of instance + children.
   unsigned Size;
-
   unsigned AbbrevNumber = ~0u;
-
-  /// Tag - Dwarf tag code.
-  ///
+  /// Dwarf tag code.
   dwarf::Tag Tag = (dwarf::Tag)0;
-
   /// Children DIEs.
   IntrusiveBackList<DIE> Children;
 
   /// The owner is either the parent DIE for children of other DIEs, or a
   /// DIEUnit which contains this DIE as its unit DIE.
   PointerUnion<DIE *, DIEUnit *> Owner;
 
   DIE() = delete;
public:
 
   /// Set the abbreviation number for this DIE.
   void setAbbrevNumber(unsigned I) { AbbrevNumber = I; }
 
   /// Get the absolute offset within the .debug_info or .debug_types section
   /// for this DIE.
   unsigned getDebugSectionOffset() const;
 
+  /// Compute the offset of this DIE and all its children.
+  ///
+  /// This function gets called just before we are going to generate the debug
+  /// 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 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,
+                                    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;
 
   /// Climb up the parent chain to get the compile unit or type unit that this

llvm/trunk/include/llvm/CodeGen/DIEValue.def

 HANDLE_DIEVALUE_SMALL(String)
 HANDLE_DIEVALUE_SMALL(Expr)
 HANDLE_DIEVALUE_SMALL(Label)
 HANDLE_DIEVALUE_LARGE(Delta)
 HANDLE_DIEVALUE_SMALL(Entry)
 HANDLE_DIEVALUE_LARGE(Block)
 HANDLE_DIEVALUE_LARGE(Loc)
 HANDLE_DIEVALUE_SMALL(LocList)
+HANDLE_DIEVALUE_LARGE(InlineString)
 
 #undef HANDLE_DIEVALUE
 #undef HANDLE_DIEVALUE_SMALL
 #undef HANDLE_DIEVALUE_LARGE

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h

public:
   const char *getAttributeValueAsString(const DWARFUnit *U, 
                                         dwarf::Attribute Attr,
                                         const char *FailValue) const;
 
   uint64_t getAttributeValueAsAddress(const DWARFUnit *U, 
                                       dwarf::Attribute Attr,
                                       uint64_t FailValue) const;
 
+  int64_t getAttributeValueAsSignedConstant(const DWARFUnit *U,
+                                            dwarf::Attribute Attr,
+                                            int64_t FailValue) const;
+
   uint64_t getAttributeValueAsUnsignedConstant(const DWARFUnit *U,
                                                dwarf::Attribute Attr,
                                                uint64_t FailValue) const;
 
   uint64_t getAttributeValueAsReference(const DWARFUnit *U, 
                                         dwarf::Attribute Attr,
                                         uint64_t FailValue) const;
 

llvm/trunk/include/llvm/MC/MCContext.h

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/Dwarf.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
 #include <tuple>
 #include <vector> // FIXME: Shouldn't be needed.
 
 namespace llvm {
   class MCAsmInfo;
   class MCExpr;
void addMCGenDwarfLabelEntry(const MCGenDwarfLabelEntry &E) {
       MCGenDwarfLabelEntries.push_back(E);
     }
 
     void setDwarfDebugFlags(StringRef S) { DwarfDebugFlags = S; }
     StringRef getDwarfDebugFlags() { return DwarfDebugFlags; }
 
     void setDwarfDebugProducer(StringRef S) { DwarfDebugProducer = S; }
     StringRef getDwarfDebugProducer() { return DwarfDebugProducer; }
-
+    dwarf::DwarfFormat getDwarfFormat() const {
+      // TODO: Support DWARF64
+      return dwarf::DWARF32;
+    }
     void setDwarfVersion(uint16_t v) { DwarfVersion = v; }
     uint16_t getDwarfVersion() const { return DwarfVersion; }
 
     /// @}
 
     char *getSecureLogFile() { return SecureLogFile; }
     raw_fd_ostream *getSecureLog() { return SecureLog.get(); }
     bool getSecureLogUsed() { return SecureLogUsed; }

llvm/trunk/lib/CodeGen/AsmPrinter/DIE.cpp

O << "  "
       << dwarf::FormEncodingString(Data[i].getForm())
       << '\n';
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEAbbrev::dump() { print(dbgs()); }
 
+//===----------------------------------------------------------------------===//
+// DIEAbbrevSet Implementation
+//===----------------------------------------------------------------------===//
+
+DIEAbbrevSet::~DIEAbbrevSet() {
+  for (DIEAbbrev *Abbrev : Abbreviations)
+    Abbrev->~DIEAbbrev();
+}
+
+DIEAbbrev &DIEAbbrevSet::uniqueAbbreviation(DIE &Die) {
+
+  FoldingSetNodeID ID;
+  DIEAbbrev Abbrev = Die.generateAbbrev();
+  Abbrev.Profile(ID);
+
+  void *InsertPos;
+  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 (Alloc) DIEAbbrev(std::move(Abbrev));
+  Abbreviations.push_back(New);
+  New->setNumber(Abbreviations.size());
+  Die.setAbbrevNumber(Abbreviations.size());
+
+  // Store it for lookup.
+  AbbreviationsSet.InsertNode(New, InsertPos);
+  return *New;
+}
+
+void DIEAbbrevSet::Emit(const AsmPrinter *AP, MCSection *Section) const {
+  if (!Abbreviations.empty()) {
+    // Start the debug abbrev section.
+    AP->OutStreamer->SwitchSection(Section);
+    AP->emitDwarfAbbrevs(Abbreviations);
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// DIE Implementation
+//===----------------------------------------------------------------------===//
+
 DIE *DIE::getParent() const {
   return Owner.dyn_cast<DIE*>();
 }
 
 DIEAbbrev DIE::generateAbbrev() const {
   DIEAbbrev Abbrev(Tag, hasChildren());
   for (const DIEValue &V : values())
     Abbrev.AddAttribute(V.getAttribute(), V.getForm());
void DIE::print(raw_ostream &O, unsigned IndentCount) const {
   O << "\n";
 }
 
 LLVM_DUMP_METHOD
 void DIE::dump() {
   print(dbgs());
 }
 
+unsigned DIE::computeOffsetsAndAbbrevs(const AsmPrinter *AP,
+                                       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);
+
+  // 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);
+
+    // 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.
+  setSize(CUOffset - getOffset());
+  return CUOffset;
+}
+
+//===----------------------------------------------------------------------===//
+// DIEUnit Implementation
+//===----------------------------------------------------------------------===//
 DIEUnit::DIEUnit(uint16_t V, uint8_t A, dwarf::Tag UnitTag)
     : Die(UnitTag), Section(nullptr), Offset(0), Length(0), Version(V),
       AddrSize(A)
 {
   Die.Owner = this;
   assert((UnitTag == dwarf::DW_TAG_compile_unit ||
           UnitTag == dwarf::DW_TAG_type_unit ||
           UnitTag == dwarf::DW_TAG_partial_unit) && "expected a unit TAG");

 
 //===----------------------------------------------------------------------===//
 // DIEInteger Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit integer of appropriate size.
 ///
 void DIEInteger::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
-  unsigned Size = ~0U;
   switch (Form) {
   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();
     return;
-  case dwarf::DW_FORM_flag:  LLVM_FALLTHROUGH;
-  case dwarf::DW_FORM_ref1:  LLVM_FALLTHROUGH;
-  case dwarf::DW_FORM_data1: Size = 1; break;
-  case dwarf::DW_FORM_ref2:  LLVM_FALLTHROUGH;
-  case dwarf::DW_FORM_data2: Size = 2; break;
-  case dwarf::DW_FORM_sec_offset: LLVM_FALLTHROUGH;
-  case dwarf::DW_FORM_strp:  LLVM_FALLTHROUGH;
-  case dwarf::DW_FORM_ref4:  LLVM_FALLTHROUGH;
-  case dwarf::DW_FORM_data4: Size = 4; break;
-  case dwarf::DW_FORM_ref8:  LLVM_FALLTHROUGH;
-  case dwarf::DW_FORM_ref_sig8:  LLVM_FALLTHROUGH;
-  case dwarf::DW_FORM_data8: Size = 8; break;
-  case dwarf::DW_FORM_GNU_str_index: Asm->EmitULEB128(Integer); return;
-  case dwarf::DW_FORM_GNU_addr_index: Asm->EmitULEB128(Integer); return;
-  case dwarf::DW_FORM_udata: Asm->EmitULEB128(Integer); return;
-  case dwarf::DW_FORM_sdata: Asm->EmitSLEB128(Integer); return;
+  case dwarf::DW_FORM_flag:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_ref1:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_data1:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_ref2:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_data2:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_strp:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_ref4:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_data4:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_ref8:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_ref_sig8:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_data8:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_GNU_ref_alt:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_GNU_strp_alt:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_line_strp:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_sec_offset:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_strp_sup:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_ref_sup:
+    LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_addr:
-    Size = Asm->getPointerSize();
-    break;
+    LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_ref_addr:
-    Size = SizeOf(Asm, dwarf::DW_FORM_ref_addr);
-    break;
+    Asm->OutStreamer->EmitIntValue(Integer, SizeOf(Asm, Form));
+    return;
+  case dwarf::DW_FORM_GNU_str_index:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_GNU_addr_index:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_ref_udata:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_udata:
+    Asm->EmitULEB128(Integer);
+    return;
+  case dwarf::DW_FORM_sdata:
+    Asm->EmitSLEB128(Integer);
+    return;
   default: llvm_unreachable("DIE Value form not supported yet");
   }
-  Asm->OutStreamer->EmitIntValue(Integer, Size);
 }
 
 /// SizeOf - Determine size of integer value in bytes.
 ///
 unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_flag_present: return 0;
   case dwarf::DW_FORM_flag:  LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_ref1:  LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_data1: return sizeof(int8_t);
   case dwarf::DW_FORM_ref2:  LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_data2: return sizeof(int16_t);
-  case dwarf::DW_FORM_sec_offset: LLVM_FALLTHROUGH;
-  case dwarf::DW_FORM_strp:  LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_ref4:  LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_data4: return sizeof(int32_t);
   case dwarf::DW_FORM_ref8:  LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_ref_sig8:  LLVM_FALLTHROUGH;
   case dwarf::DW_FORM_data8: return sizeof(int64_t);
-  case dwarf::DW_FORM_GNU_str_index: return getULEB128Size(Integer);
-  case dwarf::DW_FORM_GNU_addr_index: return getULEB128Size(Integer);
-  case dwarf::DW_FORM_udata: return getULEB128Size(Integer);
-  case dwarf::DW_FORM_sdata: return getSLEB128Size(Integer);
-  case dwarf::DW_FORM_addr:
-    return AP->getPointerSize();
   case dwarf::DW_FORM_ref_addr:
     if (AP->getDwarfVersion() == 2)
       return AP->getPointerSize();
-    return sizeof(int32_t);
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_strp:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_GNU_ref_alt:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_GNU_strp_alt:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_line_strp:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_sec_offset:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_strp_sup:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_ref_sup:
+    switch (AP->OutStreamer->getContext().getDwarfFormat()) {
+    case dwarf::DWARF32:
+      return 4;
+    case dwarf::DWARF64:
+      return 8;
+    }
+    llvm_unreachable("Invalid DWARF format");
+  case dwarf::DW_FORM_GNU_str_index:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_GNU_addr_index:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_ref_udata:
+    LLVM_FALLTHROUGH;
+  case dwarf::DW_FORM_udata:
+    return getULEB128Size(Integer);
+  case dwarf::DW_FORM_sdata:
+    return getSLEB128Size(Integer);
+  case dwarf::DW_FORM_addr:
+    return AP->getPointerSize();
   default: llvm_unreachable("DIE Value form not supported yet");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEInteger::print(raw_ostream &O) const {
   O << "Int: " << (int64_t)Integer << "  0x";
   O.write_hex(Integer);

 }
 
 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 {
+  if (Form == dwarf::DW_FORM_string) {
+    for (char ch : S)
+      AP->EmitInt8(ch);
+    AP->EmitInt8(0);
+    return;
+  }
+  llvm_unreachable("Expected valid string form");
+}
+
+unsigned DIEInlineString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+  // Emit string bytes + NULL byte.
+  return S.size() + 1;
+}
+
+LLVM_DUMP_METHOD
+void DIEInlineString::print(raw_ostream &O) const {
+  O << "InlineString: " << S.c_str();
+}
+
+//===----------------------------------------------------------------------===//
 // DIEEntry Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit debug information entry offset.
 ///
 void DIEEntry::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 
-  if (Form == dwarf::DW_FORM_ref_addr) {
+  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));
+    return;
+
+  case dwarf::DW_FORM_ref_udata:
+    AP->EmitULEB128(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 (AP->MAI->doesDwarfUseRelocationsAcrossSections()) {
       const DwarfDebug *DD = AP->getDwarfDebug();
       if (DD)
-        assert(!DD->useSplitDwarf() && "TODO: dwo files can't have relocations.");
+        assert(!DD->useSplitDwarf() &&
+               "TODO: dwo files can't have relocations.");
       const DIEUnit *Unit = Entry->getUnit();
       assert(Unit && "CUDie should belong to a CU.");
       MCSection *Section = Unit->getSection();
-      assert(Section && "Must have a section if we are doing relocations");
+      if (Section) {
         const MCSymbol *SectionSym = Section->getBeginSymbol();
-      AP->EmitLabelPlusOffset(SectionSym, Addr, DIEEntry::getRefAddrSize(AP));
-    } else
-      AP->OutStreamer->EmitIntValue(Addr, DIEEntry::getRefAddrSize(AP));
-  } else
-    AP->EmitInt32(Entry->getOffset());
+        AP->EmitLabelPlusOffset(SectionSym, Addr, SizeOf(AP, Form));
+        return;
+      }
+    }
+    AP->OutStreamer->EmitIntValue(Addr, SizeOf(AP, Form));
+    return;
+  }
+  default:
+    llvm_unreachable("Improper form for DIE reference");
+  }
 }
 
-unsigned DIEEntry::getRefAddrSize(const AsmPrinter *AP) {
-  // DWARF4: References that use the attribute form DW_FORM_ref_addr are
-  // specified to be four bytes in the DWARF 32-bit format and eight bytes
-  // in the DWARF 64-bit format, while DWARF Version 2 specifies that such
-  // references have the same size as an address on the target system.
+unsigned DIEEntry::SizeOf(const AsmPrinter *AP, 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->getPointerSize();
-  return sizeof(int32_t);
+    switch (AP->OutStreamer->getContext().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);
 }
 
 //===----------------------------------------------------------------------===//

llvm/trunk/lib/CodeGen/AsmPrinter/DIEHash.cpp

case DIEValue::isInteger: {
     break;
   }
   case DIEValue::isString:
     addULEB128('A');
     addULEB128(Attribute);
     addULEB128(dwarf::DW_FORM_string);
     addString(Value.getDIEString().getString());
     break;
+  case DIEValue::isInlineString:
+    addULEB128('A');
+    addULEB128(Attribute);
+    addULEB128(dwarf::DW_FORM_string);
+    addString(Value.getDIEInlineString().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) {
       addULEB128(Value.getDIEBlock().ComputeSize(AP));

llvm/trunk/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/DIE.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/Allocator.h"
 #include <memory>
-#include <vector>
 
 namespace llvm {
 class AsmPrinter;
 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.
-  FoldingSet<DIEAbbrev> AbbreviationsSet;
-
-  // A list of all the unique abbreviations in use.
-  std::vector<DIEAbbrev *> Abbreviations;
+  DIEAbbrevSet Abbrevs;
 
   // 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();
-
   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.
   void computeSizeAndOffsets();
 
   /// \brief Compute the size and offset of all the DIEs in the given unit.
   /// \returns The size of the root DIE.
   unsigned computeSizeAndOffsetsForUnit(DwarfUnit *TheU);
 
-  /// Define a unique number for the abbreviation.
-  ///
-  /// Compute the abbreviation for \c Die, look up its unique number, and
-  /// return a reference to it in the uniquing table.
-  DIEAbbrev &assignAbbrevNumber(DIE &Die);
-
   /// \brief Add a unit to the list of CUs.
   void addUnit(std::unique_ptr<DwarfCompileUnit> U);
 
   /// \brief Emit all of the units to the section listed with the given
   /// abbreviation section.
   void emitUnits(bool UseOffsets);
 
   /// \brief Emit the given unit to its section.

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfFile.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 namespace llvm {
 DwarfFile::DwarfFile(AsmPrinter *AP, StringRef Pref, BumpPtrAllocator &DA)
-    : Asm(AP), StrPool(DA, *Asm, Pref) {}
-
-DwarfFile::~DwarfFile() {
-  for (DIEAbbrev *Abbrev : Abbreviations)
-    Abbrev->~DIEAbbrev();
-}
-
-// Define a unique number for the abbreviation.
-//
-DIEAbbrev &DwarfFile::assignAbbrevNumber(DIE &Die) {
-  FoldingSetNodeID ID;
-  DIEAbbrev Abbrev = Die.generateAbbrev();
-  Abbrev.Profile(ID);
-
-  void *InsertPos;
-  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());
-
-  // Store it for lookup.
-  AbbreviationsSet.InsertNode(New, InsertPos);
-  return *New;
-}
+    : Asm(AP), Abbrevs(AbbrevAllocator), StrPool(DA, *Asm, Pref) {}
 
 void DwarfFile::addUnit(std::unique_ptr<DwarfCompileUnit> U) {
   CUs.push_back(std::move(U));
 }
 
 // Emit the various dwarf units to the unit section USection with
 // the abbreviations going into ASection.
 void DwarfFile::emitUnits(bool UseOffsets) {
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);
-
-  // 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);
-
-  // Size the DIE children if any.
-  if (Die.hasChildren()) {
-    (void)Abbrev;
-    assert(Abbrev.hasChildren() && "Children flag not set");
-
-    for (auto &Child : Die.children())
-      Offset = computeSizeAndOffset(Child, Offset);
-
-    // End of children marker.
-    Offset += sizeof(int8_t);
-  }
+  return Die.computeOffsetsAndAbbrevs(Asm, Abbrevs, 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()) {
-    // Start the debug abbrev section.
-    Asm->OutStreamer->SwitchSection(Section);
-    Asm->emitDwarfAbbrevs(Abbreviations);
-  }
-}
+void DwarfFile::emitAbbrevs(MCSection *Section) { Abbrevs.Emit(Asm, Section); }
 
 // Emit strings into a string section.
 void DwarfFile::emitStrings(MCSection *StrSection, MCSection *OffsetSection) {
   StrPool.emit(*Asm, StrSection, OffsetSection);
 }
 
 bool DwarfFile::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];

llvm/trunk/lib/CodeGen/CMakeLists.txt

add_llvm_library(LLVMCodeGen
   CodeGen.cpp
   CodeGenPrepare.cpp
   CountingFunctionInserter.cpp
   CriticalAntiDepBreaker.cpp
   DeadMachineInstructionElim.cpp
   DetectDeadLanes.cpp
   DFAPacketizer.cpp
   DwarfEHPrepare.cpp
+  DwarfGenerator.cpp
   EarlyIfConversion.cpp
   EdgeBundles.cpp
   ExecutionDepsFix.cpp
   ExpandISelPseudos.cpp
   ExpandPostRAPseudos.cpp
   FaultMaps.cpp
   FuncletLayout.cpp
   GCMetadata.cpp

llvm/trunk/lib/CodeGen/DwarfGenerator.h

+//===--- lib/CodeGen/DwarfGenerator.h ---------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// A file that can generate DWARF debug info for unit tests.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFGENERATOR_H
+#define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFGENERATOR_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/CodeGen/DIE.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
+#include "llvm/Support/Error.h"
+
+#include <memory>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace llvm {
+
+class AsmPrinter;
+class DIE;
+class DIEAbbrev;
+class DwarfStringPool;
+class MCAsmBackend;
+class MCAsmInfo;
+class MCCodeEmitter;
+class MCContext;
+struct MCDwarfLineTableParams;
+class MCInstrInfo;
+class MCObjectFileInfo;
+class MCRegisterInfo;
+class MCStreamer;
+class MCSubtargetInfo;
+class raw_fd_ostream;
+class TargetMachine;
+class Triple;
+
+namespace dwarfgen {
+
+class Generator;
+class CompileUnit;
+
+/// A DWARF debug information entry class used to generate DWARF DIEs.
+///
+/// This class is used to quickly generate DWARF debug information by creating
+/// child DIEs or adding attributes to the current DIE. Instances of this class
+/// are created from the compile unit (dwarfgen::CompileUnit::getUnitDIE()) or
+/// by calling dwarfgen::DIE::addChild(...) and using the returned DIE object.
+class DIE {
+  dwarfgen::CompileUnit *CU;
+  llvm::DIE *Die;
+
+protected:
+  friend class Generator;
+  friend class CompileUnit;
+
+  DIE(CompileUnit *U = nullptr, llvm::DIE *D = nullptr) : CU(U), Die(D) {}
+
+  /// Called with a compile/type unit relative offset prior to generating the
+  /// DWARF debug info.
+  ///
+  /// \param CUOffset the compile/type unit relative offset where the
+  /// abbreviation code for this DIE will be encoded.
+  unsigned computeSizeAndOffsets(unsigned CUOffset);
+
+public:
+  /// Add an attribute value that has no value.
+  ///
+  /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
+  /// represents a user defined DWARF attribute.
+  /// \param Form the dwarf::Form to use when encoding the attribute. This is
+  /// only used with the DW_FORM_flag_present form encoding.
+  void addAttribute(uint16_t Attr, dwarf::Form Form);
+
+  /// Add an attribute value to be encoded as a DIEInteger
+  ///
+  /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
+  /// represents a user defined DWARF attribute.
+  /// \param Form the dwarf::Form to use when encoding the attribute.
+  /// \param U the unsigned integer to encode.
+  void addAttribute(uint16_t Attr, dwarf::Form Form, uint64_t U);
+
+  /// Add an attribute value to be encoded as a DIEString or DIEInlinedString.
+  ///
+  /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
+  /// represents a user defined DWARF attribute.
+  /// \param Form the dwarf::Form to use when encoding the attribute. The form
+  /// must be one of DW_FORM_strp or DW_FORM_string.
+  /// \param String the string to encode.
+  void addAttribute(uint16_t Attr, dwarf::Form Form, StringRef String);
+
+  /// Add an attribute value to be encoded as a DIEEntry.
+  ///
+  /// DIEEntry attributes refer to other llvm::DIE objects that have been
+  /// created.
+  ///
+  /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
+  /// represents a user defined DWARF attribute.
+  /// \param Form the dwarf::Form to use when encoding the attribute. The form
+  /// must be one of DW_FORM_strp or DW_FORM_string.
+  /// \param RefDie the DIE that this attriute refers to.
+  void addAttribute(uint16_t Attr, dwarf::Form Form, dwarfgen::DIE &RefDie);
+
+  /// Add an attribute value to be encoded as a DIEBlock.
+  ///
+  /// DIEBlock attributes refers to binary data that is stored as the
+  /// attribute's value.
+  ///
+  /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
+  /// represents a user defined DWARF attribute.
+  /// \param Form the dwarf::Form to use when encoding the attribute. The form
+  /// must be one of DW_FORM_strp or DW_FORM_string.
+  /// \param P a pointer to the data to store as the attribute value.
+  /// \param S the size in bytes of the data pointed to by \param P.
+  void addAttribute(uint16_t Attr, dwarf::Form Form, const void *P, size_t S);
+
+  /// Add a new child to this DIE object.
+  ///
+  /// \param Tag the dwarf::Tag to assing to the llvm::DIE object.
+  /// \returns the newly created DIE object that is now a child owned by this
+  /// object.
+  dwarfgen::DIE addChild(dwarf::Tag Tag);
+};
+
+/// A DWARF compile unit used to generate DWARF compile/type units.
+///
+/// Instances of these classes are created by instances of the Generator
+/// class. All information required to generate a DWARF compile unit is
+/// contained inside this class.
+class CompileUnit {
+  Generator &DG;
+  DIEUnit DU;
+
+public:
+  CompileUnit(Generator &D, uint16_t V, uint8_t A)
+      : DG(D), DU(V, A, dwarf::DW_TAG_compile_unit) {}
+  DIE getUnitDIE();
+  Generator &getGenerator() { return DG; }
+  uint64_t getOffset() const { return DU.getDebugSectionOffset(); }
+  uint64_t getLength() const { return DU.getLength(); }
+  uint16_t getVersion() const { return DU.getDwarfVersion(); }
+  uint16_t getAddressSize() const { return DU.getAddressSize(); }
+  void setOffset(uint64_t Offset) { DU.setDebugSectionOffset(Offset); }
+  void setLength(uint64_t Length) { DU.setLength(Length); }
+};
+
+/// A DWARF generator.
+///
+/// Generate DWARF for unit tests by creating any instance of this class and
+/// calling Generator::addCompileUnit(), and then getting the dwarfgen::DIE from
+/// the returned compile unit and adding attributes and children to each DIE.
+class Generator {
+  std::unique_ptr<MCRegisterInfo> MRI;
+  std::unique_ptr<MCAsmInfo> MAI;
+  std::unique_ptr<MCObjectFileInfo> MOFI;
+  std::unique_ptr<MCContext> MC;
+  MCAsmBackend *MAB; // Owned by MCStreamer
+  std::unique_ptr<MCInstrInfo> MII;
+  std::unique_ptr<MCSubtargetInfo> MSTI;
+  MCCodeEmitter *MCE; // Owned by MCStreamer
+  MCStreamer *MS;     // Owned by AsmPrinter
+  std::unique_ptr<TargetMachine> TM;
+  std::unique_ptr<AsmPrinter> Asm;
+  std::unique_ptr<DwarfStringPool> StringPool;
+  std::vector<std::unique_ptr<CompileUnit>> CompileUnits;
+  BumpPtrAllocator Allocator;
+  DIEAbbrevSet Abbreviations;
+
+  SmallString<4096> FileBytes;
+  /// The stream we use to generate the DWARF into as an ELF file.
+  std::unique_ptr<raw_svector_ostream> Stream;
+  /// The DWARF version to generate.
+  uint16_t Version;
+
+  /// Private constructor, call Generator::Create(...) to get a DWARF generator
+  /// expected.
+  Generator();
+
+  /// Create the streamer and setup the output buffer.
+  llvm::Error init(Triple TheTriple, uint16_t DwarfVersion);
+
+public:
+  /// Create a DWARF generator or get an appropriate error.
+  ///
+  /// \param TheTriple the triple to use when creating any required support
+  /// classes needed to emit the DWARF.
+  /// \param DwarfVersion the version of DWARF to emit.
+  ///
+  /// \returns a llvm::Expected that either contains a unique_ptr to a Generator
+  /// or a llvm::Error.
+  static llvm::Expected<std::unique_ptr<Generator>>
+  create(Triple TheTriple, uint16_t DwarfVersion);
+
+  ~Generator();
+
+  /// Generate all DWARF sections and return a memory buffer that
+  /// contains an ELF file that contains the DWARF.
+  StringRef generate();
+
+  /// Add a compile unit to be generated.
+  ///
+  /// \returns a dwarfgen::CompileUnit that can be used to retrieve the compile
+  /// unit dwarfgen::DIE that can be used to add attributes and add child DIE
+  /// objedts to.
+  dwarfgen::CompileUnit &addCompileUnit();
+
+  BumpPtrAllocator &getAllocator() { return Allocator; }
+  AsmPrinter *getAsmPrinter() const { return Asm.get(); }
+  DIEAbbrevSet &getAbbrevSet() { return Abbreviations; }
+  DwarfStringPool &getStringPool() { return *StringPool; }
+
+  /// Save the generated DWARF file to disk.
+  ///
+  /// \param Path the path to save the ELF file to.
+  bool saveFile(StringRef Path);
+};
+
+} // end namespace dwarfgen
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFGENERATOR_H

llvm/trunk/lib/CodeGen/DwarfGenerator.cpp

+//===--- lib/CodeGen/DwarfGenerator.cpp -------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DwarfGenerator.h"
+#include "AsmPrinter/DwarfStringPool.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/CodeGen/AsmPrinter.h"
+#include "llvm/CodeGen/DIE.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
+#include "llvm/IR/LegacyPassManagers.h"
+#include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCCodeEmitter.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCDwarf.h"
+#include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCObjectFileInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/MCTargetOptionsCommandFlags.h"
+#include "llvm/PassAnalysisSupport.h"
+#include "llvm/Support/Dwarf.h"
+#include "llvm/Support/LEB128.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetOptions.h"
+
+using namespace llvm;
+using namespace dwarf;
+
+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);
+}
+
+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,
+                                 StringRef String) {
+  auto &DG = CU->getGenerator();
+  if (Form == DW_FORM_string) {
+    Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
+                  new (DG.getAllocator()) DIEInlineString(String));
+  } else {
+    Die->addValue(
+        DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
+        DIEString(DG.getStringPool().getEntry(*DG.getAsmPrinter(), String)));
+  }
+}
+
+void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form,
+                                 dwarfgen::DIE &RefDie) {
+  auto &DG = CU->getGenerator();
+  Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
+                DIEEntry(*RefDie.Die));
+}
+
+void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form, const void *P,
+                                 size_t S) {
+  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(((uint8_t *)P)[I]));
+
+  Block->ComputeSize(DG.getAsmPrinter());
+  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,
+                DIEInteger(1));
+}
+
+dwarfgen::DIE dwarfgen::DIE::addChild(dwarf::Tag Tag) {
+  auto &DG = CU->getGenerator();
+  return dwarfgen::DIE(CU,
+                       &Die->addChild(llvm::DIE::get(DG.getAllocator(), Tag)));
+}
+
+dwarfgen::DIE dwarfgen::CompileUnit::getUnitDIE() {
+  return dwarfgen::DIE(this, &DU.getUnitDie());
+}
+
+//===----------------------------------------------------------------------===//
+/// dwarfgen::Generator implementation.
+//===----------------------------------------------------------------------===//
+
+dwarfgen::Generator::Generator() : Abbreviations(Allocator) {}
+dwarfgen::Generator::~Generator() = default;
+
+llvm::Expected<std::unique_ptr<dwarfgen::Generator>>
+dwarfgen::Generator::create(Triple TheTriple, uint16_t DwarfVersion) {
+  std::unique_ptr<dwarfgen::Generator> GenUP(new dwarfgen::Generator());
+  llvm::Error error = GenUP->init(TheTriple, DwarfVersion);
+  if (error)
+    return Expected<std::unique_ptr<dwarfgen::Generator>>(std::move(error));
+  return Expected<std::unique_ptr<dwarfgen::Generator>>(std::move(GenUP));
+}
+
+llvm::Error dwarfgen::Generator::init(Triple TheTriple, uint16_t V) {
+  Version = V;
+  std::string ErrorStr;
+  std::string TripleName;
+
+  // Get the target.
+  const Target *TheTarget =
+      TargetRegistry::lookupTarget(TripleName, TheTriple, ErrorStr);
+  if (!TheTarget)
+    return make_error<StringError>(ErrorStr, inconvertibleErrorCode());
+
+  TripleName = TheTriple.getTriple();
+
+  // Create all the MC Objects.
+  MRI.reset(TheTarget->createMCRegInfo(TripleName));
+  if (!MRI)
+    return make_error<StringError>(Twine("no register info for target ") +
+                                       TripleName,
+                                   inconvertibleErrorCode());
+
+  MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName));
+  if (!MAI)
+    return make_error<StringError>("no asm info for target " + TripleName,
+                                   inconvertibleErrorCode());
+
+  MOFI.reset(new MCObjectFileInfo);
+  MC.reset(new MCContext(MAI.get(), MRI.get(), MOFI.get()));
+  MOFI->InitMCObjectFileInfo(TheTriple, /*PIC*/ false, CodeModel::Default, *MC);
+
+  MCTargetOptions Options;
+  MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, "", Options);
+  if (!MAB)
+    return make_error<StringError>("no asm backend for target " + TripleName,
+                                   inconvertibleErrorCode());
+
+  MII.reset(TheTarget->createMCInstrInfo());
+  if (!MII)
+    return make_error<StringError>("no instr info info for target " +
+                                       TripleName,
+                                   inconvertibleErrorCode());
+
+  MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+  if (!MSTI)
+    return make_error<StringError>("no subtarget info for target " + TripleName,
+                                   inconvertibleErrorCode());
+
+  MCE = TheTarget->createMCCodeEmitter(*MII, *MRI, *MC);
+  if (!MCE)
+    return make_error<StringError>("no code emitter for target " + TripleName,
+                                   inconvertibleErrorCode());
+
+  Stream = make_unique<raw_svector_ostream>(FileBytes);
+
+  MCTargetOptions MCOptions = InitMCTargetOptionsFromFlags();
+  MS = TheTarget->createMCObjectStreamer(
+      TheTriple, *MC, *MAB, *Stream, MCE, *MSTI, MCOptions.MCRelaxAll,
+      MCOptions.MCIncrementalLinkerCompatible,
+      /*DWARFMustBeAtTheEnd*/ false);
+  if (!MS)
+    return make_error<StringError>("no object streamer for target " +
+                                       TripleName,
+                                   inconvertibleErrorCode());
+
+  // Finally create the AsmPrinter we'll use to emit the DIEs.
+  TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
+                                          None));
+  if (!TM)
+    return make_error<StringError>("no target machine for target " + TripleName,
+                                   inconvertibleErrorCode());
+
+  Asm.reset(TheTarget->createAsmPrinter(*TM, std::unique_ptr<MCStreamer>(MS)));
+  if (!Asm)
+    return make_error<StringError>("no asm printer for target " + TripleName,
+                                   inconvertibleErrorCode());
+
+  // Set the DWARF version correctly on all classes that we use.
+  MC->setDwarfVersion(Version);
+  Asm->setDwarfVersion(Version);
+
+  StringPool.reset(new DwarfStringPool(Allocator, *Asm, StringRef()));
+
+  return Error::success();
+}
+
+StringRef dwarfgen::Generator::generate() {
+  // Offset from the first CU in the debug info section is 0 initially.
+  unsigned SecOffset = 0;
+
+  // Iterate over each compile unit and set the size and offsets for each
+  // DIE within each compile unit. All offsets are CU relative.
+  for (auto &CU : CompileUnits) {
+    // Set the absolute .debug_info offset for this compile unit.
+    CU->setOffset(SecOffset);
+    // The DIEs contain compile unit relative offsets.
+    unsigned CUOffset = 11;
+    CUOffset = CU->getUnitDIE().computeSizeAndOffsets(CUOffset);
+    // Update our absolute .debug_info offset.
+    SecOffset += CUOffset;
+    CU->setLength(CUOffset - 4);
+  }
+  Abbreviations.Emit(Asm.get(), MOFI->getDwarfAbbrevSection());
+  StringPool->emit(*Asm, MOFI->getDwarfStrSection());
+  MS->SwitchSection(MOFI->getDwarfInfoSection());
+  for (auto &CU : CompileUnits) {
+    uint16_t Version = CU->getVersion();
+    auto Length = CU->getLength();
+    MC->setDwarfVersion(Version);
+    assert(Length != -1U);
+    Asm->EmitInt32(Length);
+    Asm->EmitInt16(Version);
+    Asm->EmitInt32(0);
+    Asm->EmitInt8(CU->getAddressSize());
+    Asm->emitDwarfDIE(*CU->getUnitDIE().Die);
+  }
+
+  MS->Finish();
+  if (FileBytes.empty())
+    return StringRef();
+  return StringRef(FileBytes.data(), FileBytes.size());
+}
+
+bool dwarfgen::Generator::saveFile(StringRef Path) {
+  if (FileBytes.empty())
+    return false;
+  std::error_code EC;
+  raw_fd_ostream Strm(Path, EC, sys::fs::F_None);
+  if (EC)
+    return false;
+  Strm.write(FileBytes.data(), FileBytes.size());
+  Strm.close();
+  return true;
+}
+
+dwarfgen::CompileUnit &dwarfgen::Generator::addCompileUnit() {
+  CompileUnits.push_back(std::unique_ptr<CompileUnit>(
+      new CompileUnit(*this, Version, Asm->getPointerSize())));
+  return *CompileUnits.back();
+}

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp

uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsAddress(
     uint64_t FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
   Optional<uint64_t> Result = FormValue.getAsAddress();
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
+int64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsSignedConstant(
+    const DWARFUnit *U, dwarf::Attribute Attr, int64_t FailValue) const {
+  DWARFFormValue FormValue;
+  if (!getAttributeValue(U, Attr, FormValue))
+    return FailValue;
+  Optional<int64_t> Result = FormValue.getAsSignedConstant();
+  return Result.hasValue() ? Result.getValue() : FailValue;
+}
+
 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsUnsignedConstant(
     const DWARFUnit *U, dwarf::Attribute Attr, 
     uint64_t FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
   Optional<uint64_t> Result = FormValue.getAsUnsignedConstant();
   return Result.hasValue() ? Result.getValue() : FailValue;

llvm/trunk/unittests/DebugInfo/DWARF/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
+  ${LLVM_TARGETS_TO_BUILD}
   DebugInfoDWARF
+  CodeGen
+  Core
+  MC
+  MIRParser
+  Support
+  Target
   )
 
 set(DebugInfoSources
+  DWARFDebugInfoTest.cpp
   DWARFFormValueTest.cpp
   )
 
 add_llvm_unittest(DebugInfoDWARFTests
   ${DebugInfoSources}
   )

llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

+//===- llvm/unittest/DebugInfo/DWARFFormValueTest.cpp ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../lib/CodeGen/DwarfGenerator.h"
+#include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
+#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
+#include "llvm/Support/Dwarf.h"
+#include "llvm/Support/Host.h"
+#include "llvm/Support/TargetSelect.h"
+#include "gtest/gtest.h"
+#include <climits>
+
+using namespace llvm;
+using namespace dwarf;
+
+namespace {
+
+void initLLVMIfNeeded() {
+  static bool gInitialized = false;
+  if (!gInitialized) {
+    gInitialized = true;
+    InitializeAllTargets();
+    InitializeAllTargetMCs();
+    InitializeAllAsmPrinters();
+    InitializeAllAsmParsers();
+  }
+}
+
+Triple getHostTripleForAddrSize(uint8_t AddrSize) {
+  Triple PT(Triple::normalize(LLVM_HOST_TRIPLE));
+
+  if (AddrSize == 8 && PT.isArch32Bit())
+    return PT.get64BitArchVariant();
+  if (AddrSize == 4 && PT.isArch64Bit())
+    return PT.get32BitArchVariant();
+  return PT;
+}
+
+/// Take any llvm::Expected and check and handle any errors.
+///
+/// \param Expected a llvm::Excepted instance to check.
+/// \returns true if there were errors, false otherwise.
+template <typename T>
+static bool HandleExpectedError(T &Expected) {
+  if (!Expected)
+    return false;
+  std::string ErrorMsg;
+  handleAllErrors(Expected.takeError(), [&](const llvm::ErrorInfoBase &EI) {
+    ErrorMsg = EI.message();
+  });
+  ::testing::AssertionFailure() << "error: " << ErrorMsg;
+  return true;
+}
+
+template <uint16_t Version, class AddrType, class RefAddrType>
+void TestAllForms() {
+  // Test that we can decode all DW_FORM values correctly.
+
+  const uint8_t AddrSize = sizeof(AddrType);
+  const AddrType AddrValue = (AddrType)0x0123456789abcdefULL;
+  const uint8_t BlockData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
+  const uint32_t BlockSize = sizeof(BlockData);
+  const RefAddrType RefAddr = 0x12345678;
+  const uint8_t Data1 = 0x01U;
+  const uint16_t Data2 = 0x2345U;
+  const uint32_t Data4 = 0x6789abcdU;
+  const uint64_t Data8 = 0x0011223344556677ULL;
+  const uint64_t Data8_2 = 0xAABBCCDDEEFF0011ULL;
+  const int64_t SData = INT64_MIN;
+  const uint64_t UData[] = {UINT64_MAX - 1, UINT64_MAX - 2, UINT64_MAX - 3,
+                            UINT64_MAX - 4, UINT64_MAX - 5, UINT64_MAX - 6,
+                            UINT64_MAX - 7, UINT64_MAX - 8, UINT64_MAX - 9};
+#define UDATA_1 18446744073709551614ULL
+  const uint32_t Dwarf32Values[] = {1, 2, 3, 4, 5, 6, 7, 8};
+  const char *StringValue = "Hello";
+  const char *StrpValue = "World";
+  initLLVMIfNeeded();
+  Triple Triple = getHostTripleForAddrSize(AddrSize);
+  auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
+  if (HandleExpectedError(ExpectedDG))
+    return;
+  dwarfgen::Generator *DG = ExpectedDG.get().get();
+  dwarfgen::CompileUnit &CU = DG->addCompileUnit();
+  dwarfgen::DIE CUDie = CU.getUnitDIE();
+  uint16_t Attr = DW_AT_lo_user;
+
+  //----------------------------------------------------------------------
+  // Test address forms
+  //----------------------------------------------------------------------
+  const auto Attr_DW_FORM_addr = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_addr, DW_FORM_addr, AddrValue);
+
+  //----------------------------------------------------------------------
+  // Test block forms
+  //----------------------------------------------------------------------
+  const auto Attr_DW_FORM_block = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_block, DW_FORM_block, BlockData, BlockSize);
+
+  const auto Attr_DW_FORM_block1 = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_block1, DW_FORM_block1, BlockData, BlockSize);
+
+  const auto Attr_DW_FORM_block2 = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_block2, DW_FORM_block2, BlockData, BlockSize);
+
+  const auto Attr_DW_FORM_block4 = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_block4, DW_FORM_block4, BlockData, BlockSize);
+
+  //----------------------------------------------------------------------
+  // Test data forms
+  //----------------------------------------------------------------------
+  const auto Attr_DW_FORM_data1 = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_data1, DW_FORM_data1, Data1);
+
+  const auto Attr_DW_FORM_data2 = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_data2, DW_FORM_data2, Data2);
+
+  const auto Attr_DW_FORM_data4 = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_data4, DW_FORM_data4, Data4);
+
+  const auto Attr_DW_FORM_data8 = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_data8, DW_FORM_data8, Data8);
+
+  //----------------------------------------------------------------------
+  // Test string forms
+  //----------------------------------------------------------------------
+  const auto Attr_DW_FORM_string = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_string, DW_FORM_string, StringValue);
+
+  const auto Attr_DW_FORM_strp = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_strp, DW_FORM_strp, StrpValue);
+
+  //----------------------------------------------------------------------
+  // Test reference forms
+  //----------------------------------------------------------------------
+  const auto Attr_DW_FORM_ref_addr = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_ref_addr, DW_FORM_ref_addr, RefAddr);
+
+  const auto Attr_DW_FORM_ref1 = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_ref1, DW_FORM_ref1, Data1);
+
+  const auto Attr_DW_FORM_ref2 = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_ref2, DW_FORM_ref2, Data2);
+
+  const auto Attr_DW_FORM_ref4 = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_ref4, DW_FORM_ref4, Data4);
+
+  const auto Attr_DW_FORM_ref8 = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_ref8, DW_FORM_ref8, Data8);
+
+  const auto Attr_DW_FORM_ref_sig8 = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_ref_sig8, DW_FORM_ref_sig8, Data8_2);
+
+  const auto Attr_DW_FORM_ref_udata = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_ref_udata, DW_FORM_ref_udata, UData[0]);
+
+  //----------------------------------------------------------------------
+  // Test flag forms
+  //----------------------------------------------------------------------
+  const auto Attr_DW_FORM_flag_true = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_flag_true, DW_FORM_flag, true);
+
+  const auto Attr_DW_FORM_flag_false = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_flag_false, DW_FORM_flag, false);
+
+  const auto Attr_DW_FORM_flag_present = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_flag_present, DW_FORM_flag_present);
+
+  //----------------------------------------------------------------------
+  // Test SLEB128 based forms
+  //----------------------------------------------------------------------
+  const auto Attr_DW_FORM_sdata = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_sdata, DW_FORM_sdata, SData);
+
+  //----------------------------------------------------------------------
+  // Test ULEB128 based forms
+  //----------------------------------------------------------------------
+  const auto Attr_DW_FORM_udata = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_udata, DW_FORM_udata, UData[0]);
+
+  //----------------------------------------------------------------------
+  // Test DWARF32/DWARF64 forms
+  //----------------------------------------------------------------------
+  const auto Attr_DW_FORM_GNU_ref_alt = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_GNU_ref_alt, DW_FORM_GNU_ref_alt,
+                     Dwarf32Values[0]);
+
+  const auto Attr_DW_FORM_sec_offset = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_DW_FORM_sec_offset, DW_FORM_sec_offset,
+                     Dwarf32Values[1]);
+
+  //----------------------------------------------------------------------
+  // Add an address at the end to make sure we can decode this value
+  //----------------------------------------------------------------------
+  const auto Attr_Last = static_cast<dwarf::Attribute>(Attr++);
+  CUDie.addAttribute(Attr_Last, DW_FORM_addr, AddrValue);
+
+  //----------------------------------------------------------------------
+  // Generate the DWARF
+  //----------------------------------------------------------------------
+  StringRef FileBytes = DG->generate();
+  MemoryBufferRef FileBuffer(FileBytes, "dwarf");
+  auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
+  EXPECT_TRUE((bool)Obj);
+  DWARFContextInMemory DwarfContext(*Obj.get());
+  uint32_t NumCUs = DwarfContext.getNumCompileUnits();
+  EXPECT_EQ(NumCUs, 1u);
+  DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0);
+  auto DiePtr = U->getUnitDIE(false);
+  EXPECT_TRUE(DiePtr != nullptr);
+
+  //----------------------------------------------------------------------
+  // Test address forms
+  //----------------------------------------------------------------------
+  EXPECT_EQ(DiePtr->getAttributeValueAsAddress(U, Attr_DW_FORM_addr, 0),
+            AddrValue);
+
+  //----------------------------------------------------------------------
+  // Test block forms
+  //----------------------------------------------------------------------
+  DWARFFormValue FormValue;
+  ArrayRef<uint8_t> ExtractedBlockData;
+  Optional<ArrayRef<uint8_t>> BlockDataOpt;
+
+  EXPECT_TRUE(DiePtr->getAttributeValue(U, Attr_DW_FORM_block, FormValue));
+  BlockDataOpt = FormValue.getAsBlock();
+  EXPECT_TRUE(BlockDataOpt.hasValue());
+  ExtractedBlockData = BlockDataOpt.getValue();
+  EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
+  EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
+
+  EXPECT_TRUE(DiePtr->getAttributeValue(U, Attr_DW_FORM_block1, FormValue));
+  BlockDataOpt = FormValue.getAsBlock();
+  EXPECT_TRUE(BlockDataOpt.hasValue());
+  ExtractedBlockData = BlockDataOpt.getValue();
+  EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
+  EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
+
+  EXPECT_TRUE(DiePtr->getAttributeValue(U, Attr_DW_FORM_block2, FormValue));
+  BlockDataOpt = FormValue.getAsBlock();
+  EXPECT_TRUE(BlockDataOpt.hasValue());
+  ExtractedBlockData = BlockDataOpt.getValue();
+  EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
+  EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
+
+  EXPECT_TRUE(DiePtr->getAttributeValue(U, Attr_DW_FORM_block4, FormValue));
+  BlockDataOpt = FormValue.getAsBlock();
+  EXPECT_TRUE(BlockDataOpt.hasValue());
+  ExtractedBlockData = BlockDataOpt.getValue();
+  EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
+  EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
+
+  //----------------------------------------------------------------------
+  // Test data forms
+  //----------------------------------------------------------------------
+  EXPECT_EQ(
+      DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_data1, 0),
+      Data1);
+  EXPECT_EQ(
+      DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_data2, 0),
+      Data2);
+  EXPECT_EQ(
+      DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_data4, 0),
+      Data4);
+  EXPECT_EQ(
+      DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_data8, 0),
+      Data8);
+
+  //----------------------------------------------------------------------
+  // Test string forms
+  //----------------------------------------------------------------------
+  const char *ExtractedStringValue =
+      DiePtr->getAttributeValueAsString(U, Attr_DW_FORM_string, nullptr);
+  EXPECT_TRUE(ExtractedStringValue != nullptr);
+  EXPECT_TRUE(strcmp(StringValue, ExtractedStringValue) == 0);
+
+  const char *ExtractedStrpValue =
+      DiePtr->getAttributeValueAsString(U, Attr_DW_FORM_strp, nullptr);
+  EXPECT_TRUE(ExtractedStrpValue != nullptr);
+  EXPECT_TRUE(strcmp(StrpValue, ExtractedStrpValue) == 0);
+
+  //----------------------------------------------------------------------
+  // Test reference forms
+  //----------------------------------------------------------------------
+  EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref_addr, 0),
+            RefAddr);
+  EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref1, 0),
+            Data1);
+  EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref2, 0),
+            Data2);
+  EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref4, 0),
+            Data4);
+  EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref8, 0),
+            Data8);
+  EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref_sig8, 0),
+            Data8_2);
+  EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref_udata, 0),
+            UData[0]);
+
+  //----------------------------------------------------------------------
+  // Test flag forms
+  //----------------------------------------------------------------------
+  EXPECT_EQ(DiePtr->getAttributeValueAsUnsignedConstant(
+                U, Attr_DW_FORM_flag_true, 0ULL),
+            1ULL);
+  EXPECT_EQ(DiePtr->getAttributeValueAsUnsignedConstant(
+                U, Attr_DW_FORM_flag_false, 1ULL),
+            0ULL);
+  EXPECT_EQ(DiePtr->getAttributeValueAsUnsignedConstant(
+                U, Attr_DW_FORM_flag_present, 0ULL),
+            1ULL);
+
+  // TODO: test Attr_DW_FORM_implicit_const extraction
+
+  //----------------------------------------------------------------------
+  // Test SLEB128 based forms
+  //----------------------------------------------------------------------
+  EXPECT_EQ(DiePtr->getAttributeValueAsSignedConstant(U, Attr_DW_FORM_sdata, 0),
+            SData);
+
+  //----------------------------------------------------------------------
+  // Test ULEB128 based forms
+  //----------------------------------------------------------------------
+  EXPECT_EQ(
+      DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_udata, 0),
+      UData[0]);
+
+  //----------------------------------------------------------------------
+  // Test DWARF32/DWARF64 forms
+  //----------------------------------------------------------------------
+  EXPECT_EQ(
+      DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_GNU_ref_alt, 0),
+      Dwarf32Values[0]);
+  EXPECT_EQ(
+      DiePtr->getAttributeValueAsSectionOffset(U, Attr_DW_FORM_sec_offset, 0),
+      Dwarf32Values[1]);
+
+  //----------------------------------------------------------------------
+  // Add an address at the end to make sure we can decode this value
+  //----------------------------------------------------------------------
+  EXPECT_EQ(DiePtr->getAttributeValueAsAddress(U, Attr_Last, 0), AddrValue);
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version2Addr4AllForms) {
+  // Test that we can decode all forms for DWARF32, version 2, with 4 byte
+  // addresses.
+  typedef uint32_t AddrType;
+  // DW_FORM_ref_addr are the same as the address type in DWARF32 version 2.
+  typedef AddrType RefAddrType;
+  TestAllForms<2, AddrType, RefAddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version2Addr8AllForms) {
+  // Test that we can decode all forms for DWARF32, version 2, with 4 byte
+  // addresses.
+  typedef uint64_t AddrType;
+  // DW_FORM_ref_addr are the same as the address type in DWARF32 version 2.
+  typedef AddrType RefAddrType;
+  TestAllForms<2, AddrType, RefAddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version3Addr4AllForms) {
+  // Test that we can decode all forms for DWARF32, version 3, with 4 byte
+  // addresses.
+  typedef uint32_t AddrType;
+  // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later.
+  typedef uint32_t RefAddrType;
+  TestAllForms<3, AddrType, RefAddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version3Addr8AllForms) {
+  // Test that we can decode all forms for DWARF32, version 3, with 8 byte
+  // addresses.
+  typedef uint64_t AddrType;
+  // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
+  typedef uint32_t RefAddrType;
+  TestAllForms<3, AddrType, RefAddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version4Addr4AllForms) {
+  // Test that we can decode all forms for DWARF32, version 4, with 4 byte
+  // addresses.
+  typedef uint32_t AddrType;
+  // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
+  typedef uint32_t RefAddrType;
+  TestAllForms<4, AddrType, RefAddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version4Addr8AllForms) {
+  // Test that we can decode all forms for DWARF32, version 4, with 8 byte
+  // addresses.
+  typedef uint64_t AddrType;
+  // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
+  typedef uint32_t RefAddrType;
+  TestAllForms<4, AddrType, RefAddrType>();
+}
+
+template <uint16_t Version, class AddrType> void TestChildren() {
+  // Test that we can decode DW_FORM_ref_addr values correctly in DWARF 2 with
+  // 4 byte addresses. DW_FORM_ref_addr values should be 4 bytes when using
+  // 8 byte addresses.
+
+  const uint8_t AddrSize = sizeof(AddrType);
+  initLLVMIfNeeded();
+  Triple Triple = getHostTripleForAddrSize(AddrSize);
+  auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
+  if (HandleExpectedError(ExpectedDG))
+    return;
+  dwarfgen::Generator *DG = ExpectedDG.get().get();
+  dwarfgen::CompileUnit &CU = DG->addCompileUnit();
+  dwarfgen::DIE CUDie = CU.getUnitDIE();
+
+  CUDie.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/main.c");
+  CUDie.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C);
+
+  dwarfgen::DIE SubprogramDie = CUDie.addChild(DW_TAG_subprogram);
+  SubprogramDie.addAttribute(DW_AT_name, DW_FORM_strp, "main");
+  SubprogramDie.addAttribute(DW_AT_low_pc, DW_FORM_addr, 0x1000U);
+  SubprogramDie.addAttribute(DW_AT_high_pc, DW_FORM_addr, 0x2000U);
+
+  dwarfgen::DIE IntDie = CUDie.addChild(DW_TAG_base_type);
+  IntDie.addAttribute(DW_AT_name, DW_FORM_strp, "int");
+  IntDie.addAttribute(DW_AT_encoding, DW_FORM_data1, DW_ATE_signed);
+  IntDie.addAttribute(DW_AT_byte_size, DW_FORM_data1, 4);
+
+  dwarfgen::DIE ArgcDie = SubprogramDie.addChild(DW_TAG_formal_parameter);
+  ArgcDie.addAttribute(DW_AT_name, DW_FORM_strp, "argc");
+  // ArgcDie.addAttribute(DW_AT_type, DW_FORM_ref4, IntDie);
+  ArgcDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, IntDie);
+
+  StringRef FileBytes = DG->generate();
+  MemoryBufferRef FileBuffer(FileBytes, "dwarf");
+  auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
+  EXPECT_TRUE((bool)Obj);
+  DWARFContextInMemory DwarfContext(*Obj.get());
+
+  // Verify the number of compile units is correct.
+  uint32_t NumCUs = DwarfContext.getNumCompileUnits();
+  EXPECT_EQ(NumCUs, 1u);
+  DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0);
+
+  // Get the compile unit DIE is valid.
+  auto DiePtr = U->getUnitDIE(false);
+  EXPECT_TRUE(DiePtr != nullptr);
+  // DiePtr->dump(llvm::outs(), U, UINT32_MAX);
+
+  // Verify the first child of the compile unit DIE is our subprogram.
+  auto SubprogramDiePtr = DiePtr->getFirstChild();
+  EXPECT_TRUE(SubprogramDiePtr != nullptr);
+  EXPECT_EQ(SubprogramDiePtr->getTag(), DW_TAG_subprogram);
+
+  // Verify the first child of the subprogram is our formal parameter.
+  auto ArgcDiePtr = SubprogramDiePtr->getFirstChild();
+  EXPECT_TRUE(ArgcDiePtr != nullptr);
+  EXPECT_EQ(ArgcDiePtr->getTag(), DW_TAG_formal_parameter);
+
+  // Verify our formal parameter has a NULL tag sibling.
+  auto NullDiePtr = ArgcDiePtr->getSibling();
+  EXPECT_TRUE(NullDiePtr != nullptr);
+  if (NullDiePtr) {
+    EXPECT_EQ(NullDiePtr->getTag(), DW_TAG_null);
+    EXPECT_TRUE(NullDiePtr->getSibling() == nullptr);
+    EXPECT_TRUE(NullDiePtr->getFirstChild() == nullptr);
+  }
+
+  // Verify the sibling of our subprogram is our integer base type.
+  auto IntDiePtr = SubprogramDiePtr->getSibling();
+  EXPECT_TRUE(IntDiePtr != nullptr);
+  EXPECT_EQ(IntDiePtr->getTag(), DW_TAG_base_type);
+
+  // Verify the sibling of our subprogram is our integer base is a NULL tag.
+  NullDiePtr = IntDiePtr->getSibling();
+  EXPECT_TRUE(NullDiePtr != nullptr);
+  if (NullDiePtr) {
+    EXPECT_EQ(NullDiePtr->getTag(), DW_TAG_null);
+    EXPECT_TRUE(NullDiePtr->getSibling() == nullptr);
+    EXPECT_TRUE(NullDiePtr->getFirstChild() == nullptr);
+  }
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version2Addr4Children) {
+  // Test that we can decode all forms for DWARF32, version 2, with 4 byte
+  // addresses.
+  typedef uint32_t AddrType;
+  TestChildren<2, AddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version2Addr8Children) {
+  // Test that we can decode all forms for DWARF32, version 2, with 8 byte
+  // addresses.
+  typedef uint64_t AddrType;
+  TestChildren<2, AddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version3Addr4Children) {
+  // Test that we can decode all forms for DWARF32, version 3, with 4 byte
+  // addresses.
+  typedef uint32_t AddrType;
+  TestChildren<3, AddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version3Addr8Children) {
+  // Test that we can decode all forms for DWARF32, version 3, with 8 byte
+  // addresses.
+  typedef uint64_t AddrType;
+  TestChildren<3, AddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version4Addr4Children) {
+  // Test that we can decode all forms for DWARF32, version 4, with 4 byte
+  // addresses.
+  typedef uint32_t AddrType;
+  TestChildren<4, AddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version4Addr8Children) {
+  // Test that we can decode all forms for DWARF32, version 4, with 8 byte
+  // addresses.
+  typedef uint64_t AddrType;
+  TestChildren<4, AddrType>();
+}
+
+template <uint16_t Version, class AddrType> void TestReferences() {
+  // Test that we can decode DW_FORM_refXXX values correctly in DWARF.
+
+  const uint8_t AddrSize = sizeof(AddrType);
+  initLLVMIfNeeded();
+  Triple Triple = getHostTripleForAddrSize(AddrSize);
+  auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
+  if (HandleExpectedError(ExpectedDG))
+    return;
+  dwarfgen::Generator *DG = ExpectedDG.get().get();
+  dwarfgen::CompileUnit &CU1 = DG->addCompileUnit();
+  dwarfgen::CompileUnit &CU2 = DG->addCompileUnit();
+
+  dwarfgen::DIE CU1Die = CU1.getUnitDIE();
+  CU1Die.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/main.c");
+  CU1Die.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C);
+
+  dwarfgen::DIE CU1TypeDie = CU1Die.addChild(DW_TAG_base_type);
+  CU1TypeDie.addAttribute(DW_AT_name, DW_FORM_strp, "int");
+  CU1TypeDie.addAttribute(DW_AT_encoding, DW_FORM_data1, DW_ATE_signed);
+  CU1TypeDie.addAttribute(DW_AT_byte_size, DW_FORM_data1, 4);
+
+  dwarfgen::DIE CU1Ref1Die = CU1Die.addChild(DW_TAG_variable);
+  CU1Ref1Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU1Ref1");
+  CU1Ref1Die.addAttribute(DW_AT_type, DW_FORM_ref1, CU1TypeDie);
+
+  dwarfgen::DIE CU1Ref2Die = CU1Die.addChild(DW_TAG_variable);
+  CU1Ref2Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU1Ref2");
+  CU1Ref2Die.addAttribute(DW_AT_type, DW_FORM_ref2, CU1TypeDie);
+
+  dwarfgen::DIE CU1Ref4Die = CU1Die.addChild(DW_TAG_variable);
+  CU1Ref4Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU1Ref4");
+  CU1Ref4Die.addAttribute(DW_AT_type, DW_FORM_ref4, CU1TypeDie);
+
+  dwarfgen::DIE CU1Ref8Die = CU1Die.addChild(DW_TAG_variable);
+  CU1Ref8Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU1Ref8");
+  CU1Ref8Die.addAttribute(DW_AT_type, DW_FORM_ref8, CU1TypeDie);
+
+  dwarfgen::DIE CU1RefAddrDie = CU1Die.addChild(DW_TAG_variable);
+  CU1RefAddrDie.addAttribute(DW_AT_name, DW_FORM_strp, "CU1RefAddr");
+  CU1RefAddrDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, CU1TypeDie);
+
+  dwarfgen::DIE CU2Die = CU2.getUnitDIE();
+  CU2Die.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/foo.c");
+  CU2Die.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C);
+
+  dwarfgen::DIE CU2TypeDie = CU2Die.addChild(DW_TAG_base_type);
+  CU2TypeDie.addAttribute(DW_AT_name, DW_FORM_strp, "float");
+  CU2TypeDie.addAttribute(DW_AT_encoding, DW_FORM_data1, DW_ATE_float);
+  CU2TypeDie.addAttribute(DW_AT_byte_size, DW_FORM_data1, 4);
+
+  dwarfgen::DIE CU2Ref1Die = CU2Die.addChild(DW_TAG_variable);
+  CU2Ref1Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU2Ref1");
+  CU2Ref1Die.addAttribute(DW_AT_type, DW_FORM_ref1, CU2TypeDie);
+
+  dwarfgen::DIE CU2Ref2Die = CU2Die.addChild(DW_TAG_variable);
+  CU2Ref2Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU2Ref2");
+  CU2Ref2Die.addAttribute(DW_AT_type, DW_FORM_ref2, CU2TypeDie);
+
+  dwarfgen::DIE CU2Ref4Die = CU2Die.addChild(DW_TAG_variable);
+  CU2Ref4Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU2Ref4");
+  CU2Ref4Die.addAttribute(DW_AT_type, DW_FORM_ref4, CU2TypeDie);
+
+  dwarfgen::DIE CU2Ref8Die = CU2Die.addChild(DW_TAG_variable);
+  CU2Ref8Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU2Ref8");
+  CU2Ref8Die.addAttribute(DW_AT_type, DW_FORM_ref8, CU2TypeDie);
+
+  dwarfgen::DIE CU2RefAddrDie = CU2Die.addChild(DW_TAG_variable);
+  CU2RefAddrDie.addAttribute(DW_AT_name, DW_FORM_strp, "CU2RefAddr");
+  CU2RefAddrDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, CU2TypeDie);
+
+  // Refer to a type in CU1 from CU2
+  dwarfgen::DIE CU2ToCU1RefAddrDie = CU2Die.addChild(DW_TAG_variable);
+  CU2ToCU1RefAddrDie.addAttribute(DW_AT_name, DW_FORM_strp, "CU2ToCU1RefAddr");
+  CU2ToCU1RefAddrDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, CU1TypeDie);
+
+  // Refer to a type in CU2 from CU1
+  dwarfgen::DIE CU1ToCU2RefAddrDie = CU1Die.addChild(DW_TAG_variable);
+  CU1ToCU2RefAddrDie.addAttribute(DW_AT_name, DW_FORM_strp, "CU1ToCU2RefAddr");
+  CU1ToCU2RefAddrDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, CU2TypeDie);
+
+  StringRef FileBytes = DG->generate();
+  MemoryBufferRef FileBuffer(FileBytes, "dwarf");
+  auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
+  EXPECT_TRUE((bool)Obj);
+  DWARFContextInMemory DwarfContext(*Obj.get());
+
+  // Verify the number of compile units is correct.
+  uint32_t NumCUs = DwarfContext.getNumCompileUnits();
+  EXPECT_EQ(NumCUs, 2u);
+  DWARFCompileUnit *U1 = DwarfContext.getCompileUnitAtIndex(0);
+  DWARFCompileUnit *U2 = DwarfContext.getCompileUnitAtIndex(1);
+
+  // Get the compile unit DIE is valid.
+  auto Unit1DiePtr = U1->getUnitDIE(false);
+  EXPECT_TRUE(Unit1DiePtr != nullptr);
+  // Unit1DiePtr->dump(llvm::outs(), U1, UINT32_MAX);
+
+  auto Unit2DiePtr = U2->getUnitDIE(false);
+  EXPECT_TRUE(Unit2DiePtr != nullptr);
+  // Unit2DiePtr->dump(llvm::outs(), U2, UINT32_MAX);
+
+  // Verify the first child of the compile unit 1 DIE is our int base type.
+  auto CU1TypeDiePtr = Unit1DiePtr->getFirstChild();
+  EXPECT_TRUE(CU1TypeDiePtr != nullptr);
+  EXPECT_EQ(CU1TypeDiePtr->getTag(), DW_TAG_base_type);
+  EXPECT_EQ(
+      CU1TypeDiePtr->getAttributeValueAsUnsignedConstant(U1, DW_AT_encoding, 0),
+      DW_ATE_signed);
+
+  // Verify the first child of the compile unit 2 DIE is our float base type.
+  auto CU2TypeDiePtr = Unit2DiePtr->getFirstChild();
+  EXPECT_TRUE(CU2TypeDiePtr != nullptr);
+  EXPECT_EQ(CU2TypeDiePtr->getTag(), DW_TAG_base_type);
+  EXPECT_EQ(
+      CU2TypeDiePtr->getAttributeValueAsUnsignedConstant(U2, DW_AT_encoding, 0),
+      DW_ATE_float);
+
+  // Verify the sibling of the base type DIE is our Ref1 DIE and that its
+  // DW_AT_type points to our base type DIE.
+  auto CU1Ref1DiePtr = CU1TypeDiePtr->getSibling();
+  EXPECT_TRUE(CU1Ref1DiePtr != nullptr);
+  EXPECT_EQ(CU1Ref1DiePtr->getTag(), DW_TAG_variable);
+  EXPECT_EQ(CU1Ref1DiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL),
+            CU1TypeDiePtr->getOffset());
+  // Verify the sibling is our Ref2 DIE and that its DW_AT_type points to our
+  // base type DIE in CU1.
+  auto CU1Ref2DiePtr = CU1Ref1DiePtr->getSibling();
+  EXPECT_TRUE(CU1Ref2DiePtr != nullptr);
+  EXPECT_EQ(CU1Ref2DiePtr->getTag(), DW_TAG_variable);
+  EXPECT_EQ(CU1Ref2DiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL),
+            CU1TypeDiePtr->getOffset());
+
+  // Verify the sibling is our Ref4 DIE and that its DW_AT_type points to our
+  // base type DIE in CU1.
+  auto CU1Ref4DiePtr = CU1Ref2DiePtr->getSibling();
+  EXPECT_TRUE(CU1Ref4DiePtr != nullptr);
+  EXPECT_EQ(CU1Ref4DiePtr->getTag(), DW_TAG_variable);
+  EXPECT_EQ(CU1Ref4DiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL),
+            CU1TypeDiePtr->getOffset());
+
+  // Verify the sibling is our Ref8 DIE and that its DW_AT_type points to our
+  // base type DIE in CU1.
+  auto CU1Ref8DiePtr = CU1Ref4DiePtr->getSibling();
+  EXPECT_TRUE(CU1Ref8DiePtr != nullptr);
+  EXPECT_EQ(CU1Ref8DiePtr->getTag(), DW_TAG_variable);
+  EXPECT_EQ(CU1Ref8DiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL),
+            CU1TypeDiePtr->getOffset());
+
+  // Verify the sibling is our RefAddr DIE and that its DW_AT_type points to our
+  // base type DIE in CU1.
+  auto CU1RefAddrDiePtr = CU1Ref8DiePtr->getSibling();
+  EXPECT_TRUE(CU1RefAddrDiePtr != nullptr);
+  EXPECT_EQ(CU1RefAddrDiePtr->getTag(), DW_TAG_variable);
+  EXPECT_EQ(
+      CU1RefAddrDiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL),
+      CU1TypeDiePtr->getOffset());
+
+  // Verify the sibling of the Ref4 DIE is our RefAddr DIE and that its
+  // DW_AT_type points to our base type DIE.
+  auto CU1ToCU2RefAddrDiePtr = CU1RefAddrDiePtr->getSibling();
+  EXPECT_TRUE(CU1ToCU2RefAddrDiePtr != nullptr);
+  EXPECT_EQ(CU1ToCU2RefAddrDiePtr->getTag(), DW_TAG_variable);
+  EXPECT_EQ(CU1ToCU2RefAddrDiePtr->getAttributeValueAsReference(U1, DW_AT_type,
+                                                                -1ULL),
+            CU2TypeDiePtr->getOffset());
+
+  // Verify the sibling of the base type DIE is our Ref1 DIE and that its
+  // DW_AT_type points to our base type DIE.
+  auto CU2Ref1DiePtr = CU2TypeDiePtr->getSibling();
+  EXPECT_TRUE(CU2Ref1DiePtr != nullptr);
+  EXPECT_EQ(CU2Ref1DiePtr->getTag(), DW_TAG_variable);
+  EXPECT_EQ(CU2Ref1DiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL),
+            CU2TypeDiePtr->getOffset());
+  // Verify the sibling is our Ref2 DIE and that its DW_AT_type points to our
+  // base type DIE in CU2.
+  auto CU2Ref2DiePtr = CU2Ref1DiePtr->getSibling();
+  EXPECT_TRUE(CU2Ref2DiePtr != nullptr);
+  EXPECT_EQ(CU2Ref2DiePtr->getTag(), DW_TAG_variable);
+  EXPECT_EQ(CU2Ref2DiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL),
+            CU2TypeDiePtr->getOffset());
+
+  // Verify the sibling is our Ref4 DIE and that its DW_AT_type points to our
+  // base type DIE in CU2.
+  auto CU2Ref4DiePtr = CU2Ref2DiePtr->getSibling();
+  EXPECT_TRUE(CU2Ref4DiePtr != nullptr);
+  EXPECT_EQ(CU2Ref4DiePtr->getTag(), DW_TAG_variable);
+  EXPECT_EQ(CU2Ref4DiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL),
+            CU2TypeDiePtr->getOffset());
+
+  // Verify the sibling is our Ref8 DIE and that its DW_AT_type points to our
+  // base type DIE in CU2.
+  auto CU2Ref8DiePtr = CU2Ref4DiePtr->getSibling();
+  EXPECT_TRUE(CU2Ref8DiePtr != nullptr);
+  EXPECT_EQ(CU2Ref8DiePtr->getTag(), DW_TAG_variable);
+  EXPECT_EQ(CU2Ref8DiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL),
+            CU2TypeDiePtr->getOffset());
+
+  // Verify the sibling is our RefAddr DIE and that its DW_AT_type points to our
+  // base type DIE in CU2.
+  auto CU2RefAddrDiePtr = CU2Ref8DiePtr->getSibling();
+  EXPECT_TRUE(CU2RefAddrDiePtr != nullptr);
+  EXPECT_EQ(CU2RefAddrDiePtr->getTag(), DW_TAG_variable);
+  EXPECT_EQ(
+      CU2RefAddrDiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL),
+      CU2TypeDiePtr->getOffset());
+
+  // Verify the sibling of the Ref4 DIE is our RefAddr DIE and that its
+  // DW_AT_type points to our base type DIE.
+  auto CU2ToCU1RefAddrDiePtr = CU2RefAddrDiePtr->getSibling();
+  EXPECT_TRUE(CU2ToCU1RefAddrDiePtr != nullptr);
+  EXPECT_EQ(CU2ToCU1RefAddrDiePtr->getTag(), DW_TAG_variable);
+  EXPECT_EQ(CU2ToCU1RefAddrDiePtr->getAttributeValueAsReference(U2, DW_AT_type,
+                                                                -1ULL),
+            CU1TypeDiePtr->getOffset());
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version2Addr4References) {
+  // Test that we can decode all forms for DWARF32, version 2, with 4 byte
+  // addresses.
+  typedef uint32_t AddrType;
+  TestReferences<2, AddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version2Addr8References) {
+  // Test that we can decode all forms for DWARF32, version 2, with 8 byte
+  // addresses.
+  typedef uint64_t AddrType;
+  TestReferences<2, AddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version3Addr4References) {
+  // Test that we can decode all forms for DWARF32, version 3, with 4 byte
+  // addresses.
+  typedef uint32_t AddrType;
+  TestReferences<3, AddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version3Addr8References) {
+  // Test that we can decode all forms for DWARF32, version 3, with 8 byte
+  // addresses.
+  typedef uint64_t AddrType;
+  TestReferences<3, AddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version4Addr4References) {
+  // Test that we can decode all forms for DWARF32, version 4, with 4 byte
+  // addresses.
+  typedef uint32_t AddrType;
+  TestReferences<4, AddrType>();
+}
+
+TEST(DWARFDebugInfo, TestDWARF32Version4Addr8References) {
+  // Test that we can decode all forms for DWARF32, version 4, with 8 byte
+  // addresses.
+  typedef uint64_t AddrType;
+  TestReferences<4, AddrType>();
+}
+
+} // end anonymous namespace