Abstract almost all DwarfDebug out of the classes in DIE.cpp.

[clayborg]

Summary

This change removes the dependency on DwarfDebug that was used for DW_FORM_ref_addr by making a new DIEUnit class in DIE.cpp.

The DIEUnit class represents a compile or type unit and it owns the unit DIE as an instance variable. This allows anyone with a DIE, to get the unit DIE, and then get back to its DIEUnit without adding any new ivars to the DIE class. Why was this needed? The DIE class has an Offset that is always the CU relative DIE offset, not the "offset in debug info section" as was commented in the header file (the comment has been corrected). This is great for performance because most DIE references are compile unit relative and this means most code that accessed the DIE's offset didn't need to make it into a compile unit relative offset because it already was. When we needed to emit a DW_FORM_ref_addr though, we needed to find the absolute offset of the DIE by finding the DIE's compile/type unit. This class did have the absolute debug info/type offset and could be added to the CU relative offset to compute the absolute offset. With this change we can easily get back to a DIE's DIEUnit which will have this needed offset. Prior to this is required having a DwarfDebug and required calling:

DwarfCompileUnit *DwarfDebug::lookupUnit(const DIE *CU) const;

Now we can use the DIEUnit class to do so without needing DwarfDebug. All clients now use DIEUnit objects (the DwarfDebug stack and the DwarfLinker). A follow on patch for the DWARF generator will also take advantage of this.

[dblaikie]

include/llvm/CodeGen/DIE.h

88–89

Aren't these already implicit?

612–616

That's a pretty subtle API contract.

Duncan tried to do something similar with StringMap maybe (granted, in that case the inner variable wasn't the first member of the outer struct so he was trying to use offset_of) & for some reason that wasn't feasible, if I recall correctly. Perhaps he can tell me/us more about what the issues were there & whether the same concerns apply here.

(in any case - due to alignment, doesn't this bool variable grow the size of the struct by a pointer size anyway? The struct has to be aligned to pointer size (due to the Parent member, and probably the Children member too) , so even in a 64 bit build - Offset, Size, AbbrevNumber, and Tag are 32 bits? So 'Children' appears on the next 64 bit boundary probably, etc... )

Could we instead change 'Parent' to be a PointerUnion<DIE, DIEUnit> & wouldn't need the offset tricks anyway?

724

This is implicit/default, right? (but I suppose if this thing is movable, then having the DIE physically point to its DIEUnit could be tricky - equally, though, all the DIE's children parent pointers would be broken by such an API as well, right?)

lib/CodeGen/AsmPrinter/DIE.cpp

469–471

Guessing this is an unrelated change - but seems OK (you could commit it separately/ahead of this patch, to reduce the diff here/simplify code review).

476–477

formatting

481

Is this an unrelated/orthogonal change?

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

303

Hey Adrian - did you happen to run size numbers on whether this is important? What would happen if we just always used ref_addr when we enabled cross-unit referencing? (wondering if the complexity is worth the benefit - 4 bytes per unit reference isn't nothing, for sure - just wondering how much it is in the end)

tools/dsymutil/DwarfLinker.cpp

225–226

Moving DIEs seems problematic - any sub-DIEs parent pointers will be invalidated by this, right?

3395–3398

You could reduce indentation here in one of a couple of ways:

Remove the outer scope and nest the variable declaration in the if:

if (DIE *OutputDIE = cloneDIE(...))
  CurrentUnit.setOutputUnitDIE(std::move(*OutputDIE));
else
  continue;

or keeping the outer scope (though I don't think it's really necessary - we have moved from objects regularly - you could null out the pointer to help a bit there, if you liked - though that might trigger dead-store warnings eventually) and flipping the if condition while removing the else:

if (!OutputDIE)
  continue;
CurrentUnit.setOutputUnitDIE(...);

[clayborg]

Will switch over to using PointerUnion to avoid the strict API contracts and fix the rest accordingly.

include/llvm/CodeGen/DIE.h

88–89

Yep, they are. There was code in DwarfLinker a while back that was manually copying a DIEAbbrev for no reason so I added these when I removed that redundant code. These aren't needed.

616

Yes it is subtle API contract in an effort to save space.

This doesn't grow this class because dwarf::Tag in 16 bits (enum class uint16_t) and the next class will be 4 or 8 byte aligned so it will sit in the gap.

Could we instead change 'Parent' to be a PointerUnion<DIE, DIEUnit> & wouldn't need the offset tricks anyway?

Great idea. That solves the problem without growing the size.

724

I will think about this as I am switching over to use a PointerUnion and make any needed modifications.

lib/CodeGen/AsmPrinter/DIE.cpp

471

This is leaving in he assert that used to be on line 448 to the right? Am I missing something?

481

Intentional change that fixes emitting DW_FORM_ref_addr for DWARF version 2 which was broken. It would always emit 4 bytes regardless of the DWARF version.

tools/dsymutil/DwarfLinker.cpp

226

I will switch to DIE to use a PointerUnion and fix accordingly.

[clayborg]

Switched over to using PointerUnion and outlawed llvm::DIEUnit and llvm::DIE classes from being copied. Had to modify the DwarfLinker to not copy or move construct any DIE instances.

[clayborg]

Friendly ping. I would like to get back to the DWARF generator patch after this if possible.

[aprantl]

Some nitpicky comments.

include/llvm/CodeGen/DIE.h

705

Please don't repeat the class name in a doxygen comment.

706

I think this regular comment in-between may break doxygen?

lib/CodeGen/AsmPrinter/DIE.cpp

124

We typically write this as:
if (const auto *U = getUnit())

126

alternatively:

assert(getUnit() && "DIE must belong to a DIEUnit to find the absolute offset.")
return getUnit()->getDebugSectionOffset() + getOffset();

137

Why not return a DIEUnit & instead? This would simplify all the call sites.

145

Same comment(s) apply here :-)

211

) && "message")?

214

perhaps move these trivial accessors into the class definition?

tools/dsymutil/DwarfLinker.cpp

2718

this is confusing to read. No idea how to make it better though...

[dblaikie]

tools/dsymutil/DwarfLinker.cpp

217–218

This type includes a non-copy/movable DIEUnit, so it's implicitly non-copy/movable, so you can omit these if you like ( http://blog.florianwolters.de/educational/2015/01/31/The_Rule_of_Zero/ ) I think

1096–1097

Think the code might be more legible without these typedefs (the first moreso than the second)

1097

Alternatively, this could be a std::deque if items are added but never removed & object identity is important. (may not be better that way - just suggesting it so you, Adrian, etc can consider it)

2716

Please add a message to the assertion to explain what/why this should be true.

(I personally find a block with only an assert in it to be a little weird and might tend to phrase this as "assert(!Die || !Info.Clone); if (!Die) { ... } - but yeah, it's not exactly more legible that way :/)

2718–2720

Might this be simpler as:

if (!Info.Clone)
  Info.Clone = ...;
Die = Info.Clone;

3467–3468

prefer llvm::make_unique

[aprantl]

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

303

I just did some numbers on a couple of projects by doing

dwarfdump -F WebKit.framework.dSYM | grep FORM_ref4 |wc -l

               WebKit     clang   medium-sized ObjC project
===========================================================
FORM_ref_addr 7231489  15483428
FORM_ref4      189099    555085    189189
-----------------------------------------------------------
Savings         ~700K       ~2M     ~700K

It's not much in the grand scheme of things, but also not entirely negligible. Since .dSYM bundles are made to be stored indefinitely I think we should keep every optimization that makes them smaller.

[clayborg]

Fixed all issues found by previous comments.

[clayborg]

include/llvm/CodeGen/DIE.h

705

I was trying to be consistent with the other classes in this file. I can remove it.

lib/CodeGen/AsmPrinter/DIE.cpp

137

Since there are clients that need the getUnitOrNull() already, I would like to keep this consistent with that call. Also I would like the code to not crash if asserts are not enabled. So I would prefer to leave this as a pointer.

210–211

Not sure what I would say? && "It must be one of these?". The assert seems pretty clear. It was also moved from another location in DwarfUnit::DwarfUnit where this assert appeared just like this.

214

I generally don't like putting things with asserts in header files, but there are plenty of asserts in LLVM header files already, so I can move this.

tools/dsymutil/DwarfLinker.cpp

218

Sounds good, will remove.

[clayborg]

Commented inline on the DW_FORM_ref_addr vs DW_FORM_ref4 question.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

303

There should be no size difference at all DW_FORM_ref_addr are 4 bytes in DWARF32 unless you are emitting Version 2, which we don't emit much right? There is a computation penalty for using DW_FORM_ref_addr since and attribute in a DIE will have a DIEValue that contains a DIEEntry. DIEEntry objects point to DIE objects and these have CU relative offsets stored inside of them, so in order to emit a DW_FORM_ref_addr, we will need to get the Unit DIE and then than add the compile/type unit's absolute offset to the DIE's offset to compute the absolute offset, so there will be some performance cost to using DW_FORM_ref_addr.

[clayborg]

Address Adrian's comments from email by making DIE just have:

class DIE {
  const DIEUnit *getUnit() const;
  const DIE *getUnitDie() const;
};

And skip the "OrNull" variants. Also added a "expected a unit TAG" to the assert in the DIEUnit constructor that checks the incoming dwarf Tag.

[clayborg]

Any objections to the current state of things?

[aprantl]

Looks good to me now. Thanks!

include/llvm/CodeGen/DIE.h

598

Not super important, but we would generally spell this like this nowadays:

/// Dwarf unit relative offset.
unsigned Offset;

[dblaikie]

Realized a few bits of code review feedback got lost in the noise somewhere. So I applied some myself & left a few here.

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

622 ↗

(On Diff #79954)

This probably shouldn't be protected - there's no inheritance happening here. DIEUnit can access 'Owner' directly and probably should do that. It gives a bit of a false sense of encapsulation, I think.

710–714 ↗

(On Diff #79954)

Comment ended up out of date?

715–722 ↗

(On Diff #79954)

Are these members accessed directly?

(ah, the first two have one direct access each, that could've used an accessor - and the others not, so I made them all private and used the two accessors in the two spots that were needed)

tools/dsymutil/DwarfLinker.cpp

1097

Any thoughts on using deque here? (Adrian?)

2718–2720

Made this change in r288423

include/llvm/CodeGen/DIE.h

 
 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
 #define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
 
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/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/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>
 
 namespace llvm {
 
 class AsmPrinter;
+class DIE;
+class DIEUnit;
 class MCExpr;
+class MCSection;
 class MCSymbol;
 class raw_ostream;
 
 //===--------------------------------------------------------------------===//
 /// Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation.
 class DIEAbbrevData {
   /// Dwarf attribute code.
   dwarf::Attribute Attribute;
class DIEAbbrev : public FoldingSetNode {
   /// are 0 and 1 for no children and children respectively.
   bool Children;
 
   /// Raw data bytes for abbreviation.
   SmallVector<DIEAbbrevData, 12> Data;
 
 public:
   DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C) {}
 
   /// Accessors.
   /// @{
   dwarf::Tag getTag() const { return Tag; }
   unsigned getNumber() const { return Number; }
   bool hasChildren() const { return Children; }
   const SmallVectorImpl<DIEAbbrevData> &getData() const { return Data; }
   void setChildrenFlag(bool hasChild) { Children = hasChild; }
   void setNumber(unsigned N) { Number = N; }
   /// @}
public:
   }
   const_value_range values() const {
     return make_range(const_value_iterator(List.begin()),
                       const_value_iterator(List.end()));
   }
 };
 
 //===--------------------------------------------------------------------===//
-/// DIE - A structured debug information entry.  Has an abbreviation which
+/// 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 - Offset in debug info section.
+  /// Offset - Dwarf unit relative offset.
   ///
   unsigned Offset;
 
   /// Size - Size of instance + children.
   ///
   unsigned Size;
 
   unsigned AbbrevNumber = ~0u;
 
   /// Tag - Dwarf tag code.
   ///
   dwarf::Tag Tag = (dwarf::Tag)0;
 
   /// Children DIEs.
   IntrusiveBackList<DIE> Children;
 
-  DIE *Parent = nullptr;
+  /// 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;
   explicit DIE(dwarf::Tag Tag) : Offset(0), Size(0), Tag(Tag) {}
 
+protected:
+  void setUnit(DIEUnit *U) {
+    Owner = U;
+  }
 public:
   static DIE *get(BumpPtrAllocator &Alloc, dwarf::Tag Tag) {
     return new (Alloc) DIE(Tag);
   }
 
+  DIE(const DIE &RHS) = delete;
+  DIE(DIE &&RHS) = delete;
+  void operator=(const DIE &RHS) = delete;
+  void operator=(const DIE &&RHS) = delete;
+
   // Accessors.
   unsigned getAbbrevNumber() const { return AbbrevNumber; }
   dwarf::Tag getTag() const { return Tag; }
+  /// Get the compile/type unit relative offset of this DIE.
   unsigned getOffset() const { return Offset; }
   unsigned getSize() const { return Size; }
   bool hasChildren() const { return !Children.empty(); }
 
   typedef IntrusiveBackList<DIE>::iterator child_iterator;
   typedef IntrusiveBackList<DIE>::const_iterator const_child_iterator;
   typedef iterator_range<child_iterator> child_range;
   typedef iterator_range<const_child_iterator> const_child_range;
 
   child_range children() {
     return make_range(Children.begin(), Children.end());
   }
   const_child_range children() const {
     return make_range(Children.begin(), Children.end());
   }
 
-  DIE *getParent() const { return Parent; }
+  DIE *getParent() const;
 
   /// Generate the abbreviation for this DIE.
   ///
   /// Calculate the abbreviation for this, which should be uniqued and
   /// eventually used to call \a setAbbrevNumber().
   DIEAbbrev generateAbbrev() const;
 
   /// Set the abbreviation number for this DIE.
   void setAbbrevNumber(unsigned I) { AbbrevNumber = I; }
 
-  /// Climb up the parent chain to get the compile or type unit DIE this DIE
-  /// belongs to.
-  const DIE *getUnit() const;
-  /// Similar to getUnit, returns null when DIE is not added to an
-  /// owner yet.
-  const DIE *getUnitOrNull() const;
+  /// Get the absolute offset within the .debug_info or .debug_types section
+  /// for this DIE.
+  unsigned getDebugSectionOffset() const;
+
+  /// Climb up the parent chain to get the compile unit or type unit DIE that
+  /// this DIE belongs to.
+  ///
+  /// \returns the DW_TAG_compile_unit or DW_TAG_type_unit DIE that owns this
+  /// DIE, or NULL if this DIE hasn't been added to a unit DIE.
+  const DIE *getUnitDieOrNull() const;
+
+  /// Climb up the parent chain to get the compile unit or type unit that this
+  /// DIE belongs to.
+  const DIEUnit *getUnit() const;
+  /// Similar to getUnit, returns null when DIE is not added to an owner yet.
+  const DIEUnit *getUnitOrNull() const;
   void setOffset(unsigned O) { Offset = O; }
   void setSize(unsigned S) { Size = S; }
 
   /// Add a child to the DIE.
   DIE &addChild(DIE *Child) {
     assert(!Child->getParent() && "Child should be orphaned");
-    Child->Parent = this;
+    Child->Owner = this;
     Children.push_back(*Child);
     return Children.back();
   }
 
   /// Find a value in the DIE with the attribute given.
   ///
   /// Returns a default-constructed DIEValue (where \a DIEValue::getType()
   /// gives \a DIEValue::isNone) if no such attribute exists.
   DIEValue findAttribute(dwarf::Attribute Attribute) const;
 
   void print(raw_ostream &O, unsigned IndentCount = 0) const;
   void dump();
 };
 
 //===--------------------------------------------------------------------===//
+/// Represents a compile or type unit.
+class DIEUnit {
+protected:
+  /// The compile unit or type unit DIE. This variable must be an instance of
+  /// DIE so that we can calculate the DIEUnit from any DIE by traversing the
+  /// parent backchain and getting the Unit DIE, and then casting itself to a
+  /// DIEUnit. This allows us to be able to find the DIEUnit for any DIE without
+  /// having to store a pointer to the DIEUnit in each DIE instance.
+  DIE Die;
+  /// The section this unit will be emitted in. This may or may not be set to
+  /// a valid section depending on the client that is emitting DWARF.
+  MCSection *Section;
+  uint64_t Offset; /// .debug_info or .debug_types absolute section offset.
+  uint32_t Length; /// The length in bytes of all of the DIEs in this unit.
+  const uint16_t Version; /// The Dwarf version number for this unit.
+  const uint8_t AddrSize; /// The size in bytes of an address for this unit.
+public:
+  DIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag);
+  DIEUnit(const DIEUnit &RHS) = delete;
+  DIEUnit(DIEUnit &&RHS) = delete;
+  void operator=(const DIEUnit &RHS) = delete;
+  void operator=(const DIEUnit &&RHS) = delete;
+  /// Set the section that this DIEUnit will be emitted into.
+  ///
+  /// This function is used by some clients to set the section. Not all clients
+  /// that emit DWARF use this section variable.
+  void setSection(MCSection *Section) {
+    assert(!this->Section);
+    this->Section = Section;
+  }
+
+  /// Return the section that this DIEUnit will be emitted into.
+  ///
+  /// \returns Section pointer which can be NULL.
+  MCSection *getSection() const { return Section; }
+  void setDebugSectionOffset(unsigned O) { Offset = O; }
+  unsigned getDebugSectionOffset() const { return Offset; }
+  void setLength(uint64_t L) { Length = L; }
+  uint64_t getLength() const { return Length; }
+  uint16_t getDwarfVersion() const { return Version; }
+  uint16_t getAddressSize() const { return AddrSize; }
+  DIE &getUnitDie() { return Die; }
+  const DIE &getUnitDie() const { return Die; }
+};
+
+  
+//===--------------------------------------------------------------------===//
 /// DIELoc - Represents an expression location.
 //
 class DIELoc : public DIEValueList {
   mutable unsigned Size; // Size in bytes excluding size header.
 
 public:
   DIELoc() : Size(0) {}
 

include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h

 #ifndef LLVM_LIB_DEBUGINFO_DWARFDEBUGINFOENTRY_H
 #define LLVM_LIB_DEBUGINFO_DWARFDEBUGINFOENTRY_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/Dwarf.h"
 
 namespace llvm {
 
 class DWARFDebugAranges;
 class DWARFCompileUnit;
 class DWARFUnit;
 class DWARFContext;
 class DWARFFormValue;
public:
   /// Extracts a debug info entry, which is a child of a given unit,
   /// starting at a given offset. If DIE can't be extracted, returns false and
   /// doesn't change OffsetPtr.
   bool extractFast(const DWARFUnit &U, uint32_t *OffsetPtr);
   /// High performance extraction should use this call.
   bool extractFast(const DWARFUnit &U, uint32_t *OffsetPtr,
                    const DataExtractor &DebugInfoData, uint32_t UEndOffset);
 
-  uint32_t getTag() const { return AbbrevDecl ? AbbrevDecl->getTag() : 0; }
+  dwarf::Tag getTag() const {
+    return AbbrevDecl ? AbbrevDecl->getTag() : dwarf::DW_TAG_null;
+  }
+
   bool isNULL() const { return AbbrevDecl == nullptr; }
 
   /// Returns true if DIE represents a subprogram (not inlined).
   bool isSubprogramDIE() const;
   /// Returns true if DIE represents a subprogram or an inlined
   /// subroutine.
   bool isSubroutineDIE() const;
 

lib/CodeGen/AsmPrinter/DIE.cpp

O << "  "
       << dwarf::FormEncodingString(Data[i].getForm())
       << '\n';
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEAbbrev::dump() { print(dbgs()); }
 
+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());
   return Abbrev;
 }
 
-/// Climb up the parent chain to get the unit DIE to which this DIE
-/// belongs.
-const DIE *DIE::getUnit() const {
-  const DIE *Cu = getUnitOrNull();
-  assert(Cu && "We should not have orphaned DIEs.");
-  return Cu;
+unsigned DIE::getDebugSectionOffset() const {
+  return getUnit()->getDebugSectionOffset() + getOffset();
 }
 
-/// Climb up the parent chain to get the unit DIE this DIE belongs
-/// to. Return NULL if DIE is not added to an owner yet.
-const DIE *DIE::getUnitOrNull() const {
+const DIE *DIE::getUnitDieOrNull() const {
   const DIE *p = this;
   while (p) {
     if (p->getTag() == dwarf::DW_TAG_compile_unit ||
         p->getTag() == dwarf::DW_TAG_type_unit)
       return p;
     p = p->getParent();
   }
   return nullptr;
 }
 
+const DIEUnit *DIE::getUnit() const {
+  const DIEUnit *Unit = getUnitOrNull();
+  assert(Unit && "We should not have orphaned DIEs.");
+  return Unit;
+}
+
+const DIEUnit *DIE::getUnitOrNull() const {
+  const DIE *UnitDie = getUnitDieOrNull();
+  if (UnitDie)
+    return UnitDie->Owner.dyn_cast<DIEUnit*>();
+  return nullptr;
+}
+
 DIEValue DIE::findAttribute(dwarf::Attribute Attribute) const {
   // Iterate through all the attributes until we find the one we're
   // looking for, if we can't find it return NULL.
   for (const auto &V : values())
     if (V.getAttribute() == Attribute)
       return V;
   return DIEValue();
 }
void DIE::print(raw_ostream &O, unsigned IndentCount) const {
   O << "\n";
 }
 
 LLVM_DUMP_METHOD
 void DIE::dump() {
   print(dbgs());
 }
 
+DIEUnit::DIEUnit(uint16_t V, uint8_t A, dwarf::Tag UnitTag)
+    : Die(UnitTag), Section(nullptr), Offset(0), Length(0), Version(V),
+      AddrSize(A)
+{
+  Die.setUnit(this);
+  assert(UnitTag == dwarf::DW_TAG_compile_unit ||
+         UnitTag == dwarf::DW_TAG_type_unit);
+}
+
 void DIEValue::EmitValue(const AsmPrinter *AP) const {
   switch (Ty) {
   case isNone:
     llvm_unreachable("Expected valid DIEValue");
 #define HANDLE_DIEVALUE(T)                                                     \
   case is##T:                                                                  \
     getDIE##T().EmitValue(AP, Form);                                           \
     break;
 #include "llvm/CodeGen/DIEValue.def"

 // 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) {
+    // 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();
-    unsigned Addr = Entry->getOffset();
+      if (DD)
         assert(!DD->useSplitDwarf() && "TODO: dwo files can't have relocations.");
-    // For DW_FORM_ref_addr, output the offset from beginning of debug info
-    // section. Entry->getOffset() returns the offset from start of the
-    // compile unit.
-    DwarfCompileUnit *CU = DD->lookupUnit(Entry->getUnit());
-    assert(CU && "CUDie should belong to a CU.");
-    Addr += CU->getDebugInfoOffset();
-    if (AP->MAI->doesDwarfUseRelocationsAcrossSections())
-      AP->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
-                              DIEEntry::getRefAddrSize(AP));
-    else
+      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");
+      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());
 }
 
 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.
   if (AP->getDwarfVersion() == 2)

lib/CodeGen/AsmPrinter/DwarfAccelTable.cpp

for (HashList::const_iterator HI = Buckets[i].begin(),
       // Remember to emit the label for our offset.
       Asm->OutStreamer->EmitLabel((*HI)->Sym);
       Asm->OutStreamer->AddComment((*HI)->Str);
       Asm->emitDwarfStringOffset((*HI)->Data.Name);
       Asm->OutStreamer->AddComment("Num DIEs");
       Asm->EmitInt32((*HI)->Data.Values.size());
       for (HashDataContents *HD : (*HI)->Data.Values) {
         // Emit the DIE offset
-        DwarfCompileUnit *CU = D->lookupUnit(HD->Die->getUnit());
-        assert(CU && "Accelerated DIE should belong to a CU.");
-        Asm->EmitInt32(HD->Die->getOffset() + CU->getDebugInfoOffset());
+        Asm->EmitInt32(HD->Die->getDebugSectionOffset());
         // If we have multiple Atoms emit that info too.
         // FIXME: A bit of a hack, we either emit only one atom or all info.
         if (HeaderData.Atoms.size() > 1) {
           Asm->EmitInt16(HD->Die->getTag());
           Asm->EmitInt8(HD->Flags);
         }
       }
       PrevHash = (*HI)->HashValue;

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

 class DwarfFile;
 class MCSymbol;
 class LexicalScope;
 
 class DwarfCompileUnit : public DwarfUnit {
   /// A numeric ID unique among all CUs in the module
   unsigned UniqueID;
 
-  /// Offset of the UnitDie from beginning of debug info section.
-  unsigned DebugInfoOffset = 0;
-
   /// The attribute index of DW_AT_stmt_list in the compile unit DIE, avoiding
   /// the need to search for it in applyStmtList.
   DIE::value_iterator StmtListValue;
 
   /// Skeleton unit associated with this unit.
   DwarfCompileUnit *Skeleton;
 
   /// The start of the unit within its section.
class DwarfCompileUnit : public DwarfUnit {
 
   bool includeMinimalInlineScopes() const;
 
 public:
   DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, AsmPrinter *A,
                    DwarfDebug *DW, DwarfFile *DWU);
 
   unsigned getUniqueID() const { return UniqueID; }
-  unsigned getDebugInfoOffset() const { return DebugInfoOffset; }
-  void setDebugInfoOffset(unsigned DbgInfoOff) { DebugInfoOffset = DbgInfoOff; }
 
   DwarfCompileUnit *getSkeleton() const {
     return Skeleton;
   }
 
   void initStmtList();
 
   /// Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
public:
   /// \brief Construct import_module DIE.
   DIE *constructImportedEntityDIE(const DIImportedEntity *Module);
 
   void finishSubprogramDefinition(const DISubprogram *SP);
 
   /// Set the skeleton unit associated with this unit.
   void setSkeleton(DwarfCompileUnit &Skel) { Skeleton = &Skel; }
 
-  const MCSymbol *getSectionSym() const {
-    assert(Section);
-    return Section->getBeginSymbol();
-  }
-
   unsigned getLength() {
     return sizeof(uint32_t) + // Length field
-        getHeaderSize() + UnitDie.getSize();
+        getHeaderSize() + getUnitDie().getSize();
   }
 
   void emitHeader(bool UseOffsets) override;
 
   MCSymbol *getLabelBegin() const {
     assert(Section);
     return LabelBegin;
   }

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

void DwarfCompileUnit::initStmtList() {
 
   // DW_AT_stmt_list is a offset of line number information for this
   // compile unit in debug_line section. For split dwarf this is
   // left in the skeleton CU and so not included.
   // The line table entries are not always emitted in assembly, so it
   // is not okay to use line_table_start here.
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
   StmtListValue =
-      addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym,
+      addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym,
                       TLOF.getDwarfLineSection()->getBeginSymbol());
 }
 
 void DwarfCompileUnit::applyStmtList(DIE &D) {
   D.addValue(DIEValueAllocator, *StmtListValue);
 }
 
 void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,

lib/CodeGen/AsmPrinter/DwarfDebug.h

public:
   /// Emit the location for a debug loc entry, including the size header.
   void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry);
 
   /// Find the MDNode for the given reference.
   template <typename T> T *resolve(TypedDINodeRef<T> Ref) const {
     return Ref.resolve();
   }
 
-  /// Find the DwarfCompileUnit for the given CU Die.
-  DwarfCompileUnit *lookupUnit(const DIE *CU) const {
-    return CUDieMap.lookup(CU);
-  }
-
   void addSubprogramNames(const DISubprogram *SP, DIE &Die);
 
   AddressPool &getAddressPool() { return AddrPool; }
 
   void addAccelName(StringRef Name, const DIE &Die);
 
   void addAccelObjC(StringRef Name, const DIE &Die);
 

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

if (!Flags.empty())
       NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
 
     if (unsigned RVer = DIUnit->getRuntimeVersion())
       NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
                     dwarf::DW_FORM_data1, RVer);
   }
 
   if (useSplitDwarf())
-    NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection());
+    NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoDWOSection());
   else
-    NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
+    NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
 
   if (DIUnit->getDWOId()) {
     // This CU is either a clang module DWO or a skeleton CU.
     NewCU.addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
                   DIUnit->getDWOId());
     if (!DIUnit->getSplitDebugFilename().empty())
       // This is a prefabricated skeleton CU.
       NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,

 
 void DwarfDebug::finishVariableDefinitions() {
   for (const auto &Var : ConcreteVariables) {
     DIE *VariableDie = Var->getDIE();
     assert(VariableDie);
     // FIXME: Consider the time-space tradeoff of just storing the unit pointer
     // in the ConcreteVariables list, rather than looking it up again here.
     // DIE::getUnit isn't simple - it walks parent pointers, etc.
-    DwarfCompileUnit *Unit = lookupUnit(VariableDie->getUnit());
+    DwarfCompileUnit *Unit = CUDieMap.lookup(VariableDie->getUnitDieOrNull());
     assert(Unit);
     DbgVariable *AbsVar = getExistingAbstractVariable(
         InlinedVariable(Var->getVariable(), Var->getInlinedAt()));
     if (AbsVar && AbsVar->getDIE()) {
       Unit->addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
                         *AbsVar->getDIE());
     } else
       Unit->applyVariableAttributes(*Var, *VariableDie);

 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
 // DW_AT_addr_base, DW_AT_ranges_base.
 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
 
   auto OwnedUnit = make_unique<DwarfCompileUnit>(
       CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
   DwarfCompileUnit &NewCU = *OwnedUnit;
-  NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
+  NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
 
   NewCU.initStmtList();
 
   initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
 
   return NewCU;
 }
 
void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
   NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
                 CU.getLanguage());
 
   uint64_t Signature = makeTypeSignature(Identifier);
   NewTU.setTypeSignature(Signature);
   Ins.first->second = Signature;
 
   if (useSplitDwarf())
-    NewTU.initSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
+    NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
   else {
     CU.applyStmtList(UnitDie);
-    NewTU.initSection(
-        Asm->getObjFileLowering().getDwarfTypesSection(Signature));
+    NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesSection(Signature));
   }
 
   NewTU.setType(NewTU.createTypeDIE(CTy));
 
   if (TopLevelType) {
     auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
     TypeUnitsUnderConstruction.clear();
 

lib/CodeGen/AsmPrinter/DwarfFile.cpp

 // Compute the size and offset for each DIE.
 void DwarfFile::computeSizeAndOffsets() {
   // 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 (const auto &TheU : CUs) {
-    TheU->setDebugInfoOffset(SecOffset);
+    TheU->setDebugSectionOffset(SecOffset);
     SecOffset += computeSizeAndOffsetsForUnit(TheU.get());
   }
 }
 
 unsigned DwarfFile::computeSizeAndOffsetsForUnit(DwarfUnit *TheU) {
   // CU-relative offset is reset to 0 here.
   unsigned Offset = sizeof(int32_t) +      // Length of Unit Info
                     TheU->getHeaderSize(); // Unit-specific headers

lib/CodeGen/AsmPrinter/DwarfUnit.h

public:
   MCSymbol *getSym() const { return RangeSym; }
   const SmallVectorImpl<RangeSpan> &getRanges() const { return Ranges; }
   void addRange(RangeSpan Range) { Ranges.push_back(Range); }
 };
 
 //===----------------------------------------------------------------------===//
 /// This dwarf writer support class manages information associated with a
 /// source file.
-class DwarfUnit {
+  class DwarfUnit : public DIEUnit {
 protected:
   /// MDNode for the compile unit.
   const DICompileUnit *CUNode;
 
   // All DIEValues are allocated through this allocator.
   BumpPtrAllocator DIEValueAllocator;
 
-  /// Unit debug information entry.
-  DIE &UnitDie;
-
   /// Target of Dwarf emission.
   AsmPrinter *Asm;
 
   // Holders for some common dwarf information.
   DwarfDebug *DD;
   DwarfFile *DU;
 
-  /// An anonymous type for index type.  Owned by UnitDie.
+  /// An anonymous type for index type.  Owned by DIEUnit.
   DIE *IndexTyDie;
 
   /// Tracks the mapping of unit level debug information variables to debug
   /// information entries.
   DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
 
   /// A list of all the DIEBlocks in use.
   std::vector<DIEBlock *> DIEBlocks;
 
   /// A list of all the DIELocs in use.
   std::vector<DIELoc *> DIELocs;
 
   /// This map is used to keep track of subprogram DIEs that need
   /// DW_AT_containing_type attribute. This attribute points to a DIE that
   /// corresponds to the MDNode mapped with the subprogram DIE.
   DenseMap<DIE *, const DINode *> ContainingTypeMap;
 
-  /// The section this unit will be emitted in.
-  MCSection *Section;
-
   DwarfUnit(dwarf::Tag, const DICompileUnit *CU, AsmPrinter *A, DwarfDebug *DW,
             DwarfFile *DWU);
 
   bool applySubprogramDefinitionAttributes(const DISubprogram *SP, DIE &SPDie);
 
 public:
   virtual ~DwarfUnit();
 
-  void initSection(MCSection *Section);
-
-  MCSection *getSection() const {
-    assert(Section);
-    return Section;
-  }
-
   // Accessors.
   AsmPrinter* getAsmPrinter() const { return Asm; }
   uint16_t getLanguage() const { return CUNode->getSourceLanguage(); }
   const DICompileUnit *getCUNode() const { return CUNode; }
-  DIE &getUnitDie() { return UnitDie; }
 
   /// Return true if this compile unit has something to write out.
-  bool hasContent() const { return UnitDie.hasChildren(); }
+  bool hasContent() const { return Die.hasChildren(); }
 
   /// Get string containing language specific context for a global name.
   ///
   /// Walks the metadata parent chain in a language specific manner (using the
   /// compile unit language) and returns it as a string. This is done at the
   /// metadata level because DIEs may not currently have been added to the
   /// parent context and walking the DIEs looking for names is more expensive
   /// than walking the metadata.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 
 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
                                          unsigned MachineReg) {
   return MachineReg == TRI.getFrameRegister(*AP.MF);
 }
 
 DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node,
                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
-    : CUNode(Node), UnitDie(*DIE::get(DIEValueAllocator, UnitTag)), Asm(A),
-      DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
-  assert(UnitTag == dwarf::DW_TAG_compile_unit ||
-         UnitTag == dwarf::DW_TAG_type_unit);
+    : DIEUnit(A->getDwarfVersion(), A->getPointerSize(), UnitTag), CUNode(Node),
+      Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr) {
 }
 
 DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
                              DwarfDebug *DW, DwarfFile *DWU,
                              MCDwarfDwoLineTable *SplitLineTable)
     : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
       SplitLineTable(SplitLineTable) {
   if (SplitLineTable)
-    addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
+    addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
 }
 
 DwarfUnit::~DwarfUnit() {
   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
     DIEBlocks[j]->~DIEBlock();
   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
     DIELocs[j]->~DIELoc();
 }
void DwarfUnit::addDIETypeSignature(DIE &Die, dwarf::Attribute Attribute,
                                     StringRef Identifier) {
   uint64_t Signature = DD->makeTypeSignature(Identifier);
   Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_ref_sig8,
                DIEInteger(Signature));
 }
 
 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
                             DIEEntry Entry) {
-  const DIE *DieCU = Die.getUnitOrNull();
-  const DIE *EntryCU = Entry.getEntry().getUnitOrNull();
-  if (!DieCU)
+  const DIEUnit *CU = Die.getUnitOrNull();
+  const DIEUnit *EntryCU = Entry.getEntry().getUnitOrNull();
+  if (!CU)
     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
-    DieCU = &getUnitDie();
+    CU = getUnitDie().getUnit();
   if (!EntryCU)
-    EntryCU = &getUnitDie();
+    EntryCU = getUnitDie().getUnit();
   Die.addValue(DIEValueAllocator, Attribute,
-               EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
+               EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
                Entry);
 }
 
 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
   DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
   if (N)
     insertDIE(N, &Die);
   return Die;
if (Count != -1)
     // the array.
     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
 }
 
 DIE *DwarfUnit::getIndexTyDie() {
   if (IndexTyDie)
     return IndexTyDie;
   // Construct an integer type to use for indexes.
-  IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
+  IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie());
   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
           dwarf::DW_ATE_unsigned);
   return IndexTyDie;
 }
 
 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
             AlignInBytes);
 
   return &StaticMemberDIE;
 }
 
 void DwarfUnit::emitHeader(bool UseOffsets) {
   // Emit size of content not including length itself
   Asm->OutStreamer->AddComment("Length of Unit");
-  Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
+  Asm->EmitInt32(getHeaderSize() + getUnitDie().getSize());
 
   Asm->OutStreamer->AddComment("DWARF version number");
   Asm->EmitInt16(DD->getDwarfVersion());
   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
 
   // We share one abbreviations table across all units so it's always at the
   // start of the section. Use a relocatable offset where needed to ensure
   // linking doesn't invalidate that offset.
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
   if (UseOffsets)
     Asm->EmitInt32(0);
   else
     Asm->emitDwarfSymbolReference(
         TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
 
   Asm->OutStreamer->AddComment("Address Size (in bytes)");
   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
 }
 
-void DwarfUnit::initSection(MCSection *Section) {
-  assert(!this->Section);
-  this->Section = Section;
-}
-
 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
   DwarfUnit::emitHeader(UseOffsets);
   Asm->OutStreamer->AddComment("Type Signature");
   Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
   Asm->OutStreamer->AddComment("Type DIE Offset");
   // In a skeleton type unit there is no type DIE so emit a zero offset.
   Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
                                  sizeof(Ty->getOffset()));
 }
 
 bool DwarfTypeUnit::isDwoUnit() const {
   // Since there are no skeleton type units, all type units are dwo type units
   // when split DWARF is being used.
   return DD->useSplitDwarf();
 }

tools/dsymutil/DwarfLinker.cpp

 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptionsCommandFlags.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
+#include <memory>
 #include <string>
 #include <tuple>
 
 namespace llvm {
 namespace dsymutil {
 
 namespace {
 
struct DIEInfo {
     uint32_t ParentIdx; ///< The index of this DIE's parent.
     bool Keep : 1;      ///< Is the DIE part of the linked output?
     bool InDebugMap : 1;///< Was this DIE's entity found in the map?
     bool Prune : 1;     ///< Is this a pure forward declaration we can strip?
   };
 
   CompileUnit(DWARFUnit &OrigUnit, unsigned ID, bool CanUseODR,
               StringRef ClangModuleName)
-      : OrigUnit(OrigUnit), ID(ID), LowPc(UINT64_MAX), HighPc(0), RangeAlloc(),
-        Ranges(RangeAlloc), ClangModuleName(ClangModuleName) {
+      : OrigUnit(OrigUnit), ID(ID), NewUnit(OrigUnit.getVersion(),
+                                            OrigUnit.getAddressByteSize(),
+                                            OrigUnit.getUnitDIE()->getTag()),
+          LowPc(UINT64_MAX), HighPc(0), RangeAlloc(), Ranges(RangeAlloc),
+          ClangModuleName(ClangModuleName) {
     Info.resize(OrigUnit.getNumDIEs());
 
     const auto *CUDie = OrigUnit.getUnitDIE(false);
     unsigned Lang = CUDie->getAttributeValueAsUnsignedConstant(
         &OrigUnit, dwarf::DW_AT_language, 0);
     HasODR = CanUseODR && (Lang == dwarf::DW_LANG_C_plus_plus ||
                            Lang == dwarf::DW_LANG_C_plus_plus_03 ||
                            Lang == dwarf::DW_LANG_C_plus_plus_11 ||
                            Lang == dwarf::DW_LANG_C_plus_plus_14 ||
                            Lang == dwarf::DW_LANG_ObjC_plus_plus);
   }
 
-  CompileUnit(CompileUnit &&RHS)
-      : OrigUnit(RHS.OrigUnit), Info(std::move(RHS.Info)),
-        CUDie(std::move(RHS.CUDie)), StartOffset(RHS.StartOffset),
-        NextUnitOffset(RHS.NextUnitOffset), RangeAlloc(), Ranges(RangeAlloc) {
-    // The CompileUnit container has been 'reserve()'d with the right
-    // size. We cannot move the IntervalMap anyway.
-    llvm_unreachable("CompileUnits should not be moved.");
-  }
-
   DWARFUnit &getOrigUnit() const { return OrigUnit; }
 
   unsigned getUniqueID() const { return ID; }
 
-  DIE *getOutputUnitDIE() const { return CUDie; }
-  void setOutputUnitDIE(DIE *Die) { CUDie = Die; }
+  DIE *getOutputUnitDIE() const {
+    return &const_cast<DIEUnit &>(NewUnit).getUnitDie();
+  }
 
   bool hasODR() const { return HasODR; }
   bool isClangModule() const { return !ClangModuleName.empty(); }
   const std::string &getClangModuleName() const { return ClangModuleName; }
 
   DIEInfo &getInfo(unsigned Idx) { return Info[Idx]; }
   const DIEInfo &getInfo(unsigned Idx) const { return Info[Idx]; }
 
   uint64_t getStartOffset() const { return StartOffset; }
   uint64_t getNextUnitOffset() const { return NextUnitOffset; }
if (ResolvedPaths.size() <= FileNum)
       ResolvedPaths.resize(FileNum + 1);
     ResolvedPaths[FileNum] = Path;
   }
 
 private:
   DWARFUnit &OrigUnit;
   unsigned ID;
   std::vector<DIEInfo> Info; ///< DIE info indexed by DIE index.
-  DIE *CUDie;                ///< Root of the linked DIE tree.
+  DIEUnit NewUnit;
 
   uint64_t StartOffset;
   uint64_t NextUnitOffset;
 
   uint64_t LowPc;
   uint64_t HighPc;
 
   /// \brief A list of attributes to fixup with the absolute offset of
for (auto &I : Info)
     I.Keep = !I.Prune;
 }
 
 uint64_t CompileUnit::computeNextUnitOffset() {
   NextUnitOffset = StartOffset + 11 /* Header size */;
   // The root DIE might be null, meaning that the Unit had nothing to
   // contribute to the linked output. In that case, we will emit the
   // unit header without any actual DIE.
-  if (CUDie)
-    NextUnitOffset += CUDie->getSize();
+  NextUnitOffset += NewUnit.getUnitDie().getSize();
   return NextUnitOffset;
 }
 
 /// \brief Keep track of a forward cross-cu reference from this unit
 /// to \p Die that lives in \p RefUnit.
 void CompileUnit::noteForwardReference(DIE *Die, const CompileUnit *RefUnit,
                                        DeclContext *Ctxt, PatchLocation Attr) {
   ForwardDIEReferences.emplace_back(Die, RefUnit, Ctxt, Attr);
void DwarfStreamer::emitFDE(uint32_t CIEOffset, uint32_t AddrSize,
 
   MS->EmitIntValue(FDEBytes.size() + 4 + AddrSize, 4);
   MS->EmitIntValue(CIEOffset, 4);
   MS->EmitIntValue(Address, AddrSize);
   MS->EmitBytes(FDEBytes);
   FrameSectionSize += FDEBytes.size() + 8 + AddrSize;
 }
 
 /// \brief The core of the Dwarf linking logic.
 ///
 /// The link of the dwarf information from the object files will be
 /// driven by the selection of 'root DIEs', which are DIEs that
 /// describe variables or functions that are present in the linked
 /// binary (and thus have entries in the debug map). All the debug
 /// information that will be linked (the DIEs, but also the line
 /// tables, ranges, ...) is derived from that set of root DIEs.
 ///
 /// The root DIEs are identified because they contain relocations that
private:
   ///
   /// @{
 
   class DIECloner {
     DwarfLinker &Linker;
     RelocationManager &RelocMgr;
     /// Allocator used for all the DIEValue objects.
     BumpPtrAllocator &DIEAlloc;
-    MutableArrayRef<CompileUnit> CompileUnits;
+    std::vector<std::unique_ptr<CompileUnit>> &CompileUnits;
     LinkOptions Options;
 
   public:
     DIECloner(DwarfLinker &Linker, RelocationManager &RelocMgr,
               BumpPtrAllocator &DIEAlloc,
-              MutableArrayRef<CompileUnit> CompileUnits, LinkOptions &Options)
+              std::vector<std::unique_ptr<CompileUnit>> &CompileUnits,
+              LinkOptions &Options)
         : Linker(Linker), RelocMgr(RelocMgr), DIEAlloc(DIEAlloc),
           CompileUnits(CompileUnits), Options(Options) {}
 
     /// Recursively clone \p InputDIE into an tree of DIE objects
     /// where useless (as decided by lookForDIEsToKeep()) bits have been
     /// stripped out and addresses have been rewritten according to the
     /// debug map.
     ///
     /// \param OutOffset is the offset the cloned DIE in the output
     /// compile unit.
     /// \param PCOffset (while cloning a function scope) is the offset
     /// applied to the entry point of the function to get the linked address.
-    ///
+    /// \param Die the output DIE to use, pass NULL to create one.
     /// \returns the root of the cloned tree or null if nothing was selected.
     DIE *cloneDIE(const DWARFDebugInfoEntryMinimal &InputDIE, CompileUnit &U,
-                  int64_t PCOffset, uint32_t OutOffset, unsigned Flags);
+                  int64_t PCOffset, uint32_t OutOffset, unsigned Flags,
+                  DIE *Die = nullptr);
 
     /// Construct the output DIE tree by cloning the DIEs we
     /// chose to keep above. If there are no valid relocs, then there's
     /// nothing to clone/emit.
     void cloneAllCompileUnits(DWARFContextInMemory &DwarfContext);
 
   private:
     typedef DWARFAbbreviationDeclaration::AttributeSpec AttributeSpec;
private:
   std::string OutputFilename;
   LinkOptions Options;
   BinaryHolder BinHolder;
   std::unique_ptr<DwarfStreamer> Streamer;
   uint64_t OutputDebugInfoSize;
   unsigned UnitID; ///< A unique ID that identifies each compile unit.
 
   /// The units of the current debug map object.
-  std::vector<CompileUnit> Units;
+  std::vector<std::unique_ptr<CompileUnit>> Units;
+
 
   /// The debug map object currently under consideration.
   DebugMapObject *CurrentDebugObject;
 
   /// \brief The Dwarf string pool
   NonRelocatableStringpool StringPool;
 
   /// \brief This map is keyed by the entry PC of functions in that
private:
   StringMap<uint64_t> ClangModules;
 
   bool ModuleCacheHintDisplayed = false;
   bool ArchiveHintDisplayed = false;
 };
 
 /// Similar to DWARFUnitSection::getUnitForOffset(), but returning our
 /// CompileUnit object instead.
-static CompileUnit *getUnitForOffset(MutableArrayRef<CompileUnit> Units,
-                                     unsigned Offset) {
+static CompileUnit *getUnitForOffset(
+    std::vector<std::unique_ptr<CompileUnit>> &Units, unsigned Offset) {
   auto CU =
       std::upper_bound(Units.begin(), Units.end(), Offset,
-                       [](uint32_t LHS, const CompileUnit &RHS) {
-                         return LHS < RHS.getOrigUnit().getNextUnitOffset();
+                       [](uint32_t LHS, const std::unique_ptr<CompileUnit> &RHS) {
+                         return LHS < RHS->getOrigUnit().getNextUnitOffset();
                        });
-  return CU != Units.end() ? &*CU : nullptr;
+  return CU != Units.end() ? CU->get() : nullptr;
 }
 
 /// Resolve the DIE attribute reference that has been
 /// extracted in \p RefValue. The resulting DIE migh be in another
 /// CompileUnit which is stored into \p ReferencedCU.
 /// \returns null if resolving fails for any reason.
 static const DWARFDebugInfoEntryMinimal *resolveDIEReference(
-    const DwarfLinker &Linker, MutableArrayRef<CompileUnit> Units,
+    const DwarfLinker &Linker, std::vector<std::unique_ptr<CompileUnit>> &Units,
     const DWARFFormValue &RefValue, const DWARFUnit &Unit,
     const DWARFDebugInfoEntryMinimal &DIE, CompileUnit *&RefCU) {
   assert(RefValue.isFormClass(DWARFFormValue::FC_Reference));
   uint64_t RefOffset = *RefValue.getAsReference();
 
   if ((RefCU = getUnitForOffset(Units, RefOffset)))
     if (const auto *RefDie = RefCU->getOrigUnit().getDIEForOffset(RefOffset))
       return RefDie;
static bool dieNeedsChildrenToBeMeaningful(uint32_t Tag) {
   case dwarf::DW_TAG_class_type:
   case dwarf::DW_TAG_union_type:
     return true;
   }
   llvm_unreachable("Invalid Tag");
 }
 
 void DwarfLinker::startDebugObject(DWARFContext &Dwarf, DebugMapObject &Obj) {
-  Units.reserve(Dwarf.getNumCompileUnits());
   // Iterate over the debug map entries and put all the ones that are
   // functions (because they have a size) into the Ranges map. This
   // map is very similar to the FunctionRanges that are stored in each
   // unit, with 2 notable differences:
   //  - obviously this one is global, while the other ones are per-unit.
   //  - this one contains not only the functions described in the DIE
   // tree, but also the ones that are only in the debug map.
   // The latter information is required to reproduce dsymutil's logic
unsigned DwarfLinker::shouldKeepDIE(RelocationManager &RelocMgr,
   case dwarf::DW_TAG_subprogram:
     return shouldKeepSubprogramDIE(RelocMgr, DIE, Unit, MyInfo, Flags);
   case dwarf::DW_TAG_module:
   case dwarf::DW_TAG_imported_module:
   case dwarf::DW_TAG_imported_declaration:
   case dwarf::DW_TAG_imported_unit:
     // We always want to keep these.
     return Flags | TF_Keep;
+  default:
+    break;
   }
 
   return Flags;
 }
 
 /// \brief Mark the passed DIE as well as all the ones it depends on
 /// as kept.
 ///
for (const auto &AttrSpec : Abbrev->attributes()) {
     if (!Val.isFormClass(DWARFFormValue::FC_Reference)) {
       DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset, &Unit);
       continue;
     }
 
     Val.extractValue(Data, &Offset, &Unit);
     CompileUnit *ReferencedCU;
     if (const auto *RefDIE =
-            resolveDIEReference(*this, MutableArrayRef<CompileUnit>(Units), Val,
-                                Unit, Die, ReferencedCU)) {
+            resolveDIEReference(*this, Units, Val, Unit, Die, ReferencedCU)) {
       uint32_t RefIdx = ReferencedCU->getOrigUnit().getDIEIndex(RefDIE);
       CompileUnit::DIEInfo &Info = ReferencedCU->getInfo(RefIdx);
       // If the referenced DIE has a DeclContext that has already been
       // emitted, then do not keep the one in this CU. We'll link to
       // the canonical DIE in cloneDieReferenceAttribute.
       // FIXME: compatibility with dsymutil-classic. UseODR shouldn't
       // be necessary and could be advantageously replaced by
       // ReferencedCU->hasODR() && CU.hasODR().
case dwarf::DW_AT_frame_base:
     return (SkipPC || (!InFunctionScope && Tag == dwarf::DW_TAG_variable &&
                        !InDebugMap)) &&
            !DWARFFormValue(AttrSpec.Form).isFormClass(DWARFFormValue::FC_Block);
   }
 }
 
 DIE *DwarfLinker::DIECloner::cloneDIE(
     const DWARFDebugInfoEntryMinimal &InputDIE, CompileUnit &Unit,
-    int64_t PCOffset, uint32_t OutOffset, unsigned Flags) {
+    int64_t PCOffset, uint32_t OutOffset, unsigned Flags, DIE *Die) {
   DWARFUnit &U = Unit.getOrigUnit();
   unsigned Idx = U.getDIEIndex(&InputDIE);
   CompileUnit::DIEInfo &Info = Unit.getInfo(Idx);
 
   // Should the DIE appear in the output?
   if (!Unit.getInfo(Idx).Keep)
     return nullptr;
 
   uint32_t Offset = InputDIE.getOffset();
+  assert(!(Die && Info.Clone) && "Can't supply a DIE and a cloned DIE");
+  if (!Die) {
     // The DIE might have been already created by a forward reference
     // (see cloneDieReferenceAttribute()).
-  DIE *Die = Info.Clone;
-  if (!Die)
+    if (Info.Clone)
+      Die = Info.Clone;
+    else
       Die = Info.Clone = DIE::get(DIEAlloc, dwarf::Tag(InputDIE.getTag()));
+  }
+
   assert(Die->getTag() == InputDIE.getTag());
   Die->setOffset(OutOffset);
   if ((Unit.hasODR() || Unit.isClangModule()) &&
       Die->getTag() != dwarf::DW_TAG_namespace && Info.Ctxt &&
       Info.Ctxt != Unit.getInfo(Info.ParentIdx).Ctxt &&
       !Info.Ctxt->getCanonicalDIEOffset()) {
     // We are about to emit a DIE that is the root of its own valid
     // DeclContext tree. Make the current offset the canonical offset
if (!registerModuleReference(*CUDie, *CU, ModuleMap, Indent)) {
       Unit->markEverythingAsKept();
     }
   }
   if (Options.Verbose) {
     outs().indent(Indent);
     outs() << "cloning .debug_info from " << Filename << "\n";
   }
 
-  DIECloner(*this, RelocMgr, DIEAlloc, MutableArrayRef<CompileUnit>(*Unit),
-            Options)
+  std::vector<std::unique_ptr<CompileUnit>> CompileUnits;
+  CompileUnits.push_back(std::move(Unit));
+  DIECloner(*this, RelocMgr, DIEAlloc, CompileUnits, Options)
       .cloneAllCompileUnits(DwarfContext);
 }
 
 void DwarfLinker::DIECloner::cloneAllCompileUnits(
     DWARFContextInMemory &DwarfContext) {
   if (!Linker.Streamer)
     return;
 
   for (auto &CurrentUnit : CompileUnits) {
-    const auto *InputDIE = CurrentUnit.getOrigUnit().getUnitDIE();
-    CurrentUnit.setStartOffset(Linker.OutputDebugInfoSize);
-    DIE *OutputDIE = cloneDIE(*InputDIE, CurrentUnit, 0 /* PC offset */,
-                              11 /* Unit Header size */, 0);
-    CurrentUnit.setOutputUnitDIE(OutputDIE);
-    Linker.OutputDebugInfoSize = CurrentUnit.computeNextUnitOffset();
+    const auto *InputDIE = CurrentUnit->getOrigUnit().getUnitDIE();
+    CurrentUnit->setStartOffset(Linker.OutputDebugInfoSize);
+    // Clonse the InputDIE into your Unit DIE in our compile unit since it
+    // already has a DIE inside of it.
+    if (!cloneDIE(*InputDIE, *CurrentUnit, 0 /* PC offset */,
+                  11 /* Unit Header size */, 0,
+                  CurrentUnit->getOutputUnitDIE()))
+      continue;
+    Linker.OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset();
     if (Linker.Options.NoOutput)
       continue;
     // FIXME: for compatibility with the classic dsymutil, we emit
     // an empty line table for the unit, even if the unit doesn't
     // actually exist in the DIE tree.
-    Linker.patchLineTableForUnit(CurrentUnit, DwarfContext);
-    if (!OutputDIE)
-      continue;
-    Linker.patchRangesForUnit(CurrentUnit, DwarfContext);
-    Linker.Streamer->emitLocationsForUnit(CurrentUnit, DwarfContext);
-    Linker.emitAcceleratorEntriesForUnit(CurrentUnit);
+    Linker.patchLineTableForUnit(*CurrentUnit, DwarfContext);
+    Linker.patchRangesForUnit(*CurrentUnit, DwarfContext);
+    Linker.Streamer->emitLocationsForUnit(*CurrentUnit, DwarfContext);
+    Linker.emitAcceleratorEntriesForUnit(*CurrentUnit);
   }
 
   if (Linker.Options.NoOutput)
     return;
 
   // Emit all the compile unit's debug information.
   for (auto &CurrentUnit : CompileUnits) {
-    Linker.generateUnitRanges(CurrentUnit);
-    CurrentUnit.fixupForwardReferences();
-    Linker.Streamer->emitCompileUnitHeader(CurrentUnit);
-    if (!CurrentUnit.getOutputUnitDIE())
+    Linker.generateUnitRanges(*CurrentUnit);
+    CurrentUnit->fixupForwardReferences();
+    Linker.Streamer->emitCompileUnitHeader(*CurrentUnit);
+    if (!CurrentUnit->getOutputUnitDIE())
       continue;
-    Linker.Streamer->emitDIE(*CurrentUnit.getOutputUnitDIE());
+    Linker.Streamer->emitDIE(*CurrentUnit->getOutputUnitDIE());
   }
 }
 
 bool DwarfLinker::link(const DebugMap &Map) {
 
   if (!createStreamer(Map.getTriple(), OutputFilename))
     return false;
 
for (const auto &Obj : Map.objects()) {
     for (const auto &CU : DwarfContext.compile_units()) {
       auto *CUDie = CU->getUnitDIE(false);
       if (Options.Verbose) {
         outs() << "Input compilation unit:";
         CUDie->dump(outs(), CU.get(), 0);
       }
 
       if (!registerModuleReference(*CUDie, *CU, ModuleMap))
-        Units.emplace_back(*CU, UnitID++, !Options.NoODR, "");
+        Units.push_back(llvm::make_unique<CompileUnit>(*CU, UnitID++,
+                                                       !Options.NoODR, ""));
     }
 
     // Now build the DIE parent links that we will use during the next phase.
     for (auto &CurrentUnit : Units)
-      analyzeContextInfo(CurrentUnit.getOrigUnit().getUnitDIE(), 0, CurrentUnit,
+      analyzeContextInfo(CurrentUnit->getOrigUnit().getUnitDIE(), 0, *CurrentUnit,
                          &ODRContexts.getRoot(), StringPool, ODRContexts);
 
     // Then mark all the DIEs that need to be present in the linked
     // output and collect some information about them. Note that this
     // loop can not be merged with the previous one becaue cross-cu
     // references require the ParentIdx to be setup for every CU in
     // the object file before calling this.
     for (auto &CurrentUnit : Units)
-      lookForDIEsToKeep(RelocMgr, *CurrentUnit.getOrigUnit().getUnitDIE(), *Obj,
-                        CurrentUnit, 0);
+      lookForDIEsToKeep(RelocMgr, *CurrentUnit->getOrigUnit().getUnitDIE(), *Obj,
+                        *CurrentUnit, 0);
 
     // The calls to applyValidRelocs inside cloneDIE will walk the
     // reloc array again (in the same way findValidRelocsInDebugInfo()
     // did). We need to reset the NextValidReloc index to the beginning.
     RelocMgr.resetValidRelocs();
     if (RelocMgr.hasValidRelocs())
       DIECloner(*this, RelocMgr, DIEAlloc, Units, Options)
           .cloneAllCompileUnits(DwarfContext);
     if (!Options.NoOutput && !Units.empty())
       patchFrameInfoForObject(*Obj, DwarfContext,
-                              Units[0].getOrigUnit().getAddressByteSize());
+                              Units[0]->getOrigUnit().getAddressByteSize());
 
     // Clean-up before starting working on the next object.
     endDebugObject();
   }
 
   // Emit everything that's global.
   if (!Options.NoOutput) {
     Streamer->emitAbbrevs(Abbreviations);