[PATCH/RFC] Use a BumpAllocator for DIEs

[friss]

Summary

First of all, although this patch passes the testsuite, I don't
think it is ready to go in, at least not without a thorough
discussion of its downsides.

What the patch does is move away from using unique_ptr<>s to
track DIE object memory and allocate most of them using a
BumpAllocator. Making releasing the memory for the DIE tree
basically free. (DIEBlocks and DIELocs are still allocated using
the standard allocator, but they were already using separate
bookkeeping, so this doesn't complicate the patch).

I'm going down this road because the teardown of the DIE tree
uses a lot of CPU time, especially in dsymutil's usecase. In
my prototype, the DIE destructors take ~40 seconds to run for
DIE trees worth of 700MB of debug infomration. That's quite a
lot especially considering that dsymutil's runtime on this kind
of data should be around 2 minutes. I really need to find an
acceptale solution for dsymutil's usecase.

This patch achieves the performance gains that I expect, but there
is one big downside: it limits the number of attributes a DIE can
accept to a fixed maximum (well technically, if you remove the
assert in the code, it will work, but it will leak the attribute
vectors going over the limit).

Imposing this limit on users seems too strong as a constraint.
Especially considering not all frontends are in-tree. I can imagine
more flexible solutions involving complicated allocation strategies,
but I wanted to ask for opinions before I work on something that I
fear would end up much more complicated than this patch. Maybe
there's an easier solution that I haven't seen, happy to hear
suggestions.

BTW, the runtime difference is definitely measurable on a clang
debug build also, although the gained seconds do not represent
40% of the runtime like in dsymutil's case. On my machine, a clang
debug build goes from:

real 14m38.308s
user 45m26.856s
sys 3m53.519s

without the patch, to:

real 14m19.762s
user 44m14.438s
sys 3m45.520s

Shaving more than one minute of user time and 15 to 20 seconds from
wall-clock time.

[friss]

This update removes the limitation to a fixed maximum number of
attributes per DIE. The patch is very similar to the first one that
I sent for discussion. It only adds a pointer to a vector of DIEs
as arguement to DIE::addValue(). If a DIE overflows its inline storage
for attributes, it is added to the vector. The vector is then iterated
just before the BumpPtrAllocator is destroyed to call the destructors
of all these DIEs.

This approach gives the most flexibilty as it doesn't impose the
memory management upon the user (for example DIEHashTest.cpp continues
to use stack allocated DIEs and it works fine).

I've been playing with this for the last few days, and I have quite
a few different implementations lying around (for example using
std::vectors with a custom stateful allocator). They are all more
complicated and don't perform as well as this patch.

There's one point that I'd like to mention: the patch unifies the
existing bookkeeping of the DIEBlock and DIELoc objects and treats
them the same as standard DIEs. This means that we will call ~DIE
on DIEBlock and DIELoc objects which will result in a 'partial'
destruction (DIEBlock inherits both from DIEValue and from DIE).
I think this is fine. It should do exactly what we want and just
call the destructors of the SmallVectors in the DIE part of the
object, but I wanted to mention it in case someone thinks its not
legal to do that.

[dblaikie]

include/llvm/CodeGen/DIE.h

135

This might be able to be private inheritance? (just handle the DIEs by unique_ptr and then pass them into addChild)

Hmm, I suppose it'd need to friend the ilist instantiation & maybe other things, for this to be private inheritance?

157

I've a bit of an aversion to intrusive lists - so I wonder if you'd be willing to revisit the issues in the comment above (including the issue about why list<DIE> was insufficient - picking up from where I left off to see if we could reasonably rely on post-insertion pointer validity without too much convolution?).

Actually why move to ilist? These objects will never have their dtors run, right? So you could just switch from vector<unique_ptr<DIE>> to vector<DIE*> - everything's non-owning now, since their memory is managed by the BumpPtrAllocator entirely?

220

If we're going to go with ilist, could we improve/overload ilist's push_back to take unique_ptr for clarity?

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

67

Doesn't seem like it'd be too important to allocate the unit die with the DIEValueAllocator, does it?

I guess if you don't, then it can end up in the list of DIEs to deallocate, and ends up double-deleted? Again, this would be the sort of subtlety it might be best to avoid.

lib/CodeGen/AsmPrinter/DwarfUnit.h

116

This seems a bit subtle - having the SmallVector's dtors not be run unless they happen to go over the limit & reallocate. Could we use the existing BumpPtrAllocator as the allocator to the SmallVectors? Or something similar. (perhaps we discussed this, it's been a while)

unittests/CodeGen/DIEHashTest.cpp

626

Again, bit subtle - in the real use case this is non-owning because the parent's dtor is never run, etc, etc. But in the test case it is owning because the parent's dtor is run?

Hmm, that raises another question - once a DIE is added to the "DIEs to delete" list, what stops it from deleting its children DIEs? (since it's a member std::ilist in there) possibly leading to excess deletes (inefficiencies you're trying to remove) or double/triple/multiple deletes if children are in the "DIEs to delete" list too?

[friss]

include/llvm/CodeGen/DIE.h

135

Could try it, though I don't think I've seen that pattern anywhere else.

157

If we use list<DIE>, we'd need to use a std custom allocator that wraps the BumpPtrAllocator which would complicate things quite a bit. I could try it though. The whole point of the ilist here is that allocating a DIE allocates everything that's needed for the list bookkeeping.

Re: vector<DIE*>, you'd leak the vector storage if you do not call the destructor on every DIE.

220

I can try that.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

67

It's not important from a performance standpoint, but if I find the logic easier to follow if the rule is "allocate everything DIE related on the BumpPtrAllocator". If we allow this on to be a an exception to this rule, we must then handle its destruction specifically (as you point out, removing it from the DIEsToDelete list, but also making sure it drops its children and does not delete them).

lib/CodeGen/AsmPrinter/DwarfUnit.h

116

SmallVector don't accept configurable allocators AFAICS. I tried going with a std::vector with a custom allocator that wrapped a mix of recycliing + BumpPtrAllocator, but it didn't perform well.

I agree it's subtle, but it's the best tradeoff I could find.

unittests/CodeGen/DIEHashTest.cpp

626

This approach basically gives you the choice of ownership. If you wanna use something like a BumpPtrAllocator, then you use the DIEsToDelete trick to avoid leaking memory.

If you wanna use a more 'traditional' memory management scheme, it's also possible like in this test. The DIEs are still owned by their parents through the ilist of children, which means calling the root destructor will destroy everything.

This is handled in the BumpPtrAllocator by preventing the DIEs from the DIEsToDelete array to delete their children (look for clearAndLeakNodesUnsafely() in ~DwarfUnit). Yeah, subtle again...

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/SmallVector.h"
+#include "llvm/ADT/ilist_node.h"
+#include "llvm/ADT/ilist.h"
 #include "llvm/Support/Dwarf.h"
 #include <vector>
 
 namespace llvm {
 class AsmPrinter;
 class MCExpr;
 class MCSymbol;
 class raw_ostream;
 class DwarfTypeUnit;
 
+class DIE;
+
+template<>
+struct ilist_traits<DIE> : public ilist_default_traits<DIE> {
+  mutable ilist_half_node<DIE> Sentinel;
+
+  DIE *createSentinel() const;
+  void destroySentinel(DIE *) const {}
+
+  DIE *provideInitialHead() const { return createSentinel(); }
+  DIE *ensureHead(DIE*) const { return createSentinel(); }
+  static void noteHead(DIE*, DIE*) {}
+};
+
 //===--------------------------------------------------------------------===//
 /// DIEAbbrevData - Dwarf abbreviation data, describes one attribute of a
 /// Dwarf abbreviation.
 class DIEAbbrevData {
   /// Attribute - Dwarf attribute code.
   ///
   dwarf::Attribute Attribute;
 
public:
   ///
   void Profile(FoldingSetNodeID &ID) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// DIEAbbrev - Dwarf abbreviation, describes the organization of a debug
 /// information object.
 class DIEAbbrev : public FoldingSetNode {
+public:
+  // Number of inline elements in the SmallVector containing the
+  // AbbrevData elements. This needs to be the same as used inside DIE
+  // for the DIEValue lists so that we do not leak memory (see
+  // DIE::addValue()).
+  static const unsigned NumInlineAttributes = 12;
+
+private:
   /// Unique number for node.
   ///
   unsigned Number;
 
   /// Tag - Dwarf tag code.
   ///
   dwarf::Tag Tag;
 
   /// Children - Whether or not this node has children.
   ///
   // This cheats a bit in all of the uses since the values in the standard
   // are 0 and 1 for no children and children respectively.
   bool Children;
 
   /// Data - Raw data bytes for abbreviation.
   ///
-  SmallVector<DIEAbbrevData, 12> Data;
+  SmallVector<DIEAbbrevData, NumInlineAttributes> Data;
 
 public:
   DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C), Data() {}
 
   // Accessors.
   dwarf::Tag getTag() const { return Tag; }
   unsigned getNumber() const { return Number; }
   bool hasChildren() const { return Children; }

 #endif
 };
 
 //===--------------------------------------------------------------------===//
 /// DIE - A structured debug information entry.  Has an abbreviation which
 /// describes its organization.
 class DIEValue;
 
-class DIE {
+class DIE : public ilist_node<DIE> {
 protected:
   /// Offset - Offset in debug info section.
   ///
   unsigned Offset;
 
   /// Size - Size of instance + children.
   ///
   unsigned Size;
 
   /// Abbrev - Buffer for constructing abbreviation.
   ///
   DIEAbbrev Abbrev;
 
   /// Children DIEs.
   ///
   // This can't be a vector<DIE> because pointer validity is requirent for the
   // Parent pointer and DIEEntry.
   // It can't be a list<DIE> because some clients need pointer validity before
   // the object has been added to any child list
   // (eg: DwarfUnit::constructVariableDIE). These aren't insurmountable, but may
   // be more convoluted than beneficial.
-  std::vector<std::unique_ptr<DIE>> Children;
+  ilist<DIE> Children;
 
   DIE *Parent;
 
   /// Attribute values.
   ///
-  SmallVector<DIEValue *, 12> Values;
+  SmallVector<DIEValue *, DIEAbbrev::NumInlineAttributes> Values;
 
 protected:
   DIE()
       : Offset(0), Size(0), Abbrev((dwarf::Tag)0, dwarf::DW_CHILDREN_no),
         Parent(nullptr) {}
 
 public:
   explicit DIE(dwarf::Tag Tag)
       : Offset(0), Size(0), Abbrev((dwarf::Tag)Tag, dwarf::DW_CHILDREN_no),
         Parent(nullptr) {}
 
   // Accessors.
   DIEAbbrev &getAbbrev() { return Abbrev; }
   const DIEAbbrev &getAbbrev() const { return Abbrev; }
   unsigned getAbbrevNumber() const { return Abbrev.getNumber(); }
   dwarf::Tag getTag() const { return Abbrev.getTag(); }
   unsigned getOffset() const { return Offset; }
   unsigned getSize() const { return Size; }
-  const std::vector<std::unique_ptr<DIE>> &getChildren() const {
+  const ilist<DIE> &getChildren() const {
+    return Children;
+  }
+  ilist<DIE> &getChildren() {
     return Children;
   }
   const SmallVectorImpl<DIEValue *> &getValues() const { return Values; }
   DIE *getParent() const { return Parent; }
   /// Climb up the parent chain to get the compile or type unit DIE this DIE
   /// belongs to.
   const DIE *getUnit() const;
   /// Similar to getUnit, returns null when DIE is not added to an
   /// owner yet.
   const DIE *getUnitOrNull() const;
   void setOffset(unsigned O) { Offset = O; }
   void setSize(unsigned S) { Size = S; }
 
-  /// addValue - Add a value and attributes to a DIE.
+  /// \brief Add a value and attributes to a DIE.
   ///
-  void addValue(dwarf::Attribute Attribute, dwarf::Form Form, DIEValue *Value) {
+  /// \param DIEsToDelete If not null, the DIEs which contain
+  /// SmallVectors that needed to allocate out-of-line storage for
+  /// their elements are stored in this list. This allows to allocate
+  /// everything DIE-related from a BumpPtrAllocator while still
+  /// keeping track of the DIEs that need their destructors called so
+  /// that we don't leak their external memory.
+  void addValue(dwarf::Attribute Attribute, dwarf::Form Form, DIEValue *Value, std::vector<DIE *> *DIEsToDelete = nullptr) {
     Abbrev.AddAttribute(Attribute, Form);
     Values.push_back(Value);
+    if (DIEsToDelete && Values.size() == DIEAbbrev::NumInlineAttributes + 1)
+      DIEsToDelete->push_back(this);
   }
 
   /// addChild - Add a child to the DIE.
   ///
-  void addChild(std::unique_ptr<DIE> Child) {
+  void addChild(DIE* Child) {
     assert(!Child->getParent());
     Abbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes);
     Child->Parent = this;
     Children.push_back(std::move(Child));
   }
 
   /// findAttribute - Find a value in the DIE with the attribute given,
   /// returns NULL if no such attribute exists.
   DIEValue *findAttribute(dwarf::Attribute Attribute) const;
 
 #ifndef NDEBUG
   void print(raw_ostream &O, unsigned IndentCount = 0) const;
   void dump();
 #endif
 };
 
+inline DIE *
+ilist_traits<DIE>::createSentinel() const {
+  return static_cast<DIE*>(&Sentinel);
+}
+
 //===--------------------------------------------------------------------===//
 /// DIEValue - A debug information entry value. Some of these roughly correlate
 /// to DWARF attribute classes.
 ///
 class DIEValue {
   virtual void anchor();
 
 public:

lib/CodeGen/AsmPrinter/DIE.cpp

for (unsigned i = 0, N = Data.size(); i < N; ++i) {
     O <<  "  "
       << dwarf::FormEncodingString(Data[i].getForm())
       << " ";
     Values[i]->print(O);
     O << "\n";
   }
   IndentCount -= 2;
 
-  for (unsigned j = 0, M = Children.size(); j < M; ++j) {
-    Children[j]->print(O, IndentCount+4);
+  for (const auto &Child : Children) {
+    Child.print(O, IndentCount+4);
   }
 
   if (!isBlock) O << "\n";
 }
 
 void DIE::dump() {
   print(dbgs());
 }

lib/CodeGen/AsmPrinter/DIEHash.cpp

void DIEHash::computeHash(const DIE &Die) {
 
   // Add each of the attributes of the DIE.
   addAttributes(Die);
 
   // Then hash each of the children of the DIE.
   for (auto &C : Die.getChildren()) {
     // 7.27 Step 7
     // If C is a nested type entry or a member function entry, ...
-    if (isType(C->getTag()) || C->getTag() == dwarf::DW_TAG_subprogram) {
-      StringRef Name = getDIEStringAttr(*C, dwarf::DW_AT_name);
+    if (isType(C.getTag()) || C.getTag() == dwarf::DW_TAG_subprogram) {
+      StringRef Name = getDIEStringAttr(C, dwarf::DW_AT_name);
       // ... and has a DW_AT_name attribute
       if (!Name.empty()) {
-        hashNestedType(*C, Name);
+        hashNestedType(C, Name);
         continue;
       }
     }
-    computeHash(*C);
+    computeHash(C);
   }
 
   // Following the last (or if there are no children), append a zero byte.
   Hash.update(makeArrayRef((uint8_t)'\0'));
 }
 
 /// This is based on the type signature computation given in section 7.27 of the
 /// DWARF4 standard. It is the md5 hash of a flattened description of the DIE

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

class DwarfCompileUnit : public DwarfUnit {
   SmallVector<RangeSpan, 2> CURanges;
 
   // The base address of this unit, if any. Used for relative references in
   // ranges/locs.
   const MCSymbol *BaseAddress;
 
   /// \brief Construct a DIE for the given DbgVariable without initializing the
   /// DbgVariable's DIE reference.
-  std::unique_ptr<DIE> constructVariableDIEImpl(const DbgVariable &DV,
+  DIE *constructVariableDIEImpl(const DbgVariable &DV,
                                                 bool Abstract);
 
   bool isDwoUnit() const override;
 
   bool includeMinimalInlineScopes() const;
 
 public:
   DwarfCompileUnit(unsigned UID, DICompileUnit Node, AsmPrinter *A,
public:
 
   /// \brief Find DIE for the given subprogram and attach appropriate
   /// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global
   /// variables in this scope then create and insert DIEs for these
   /// variables.
   DIE &updateSubprogramScopeDIE(DISubprogram SP);
 
   void constructScopeDIE(LexicalScope *Scope,
-                         SmallVectorImpl<std::unique_ptr<DIE>> &FinalChildren);
+                         SmallVectorImpl<DIE *> &FinalChildren);
 
   /// \brief A helper function to construct a RangeSpanList for a given
   /// lexical scope.
   void addScopeRangeList(DIE &ScopeDIE, SmallVector<RangeSpan, 2> Range);
 
   void attachRangesOrLowHighPC(DIE &D, SmallVector<RangeSpan, 2> Ranges);
 
   void attachRangesOrLowHighPC(DIE &D,
                                const SmallVectorImpl<InsnRange> &Ranges);
   /// \brief This scope represents inlined body of a function. Construct
   /// DIE to represent this concrete inlined copy of the function.
-  std::unique_ptr<DIE> constructInlinedScopeDIE(LexicalScope *Scope);
+  DIE *constructInlinedScopeDIE(LexicalScope *Scope);
 
   /// \brief Construct new DW_TAG_lexical_block for this scope and
   /// attach DW_AT_low_pc/DW_AT_high_pc labels.
-  std::unique_ptr<DIE> constructLexicalScopeDIE(LexicalScope *Scope);
+  DIE *constructLexicalScopeDIE(LexicalScope *Scope);
 
   /// constructVariableDIE - Construct a DIE for the given DbgVariable.
-  std::unique_ptr<DIE> constructVariableDIE(DbgVariable &DV,
-                                            bool Abstract = false);
+  DIE *constructVariableDIE(DbgVariable &DV,
 
-  std::unique_ptr<DIE> constructVariableDIE(DbgVariable &DV,
-                                            const LexicalScope &Scope,
-                                            DIE *&ObjectPointer);
+  DIE *constructVariableDIE(DbgVariable &DV,
 
   /// A helper function to create children of a Scope DIE.
   DIE *createScopeChildrenDIE(LexicalScope *Scope,
-                              SmallVectorImpl<std::unique_ptr<DIE>> &Children,
+                              SmallVectorImpl<DIE *> &Children,
                               unsigned *ChildScopeCount = nullptr);
 
   /// \brief Construct a DIE for this subprogram scope.
   void constructSubprogramScopeDIE(LexicalScope *Scope);
 
   DIE *createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE);
 
   void constructAbstractSubprogramScopeDIE(LexicalScope *Scope);
 
   /// \brief Construct import_module DIE.
-  std::unique_ptr<DIE>
+  DIE *
   constructImportedEntityDIE(const DIImportedEntity &Module);
 
   void finishSubprogramDefinition(DISubprogram SP);
 
   void collectDeadVariables(DISubprogram SP);
 
   /// Set the skeleton unit associated with this unit.
   void setSkeleton(DwarfCompileUnit &Skel) { Skeleton = &Skel; }
void initSection(const MCSection *Section, MCSymbol *SectionSym) {
     // Don't bother labeling the .dwo unit, as its offset isn't used.
     if (!Skeleton)
       LabelBegin =
           Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
   }
 
   unsigned getLength() {
     return sizeof(uint32_t) + // Length field
-        getHeaderSize() + UnitDie.getSize();
+        getHeaderSize() + UnitDie->getSize();
   }
 
   void emitHeader(const MCSymbol *ASectionSym) const override;
 
   MCSymbol *getLabelBegin() const {
     assert(Section);
     return LabelBegin;
   }

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
   if (!DD->useSplitDwarf() || !Skeleton)
     return addLocalLabelAddress(Die, Attribute, Label);
 
   if (Label)
     DD->addArangeLabel(SymbolCU(this, Label));
 
   unsigned idx = DD->getAddressPool().getIndex(Label);
   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
-  Die.addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
+  Die.addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value, &DIEsToDelete);
 }
 
 void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
                                             dwarf::Attribute Attribute,
                                             const MCSymbol *Label) {
   if (Label)
     DD->addArangeLabel(SymbolCU(this, Label));
 
   Die.addValue(Attribute, dwarf::DW_FORM_addr,
                Label ? (DIEValue *)new (DIEValueAllocator) DIELabel(Label)
-                     : new (DIEValueAllocator) DIEInteger(0));
+                     : new (DIEValueAllocator) DIEInteger(0),
+               &DIEsToDelete);
 }
 
 unsigned DwarfCompileUnit::getOrCreateSourceID(StringRef FileName,
                                                StringRef DirName) {
   // If we print assembly, we can't separate .file entries according to
   // compile units. Thus all files will belong to the default compile unit.
 
   // FIXME: add a better feature test than hasRawTextSupport. Even better,
else
     addSectionDelta(Die, Attribute, Label, Sec);
 }
 
 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
   // Define start line table label for each Compile Unit.
   MCSymbol *LineTableStartSym =
       Asm->OutStreamer.getDwarfLineTableSymbol(getUniqueID());
 
-  stmtListIndex = UnitDie.getValues().size();
+  stmtListIndex = UnitDie->getValues().size();
 
   // 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.
-  addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym,
+  addSectionLabel(*UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym,
                   DwarfLineSectionSym);
 }
 
 void DwarfCompileUnit::applyStmtList(DIE &D) {
   D.addValue(dwarf::DW_AT_stmt_list,
-             UnitDie.getAbbrev().getData()[stmtListIndex].getForm(),
-             UnitDie.getValues()[stmtListIndex]);
+             UnitDie->getAbbrev().getData()[stmtListIndex].getForm(),
+             UnitDie->getValues()[stmtListIndex],
+             &DIEsToDelete);
 }
 
 void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,
                                        const MCSymbol *End) {
   assert(Begin && "Begin label should not be null!");
   assert(End && "End label should not be null!");
   assert(Begin->isDefined() && "Invalid starting label");
   assert(End->isDefined() && "Invalid end label");
DIE &DwarfCompileUnit::updateSubprogramScopeDIE(DISubprogram SP) {
   // to have concrete versions of our DW_TAG_subprogram nodes.
   DD->addSubprogramNames(SP, *SPDie);
 
   return *SPDie;
 }
 
 // Construct a DIE for this scope.
 void DwarfCompileUnit::constructScopeDIE(
-    LexicalScope *Scope, SmallVectorImpl<std::unique_ptr<DIE>> &FinalChildren) {
+    LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) {
   if (!Scope || !Scope->getScopeNode())
     return;
 
   DIScope DS(Scope->getScopeNode());
 
   assert((Scope->getInlinedAt() || !DS.isSubprogram()) &&
          "Only handle inlined subprograms here, use "
          "constructSubprogramScopeDIE for non-inlined "
          "subprograms");
 
-  SmallVector<std::unique_ptr<DIE>, 8> Children;
+  SmallVector<DIE *, 8> Children;
 
   // We try to create the scope DIE first, then the children DIEs. This will
   // avoid creating un-used children then removing them later when we find out
   // the scope DIE is null.
-  std::unique_ptr<DIE> ScopeDIE;
+  DIE *ScopeDIE;
   if (Scope->getParent() && DS.isSubprogram()) {
     ScopeDIE = constructInlinedScopeDIE(Scope);
     if (!ScopeDIE)
       return;
     // We create children when the scope DIE is not null.
     createScopeChildrenDIE(Scope, Children);
   } else {
     // Early exit when we know the scope DIE is going to be null.
void DwarfCompileUnit::constructScopeDIE(
   FinalChildren.push_back(std::move(ScopeDIE));
 }
 
 void DwarfCompileUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
                                        const MCSymbol *Hi, const MCSymbol *Lo) {
   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
   Die.addValue(Attribute, DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
                                                      : dwarf::DW_FORM_data4,
-               Value);
+               Value, &DIEsToDelete);
 }
 
 void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
                                          SmallVector<RangeSpan, 2> Range) {
   // Emit offset in .debug_range as a relocatable label. emitDIE will handle
   // emitting it appropriately.
   auto *RangeSectionSym = DD->getRangeSectionSym();
 
void DwarfCompileUnit::attachRangesOrLowHighPC(
   for (const InsnRange &R : Ranges)
     List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first),
                              DD->getLabelAfterInsn(R.second)));
   attachRangesOrLowHighPC(Die, std::move(List));
 }
 
 // This scope represents inlined body of a function. Construct DIE to
 // represent this concrete inlined copy of the function.
-std::unique_ptr<DIE>
+DIE *
 DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
   assert(Scope->getScopeNode());
   DIScope DS(Scope->getScopeNode());
   DISubprogram InlinedSP = getDISubprogram(DS);
   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
   // was inlined from another compile unit.
   DIE *OriginDIE = DU->getAbstractSPDies()[InlinedSP];
   assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
 
-  auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_inlined_subroutine);
+  auto ScopeDIE = new (DIEValueAllocator) DIE(dwarf::DW_TAG_inlined_subroutine);
   addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
 
   attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
 
   // Add the call site information to the DIE.
   DILocation DL(Scope->getInlinedAt());
   addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
           getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
   addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
 
   // Add name to the name table, we do this here because we're guaranteed
   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
   DD->addSubprogramNames(InlinedSP, *ScopeDIE);
 
   return ScopeDIE;
 }
 
 // Construct new DW_TAG_lexical_block for this scope and attach
 // DW_AT_low_pc/DW_AT_high_pc labels.
-std::unique_ptr<DIE>
+DIE *
 DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) {
   if (DD->isLexicalScopeDIENull(Scope))
     return nullptr;
 
-  auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_lexical_block);
+  auto ScopeDIE = new (DIEValueAllocator) DIE(dwarf::DW_TAG_lexical_block);
   if (Scope->isAbstractScope())
     return ScopeDIE;
 
   attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
 
   return ScopeDIE;
 }
 
 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
-std::unique_ptr<DIE> DwarfCompileUnit::constructVariableDIE(DbgVariable &DV,
-                                                            bool Abstract) {
+DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV,
   auto D = constructVariableDIEImpl(DV, Abstract);
   DV.setDIE(*D);
   return D;
 }
 
-std::unique_ptr<DIE>
+DIE *
 DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
                                            bool Abstract) {
   // Define variable debug information entry.
-  auto VariableDie = make_unique<DIE>(DV.getTag());
+  auto *VariableDie = new (DIEValueAllocator) DIE(DV.getTag());
 
   if (Abstract) {
     applyVariableAttributes(DV, *VariableDie);
     return VariableDie;
   }
 
   // Add variable address.
 
if (FI != ~0) {
     int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
     MachineLocation Location(FrameReg, Offset);
     addVariableAddress(DV, *VariableDie, Location);
   }
 
   return VariableDie;
 }
 
-std::unique_ptr<DIE> DwarfCompileUnit::constructVariableDIE(
+DIE *DwarfCompileUnit::constructVariableDIE(
     DbgVariable &DV, const LexicalScope &Scope, DIE *&ObjectPointer) {
   auto Var = constructVariableDIE(DV, Scope.isAbstractScope());
   if (DV.isObjectPointer())
-    ObjectPointer = Var.get();
+    ObjectPointer = Var;
   return Var;
 }
 
 DIE *DwarfCompileUnit::createScopeChildrenDIE(
-    LexicalScope *Scope, SmallVectorImpl<std::unique_ptr<DIE>> &Children,
+    LexicalScope *Scope, SmallVectorImpl<DIE *> &Children,
     unsigned *ChildScopeCount) {
   DIE *ObjectPointer = nullptr;
 
   for (DbgVariable *DV : DU->getScopeVariables().lookup(Scope))
     Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer));
 
   unsigned ChildCountWithoutScopes = Children.size();
 
if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
     addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
 
   // If we have a single element of null, it is a function that returns void.
   // If we have more than one elements and the last one is null, it is a
   // variadic function.
   if (FnArgs.getNumElements() > 1 &&
       !FnArgs.getElement(FnArgs.getNumElements() - 1) &&
       !includeMinimalInlineScopes())
-    ScopeDIE.addChild(make_unique<DIE>(dwarf::DW_TAG_unspecified_parameters));
+    ScopeDIE.addChild(new (DIEValueAllocator) DIE(dwarf::DW_TAG_unspecified_parameters));
 }
 
 DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
                                                  DIE &ScopeDIE) {
   // We create children when the scope DIE is not null.
-  SmallVector<std::unique_ptr<DIE>, 8> Children;
+  SmallVector<DIE *, 8> Children;
   DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children);
 
   // Add children
   for (auto &I : Children)
     ScopeDIE.addChild(std::move(I));
 
   return ObjectPointer;
 }
DwarfCompileUnit::constructAbstractSubprogramScopeDIE(LexicalScope *Scope) {
   applySubprogramAttributesToDefinition(SP, *AbsDef);
 
   if (!includeMinimalInlineScopes())
     addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
   if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, *AbsDef))
     addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
 }
 
-std::unique_ptr<DIE>
+DIE *
 DwarfCompileUnit::constructImportedEntityDIE(const DIImportedEntity &Module) {
   assert(Module.Verify() &&
          "Use one of the MDNode * overloads to handle invalid metadata");
-  std::unique_ptr<DIE> IMDie = make_unique<DIE>((dwarf::Tag)Module.getTag());
-  insertDIE(Module, IMDie.get());
+  DIE *IMDie = new (DIEValueAllocator) DIE((dwarf::Tag)Module.getTag());
+  insertDIE(Module, IMDie);
   DIE *EntityDie;
   DIDescriptor Entity = resolve(Module.getEntity());
   if (Entity.isNameSpace())
     EntityDie = getOrCreateNameSpace(DINameSpace(Entity));
   else if (Entity.isSubprogram())
     EntityDie = getOrCreateSubprogramDIE(DISubprogram(Entity));
   else if (Entity.isType())
     EntityDie = getOrCreateTypeDIE(DIType(Entity));

 }
 
 /// Add a Dwarf loclistptr attribute data and value.
 void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
                                        unsigned Index) {
   DIEValue *Value = new (DIEValueAllocator) DIELocList(Index);
   dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
                                                 : dwarf::DW_FORM_data4;
-  Die.addValue(Attribute, Form, Value);
+  Die.addValue(Attribute, Form, Value, &DIEsToDelete);
 }
 
 void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
                                                DIE &VariableDie) {
   StringRef Name = Var.getName();
   if (!Name.empty())
     addString(VariableDie, dwarf::DW_AT_name, Name);
   addSourceLine(VariableDie, Var.getVariable());
   addType(VariableDie, Var.getType());
   if (Var.isArtificial())
     addFlag(VariableDie, dwarf::DW_AT_artificial);
 }
 
 /// Add a Dwarf expression attribute data and value.
 void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form,
                                const MCExpr *Expr) {
   DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
-  Die.addValue((dwarf::Attribute)0, Form, Value);
+  Die.addValue((dwarf::Attribute)0, Form, Value, &DIEsToDelete);
 }
 
 void DwarfCompileUnit::applySubprogramAttributesToDefinition(DISubprogram SP,
                                                              DIE &SPDie) {
   DISubprogram SPDecl = SP.getFunctionDeclaration();
   DIScope Context = resolve(SPDecl ? SPDecl.getContext() : SP.getContext());
   applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes());
   addGlobalName(SP.getName(), SPDie, Context);

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (unsigned i = 0, N = Values.size(); i < N; ++i) {
 
     // Emit an attribute using the defined form.
     Values[i]->EmitValue(Asm, Form);
   }
 
   // Emit the DIE children if any.
   if (Abbrev.hasChildren()) {
     for (auto &Child : Die.getChildren())
-      emitDIE(*Child);
+      emitDIE(Child);
 
     Asm->OutStreamer.AddComment("End Of Children Mark");
     Asm->EmitInt8(0);
   }
 }
 
 // Emit the debug info section.
 void DwarfDebug::emitDebugInfo() {

lib/CodeGen/AsmPrinter/DwarfFile.cpp

unsigned DwarfFile::computeSizeAndOffset(DIE &Die, unsigned Offset) {
   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
 
   // Size the DIE attribute values.
   for (unsigned i = 0, N = Values.size(); i < N; ++i)
     // Size attribute value.
     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
 
   // Get the children.
-  const auto &Children = Die.getChildren();
+  auto &Children = Die.getChildren();
 
   // Size the DIE children if any.
   if (!Children.empty()) {
     assert(Abbrev.hasChildren() && "Children flag not set");
 
     for (auto &Child : Children)
-      Offset = computeSizeAndOffset(*Child, Offset);
+      Offset = computeSizeAndOffset(Child, Offset);
 
     // End of children marker.
     Offset += sizeof(int8_t);
   }
 
   Die.setSize(Offset - Die.getOffset());
   return Offset;
 }

lib/CodeGen/AsmPrinter/DwarfUnit.h

 protected:
   /// UniqueID - a numeric ID unique among all CUs in the module
   unsigned UniqueID;
 
   /// Node - MDNode for the compile unit.
   DICompileUnit CUNode;
 
   /// Unit debug information entry.
-  DIE UnitDie;
+  DIE *UnitDie;
 
   /// Offset of the UnitDie from beginning of debug info section.
   unsigned DebugInfoOffset;
 
   /// Asm - Target of Dwarf emission.
   AsmPrinter *Asm;
 
   // Holders for some common dwarf information.
   DwarfDebug *DD;
   DwarfFile *DU;
 
   /// IndexTyDie - An anonymous type for index type.  Owned by UnitDie.
   DIE *IndexTyDie;
 
   /// MDNodeToDieMap - Tracks the mapping of unit level debug information
   /// variables to debug information entries.
   DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
 
   /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug information
   /// descriptors to debug information entries using a DIEEntry proxy.
   DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
 
   /// DIEBlocks - A list of all the DIEBlocks in use.
-  std::vector<DIEBlock *> DIEBlocks;
+  //  std::vector<DIEBlock *> DIEBlocks;
   
   /// DIELocs - A list of all the DIELocs in use.
-  std::vector<DIELoc *> DIELocs;
+  //  std::vector<DIELoc *> DIELocs;
 
   /// ContainingTypeMap - 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 MDNode *> ContainingTypeMap;
 
   // DIEValueAllocator - All DIEValues are allocated through this allocator.
   BumpPtrAllocator DIEValueAllocator;
+  // Contains the DIEs that have had more attributes added that their
+  // inline SmallVector can contain. Their destructor needs to be
+  // called so that the SmallVector's memory isn't leaked.
+  std::vector<DIE*> DIEsToDelete;
 
   // DIEIntegerOne - A preallocated DIEValue because 1 is used frequently.
   DIEInteger *DIEIntegerOne;
 
   /// The section this unit will be emitted in.
   const MCSection *Section;
 
   DwarfUnit(unsigned UID, dwarf::Tag, DICompileUnit CU, AsmPrinter *A,
const MCSection *getSection() const {
     return Section;
   }
 
   // Accessors.
   AsmPrinter* getAsmPrinter() const { return Asm; }
   unsigned getUniqueID() const { return UniqueID; }
   uint16_t getLanguage() const { return CUNode.getLanguage(); }
   DICompileUnit getCUNode() const { return CUNode; }
-  DIE &getUnitDie() { return UnitDie; }
+  DIE &getUnitDie() { return *UnitDie; }
 
   unsigned getDebugInfoOffset() const { return DebugInfoOffset; }
   void setDebugInfoOffset(unsigned DbgInfoOff) { DebugInfoOffset = DbgInfoOff; }
 
   /// hasContent - Return true if this compile unit has something to write out.
-  bool hasContent() const { return !UnitDie.getChildren().empty(); }
+  bool hasContent() const { return !UnitDie->getChildren().empty(); }
 
   /// getParentContextString - Get a string containing the language specific
   /// context for a global name.
   std::string getParentContextString(DIScope Context) const;
 
   /// Add a new global name to the compile unit.
   virtual void addGlobalName(StringRef Name, DIE &Die, DIScope Context) {}
 

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 bool DIEDwarfExpression::isFrameRegister(unsigned MachineReg) {
   return MachineReg == getTRI()->getFrameRegister(*AP.MF);
 }
 
 
 /// Unit - Unit constructor.
 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
-    : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
+    : UniqueID(UID), CUNode(Node), DebugInfoOffset(0), Asm(A),
       DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
   assert(UnitTag == dwarf::DW_TAG_compile_unit ||
          UnitTag == dwarf::DW_TAG_type_unit);
+  UnitDie = new (DIEValueAllocator) DIE(UnitTag);
   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
 }
 
 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
                              DwarfDebug *DW, DwarfFile *DWU,
                              MCDwarfDwoLineTable *SplitLineTable)
     : DwarfUnit(UID, 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(*UnitDie, dwarf::DW_AT_stmt_list, 0);
 }
 
 /// ~Unit - Destructor for compile unit.
 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();
+  // The BumpPtrAllocator we have used for everything DIE related will
+  // be destroyed. Free the AbbrevData/DIEValue SmallVectors that have
+  // grown over their inline size().
+  for (unsigned j = 0, M = DIEsToDelete.size(); j < M; ++j) {
+    // Prevent the list of children from being deleted with the
+    // DIE. They have been allocated through the BumpPtrAllocator, we
+    // must not destroy the list elements.
+    DIEsToDelete[j]->getChildren().clearAndLeakNodesUnsafely();
+    DIEsToDelete[j]->~DIE();
+  }
 }
 
 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
 /// information entry.
 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
   return Value;
 }
if (isShareableAcrossCUs(Desc)) {
     return;
   }
   MDNodeToDieMap.insert(std::make_pair(Desc, D));
 }
 
 /// addFlag - Add a flag that is true.
 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
   if (DD->getDwarfVersion() >= 4)
-    Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
+    Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne,
+                 &DIEsToDelete);
   else
-    Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
+    Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne, &DIEsToDelete);
 }
 
 /// addUInt - Add an unsigned integer attribute data and value.
 ///
 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
                         Optional<dwarf::Form> Form, uint64_t Integer) {
   if (!Form)
     Form = DIEInteger::BestForm(false, Integer);
   DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
                         DIEInteger(Integer);
-  Die.addValue(Attribute, *Form, Value);
+  Die.addValue(Attribute, *Form, Value, &DIEsToDelete);
 }
 
 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
 }
 
 /// addSInt - Add an signed integer attribute data and value.
 ///
 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
                         Optional<dwarf::Form> Form, int64_t Integer) {
   if (!Form)
     Form = DIEInteger::BestForm(true, Integer);
   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
-  Die.addValue(Attribute, *Form, Value);
+  Die.addValue(Attribute, *Form, Value, &DIEsToDelete);
 }
 
 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
                         int64_t Integer) {
   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 }
 
 /// addString - Add a string attribute data and value. We always emit a
void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
   addIndexedString(Die, Attribute, String);
 }
 
 void DwarfUnit::addIndexedString(DIE &Die, dwarf::Attribute Attribute,
                                  StringRef String) {
   unsigned idx = DU->getStringPool().getIndex(*Asm, String);
   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
-  Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
+  Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str, &DIEsToDelete);
 }
 
 /// addLocalString - Add a string attribute data and value. This is guaranteed
 /// to be in the local string pool instead of indirected.
 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
                                StringRef String) {
   MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
   DIEValue *Value;
   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
     Value = new (DIEValueAllocator) DIELabel(Symb);
   else
     Value = new (DIEValueAllocator) DIEDelta(Symb, DD->getDebugStrSym());
   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
-  Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
+  Die.addValue(Attribute, dwarf::DW_FORM_strp, Str, &DIEsToDelete);
 }
 
 /// addLabel - Add a Dwarf label attribute data and value.
 ///
 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
                          const MCSymbol *Label) {
   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
-  Die.addValue(Attribute, Form, Value);
+  Die.addValue(Attribute, Form, Value, &DIEsToDelete);
 }
 
 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
   addLabel(Die, (dwarf::Attribute)0, Form, Label);
 }
 
 /// addSectionOffset - Add an offset into a section attribute data and value.
 ///
if (!DD->useSplitDwarf()) {
     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
             DD->getAddressPool().getIndex(Sym));
   }
 }
 
 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
                               const MCSymbol *Hi, const MCSymbol *Lo) {
   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
-  Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
+  Die.addValue(Attribute, dwarf::DW_FORM_data4, Value, &DIEsToDelete);
 }
 
 /// addDIEEntry - Add a DIE attribute data and value.
 ///
 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
 }
 
 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
   // Flag the type unit reference as a declaration so that if it contains
   // members (implicit special members, static data member definitions, member
   // declarations for definitions in this CU, etc) consumers don't get confused
   // and think this is a full definition.
   addFlag(Die, dwarf::DW_AT_declaration);
 
   Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
-               new (DIEValueAllocator) DIETypeSignature(Type));
+               new (DIEValueAllocator) DIETypeSignature(Type), &DIEsToDelete);
 }
 
 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
                             DIEEntry *Entry) {
   const DIE *DieCU = Die.getUnitOrNull();
   const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
   if (!DieCU)
     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
     DieCU = &getUnitDie();
   if (!EntryCU)
     EntryCU = &getUnitDie();
   Die.addValue(Attribute,
                EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
-               Entry);
+               Entry, &DIEsToDelete);
 }
 
 /// Create a DIE with the given Tag, add the DIE to its parent, and
 /// call insertDIE if MD is not null.
 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
   assert(Tag != dwarf::DW_TAG_auto_variable &&
          Tag != dwarf::DW_TAG_arg_variable);
-  Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
-  DIE &Die = *Parent.getChildren().back();
+  Parent.addChild(new (DIEValueAllocator) DIE((dwarf::Tag)Tag));
+  DIE &Die = Parent.getChildren().back();
   if (N)
     insertDIE(N, &Die);
   return Die;
 }
 
 /// addBlock - Add block data.
 ///
 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
   Loc->ComputeSize(Asm);
-  DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
-  Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
+  Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc,
+               &DIEsToDelete);
 }
 
 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
                          DIEBlock *Block) {
   Block->ComputeSize(Asm);
-  DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
-  Die.addValue(Attribute, Block->BestForm(), Block);
+  Die.addValue(Attribute, Block->BestForm(), Block, &DIEsToDelete);
 }
 
 /// addSourceLine - Add location information to specified debug information
 /// entry.
 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
                               StringRef Directory) {
   if (Line == 0)
     return;
void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
   }
 
   // Get the offsets for the forwarding field and the variable field.
   unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
   unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
 
   // Decode the original location, and use that as the start of the byref
   // variable's location.
-  DIELoc *Loc = new (DIEValueAllocator) DIELoc();
+  DIELoc *Loc = new DIELoc();
 
   bool validReg;
   if (Location.isReg())
     validReg = addRegisterOpPiece(*Loc, Location.getReg());
   else
     validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
 
   if (!validReg)
if (BaseType.isDerivedType())
     return getBaseTypeSize(DD, DIDerivedType(BaseType));
 
   return BaseType.getSizeInBits();
 }
 
 /// addConstantFPValue - Add constant value entry in variable DIE.
 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
   assert(MO.isFPImm() && "Invalid machine operand!");
-  DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
+  DIEBlock *Block = new DIEBlock();
   APFloat FPImm = MO.getFPImm()->getValueAPF();
 
   // Get the raw data form of the floating point.
   const APInt FltVal = FPImm.bitcastToAPInt();
   const char *FltPtr = (const char *)FltVal.getRawData();
 
   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
   bool LittleEndian = Asm->getDataLayout().isLittleEndian();

 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
   unsigned CIBitWidth = Val.getBitWidth();
   if (CIBitWidth <= 64) {
     addConstantValue(Die, Unsigned,
                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
     return;
   }
 
-  DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
+  DIEBlock *Block = new DIEBlock();
 
   // Get the raw data form of the large APInt.
   const uint64_t *Ptr64 = Val.getRawData();
 
   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 
   // Output the constant to DWARF one byte at a time.
DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
   if (!VP.getName().empty())
     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
   if (Metadata *Val = VP.getValue()) {
     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
       addConstantValue(ParamDIE, CI, resolve(VP.getType()));
     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
       // For declaration non-type template parameters (such as global values and
       // functions)
-      DIELoc *Loc = new (DIEValueAllocator) DIELoc();
+      DIELoc *Loc = new DIELoc();
       addOpAddress(*Loc, Asm->getSymbol(GV));
       // Emit DW_OP_stack_value to use the address as the immediate value of the
       // parameter, rather than a pointer to it.
       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
       assert(isa<MDString>(Val));
       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
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, *UnitDie);
   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;
 }
 
 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
   addSourceLine(MemberDie, DT);
 
   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
 
     // For C++, virtual base classes are not at fixed offset. Use following
     // expression to extract appropriate offset from vtable.
     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
 
-    DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
+    DIELoc *VBaseLocationDie = new DIELoc();
     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
 
if (Size != FieldSize) {
       // Here DW_AT_data_member_location points to the anonymous
       // field that includes this bit field.
       OffsetInBytes = FieldOffset >> 3;
     } else
       // This is not a bitfield.
       OffsetInBytes = DT.getOffsetInBits() >> 3;
 
     if (DD->getDwarfVersion() <= 2) {
-      DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
+      DIELoc *MemLocationDie = new DIELoc();
       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
     } else
       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
               OffsetInBytes);
   }
 
void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
   if (DT.isVirtual())
     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
             dwarf::DW_VIRTUALITY_virtual);
 
   // Objective-C properties.
   if (MDNode *PNode = DT.getObjCProperty())
     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
-                         PropertyDie);
+                         PropertyDie, &DIEsToDelete);
 
   if (DT.isArtificial())
     addFlag(MemberDie, dwarf::DW_AT_artificial);
 }
 
 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
   if (!DT.Verify())
if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
     addConstantFPValue(StaticMemberDIE, CFP);
 
   return &StaticMemberDIE;
 }
 
 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
   // Emit size of content not including length itself
   Asm->OutStreamer.AddComment("Length of Unit");
-  Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
+  Asm->EmitInt32(getHeaderSize() + UnitDie->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.
   if (ASectionSym)

unittests/CodeGen/DIEHashTest.cpp

TEST(DIEHashTest, NamedType) {
   // The exact same hash GCC produces for this DIE.
   ASSERT_EQ(0xd566dbd2ca5265ffULL, MD5Res);
 }
 
 // namespace space { struct foo { }; }
 TEST(DIEHashTest, NamespacedType) {
   DIE CU(dwarf::DW_TAG_compile_unit);
 
-  auto Space = make_unique<DIE>(dwarf::DW_TAG_namespace);
+  DIE *Space = new DIE(dwarf::DW_TAG_namespace);
   DIEInteger One(1);
   DIEString SpaceStr(&One, "space");
   Space->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &SpaceStr);
   // DW_AT_declaration is ignored.
   Space->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
   // sibling?
 
-  auto Foo = make_unique<DIE>(dwarf::DW_TAG_structure_type);
+  DIE *Foo = new DIE(dwarf::DW_TAG_structure_type);
   DIEString FooStr(&One, "foo");
   Foo->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
   Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 
   DIE &N = *Foo;
-  Space->addChild(std::move(Foo));
-  CU.addChild(std::move(Space));
+  Space->addChild(Foo);
+  CU.addChild(Space);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(N);
 
   // The exact same hash GCC produces for this DIE.
   ASSERT_EQ(0x7b80381fd17f1e33ULL, MD5Res);
 }
 
 // struct { int member; };
 TEST(DIEHashTest, TypeWithMember) {
   DIE Unnamed(dwarf::DW_TAG_structure_type);
   DIEInteger Four(4);
   Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
 
   DIE Int(dwarf::DW_TAG_base_type);
   DIEString IntStr(&Four, "int");
   Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &IntStr);
   Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
   DIEInteger Five(5);
   Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
 
   DIEEntry IntRef(Int);
 
-  auto Member = make_unique<DIE>(dwarf::DW_TAG_member);
+  DIE *Member = new DIE(dwarf::DW_TAG_member);
   DIEString MemberStr(&Four, "member");
   Member->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemberStr);
   DIEInteger Zero(0);
   Member->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
                    &Zero);
   Member->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
 
-  Unnamed.addChild(std::move(Member));
+  Unnamed.addChild(Member);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
 
   ASSERT_EQ(0x5646aa436b7e07c6ULL, MD5Res);
 }
 
 // struct foo { int mem1, mem2; };
 TEST(DIEHashTest, ReusedType) {
   DIE Unnamed(dwarf::DW_TAG_structure_type);
   DIEInteger Eight(8);
   Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 
   DIEInteger Four(4);
   DIE Int(dwarf::DW_TAG_base_type);
   DIEString IntStr(&Four, "int");
   Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &IntStr);
   Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
   DIEInteger Five(5);
   Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
 
   DIEEntry IntRef(Int);
 
-  auto Mem1 = make_unique<DIE>(dwarf::DW_TAG_member);
+  DIE *Mem1 = new DIE(dwarf::DW_TAG_member);
   DIEString Mem1Str(&Four, "mem1");
   Mem1->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem1Str);
   DIEInteger Zero(0);
   Mem1->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
                  &Zero);
   Mem1->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
 
-  Unnamed.addChild(std::move(Mem1));
+  Unnamed.addChild(Mem1);
 
-  auto Mem2 = make_unique<DIE>(dwarf::DW_TAG_member);
+  DIE *Mem2 = new DIE(dwarf::DW_TAG_member);
   DIEString Mem2Str(&Four, "mem2");
   Mem2->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem2Str);
   Mem2->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
                  &Four);
   Mem2->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
 
-  Unnamed.addChild(std::move(Mem2));
+  Unnamed.addChild(Mem2);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
 
   ASSERT_EQ(0x3a7dc3ed7b76b2f8ULL, MD5Res);
 }
 
 // struct foo { static foo f; };
 TEST(DIEHashTest, RecursiveType) {
   DIE Foo(dwarf::DW_TAG_structure_type);
   DIEInteger One(1);
   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
   DIEString FooStr(&One, "foo");
   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 
-  auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
+  DIE *Mem = new DIE(dwarf::DW_TAG_member);
   DIEString MemStr(&One, "mem");
   Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
   DIEEntry FooRef(Foo);
   Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef);
   // DW_AT_external and DW_AT_declaration are ignored anyway, so skip them.
 
-  Foo.addChild(std::move(Mem));
+  Foo.addChild(Mem);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 
   ASSERT_EQ(0x73d8b25aef227b06ULL, MD5Res);
 }
 
 // struct foo { foo *mem; };
 TEST(DIEHashTest, Pointer) {
   DIE Foo(dwarf::DW_TAG_structure_type);
   DIEInteger Eight(8);
   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
   DIEString FooStr(&Eight, "foo");
   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 
-  auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
+  DIE *Mem = new DIE(dwarf::DW_TAG_member);
   DIEString MemStr(&Eight, "mem");
   Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
   DIEInteger Zero(0);
   Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
 
   DIE FooPtr(dwarf::DW_TAG_pointer_type);
   FooPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
   DIEEntry FooRef(Foo);
   FooPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef);
 
   DIEEntry FooPtrRef(FooPtr);
   Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooPtrRef);
 
-  Foo.addChild(std::move(Mem));
+  Foo.addChild(Mem);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 
   ASSERT_EQ(0x74ea73862e8708d2ULL, MD5Res);
 }
 
 // struct foo { foo &mem; };
 TEST(DIEHashTest, Reference) {
   DIE Foo(dwarf::DW_TAG_structure_type);
   DIEInteger Eight(8);
   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
   DIEString FooStr(&Eight, "foo");
   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 
-  auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
+  DIE *Mem = new DIE(dwarf::DW_TAG_member);
   DIEString MemStr(&Eight, "mem");
   Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
   DIEInteger Zero(0);
   Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
 
   DIE FooRef(dwarf::DW_TAG_reference_type);
   FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
   DIEEntry FooEntry(Foo);
   FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
 
   DIE FooRefConst(dwarf::DW_TAG_const_type);
   DIEEntry FooRefRef(FooRef);
   FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
 
   DIEEntry FooRefConstRef(FooRefConst);
   Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
 
-  Foo.addChild(std::move(Mem));
+  Foo.addChild(Mem);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 
   ASSERT_EQ(0xa0b15f467ad4525bULL, MD5Res);
 }
 
 // struct foo { foo &&mem; };
 TEST(DIEHashTest, RValueReference) {
   DIE Foo(dwarf::DW_TAG_structure_type);
   DIEInteger Eight(8);
   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
   DIEString FooStr(&Eight, "foo");
   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 
-  auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
+  DIE *Mem = new DIE(dwarf::DW_TAG_member);
   DIEString MemStr(&Eight, "mem");
   Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
   DIEInteger Zero(0);
   Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
 
   DIE FooRef(dwarf::DW_TAG_rvalue_reference_type);
   FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
   DIEEntry FooEntry(Foo);
   FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
 
   DIE FooRefConst(dwarf::DW_TAG_const_type);
   DIEEntry FooRefRef(FooRef);
   FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
 
   DIEEntry FooRefConstRef(FooRefConst);
   Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
 
-  Foo.addChild(std::move(Mem));
+  Foo.addChild(Mem);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 
   ASSERT_EQ(0xad211c8c3b31e57ULL, MD5Res);
 }
 
 // struct foo { foo foo::*mem; };
 TEST(DIEHashTest, PtrToMember) {
   DIE Foo(dwarf::DW_TAG_structure_type);
   DIEInteger Eight(8);
   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
   DIEString FooStr(&Eight, "foo");
   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 
-  auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
+  DIE *Mem = new DIE(dwarf::DW_TAG_member);
   DIEString MemStr(&Eight, "mem");
   Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
   DIEInteger Zero(0);
   Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
 
   DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
   DIEEntry FooEntry(Foo);
   PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
   PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
                        &FooEntry);
 
   DIEEntry PtrToFooMemRef(PtrToFooMem);
   Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
 
-  Foo.addChild(std::move(Mem));
+  Foo.addChild(Mem);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 
   ASSERT_EQ(0x852e0c9ff7c04ebULL, MD5Res);
 }
 
 // Check that the hash for a pointer-to-member matches regardless of whether the
 // pointed-to type is a declaration or a definition.
uint64_t MD5ResDecl;
     DIE Bar(dwarf::DW_TAG_structure_type);
     Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
     Bar.addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
 
     DIE Foo(dwarf::DW_TAG_structure_type);
     Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
     Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 
-    auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
+    DIE *Mem = new DIE(dwarf::DW_TAG_member);
     Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
     Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
                   &Zero);
 
     DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
     DIEEntry BarEntry(Bar);
     PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
     DIEEntry FooEntry(Foo);
     PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
                          &FooEntry);
 
     DIEEntry PtrToFooMemRef(PtrToFooMem);
     Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
 
-    Foo.addChild(std::move(Mem));
+    Foo.addChild(Mem);
 
     MD5ResDecl = DIEHash().computeTypeSignature(Foo);
   }
   uint64_t MD5ResDef;
   {
     DIE Bar(dwarf::DW_TAG_structure_type);
     Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
     Bar.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 
     DIE Foo(dwarf::DW_TAG_structure_type);
     Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
     Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 
-    auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
+    DIE *Mem = new DIE(dwarf::DW_TAG_member);
     Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
     Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
                   &Zero);
 
     DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
     DIEEntry BarEntry(Bar);
     PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
     DIEEntry FooEntry(Foo);
     PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
                          &FooEntry);
 
     DIEEntry PtrToFooMemRef(PtrToFooMem);
     Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
 
-    Foo.addChild(std::move(Mem));
+    Foo.addChild(Mem);
 
     MD5ResDef = DIEHash().computeTypeSignature(Foo);
   }
   ASSERT_EQ(MD5ResDef, MD5ResDecl);
 }
 
 // Check that the hash for a pointer-to-member matches regardless of whether the
 // pointed-to type is a declaration or a definition.
uint64_t MD5ResDecl;
     DIE Bar(dwarf::DW_TAG_structure_type);
     Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
     Bar.addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
 
     DIE Foo(dwarf::DW_TAG_structure_type);
     Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
     Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 
-    auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
+    DIE *Mem = new DIE(dwarf::DW_TAG_member);
     Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
     Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
                   &Zero);
 
     DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
     DIEEntry BarEntry(Bar);
     PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
     PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
                          &BarEntry);
 
     DIEEntry PtrToFooMemRef(PtrToFooMem);
     Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
 
-    Foo.addChild(std::move(Mem));
+    Foo.addChild(Mem);
 
     MD5ResDecl = DIEHash().computeTypeSignature(Foo);
   }
   uint64_t MD5ResDef;
   {
     DIE Bar(dwarf::DW_TAG_structure_type);
     Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
     Bar.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 
     DIE Foo(dwarf::DW_TAG_structure_type);
     Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
     Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 
-    auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
+    DIE *Mem = new DIE(dwarf::DW_TAG_member);
     Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
     Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
                   &Zero);
 
     DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
     DIEEntry BarEntry(Bar);
     PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
     PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
                          &BarEntry);
 
     DIEEntry PtrToFooMemRef(PtrToFooMem);
     Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
 
-    Foo.addChild(std::move(Mem));
+    Foo.addChild(Mem);
 
     MD5ResDef = DIEHash().computeTypeSignature(Foo);
   }
   // FIXME: This seems to be a bug in the DWARF type hashing specification that
   // only uses the brief name hashing for types referenced via DW_AT_type. In
   // this case the type is referenced via DW_AT_containing_type and full hashing
   // causes a hash to differ when the containing type is a declaration in one TU
   // and a definition in another.
TEST(DIEHashTest, RefUnnamedType) {
 
   DIE Unnamed(dwarf::DW_TAG_structure_type);
   Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 
   DIE Foo(dwarf::DW_TAG_structure_type);
   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 
-  auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
+  DIE *Mem = new DIE(dwarf::DW_TAG_member);
   Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
   Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
 
   DIE UnnamedPtr(dwarf::DW_TAG_pointer_type);
   UnnamedPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
   DIEEntry UnnamedRef(Unnamed);
   UnnamedPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedRef);
 
   DIEEntry UnnamedPtrRef(UnnamedPtr);
   Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedPtrRef);
 
-  Foo.addChild(std::move(Mem));
+  Foo.addChild(Mem);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 
   ASSERT_EQ(0x954e026f01c02529ULL, MD5Res);
 }
 
 // struct { struct foo { }; };
 TEST(DIEHashTest, NestedType) {
   DIE Unnamed(dwarf::DW_TAG_structure_type);
   DIEInteger One(1);
   Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 
-  auto Foo = make_unique<DIE>(dwarf::DW_TAG_structure_type);
+  DIE *Foo = new DIE(dwarf::DW_TAG_structure_type);
   DIEString FooStr(&One, "foo");
   Foo->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
   Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 
-  Unnamed.addChild(std::move(Foo));
+  Unnamed.addChild(Foo);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
 
   // The exact same hash GCC produces for this DIE.
   ASSERT_EQ(0xde8a3b7b43807f4aULL, MD5Res);
 }
 
 // struct { static void func(); };
 TEST(DIEHashTest, MemberFunc) {
   DIE Unnamed(dwarf::DW_TAG_structure_type);
   DIEInteger One(1);
   Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 
-  auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram);
+  DIE *Func = new DIE(dwarf::DW_TAG_subprogram);
   DIEString FuncStr(&One, "func");
   Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FuncStr);
 
-  Unnamed.addChild(std::move(Func));
+  Unnamed.addChild(Func);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
 
   // The exact same hash GCC produces for this DIE.
   ASSERT_EQ(0xd36a1b6dfb604ba0ULL, MD5Res);
 }
 
 // struct A {
 //   static void func();
 // };
 TEST(DIEHashTest, MemberFuncFlag) {
   DIE A(dwarf::DW_TAG_structure_type);
   DIEInteger One(1);
   DIEString AStr(&One, "A");
   A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &AStr);
   A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
   A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
   A.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One);
 
-  auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram);
+  DIE *Func = new DIE(dwarf::DW_TAG_subprogram);
   DIEString FuncStr(&One, "func");
   DIEString FuncLinkage(&One, "_ZN1A4funcEv");
   DIEInteger Two(2);
   Func->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, &One);
   Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FuncStr);
   Func->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
   Func->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &Two);
   Func->addValue(dwarf::DW_AT_linkage_name, dwarf::DW_FORM_strp, &FuncLinkage);
   Func->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
 
-  A.addChild(std::move(Func));
+  A.addChild(Func);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(A);
 
   // The exact same hash GCC produces for this DIE.
   ASSERT_EQ(0x8f78211ddce3df10ULL, MD5Res);
 }
 
 // Derived from:
TEST(DIEHashTest, MemberSdata) {
   IntTyDIE.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
   IntTyDIE.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FStr);
 
   DIEEntry IntTy(IntTyDIE);
   auto PITyDIE = make_unique<DIE>(dwarf::DW_TAG_const_type);
   PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntTy);
 
   DIEEntry PITy(*PITyDIE);
-  auto PI = make_unique<DIE>(dwarf::DW_TAG_member);
+  DIE *PI = new DIE(dwarf::DW_TAG_member);
   DIEString PIStr(&One, "PI");
   DIEInteger Two(2);
   DIEInteger NegThree(-3);
   PI->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &PIStr);
   PI->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
   PI->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &Two);
   PI->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PITy);
   PI->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, &One);
   PI->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
   PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, &NegThree);
 
-  A.addChild(std::move(PI));
+  A.addChild(PI);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(A);
   ASSERT_EQ(0x9a216000dd3788a7ULL, MD5Res);
 }
 
 // Derived from:
 // struct A {
 //   const static float PI = 3.14;
TEST(DIEHashTest, MemberBlock) {
   FloatTyDIE->addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Four);
   FloatTyDIE->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FStr);
 
   DIEEntry FloatTy(*FloatTyDIE);
   auto PITyDIE = make_unique<DIE>(dwarf::DW_TAG_const_type);
   PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FloatTy);
 
   DIEEntry PITy(*PITyDIE);
-  auto PI = make_unique<DIE>(dwarf::DW_TAG_member);
+  DIE *PI = new DIE(dwarf::DW_TAG_member);
   DIEString PIStr(&One, "PI");
   DIEInteger Two(2);
   PI->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &PIStr);
   PI->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
   PI->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &Two);
   PI->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PITy);
   PI->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, &One);
   PI->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
 
   DIEBlock PIBlock;
   DIEInteger Blk1(0xc3);
   DIEInteger Blk2(0xf5);
   DIEInteger Blk3(0x48);
   DIEInteger Blk4(0x40);
 
   PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk1);
   PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk2);
   PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk3);
   PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk4);
 
   PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_block1, &PIBlock);
 
-  A.addChild(std::move(PI));
+  A.addChild(PI);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(A);
   ASSERT_EQ(0x493af53ad3d3f651ULL, MD5Res);
 }
 }