From: Duncan P. N. Exon Smith Date: Thu, 25 Jun 2015 23:46:41 +0000 (+0000) Subject: AsmPrinter: Convert DIE::Values to a linked list X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=73e3fb6ba88bee77e46f15da4994299572cd15a0;p=oota-llvm.git AsmPrinter: Convert DIE::Values to a linked list Change `DIE::Values` to a singly linked list, where each node is allocated on a `BumpPtrAllocator`. In order to support `push_back()`, the list is circular, and points at the tail element instead of the head. I abstracted the core list logic out to `IntrusiveBackList` so that it can be reused for `DIE::Children`, which also cares about `push_back()`. This drops llc memory usage from 799 MB down to 735 MB, about 8%. (I'm looking at `llc` memory usage on `verify-uselistorder.lto.opt.bc`; see r236629 for details.) git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@240733 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/ADT/iterator.h b/include/llvm/ADT/iterator.h index 54a288df017..c3079289270 100644 --- a/include/llvm/ADT/iterator.h +++ b/include/llvm/ADT/iterator.h @@ -162,6 +162,8 @@ protected: int>::type = 0) : I(std::forward(u)) {} + const WrappedIteratorT &wrapped() const { return I; } + public: typedef DifferenceTypeT difference_type; diff --git a/include/llvm/CodeGen/DIE.h b/include/llvm/CodeGen/DIE.h index 7d98b4e1483..5d589f7619b 100644 --- a/include/llvm/CodeGen/DIE.h +++ b/include/llvm/CodeGen/DIE.h @@ -15,6 +15,8 @@ #define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H #include "llvm/ADT/FoldingSet.h" +#include "llvm/ADT/PointerIntPair.h" +#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallVector.h" #include "llvm/CodeGen/DwarfStringPoolEntry.h" #include "llvm/Support/Dwarf.h" @@ -448,6 +450,162 @@ public: #endif }; +struct IntrusiveBackListNode { + PointerIntPair Next; + IntrusiveBackListNode() : Next(this, true) {} + + IntrusiveBackListNode *getNext() const { + return Next.getInt() ? nullptr : Next.getPointer(); + } +}; + +struct IntrusiveBackListBase { + typedef IntrusiveBackListNode Node; + Node *Last = nullptr; + + bool empty() const { return !Last; } + void push_back(Node &N) { + assert(N.Next.getPointer() == &N && "Expected unlinked node"); + assert(N.Next.getInt() == true && "Expected unlinked node"); + + if (Last) { + N.Next = Last->Next; + Last->Next.setPointerAndInt(&N, false); + } + Last = &N; + } +}; + +template class IntrusiveBackList : IntrusiveBackListBase { +public: + using IntrusiveBackListBase::empty; + void push_back(T &N) { IntrusiveBackListBase::push_back(N); } + T &back() { return *static_cast(Last); } + const T &back() const { return *static_cast(Last); } + + class const_iterator; + class iterator + : public iterator_facade_base { + friend class const_iterator; + Node *N = nullptr; + + public: + iterator() = default; + explicit iterator(T *N) : N(N) {} + + iterator &operator++() { + N = N->getNext(); + return *this; + } + + explicit operator bool() const { return N; } + T &operator*() const { return *static_cast(N); } + + bool operator==(const iterator &X) const { return N == X.N; } + bool operator!=(const iterator &X) const { return N != X.N; } + }; + + class const_iterator + : public iterator_facade_base { + const Node *N = nullptr; + + public: + const_iterator() = default; + const_iterator(iterator X) : N(X.N) {} + explicit const_iterator(const T *N) : N(N) {} + + const_iterator &operator++() { + N = N->getNext(); + return *this; + } + + explicit operator bool() const { return N; } + const T &operator*() const { return *static_cast(N); } + + bool operator==(const const_iterator &X) const { return N == X.N; } + bool operator!=(const const_iterator &X) const { return N != X.N; } + }; + + iterator begin() { + return Last ? iterator(static_cast(Last->Next.getPointer())) : end(); + } + const_iterator begin() const { + return const_cast(this)->begin(); + } + iterator end() { return iterator(); } + const_iterator end() const { return const_iterator(); } + + static iterator toIterator(T &N) { return iterator(&N); } + static const_iterator toIterator(const T &N) { return const_iterator(&N); } +}; + +/// A list of DIE values. +/// +/// This is a singly-linked list, but instead of reversing the order of +/// insertion, we keep a pointer to the back of the list so we can push in +/// order. +class DIEValueList { + struct Node : IntrusiveBackListNode { + DIEValue V; + explicit Node(DIEValue V) : V(V) {} + }; + + typedef IntrusiveBackList ListTy; + ListTy List; + +public: + bool empty() const { return List.empty(); } + + class const_iterator; + class iterator + : public iterator_adaptor_base { + friend class const_iterator; + typedef iterator_adaptor_base iterator_adaptor; + + public: + iterator() = default; + explicit iterator(ListTy::iterator X) : iterator_adaptor(X) {} + + explicit operator bool() const { return bool(wrapped()); } + DIEValue &operator*() const { return wrapped()->V; } + }; + + class const_iterator + : public iterator_adaptor_base { + typedef iterator_adaptor_base iterator_adaptor; + + public: + const_iterator() = default; + const_iterator(DIEValueList::iterator X) : iterator_adaptor(X.wrapped()) {} + explicit const_iterator(ListTy::const_iterator X) : iterator_adaptor(X) {} + + explicit operator bool() const { return bool(wrapped()); } + const DIEValue &operator*() const { return wrapped()->V; } + }; + + iterator insert(BumpPtrAllocator &Alloc, DIEValue V) { + List.push_back(*new (Alloc) Node(V)); + return iterator(ListTy::toIterator(List.back())); + } + template + iterator emplace(BumpPtrAllocator &Alloc, Ts &&... Args) { + return insert(Alloc, DIEValue(std::forward(Args)...)); + } + + iterator begin() { return iterator(List.begin()); } + iterator end() { return iterator(List.end()); } + const_iterator begin() const { return const_iterator(List.begin()); } + const_iterator end() const { return const_iterator(List.end()); } +}; + //===--------------------------------------------------------------------===// /// DIE - A structured debug information entry. Has an abbreviation which /// describes its organization. @@ -481,7 +639,7 @@ protected: /// Attribute values. /// - SmallVector Values; + DIEValueList Values; protected: DIE() : Offset(0), Size(0), Parent(nullptr) {} @@ -504,19 +662,20 @@ public: return llvm::make_range(Children.begin(), Children.end()); } - typedef SmallVectorImpl::const_iterator value_iterator; + typedef DIEValueList::iterator value_iterator; typedef iterator_range value_range; - value_iterator values_begin() const { return Values.begin(); } - value_iterator values_end() const { return Values.end(); } - value_range values() const { - return llvm::make_range(values_begin(), values_end()); + value_range values() { + return llvm::make_range(Values.begin(), Values.end()); } - void setValue(unsigned I, DIEValue New) { - assert(I < Values.size()); - Values[I] = New; + typedef DIEValueList::const_iterator const_value_iterator; + typedef iterator_range const_value_range; + + const_value_range values() const { + return llvm::make_range(Values.begin(), Values.end()); } + DIE *getParent() const { return Parent; } /// Generate the abbreviation for this DIE. @@ -539,10 +698,13 @@ public: /// addValue - Add a value and attributes to a DIE. /// - void addValue(DIEValue Value) { Values.push_back(Value); } + value_iterator addValue(BumpPtrAllocator &Alloc, DIEValue Value) { + return Values.insert(Alloc, Value); + } template - void addValue(dwarf::Attribute Attribute, dwarf::Form Form, T &&Value) { - Values.emplace_back(Attribute, Form, std::forward(Value)); + value_iterator addValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute, + dwarf::Form Form, T &&Value) { + return Values.emplace(Alloc, Attribute, Form, std::forward(Value)); } /// addChild - Add a child to the DIE. diff --git a/lib/CodeGen/AsmPrinter/DIE.cpp b/lib/CodeGen/AsmPrinter/DIE.cpp index 80e9096bfea..30493c82565 100644 --- a/lib/CodeGen/AsmPrinter/DIE.cpp +++ b/lib/CodeGen/AsmPrinter/DIE.cpp @@ -165,18 +165,17 @@ void DIE::print(raw_ostream &O, unsigned IndentCount) const { } IndentCount += 2; - for (unsigned i = 0, N = Values.size(); i < N; ++i) { + unsigned I = 0; + for (const auto &V : Values) { O << Indent; if (!isBlock) - O << dwarf::AttributeString(Values[i].getAttribute()); + O << dwarf::AttributeString(V.getAttribute()); else - O << "Blk[" << i << "]"; + O << "Blk[" << I++ << "]"; - O << " " - << dwarf::FormEncodingString(Values[i].getForm()) - << " "; - Values[i].print(O); + O << " " << dwarf::FormEncodingString(V.getForm()) << " "; + V.print(O); O << "\n"; } IndentCount -= 2; diff --git a/lib/CodeGen/AsmPrinter/DIEHash.cpp b/lib/CodeGen/AsmPrinter/DIEHash.cpp index 1445254e6c2..56bd9067bf3 100644 --- a/lib/CodeGen/AsmPrinter/DIEHash.cpp +++ b/lib/CodeGen/AsmPrinter/DIEHash.cpp @@ -263,7 +263,7 @@ void DIEHash::hashDIEEntry(dwarf::Attribute Attribute, dwarf::Tag Tag, // Hash all of the values in a block like set of values. This assumes that // all of the data is going to be added as integers. -void DIEHash::hashBlockData(const DIE::value_range &Values) { +void DIEHash::hashBlockData(const DIE::const_value_range &Values) { for (const auto &V : Values) Hash.update((uint64_t)V.getDIEInteger().getValue()); } diff --git a/lib/CodeGen/AsmPrinter/DIEHash.h b/lib/CodeGen/AsmPrinter/DIEHash.h index 1850e042f92..833ca0276fd 100644 --- a/lib/CodeGen/AsmPrinter/DIEHash.h +++ b/lib/CodeGen/AsmPrinter/DIEHash.h @@ -128,7 +128,7 @@ private: /// \brief Hashes the data in a block like DIEValue, e.g. DW_FORM_block or /// DW_FORM_exprloc. - void hashBlockData(const DIE::value_range &Values); + void hashBlockData(const DIE::const_value_range &Values); /// \brief Hashes the contents pointed to in the .debug_loc section. void hashLocList(const DIELocList &LocList); diff --git a/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp b/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp index 70ebd72d3e1..46cde884401 100644 --- a/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp +++ b/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp @@ -42,7 +42,8 @@ void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute, DD->addArangeLabel(SymbolCU(this, Label)); unsigned idx = DD->getAddressPool().getIndex(Label); - Die.addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, DIEInteger(idx)); + Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_GNU_addr_index, + DIEInteger(idx)); } void DwarfCompileUnit::addLocalLabelAddress(DIE &Die, @@ -52,9 +53,11 @@ void DwarfCompileUnit::addLocalLabelAddress(DIE &Die, DD->addArangeLabel(SymbolCU(this, Label)); if (Label) - Die.addValue(Attribute, dwarf::DW_FORM_addr, DIELabel(Label)); + Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr, + DIELabel(Label)); else - Die.addValue(Attribute, dwarf::DW_FORM_addr, DIEInteger(0)); + Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr, + DIEInteger(0)); } unsigned DwarfCompileUnit::getOrCreateSourceID(StringRef FileName, @@ -225,16 +228,15 @@ void DwarfCompileUnit::addRange(RangeSpan Range) { CURanges.back().setEnd(Range.getEnd()); } -void DwarfCompileUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute, - const MCSymbol *Label, - const MCSymbol *Sec) { +DIE::value_iterator +DwarfCompileUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute, + const MCSymbol *Label, const MCSymbol *Sec) { if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) - addLabel(Die, Attribute, - DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset - : dwarf::DW_FORM_data4, - Label); - else - addSectionDelta(Die, Attribute, Label, Sec); + return addLabel(Die, Attribute, + DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset + : dwarf::DW_FORM_data4, + Label); + return addSectionDelta(Die, Attribute, Label, Sec); } void DwarfCompileUnit::initStmtList() { @@ -242,20 +244,19 @@ void DwarfCompileUnit::initStmtList() { MCSymbol *LineTableStartSym = Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID()); - stmtListIndex = std::distance(UnitDie.values_begin(), UnitDie.values_end()); - // 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(); - addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym, - TLOF.getDwarfLineSection()->getBeginSymbol()); + StmtListValue = + addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym, + TLOF.getDwarfLineSection()->getBeginSymbol()); } void DwarfCompileUnit::applyStmtList(DIE &D) { - D.addValue(UnitDie.values_begin()[stmtListIndex]); + D.addValue(DIEValueAllocator, *StmtListValue); } void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin, @@ -361,11 +362,13 @@ void DwarfCompileUnit::constructScopeDIE( FinalChildren.push_back(std::move(ScopeDIE)); } -void DwarfCompileUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute, - const MCSymbol *Hi, const MCSymbol *Lo) { - Die.addValue(Attribute, DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset - : dwarf::DW_FORM_data4, - new (DIEValueAllocator) DIEDelta(Hi, Lo)); +DIE::value_iterator +DwarfCompileUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute, + const MCSymbol *Hi, const MCSymbol *Lo) { + return Die.addValue(DIEValueAllocator, Attribute, + DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset + : dwarf::DW_FORM_data4, + new (DIEValueAllocator) DIEDelta(Hi, Lo)); } void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE, @@ -781,7 +784,7 @@ void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute, unsigned Index) { dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset : dwarf::DW_FORM_data4; - Die.addValue(Attribute, Form, DIELocList(Index)); + Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index)); } void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var, @@ -798,7 +801,7 @@ void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var, /// Add a Dwarf expression attribute data and value. void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr) { - Die.addValue((dwarf::Attribute)0, Form, DIEExpr(Expr)); + Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr)); } void DwarfCompileUnit::applySubprogramAttributesToDefinition( diff --git a/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h b/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h index 50e4a54eb3e..03721a21ee1 100644 --- a/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h +++ b/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h @@ -31,7 +31,7 @@ class LexicalScope; class DwarfCompileUnit : public DwarfUnit { /// The attribute index of DW_AT_stmt_list in the compile unit DIE, avoiding /// the need to search for it in applyStmtList. - unsigned stmtListIndex; + DIE::value_iterator StmtListValue; /// Skeleton unit associated with this unit. DwarfCompileUnit *Skeleton; @@ -92,8 +92,8 @@ public: const MCSymbol *Label); /// addSectionDelta - Add a label delta attribute data and value. - void addSectionDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, - const MCSymbol *Lo); + DIE::value_iterator addSectionDelta(DIE &Die, dwarf::Attribute Attribute, + const MCSymbol *Hi, const MCSymbol *Lo); DwarfCompileUnit &getCU() override { return *this; } @@ -106,8 +106,9 @@ public: /// addSectionLabel - Add a Dwarf section label attribute data and value. /// - void addSectionLabel(DIE &Die, dwarf::Attribute Attribute, - const MCSymbol *Label, const MCSymbol *Sec); + DIE::value_iterator addSectionLabel(DIE &Die, dwarf::Attribute Attribute, + const MCSymbol *Label, + const MCSymbol *Sec); /// \brief Find DIE for the given subprogram and attach appropriate /// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global diff --git a/lib/CodeGen/AsmPrinter/DwarfUnit.cpp b/lib/CodeGen/AsmPrinter/DwarfUnit.cpp index f4b15ba053e..6977e300200 100644 --- a/lib/CodeGen/AsmPrinter/DwarfUnit.cpp +++ b/lib/CodeGen/AsmPrinter/DwarfUnit.cpp @@ -184,16 +184,18 @@ void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) { void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) { if (DD->getDwarfVersion() >= 4) - Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEInteger(1)); + Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present, + DIEInteger(1)); else - Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEInteger(1)); + Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag, + DIEInteger(1)); } void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute, Optional Form, uint64_t Integer) { if (!Form) Form = DIEInteger::BestForm(false, Integer); - Die.addValue(Attribute, *Form, DIEInteger(Integer)); + Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer)); } void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) { @@ -204,7 +206,7 @@ void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute, Optional Form, int64_t Integer) { if (!Form) Form = DIEInteger::BestForm(true, Integer); - Die.addValue(Attribute, *Form, DIEInteger(Integer)); + Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer)); } void DwarfUnit::addSInt(DIELoc &Die, Optional Form, @@ -214,14 +216,15 @@ void DwarfUnit::addSInt(DIELoc &Die, Optional Form, void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute, StringRef String) { - Die.addValue(Attribute, + Die.addValue(DIEValueAllocator, Attribute, isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp, DIEString(DU->getStringPool().getEntry(*Asm, String))); } -void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form, - const MCSymbol *Label) { - Die.addValue(Attribute, Form, DIELabel(Label)); +DIE::value_iterator DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, + dwarf::Form Form, + const MCSymbol *Label) { + return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label)); } void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) { @@ -254,7 +257,7 @@ void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) { void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo) { - Die.addValue(Attribute, dwarf::DW_FORM_data4, + Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_data4, new (DIEValueAllocator) DIEDelta(Hi, Lo)); } @@ -269,8 +272,8 @@ void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) { // and think this is a full definition. addFlag(Die, dwarf::DW_AT_declaration); - Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8, - DIETypeSignature(Type)); + Die.addValue(DIEValueAllocator, dwarf::DW_AT_signature, + dwarf::DW_FORM_ref_sig8, DIETypeSignature(Type)); } void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, @@ -282,7 +285,7 @@ void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DieCU = &getUnitDie(); if (!EntryCU) EntryCU = &getUnitDie(); - Die.addValue(Attribute, + Die.addValue(DIEValueAllocator, Attribute, EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr, Entry); } @@ -299,14 +302,15 @@ DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) { 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(DIEValueAllocator, Attribute, + Loc->BestForm(DD->getDwarfVersion()), Loc); } 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(DIEValueAllocator, Attribute, Block->BestForm(), Block); } void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File, @@ -1386,8 +1390,8 @@ void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) { // Objective-C properties. if (DINode *PNode = DT->getObjCProperty()) if (DIE *PDie = getDIE(PNode)) - MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4, - DIEEntry(*PDie)); + MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property, + dwarf::DW_FORM_ref4, DIEEntry(*PDie)); if (DT->isArtificial()) addFlag(MemberDie, dwarf::DW_AT_artificial); diff --git a/lib/CodeGen/AsmPrinter/DwarfUnit.h b/lib/CodeGen/AsmPrinter/DwarfUnit.h index f56c9b4eb13..bf2b872e69b 100644 --- a/lib/CodeGen/AsmPrinter/DwarfUnit.h +++ b/lib/CodeGen/AsmPrinter/DwarfUnit.h @@ -73,6 +73,9 @@ protected: /// MDNode for the compile unit. const DICompileUnit *CUNode; + // All DIEValues are allocated through this allocator. + BumpPtrAllocator DIEValueAllocator; + /// Unit debug information entry. DIE UnitDie; @@ -104,9 +107,6 @@ protected: /// corresponds to the MDNode mapped with the subprogram DIE. DenseMap ContainingTypeMap; - // All DIEValues are allocated through this allocator. - BumpPtrAllocator DIEValueAllocator; - /// The section this unit will be emitted in. MCSection *Section; @@ -206,8 +206,8 @@ public: void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str); /// \brief Add a Dwarf label attribute data and value. - void addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form, - const MCSymbol *Label); + DIE::value_iterator addLabel(DIE &Die, dwarf::Attribute Attribute, + dwarf::Form Form, const MCSymbol *Label); void addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label); diff --git a/tools/dsymutil/DwarfLinker.cpp b/tools/dsymutil/DwarfLinker.cpp index a678a01f8da..a2cf7d3dc6e 100644 --- a/tools/dsymutil/DwarfLinker.cpp +++ b/tools/dsymutil/DwarfLinker.cpp @@ -60,33 +60,23 @@ using HalfOpenIntervalMap = typedef HalfOpenIntervalMap FunctionIntervals; -// FIXME: Delete this structure once DIE::Values has a stable iterator we can -// use instead. +// FIXME: Delete this structure. struct PatchLocation { - DIE *Die; - unsigned Index; + DIE::value_iterator I; - PatchLocation() : Die(nullptr), Index(0) {} - PatchLocation(DIE &Die, unsigned Index) : Die(&Die), Index(Index) {} - PatchLocation(DIE &Die) - : Die(&Die), Index(std::distance(Die.values_begin(), Die.values_end())) {} + PatchLocation() = default; + PatchLocation(DIE::value_iterator I) : I(I) {} void set(uint64_t New) const { - assert(Die); - assert((signed)Index < - std::distance(Die->values_begin(), Die->values_end())); - const auto &Old = Die->values_begin()[Index]; + assert(I); + const auto &Old = *I; assert(Old.getType() == DIEValue::isInteger); - Die->setValue(Index, - DIEValue(Old.getAttribute(), Old.getForm(), DIEInteger(New))); + *I = DIEValue(Old.getAttribute(), Old.getForm(), DIEInteger(New)); } uint64_t get() const { - assert(Die); - assert((signed)Index < - std::distance(Die->values_begin(), Die->values_end())); - assert(Die->values_begin()[Index].getType() == DIEValue::isInteger); - return Die->values_begin()[Index].getDIEInteger().getValue(); + assert(I); + return I->getDIEInteger().getValue(); } }; @@ -1837,7 +1827,7 @@ unsigned DwarfLinker::cloneStringAttribute(DIE &Die, AttributeSpec AttrSpec, // Switch everything to out of line strings. const char *String = *Val.getAsCString(&U); unsigned Offset = StringPool.getStringOffset(String); - Die.addValue(dwarf::Attribute(AttrSpec.Attr), dwarf::DW_FORM_strp, + Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), dwarf::DW_FORM_strp, DIEInteger(Offset)); return 4; } @@ -1887,18 +1877,21 @@ unsigned DwarfLinker::cloneDieReferenceAttribute( uint32_t NewRefOffset = RefUnit->getStartOffset() + NewRefDie->getOffset(); Attr = NewRefOffset; + Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), + dwarf::DW_FORM_ref_addr, DIEInteger(Attr)); } else { // A forward reference. Note and fixup later. Attr = 0xBADDEF; - Unit.noteForwardReference(NewRefDie, RefUnit, PatchLocation(Die)); + Unit.noteForwardReference( + NewRefDie, RefUnit, + Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), + dwarf::DW_FORM_ref_addr, DIEInteger(Attr))); } - Die.addValue(dwarf::Attribute(AttrSpec.Attr), dwarf::DW_FORM_ref_addr, - DIEInteger(Attr)); return AttrSize; } - Die.addValue(dwarf::Attribute(AttrSpec.Attr), dwarf::Form(AttrSpec.Form), - DIEEntry(*NewRefDie)); + Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), + dwarf::Form(AttrSpec.Form), DIEEntry(*NewRefDie)); return AttrSize; } @@ -1930,8 +1923,8 @@ unsigned DwarfLinker::cloneBlockAttribute(DIE &Die, AttributeSpec AttrSpec, dwarf::Form(AttrSpec.Form), Block); ArrayRef Bytes = *Val.getAsBlock(); for (auto Byte : Bytes) - Attr->addValue(static_cast(0), dwarf::DW_FORM_data1, - DIEInteger(Byte)); + Attr->addValue(DIEAlloc, static_cast(0), + dwarf::DW_FORM_data1, DIEInteger(Byte)); // FIXME: If DIEBlock and DIELoc just reuses the Size field of // the DIE class, this if could be replaced by // Attr->setSize(Bytes.size()). @@ -1941,7 +1934,7 @@ unsigned DwarfLinker::cloneBlockAttribute(DIE &Die, AttributeSpec AttrSpec, else Block->ComputeSize(&Streamer->getAsmPrinter()); } - Die.addValue(Value); + Die.addValue(DIEAlloc, Value); return AttrSize; } @@ -1975,7 +1968,7 @@ unsigned DwarfLinker::cloneAddressAttribute(DIE &Die, AttributeSpec AttrSpec, Addr = (Info.OrigHighPc ? Info.OrigHighPc : Addr) + Info.PCOffset; } - Die.addValue(static_cast(AttrSpec.Attr), + Die.addValue(DIEAlloc, static_cast(AttrSpec.Attr), static_cast(AttrSpec.Form), DIEInteger(Addr)); return Unit.getOrigUnit().getAddressByteSize(); } @@ -2004,20 +1997,20 @@ unsigned DwarfLinker::cloneScalarAttribute( &Unit.getOrigUnit(), &InputDIE); return 0; } - DIEInteger Attr(Value); + PatchLocation Patch = + Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), + dwarf::Form(AttrSpec.Form), DIEInteger(Value)); if (AttrSpec.Attr == dwarf::DW_AT_ranges) - Unit.noteRangeAttribute(Die, PatchLocation(Die)); + Unit.noteRangeAttribute(Die, Patch); // A more generic way to check for location attributes would be // nice, but it's very unlikely that any other attribute needs a // location list. else if (AttrSpec.Attr == dwarf::DW_AT_location || AttrSpec.Attr == dwarf::DW_AT_frame_base) - Unit.noteLocationAttribute(PatchLocation(Die), Info.PCOffset); + Unit.noteLocationAttribute(Patch, Info.PCOffset); else if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value) Info.IsDeclaration = true; - Die.addValue(dwarf::Attribute(AttrSpec.Attr), dwarf::Form(AttrSpec.Form), - Attr); return AttrSize; } @@ -2367,8 +2360,7 @@ static void insertLineSequence(std::vector &Seq, static void patchStmtList(DIE &Die, DIEInteger Offset) { for (auto &V : Die.values()) if (V.getAttribute() == dwarf::DW_AT_stmt_list) { - Die.setValue(&V - Die.values_begin(), - DIEValue(V.getAttribute(), V.getForm(), Offset)); + V = DIEValue(V.getAttribute(), V.getForm(), Offset); return; } diff --git a/unittests/CodeGen/DIEHashTest.cpp b/unittests/CodeGen/DIEHashTest.cpp index 8e78f0ca13b..5476463e9da 100644 --- a/unittests/CodeGen/DIEHashTest.cpp +++ b/unittests/CodeGen/DIEHashTest.cpp @@ -22,6 +22,10 @@ namespace { // Test fixture class DIEHashTest : public testing::Test { +public: + BumpPtrAllocator Alloc; + +private: StringMap Pool; public: @@ -36,7 +40,7 @@ TEST_F(DIEHashTest, Data1) { DIEHash Hash; DIE Die(dwarf::DW_TAG_base_type); DIEInteger Size(4); - Die.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Size); + Die.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Size); uint64_t MD5Res = Hash.computeTypeSignature(Die); ASSERT_EQ(0x1AFE116E83701108ULL, MD5Res); } @@ -45,11 +49,11 @@ TEST_F(DIEHashTest, Data1) { TEST_F(DIEHashTest, TrivialType) { DIE Unnamed(dwarf::DW_TAG_structure_type); DIEInteger One(1); - Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); + Unnamed.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); // Line and file number are ignored. - Unnamed.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); - Unnamed.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, One); + Unnamed.addValue(Alloc, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); + Unnamed.addValue(Alloc, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, One); uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed); // The exact same hash GCC produces for this DIE. @@ -61,8 +65,8 @@ TEST_F(DIEHashTest, NamedType) { DIE Foo(dwarf::DW_TAG_structure_type); DIEInteger One(1); DIEString FooStr = getString("foo"); - Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); - Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); + Foo.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); + Foo.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); @@ -77,15 +81,16 @@ TEST_F(DIEHashTest, NamespacedType) { auto Space = make_unique(dwarf::DW_TAG_namespace); DIEInteger One(1); DIEString SpaceStr = getString("space"); - Space->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, SpaceStr); + Space->addValue(Alloc, 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); + Space->addValue(Alloc, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, + One); // sibling? auto Foo = make_unique(dwarf::DW_TAG_structure_type); DIEString FooStr = getString("foo"); - Foo->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); - Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); + Foo->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); + Foo->addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); DIE &N = *Foo; Space->addChild(std::move(Foo)); @@ -101,24 +106,24 @@ TEST_F(DIEHashTest, NamespacedType) { TEST_F(DIEHashTest, TypeWithMember) { DIE Unnamed(dwarf::DW_TAG_structure_type); DIEInteger Four(4); - Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four); + Unnamed.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four); DIE Int(dwarf::DW_TAG_base_type); DIEString IntStr = getString("int"); - Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, IntStr); - Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four); + Int.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, IntStr); + Int.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four); DIEInteger Five(5); - Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Five); + Int.addValue(Alloc, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Five); DIEEntry IntRef(Int); auto Member = make_unique(dwarf::DW_TAG_member); DIEString MemberStr = getString("member"); - Member->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemberStr); + Member->addValue(Alloc, 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); + Member->addValue(Alloc, dwarf::DW_AT_data_member_location, + dwarf::DW_FORM_data1, Zero); + Member->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntRef); Unnamed.addChild(std::move(Member)); @@ -131,34 +136,34 @@ TEST_F(DIEHashTest, TypeWithMember) { TEST_F(DIEHashTest, ReusedType) { DIE Unnamed(dwarf::DW_TAG_structure_type); DIEInteger Eight(8); - Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); + Unnamed.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); DIEInteger Four(4); DIE Int(dwarf::DW_TAG_base_type); DIEString IntStr = getString("int"); - Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, IntStr); - Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four); + Int.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, IntStr); + Int.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four); DIEInteger Five(5); - Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Five); + Int.addValue(Alloc, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Five); DIEEntry IntRef(Int); auto Mem1 = make_unique(dwarf::DW_TAG_member); DIEString Mem1Str = getString("mem1"); - Mem1->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, Mem1Str); + Mem1->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, Mem1Str); DIEInteger Zero(0); - Mem1->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, + Mem1->addValue(Alloc, dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, Zero); - Mem1->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntRef); + Mem1->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntRef); Unnamed.addChild(std::move(Mem1)); auto Mem2 = make_unique(dwarf::DW_TAG_member); DIEString Mem2Str = getString("mem2"); - Mem2->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, Mem2Str); - Mem2->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, + Mem2->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, Mem2Str); + Mem2->addValue(Alloc, dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, Four); - Mem2->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntRef); + Mem2->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntRef); Unnamed.addChild(std::move(Mem2)); @@ -171,15 +176,15 @@ TEST_F(DIEHashTest, ReusedType) { TEST_F(DIEHashTest, RecursiveType) { DIE Foo(dwarf::DW_TAG_structure_type); DIEInteger One(1); - Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); + Foo.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); DIEString FooStr = getString("foo"); - Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); + Foo.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); auto Mem = make_unique(dwarf::DW_TAG_member); DIEString MemStr = getString("mem"); - Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); + Mem->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); DIEEntry FooRef(Foo); - Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRef); + Mem->addValue(Alloc, 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)); @@ -193,23 +198,24 @@ TEST_F(DIEHashTest, RecursiveType) { TEST_F(DIEHashTest, Pointer) { DIE Foo(dwarf::DW_TAG_structure_type); DIEInteger Eight(8); - Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); + Foo.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); DIEString FooStr = getString("foo"); - Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); + Foo.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); auto Mem = make_unique(dwarf::DW_TAG_member); DIEString MemStr = getString("mem"); - Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); + Mem->addValue(Alloc, 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); + Mem->addValue(Alloc, 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); + FooPtr.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); DIEEntry FooRef(Foo); - FooPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRef); + FooPtr.addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRef); DIEEntry FooPtrRef(FooPtr); - Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooPtrRef); + Mem->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooPtrRef); Foo.addChild(std::move(Mem)); @@ -222,27 +228,29 @@ TEST_F(DIEHashTest, Pointer) { TEST_F(DIEHashTest, Reference) { DIE Foo(dwarf::DW_TAG_structure_type); DIEInteger Eight(8); - Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); + Foo.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); DIEString FooStr = getString("foo"); - Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); + Foo.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); auto Mem = make_unique(dwarf::DW_TAG_member); DIEString MemStr = getString("mem"); - Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); + Mem->addValue(Alloc, 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); + Mem->addValue(Alloc, 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); + FooRef.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); DIEEntry FooEntry(Foo); - FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooEntry); + FooRef.addValue(Alloc, 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); + FooRefConst.addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, + FooRefRef); DIEEntry FooRefConstRef(FooRefConst); - Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRefConstRef); + Mem->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRefConstRef); Foo.addChild(std::move(Mem)); @@ -255,27 +263,29 @@ TEST_F(DIEHashTest, Reference) { TEST_F(DIEHashTest, RValueReference) { DIE Foo(dwarf::DW_TAG_structure_type); DIEInteger Eight(8); - Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); + Foo.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); DIEString FooStr = getString("foo"); - Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); + Foo.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); auto Mem = make_unique(dwarf::DW_TAG_member); DIEString MemStr = getString("mem"); - Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); + Mem->addValue(Alloc, 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); + Mem->addValue(Alloc, 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); + FooRef.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); DIEEntry FooEntry(Foo); - FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooEntry); + FooRef.addValue(Alloc, 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); + FooRefConst.addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, + FooRefRef); DIEEntry FooRefConstRef(FooRefConst); - Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRefConstRef); + Mem->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRefConstRef); Foo.addChild(std::move(Mem)); @@ -288,24 +298,25 @@ TEST_F(DIEHashTest, RValueReference) { TEST_F(DIEHashTest, PtrToMember) { DIE Foo(dwarf::DW_TAG_structure_type); DIEInteger Eight(8); - Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); + Foo.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); DIEString FooStr = getString("foo"); - Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); + Foo.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); auto Mem = make_unique(dwarf::DW_TAG_member); DIEString MemStr = getString("mem"); - Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); + Mem->addValue(Alloc, 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); + Mem->addValue(Alloc, 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, + PtrToFooMem.addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooEntry); + PtrToFooMem.addValue(Alloc, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, FooEntry); DIEEntry PtrToFooMemRef(PtrToFooMem); - Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PtrToFooMemRef); + Mem->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PtrToFooMemRef); Foo.addChild(std::move(Mem)); @@ -329,27 +340,30 @@ TEST_F(DIEHashTest, PtrToMemberDeclDefMatch) { 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); + Bar.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, BarStr); + Bar.addValue(Alloc, 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); + Foo.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); + Foo.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); auto Mem = make_unique(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); + Mem->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); + Mem->addValue(Alloc, 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(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, + BarEntry); DIEEntry FooEntry(Foo); - PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, - FooEntry); + PtrToFooMem.addValue(Alloc, dwarf::DW_AT_containing_type, + dwarf::DW_FORM_ref4, FooEntry); DIEEntry PtrToFooMemRef(PtrToFooMem); - Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PtrToFooMemRef); + Mem->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, + PtrToFooMemRef); Foo.addChild(std::move(Mem)); @@ -358,27 +372,29 @@ TEST_F(DIEHashTest, PtrToMemberDeclDefMatch) { 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); + Bar.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, BarStr); + Bar.addValue(Alloc, 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); + Foo.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); + Foo.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); auto Mem = make_unique(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); + Mem->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); + Mem->addValue(Alloc, 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(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, + BarEntry); DIEEntry FooEntry(Foo); - PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, - FooEntry); + PtrToFooMem.addValue(Alloc, dwarf::DW_AT_containing_type, + dwarf::DW_FORM_ref4, FooEntry); DIEEntry PtrToFooMemRef(PtrToFooMem); - Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PtrToFooMemRef); + Mem->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, + PtrToFooMemRef); Foo.addChild(std::move(Mem)); @@ -402,26 +418,29 @@ TEST_F(DIEHashTest, PtrToMemberDeclDefMisMatch) { 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); + Bar.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, BarStr); + Bar.addValue(Alloc, 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); + Foo.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); + Foo.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); auto Mem = make_unique(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); + Mem->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); + Mem->addValue(Alloc, 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, + PtrToFooMem.addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, BarEntry); + PtrToFooMem.addValue(Alloc, dwarf::DW_AT_containing_type, + dwarf::DW_FORM_ref4, BarEntry); DIEEntry PtrToFooMemRef(PtrToFooMem); - Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PtrToFooMemRef); + Mem->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, + PtrToFooMemRef); Foo.addChild(std::move(Mem)); @@ -430,26 +449,28 @@ TEST_F(DIEHashTest, PtrToMemberDeclDefMisMatch) { 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); + Bar.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, BarStr); + Bar.addValue(Alloc, 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); + Foo.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); + Foo.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); auto Mem = make_unique(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); + Mem->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); + Mem->addValue(Alloc, 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, + PtrToFooMem.addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, BarEntry); + PtrToFooMem.addValue(Alloc, dwarf::DW_AT_containing_type, + dwarf::DW_FORM_ref4, BarEntry); DIEEntry PtrToFooMemRef(PtrToFooMem); - Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PtrToFooMemRef); + Mem->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, + PtrToFooMemRef); Foo.addChild(std::move(Mem)); @@ -473,23 +494,26 @@ TEST_F(DIEHashTest, RefUnnamedType) { DIEString MemStr = getString("mem"); DIE Unnamed(dwarf::DW_TAG_structure_type); - Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); + Unnamed.addValue(Alloc, 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); + Foo.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight); + Foo.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); auto Mem = make_unique(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); + Mem->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); + Mem->addValue(Alloc, 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); + UnnamedPtr.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, + Eight); DIEEntry UnnamedRef(Unnamed); - UnnamedPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, UnnamedRef); + UnnamedPtr.addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, + UnnamedRef); DIEEntry UnnamedPtrRef(UnnamedPtr); - Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, UnnamedPtrRef); + Mem->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, UnnamedPtrRef); Foo.addChild(std::move(Mem)); @@ -502,12 +526,12 @@ TEST_F(DIEHashTest, RefUnnamedType) { TEST_F(DIEHashTest, NestedType) { DIE Unnamed(dwarf::DW_TAG_structure_type); DIEInteger One(1); - Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); + Unnamed.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); auto Foo = make_unique(dwarf::DW_TAG_structure_type); DIEString FooStr = getString("foo"); - Foo->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); - Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); + Foo->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr); + Foo->addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); Unnamed.addChild(std::move(Foo)); @@ -521,11 +545,11 @@ TEST_F(DIEHashTest, NestedType) { TEST_F(DIEHashTest, MemberFunc) { DIE Unnamed(dwarf::DW_TAG_structure_type); DIEInteger One(1); - Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); + Unnamed.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); auto Func = make_unique(dwarf::DW_TAG_subprogram); DIEString FuncStr = getString("func"); - Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FuncStr); + Func->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FuncStr); Unnamed.addChild(std::move(Func)); @@ -542,21 +566,24 @@ TEST_F(DIEHashTest, MemberFuncFlag) { DIE A(dwarf::DW_TAG_structure_type); DIEInteger One(1); DIEString AStr = getString("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); + A.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, AStr); + A.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); + A.addValue(Alloc, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); + A.addValue(Alloc, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, One); auto Func = make_unique(dwarf::DW_TAG_subprogram); DIEString FuncStr = getString("func"); DIEString FuncLinkage = getString("_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); + Func->addValue(Alloc, dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, + One); + Func->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FuncStr); + Func->addValue(Alloc, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); + Func->addValue(Alloc, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, Two); + Func->addValue(Alloc, dwarf::DW_AT_linkage_name, dwarf::DW_FORM_strp, + FuncLinkage); + Func->addValue(Alloc, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, + One); A.addChild(std::move(Func)); @@ -575,35 +602,36 @@ TEST_F(DIEHashTest, MemberSdata) { DIE A(dwarf::DW_TAG_structure_type); DIEInteger One(1); DIEString AStr = getString("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); + A.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, AStr); + A.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); + A.addValue(Alloc, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); + A.addValue(Alloc, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, One); DIEInteger Four(4); DIEInteger Five(5); DIEString FStr = getString("int"); DIE IntTyDIE(dwarf::DW_TAG_base_type); - IntTyDIE.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four); - IntTyDIE.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Five); - IntTyDIE.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FStr); + IntTyDIE.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four); + IntTyDIE.addValue(Alloc, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Five); + IntTyDIE.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FStr); DIEEntry IntTy(IntTyDIE); auto PITyDIE = make_unique(dwarf::DW_TAG_const_type); - PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntTy); + PITyDIE->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntTy); DIEEntry PITy(*PITyDIE); auto PI = make_unique(dwarf::DW_TAG_member); DIEString PIStr = getString("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); + PI->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, PIStr); + PI->addValue(Alloc, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); + PI->addValue(Alloc, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, Two); + PI->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PITy); + PI->addValue(Alloc, dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, One); + PI->addValue(Alloc, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, + One); + PI->addValue(Alloc, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, NegThree); A.addChild(std::move(PI)); @@ -620,32 +648,35 @@ TEST_F(DIEHashTest, MemberBlock) { DIE A(dwarf::DW_TAG_structure_type); DIEInteger One(1); DIEString AStr = getString("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); + A.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, AStr); + A.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); + A.addValue(Alloc, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); + A.addValue(Alloc, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, One); DIEInteger Four(4); DIEString FStr = getString("float"); auto FloatTyDIE = make_unique(dwarf::DW_TAG_base_type); - FloatTyDIE->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four); - FloatTyDIE->addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Four); - FloatTyDIE->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FStr); + FloatTyDIE->addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, + Four); + FloatTyDIE->addValue(Alloc, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, + Four); + FloatTyDIE->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FStr); DIEEntry FloatTy(*FloatTyDIE); auto PITyDIE = make_unique(dwarf::DW_TAG_const_type); - PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FloatTy); + PITyDIE->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FloatTy); DIEEntry PITy(*PITyDIE); auto PI = make_unique(dwarf::DW_TAG_member); DIEString PIStr = getString("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); + PI->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, PIStr); + PI->addValue(Alloc, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); + PI->addValue(Alloc, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, Two); + PI->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PITy); + PI->addValue(Alloc, dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, One); + PI->addValue(Alloc, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, + One); DIEBlock PIBlock; DIEInteger Blk1(0xc3); @@ -653,12 +684,13 @@ TEST_F(DIEHashTest, MemberBlock) { 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); + PIBlock.addValue(Alloc, (dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk1); + PIBlock.addValue(Alloc, (dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk2); + PIBlock.addValue(Alloc, (dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk3); + PIBlock.addValue(Alloc, (dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk4); - PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_block1, &PIBlock); + PI->addValue(Alloc, dwarf::DW_AT_const_value, dwarf::DW_FORM_block1, + &PIBlock); A.addChild(std::move(PI));