6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-13 22:24:07 +00:00
Code Issues Projects Releases Wiki Activity

AsmPrinter: Convert DIE::Values to a linked list

Browse Source 
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
This commit is contained in:
Duncan P. N. Exon Smith
2015-06-25 23:46:41 +00:00
parent d1ceba0333
commit 73e3fb6ba8
11 changed files with 463 additions and 268 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/ADT/iterator.h
View File

@ -162,6 +162,8 @@ protected:
int>::type = 0) int>::type = 0)
: I(std::forward<U &&>(u)) {} : I(std::forward<U &&>(u)) {}
const WrappedIteratorT &wrapped() const { return I; }
public: public:
typedef DifferenceTypeT difference_type; typedef DifferenceTypeT difference_type;

186
include/llvm/CodeGen/DIE.h
View File

@ -15,6 +15,8 @@
#define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H #define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
#include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/PointerIntPair.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/CodeGen/DwarfStringPoolEntry.h" #include "llvm/CodeGen/DwarfStringPoolEntry.h"
#include "llvm/Support/Dwarf.h" #include "llvm/Support/Dwarf.h"
@ -448,6 +450,162 @@ public:
#endif #endif
}; };
struct IntrusiveBackListNode {
PointerIntPair<IntrusiveBackListNode *, 1> 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 T> class IntrusiveBackList : IntrusiveBackListBase {
public:
using IntrusiveBackListBase::empty;
void push_back(T &N) { IntrusiveBackListBase::push_back(N); }
T &back() { return *static_cast<T *>(Last); }
const T &back() const { return *static_cast<T *>(Last); }
class const_iterator;
class iterator
: public iterator_facade_base<iterator, std::forward_iterator_tag, T> {
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<T *>(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_iterator, std::forward_iterator_tag,
const T> {
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<const T *>(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<T *>(Last->Next.getPointer())) : end();
}
const_iterator begin() const {
return const_cast<IntrusiveBackList *>(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<Node> ListTy;
ListTy List;
public:
bool empty() const { return List.empty(); }
class const_iterator;
class iterator
: public iterator_adaptor_base<iterator, ListTy::iterator,
std::forward_iterator_tag, DIEValue> {
friend class const_iterator;
typedef iterator_adaptor_base<iterator, ListTy::iterator,
std::forward_iterator_tag,
DIEValue> 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<const_iterator, ListTy::const_iterator,
std::forward_iterator_tag,
const DIEValue> {
typedef iterator_adaptor_base<const_iterator, ListTy::const_iterator,
std::forward_iterator_tag,
const DIEValue> 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 <class... Ts>
iterator emplace(BumpPtrAllocator &Alloc, Ts &&... Args) {
return insert(Alloc, DIEValue(std::forward<Ts>(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 /// DIE - A structured debug information entry. Has an abbreviation which
/// describes its organization. /// describes its organization.
@ -481,7 +639,7 @@ protected:
/// Attribute values. /// Attribute values.
/// ///
SmallVector<DIEValue, 12> Values; DIEValueList Values;
protected: protected:
DIE() : Offset(0), Size(0), Parent(nullptr) {} DIE() : Offset(0), Size(0), Parent(nullptr) {}
@ -504,19 +662,20 @@ public:
return llvm::make_range(Children.begin(), Children.end()); return llvm::make_range(Children.begin(), Children.end());
} }
typedef SmallVectorImpl<DIEValue>::const_iterator value_iterator; typedef DIEValueList::iterator value_iterator;
typedef iterator_range<value_iterator> value_range; typedef iterator_range<value_iterator> value_range;
value_iterator values_begin() const { return Values.begin(); } value_range values() {
value_iterator values_end() const { return Values.end(); } return llvm::make_range(Values.begin(), Values.end());
value_range values() const {
return llvm::make_range(values_begin(), values_end());
} }
void setValue(unsigned I, DIEValue New) { typedef DIEValueList::const_iterator const_value_iterator;
assert(I < Values.size()); typedef iterator_range<const_value_iterator> const_value_range;
Values[I] = New;
const_value_range values() const {
return llvm::make_range(Values.begin(), Values.end());
} }
DIE *getParent() const { return Parent; } DIE *getParent() const { return Parent; }
/// Generate the abbreviation for this DIE. /// Generate the abbreviation for this DIE.
@ -539,10 +698,13 @@ public:
/// addValue - Add a value and attributes to a DIE. /// 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 <class T> template <class T>
void addValue(dwarf::Attribute Attribute, dwarf::Form Form, T &&Value) { value_iterator addValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,
Values.emplace_back(Attribute, Form, std::forward<T>(Value)); dwarf::Form Form, T &&Value) {
return Values.emplace(Alloc, Attribute, Form, std::forward<T>(Value));
} }
/// addChild - Add a child to the DIE. /// addChild - Add a child to the DIE.

13
lib/CodeGen/AsmPrinter/DIE.cpp
View File

@ -165,18 +165,17 @@ void DIE::print(raw_ostream &O, unsigned IndentCount) const {
} }
IndentCount += 2; IndentCount += 2;
for (unsigned i = 0, N = Values.size(); i < N; ++i) { unsigned I = 0;
for (const auto &V : Values) {
O << Indent; O << Indent;
if (!isBlock) if (!isBlock)
O << dwarf::AttributeString(Values[i].getAttribute()); O << dwarf::AttributeString(V.getAttribute());
else else
O << "Blk[" << i << "]"; O << "Blk[" << I++ << "]";
O << " " O << " " << dwarf::FormEncodingString(V.getForm()) << " ";
<< dwarf::FormEncodingString(Values[i].getForm()) V.print(O);
<< " ";
Values[i].print(O);
O << "\n"; O << "\n";
} }
IndentCount -= 2; IndentCount -= 2;

2
lib/CodeGen/AsmPrinter/DIEHash.cpp
View File

@ -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 // 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. // 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) for (const auto &V : Values)
Hash.update((uint64_t)V.getDIEInteger().getValue()); Hash.update((uint64_t)V.getDIEInteger().getValue());
} }

2
lib/CodeGen/AsmPrinter/DIEHash.h
View File

@ -128,7 +128,7 @@ private:
/// \brief Hashes the data in a block like DIEValue, e.g. DW_FORM_block or /// \brief Hashes the data in a block like DIEValue, e.g. DW_FORM_block or
/// DW_FORM_exprloc. /// 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. /// \brief Hashes the contents pointed to in the .debug_loc section.
void hashLocList(const DIELocList &LocList); void hashLocList(const DIELocList &LocList);

51
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
View File

@ -42,7 +42,8 @@ void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
DD->addArangeLabel(SymbolCU(this, Label)); DD->addArangeLabel(SymbolCU(this, Label));
unsigned idx = DD->getAddressPool().getIndex(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, void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
@ -52,9 +53,11 @@ void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
DD->addArangeLabel(SymbolCU(this, Label)); DD->addArangeLabel(SymbolCU(this, Label));
if (Label) if (Label)
Die.addValue(Attribute, dwarf::DW_FORM_addr, DIELabel(Label)); Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
DIELabel(Label));
else 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, unsigned DwarfCompileUnit::getOrCreateSourceID(StringRef FileName,
@ -225,16 +228,15 @@ void DwarfCompileUnit::addRange(RangeSpan Range) {
CURanges.back().setEnd(Range.getEnd()); CURanges.back().setEnd(Range.getEnd());
} }
void DwarfCompileUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute, DIE::value_iterator
const MCSymbol *Label, DwarfCompileUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
const MCSymbol *Sec) { const MCSymbol *Label, const MCSymbol *Sec) {
if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
addLabel(Die, Attribute, return addLabel(Die, Attribute,
DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
: dwarf::DW_FORM_data4, : dwarf::DW_FORM_data4,
Label); Label);
else return addSectionDelta(Die, Attribute, Label, Sec);
addSectionDelta(Die, Attribute, Label, Sec);
} }
void DwarfCompileUnit::initStmtList() { void DwarfCompileUnit::initStmtList() {
@ -242,20 +244,19 @@ void DwarfCompileUnit::initStmtList() {
MCSymbol *LineTableStartSym = MCSymbol *LineTableStartSym =
Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID()); 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 // DW_AT_stmt_list is a offset of line number information for this
// compile unit in debug_line section. For split dwarf this is // compile unit in debug_line section. For split dwarf this is
// left in the skeleton CU and so not included. // left in the skeleton CU and so not included.
// The line table entries are not always emitted in assembly, so it // The line table entries are not always emitted in assembly, so it
// is not okay to use line_table_start here. // is not okay to use line_table_start here.
const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym, StmtListValue =
TLOF.getDwarfLineSection()->getBeginSymbol()); addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym,
TLOF.getDwarfLineSection()->getBeginSymbol());
} }
void DwarfCompileUnit::applyStmtList(DIE &D) { void DwarfCompileUnit::applyStmtList(DIE &D) {
D.addValue(UnitDie.values_begin()[stmtListIndex]); D.addValue(DIEValueAllocator, *StmtListValue);
} }
void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin, void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,
@ -361,11 +362,13 @@ void DwarfCompileUnit::constructScopeDIE(
FinalChildren.push_back(std::move(ScopeDIE)); FinalChildren.push_back(std::move(ScopeDIE));
} }
void DwarfCompileUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute, DIE::value_iterator
const MCSymbol *Hi, const MCSymbol *Lo) { DwarfCompileUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
Die.addValue(Attribute, DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset const MCSymbol *Hi, const MCSymbol *Lo) {
: dwarf::DW_FORM_data4, return Die.addValue(DIEValueAllocator, Attribute,
new (DIEValueAllocator) DIEDelta(Hi, Lo)); DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
: dwarf::DW_FORM_data4,
new (DIEValueAllocator) DIEDelta(Hi, Lo));
} }
void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE, void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
@ -781,7 +784,7 @@ void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
unsigned Index) { unsigned Index) {
dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
: dwarf::DW_FORM_data4; : dwarf::DW_FORM_data4;
Die.addValue(Attribute, Form, DIELocList(Index)); Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index));
} }
void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var, void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
@ -798,7 +801,7 @@ void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
/// Add a Dwarf expression attribute data and value. /// Add a Dwarf expression attribute data and value.
void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form, void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form,
const MCExpr *Expr) { const MCExpr *Expr) {
Die.addValue((dwarf::Attribute)0, Form, DIEExpr(Expr)); Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr));
} }
void DwarfCompileUnit::applySubprogramAttributesToDefinition( void DwarfCompileUnit::applySubprogramAttributesToDefinition(

11
lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
View File

@ -31,7 +31,7 @@ class LexicalScope;
class DwarfCompileUnit : public DwarfUnit { class DwarfCompileUnit : public DwarfUnit {
/// The attribute index of DW_AT_stmt_list in the compile unit DIE, avoiding /// The attribute index of DW_AT_stmt_list in the compile unit DIE, avoiding
/// the need to search for it in applyStmtList. /// the need to search for it in applyStmtList.
unsigned stmtListIndex; DIE::value_iterator StmtListValue;
/// Skeleton unit associated with this unit. /// Skeleton unit associated with this unit.
DwarfCompileUnit *Skeleton; DwarfCompileUnit *Skeleton;
@ -92,8 +92,8 @@ public:
const MCSymbol *Label); const MCSymbol *Label);
/// addSectionDelta - Add a label delta attribute data and value. /// addSectionDelta - Add a label delta attribute data and value.
void addSectionDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, DIE::value_iterator addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
const MCSymbol *Lo); const MCSymbol *Hi, const MCSymbol *Lo);
DwarfCompileUnit &getCU() override { return *this; } DwarfCompileUnit &getCU() override { return *this; }
@ -106,8 +106,9 @@ public:
/// addSectionLabel - Add a Dwarf section label attribute data and value. /// addSectionLabel - Add a Dwarf section label attribute data and value.
/// ///
void addSectionLabel(DIE &Die, dwarf::Attribute Attribute, DIE::value_iterator addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
const MCSymbol *Label, const MCSymbol *Sec); const MCSymbol *Label,
const MCSymbol *Sec);
/// \brief Find DIE for the given subprogram and attach appropriate /// \brief Find DIE for the given subprogram and attach appropriate
/// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global /// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global

36
lib/CodeGen/AsmPrinter/DwarfUnit.cpp
View File

@ -184,16 +184,18 @@ void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) { void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
if (DD->getDwarfVersion() >= 4) 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 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, void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
Optional<dwarf::Form> Form, uint64_t Integer) { Optional<dwarf::Form> Form, uint64_t Integer) {
if (!Form) if (!Form)
Form = DIEInteger::BestForm(false, Integer); 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) { void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
@ -204,7 +206,7 @@ void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
Optional<dwarf::Form> Form, int64_t Integer) { Optional<dwarf::Form> Form, int64_t Integer) {
if (!Form) if (!Form)
Form = DIEInteger::BestForm(true, Integer); Form = DIEInteger::BestForm(true, Integer);
Die.addValue(Attribute, *Form, DIEInteger(Integer)); Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
} }
void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form, void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
@ -214,14 +216,15 @@ void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute, void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
StringRef String) { StringRef String) {
Die.addValue(Attribute, Die.addValue(DIEValueAllocator, Attribute,
isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp, isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp,
DIEString(DU->getStringPool().getEntry(*Asm, String))); DIEString(DU->getStringPool().getEntry(*Asm, String)));
} }
void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form, DIE::value_iterator DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute,
const MCSymbol *Label) { dwarf::Form Form,
Die.addValue(Attribute, Form, DIELabel(Label)); const MCSymbol *Label) {
return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label));
} }
void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *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, void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
const MCSymbol *Hi, const MCSymbol *Lo) { 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)); new (DIEValueAllocator) DIEDelta(Hi, Lo));
} }
@ -269,8 +272,8 @@ void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
// and think this is a full definition. // and think this is a full definition.
addFlag(Die, dwarf::DW_AT_declaration); addFlag(Die, dwarf::DW_AT_declaration);
Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8, Die.addValue(DIEValueAllocator, dwarf::DW_AT_signature,
DIETypeSignature(Type)); dwarf::DW_FORM_ref_sig8, DIETypeSignature(Type));
} }
void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
@ -282,7 +285,7 @@ void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
DieCU = &getUnitDie(); DieCU = &getUnitDie();
if (!EntryCU) if (!EntryCU)
EntryCU = &getUnitDie(); EntryCU = &getUnitDie();
Die.addValue(Attribute, Die.addValue(DIEValueAllocator, Attribute,
EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr, EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
Entry); 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) { void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
Loc->ComputeSize(Asm); Loc->ComputeSize(Asm);
DIELocs.push_back(Loc); // Memoize so we can call the destructor later on. 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, void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
DIEBlock *Block) { DIEBlock *Block) {
Block->ComputeSize(Asm); Block->ComputeSize(Asm);
DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on. 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, void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
@ -1386,8 +1390,8 @@ void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
// Objective-C properties. // Objective-C properties.
if (DINode *PNode = DT->getObjCProperty()) if (DINode *PNode = DT->getObjCProperty())
if (DIE *PDie = getDIE(PNode)) if (DIE *PDie = getDIE(PNode))
MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4, MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
DIEEntry(*PDie)); dwarf::DW_FORM_ref4, DIEEntry(*PDie));
if (DT->isArtificial()) if (DT->isArtificial())
addFlag(MemberDie, dwarf::DW_AT_artificial); addFlag(MemberDie, dwarf::DW_AT_artificial);

10
lib/CodeGen/AsmPrinter/DwarfUnit.h
View File

@ -73,6 +73,9 @@ protected:
/// MDNode for the compile unit. /// MDNode for the compile unit.
const DICompileUnit *CUNode; const DICompileUnit *CUNode;
// All DIEValues are allocated through this allocator.
BumpPtrAllocator DIEValueAllocator;
/// Unit debug information entry. /// Unit debug information entry.
DIE UnitDie; DIE UnitDie;
@ -104,9 +107,6 @@ protected:
/// corresponds to the MDNode mapped with the subprogram DIE. /// corresponds to the MDNode mapped with the subprogram DIE.
DenseMap<DIE *, const DINode *> ContainingTypeMap; DenseMap<DIE *, const DINode *> ContainingTypeMap;
// All DIEValues are allocated through this allocator.
BumpPtrAllocator DIEValueAllocator;
/// The section this unit will be emitted in. /// The section this unit will be emitted in.
MCSection *Section; MCSection *Section;
@ -206,8 +206,8 @@ public:
void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str); void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str);
/// \brief Add a Dwarf label attribute data and value. /// \brief Add a Dwarf label attribute data and value.
void addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form, DIE::value_iterator addLabel(DIE &Die, dwarf::Attribute Attribute,
const MCSymbol *Label); dwarf::Form Form, const MCSymbol *Label);
void addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label); void addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label);

64
tools/dsymutil/DwarfLinker.cpp
View File

@ -60,33 +60,23 @@ using HalfOpenIntervalMap =
typedef HalfOpenIntervalMap<uint64_t, int64_t> FunctionIntervals; typedef HalfOpenIntervalMap<uint64_t, int64_t> FunctionIntervals;
// FIXME: Delete this structure once DIE::Values has a stable iterator we can // FIXME: Delete this structure.
// use instead.
struct PatchLocation { struct PatchLocation {
DIE *Die; DIE::value_iterator I;
unsigned Index;
PatchLocation() : Die(nullptr), Index(0) {} PatchLocation() = default;
PatchLocation(DIE &Die, unsigned Index) : Die(&Die), Index(Index) {} PatchLocation(DIE::value_iterator I) : I(I) {}
PatchLocation(DIE &Die)
: Die(&Die), Index(std::distance(Die.values_begin(), Die.values_end())) {}
void set(uint64_t New) const { void set(uint64_t New) const {
assert(Die); assert(I);
assert((signed)Index < const auto &Old = *I;
std::distance(Die->values_begin(), Die->values_end()));
const auto &Old = Die->values_begin()[Index];
assert(Old.getType() == DIEValue::isInteger); assert(Old.getType() == DIEValue::isInteger);
Die->setValue(Index, *I = DIEValue(Old.getAttribute(), Old.getForm(), DIEInteger(New));
DIEValue(Old.getAttribute(), Old.getForm(), DIEInteger(New)));
} }
uint64_t get() const { uint64_t get() const {
assert(Die); assert(I);
assert((signed)Index < return I->getDIEInteger().getValue();
std::distance(Die->values_begin(), Die->values_end()));
assert(Die->values_begin()[Index].getType() == DIEValue::isInteger);
return Die->values_begin()[Index].getDIEInteger().getValue();
} }
}; };
@ -1837,7 +1827,7 @@ unsigned DwarfLinker::cloneStringAttribute(DIE &Die, AttributeSpec AttrSpec,
// Switch everything to out of line strings. // Switch everything to out of line strings.
const char *String = *Val.getAsCString(&U); const char *String = *Val.getAsCString(&U);
unsigned Offset = StringPool.getStringOffset(String); 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)); DIEInteger(Offset));
return 4; return 4;
} }
@ -1887,18 +1877,21 @@ unsigned DwarfLinker::cloneDieReferenceAttribute(
uint32_t NewRefOffset = uint32_t NewRefOffset =
RefUnit->getStartOffset() + NewRefDie->getOffset(); RefUnit->getStartOffset() + NewRefDie->getOffset();
Attr = NewRefOffset; Attr = NewRefOffset;
Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
dwarf::DW_FORM_ref_addr, DIEInteger(Attr));
} else { } else {
// A forward reference. Note and fixup later. // A forward reference. Note and fixup later.
Attr = 0xBADDEF; 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; return AttrSize;
} }
Die.addValue(dwarf::Attribute(AttrSpec.Attr), dwarf::Form(AttrSpec.Form), Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
DIEEntry(*NewRefDie)); dwarf::Form(AttrSpec.Form), DIEEntry(*NewRefDie));
return AttrSize; return AttrSize;
} }
@ -1930,8 +1923,8 @@ unsigned DwarfLinker::cloneBlockAttribute(DIE &Die, AttributeSpec AttrSpec,
dwarf::Form(AttrSpec.Form), Block); dwarf::Form(AttrSpec.Form), Block);
ArrayRef<uint8_t> Bytes = *Val.getAsBlock(); ArrayRef<uint8_t> Bytes = *Val.getAsBlock();
for (auto Byte : Bytes) for (auto Byte : Bytes)
Attr->addValue(static_cast<dwarf::Attribute>(0), dwarf::DW_FORM_data1, Attr->addValue(DIEAlloc, static_cast<dwarf::Attribute>(0),
DIEInteger(Byte)); dwarf::DW_FORM_data1, DIEInteger(Byte));
// FIXME: If DIEBlock and DIELoc just reuses the Size field of // FIXME: If DIEBlock and DIELoc just reuses the Size field of
// the DIE class, this if could be replaced by // the DIE class, this if could be replaced by
// Attr->setSize(Bytes.size()). // Attr->setSize(Bytes.size()).
@ -1941,7 +1934,7 @@ unsigned DwarfLinker::cloneBlockAttribute(DIE &Die, AttributeSpec AttrSpec,
else else
Block->ComputeSize(&Streamer->getAsmPrinter()); Block->ComputeSize(&Streamer->getAsmPrinter());
} }
Die.addValue(Value); Die.addValue(DIEAlloc, Value);
return AttrSize; return AttrSize;
} }
@ -1975,7 +1968,7 @@ unsigned DwarfLinker::cloneAddressAttribute(DIE &Die, AttributeSpec AttrSpec,
Addr = (Info.OrigHighPc ? Info.OrigHighPc : Addr) + Info.PCOffset; Addr = (Info.OrigHighPc ? Info.OrigHighPc : Addr) + Info.PCOffset;
} }
Die.addValue(static_cast<dwarf::Attribute>(AttrSpec.Attr), Die.addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
static_cast<dwarf::Form>(AttrSpec.Form), DIEInteger(Addr)); static_cast<dwarf::Form>(AttrSpec.Form), DIEInteger(Addr));
return Unit.getOrigUnit().getAddressByteSize(); return Unit.getOrigUnit().getAddressByteSize();
} }
@ -2004,20 +1997,20 @@ unsigned DwarfLinker::cloneScalarAttribute(
&Unit.getOrigUnit(), &InputDIE); &Unit.getOrigUnit(), &InputDIE);
return 0; 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) 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 // A more generic way to check for location attributes would be
// nice, but it's very unlikely that any other attribute needs a // nice, but it's very unlikely that any other attribute needs a
// location list. // location list.
else if (AttrSpec.Attr == dwarf::DW_AT_location || else if (AttrSpec.Attr == dwarf::DW_AT_location ||
AttrSpec.Attr == dwarf::DW_AT_frame_base) 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) else if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
Info.IsDeclaration = true; Info.IsDeclaration = true;
Die.addValue(dwarf::Attribute(AttrSpec.Attr), dwarf::Form(AttrSpec.Form),
Attr);
return AttrSize; return AttrSize;
} }
@ -2367,8 +2360,7 @@ static void insertLineSequence(std::vector<DWARFDebugLine::Row> &Seq,
static void patchStmtList(DIE &Die, DIEInteger Offset) { static void patchStmtList(DIE &Die, DIEInteger Offset) {
for (auto &V : Die.values()) for (auto &V : Die.values())
if (V.getAttribute() == dwarf::DW_AT_stmt_list) { if (V.getAttribute() == dwarf::DW_AT_stmt_list) {
Die.setValue(&V - Die.values_begin(), V = DIEValue(V.getAttribute(), V.getForm(), Offset);
DIEValue(V.getAttribute(), V.getForm(), Offset));
return; return;
} }

354
unittests/CodeGen/DIEHashTest.cpp
View File

@ -22,6 +22,10 @@ namespace {
// Test fixture // Test fixture
class DIEHashTest : public testing::Test { class DIEHashTest : public testing::Test {
public:
BumpPtrAllocator Alloc;
private:
StringMap<DwarfStringPoolEntry> Pool; StringMap<DwarfStringPoolEntry> Pool;
public: public:
@ -36,7 +40,7 @@ TEST_F(DIEHashTest, Data1) {
DIEHash Hash; DIEHash Hash;
DIE Die(dwarf::DW_TAG_base_type); DIE Die(dwarf::DW_TAG_base_type);
DIEInteger Size(4); 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); uint64_t MD5Res = Hash.computeTypeSignature(Die);
ASSERT_EQ(0x1AFE116E83701108ULL, MD5Res); ASSERT_EQ(0x1AFE116E83701108ULL, MD5Res);
} }
@ -45,11 +49,11 @@ TEST_F(DIEHashTest, Data1) {
TEST_F(DIEHashTest, TrivialType) { TEST_F(DIEHashTest, TrivialType) {
DIE Unnamed(dwarf::DW_TAG_structure_type); DIE Unnamed(dwarf::DW_TAG_structure_type);
DIEInteger One(1); 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. // Line and file number are ignored.
Unnamed.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); Unnamed.addValue(Alloc, 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_line, dwarf::DW_FORM_data1, One);
uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed); uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
// The exact same hash GCC produces for this DIE. // The exact same hash GCC produces for this DIE.
@ -61,8 +65,8 @@ TEST_F(DIEHashTest, NamedType) {
DIE Foo(dwarf::DW_TAG_structure_type); DIE Foo(dwarf::DW_TAG_structure_type);
DIEInteger One(1); DIEInteger One(1);
DIEString FooStr = getString("foo"); 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);
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);
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
@ -77,15 +81,16 @@ TEST_F(DIEHashTest, NamespacedType) {
auto Space = make_unique<DIE>(dwarf::DW_TAG_namespace); auto Space = make_unique<DIE>(dwarf::DW_TAG_namespace);
DIEInteger One(1); DIEInteger One(1);
DIEString SpaceStr = getString("space"); 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. // 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? // sibling?
auto Foo = make_unique<DIE>(dwarf::DW_TAG_structure_type); auto Foo = make_unique<DIE>(dwarf::DW_TAG_structure_type);
DIEString FooStr = getString("foo"); 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);
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);
DIE &N = *Foo; DIE &N = *Foo;
Space->addChild(std::move(Foo)); Space->addChild(std::move(Foo));
@ -101,24 +106,24 @@ TEST_F(DIEHashTest, NamespacedType) {
TEST_F(DIEHashTest, TypeWithMember) { TEST_F(DIEHashTest, TypeWithMember) {
DIE Unnamed(dwarf::DW_TAG_structure_type); DIE Unnamed(dwarf::DW_TAG_structure_type);
DIEInteger Four(4); 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); DIE Int(dwarf::DW_TAG_base_type);
DIEString IntStr = getString("int"); DIEString IntStr = getString("int");
Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, IntStr); Int.addValue(Alloc, 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_byte_size, dwarf::DW_FORM_data1, Four);
DIEInteger Five(5); 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); DIEEntry IntRef(Int);
auto Member = make_unique<DIE>(dwarf::DW_TAG_member); auto Member = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemberStr = getString("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); DIEInteger Zero(0);
Member->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, Member->addValue(Alloc, dwarf::DW_AT_data_member_location,
Zero); dwarf::DW_FORM_data1, Zero);
Member->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntRef); Member->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntRef);
Unnamed.addChild(std::move(Member)); Unnamed.addChild(std::move(Member));
@ -131,34 +136,34 @@ TEST_F(DIEHashTest, TypeWithMember) {
TEST_F(DIEHashTest, ReusedType) { TEST_F(DIEHashTest, ReusedType) {
DIE Unnamed(dwarf::DW_TAG_structure_type); DIE Unnamed(dwarf::DW_TAG_structure_type);
DIEInteger Eight(8); 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); DIEInteger Four(4);
DIE Int(dwarf::DW_TAG_base_type); DIE Int(dwarf::DW_TAG_base_type);
DIEString IntStr = getString("int"); DIEString IntStr = getString("int");
Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, IntStr); Int.addValue(Alloc, 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_byte_size, dwarf::DW_FORM_data1, Four);
DIEInteger Five(5); 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); DIEEntry IntRef(Int);
auto Mem1 = make_unique<DIE>(dwarf::DW_TAG_member); auto Mem1 = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString Mem1Str = getString("mem1"); 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); 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); 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)); Unnamed.addChild(std::move(Mem1));
auto Mem2 = make_unique<DIE>(dwarf::DW_TAG_member); auto Mem2 = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString Mem2Str = getString("mem2"); DIEString Mem2Str = getString("mem2");
Mem2->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, Mem2Str); Mem2->addValue(Alloc, 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_data_member_location, dwarf::DW_FORM_data1,
Four); 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)); Unnamed.addChild(std::move(Mem2));
@ -171,15 +176,15 @@ TEST_F(DIEHashTest, ReusedType) {
TEST_F(DIEHashTest, RecursiveType) { TEST_F(DIEHashTest, RecursiveType) {
DIE Foo(dwarf::DW_TAG_structure_type); DIE Foo(dwarf::DW_TAG_structure_type);
DIEInteger One(1); 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"); 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<DIE>(dwarf::DW_TAG_member); auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr = getString("mem"); 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); 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. // DW_AT_external and DW_AT_declaration are ignored anyway, so skip them.
Foo.addChild(std::move(Mem)); Foo.addChild(std::move(Mem));
@ -193,23 +198,24 @@ TEST_F(DIEHashTest, RecursiveType) {
TEST_F(DIEHashTest, Pointer) { TEST_F(DIEHashTest, Pointer) {
DIE Foo(dwarf::DW_TAG_structure_type); DIE Foo(dwarf::DW_TAG_structure_type);
DIEInteger Eight(8); 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"); 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<DIE>(dwarf::DW_TAG_member); auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr = getString("mem"); 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); 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); 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); 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); 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)); Foo.addChild(std::move(Mem));
@ -222,27 +228,29 @@ TEST_F(DIEHashTest, Pointer) {
TEST_F(DIEHashTest, Reference) { TEST_F(DIEHashTest, Reference) {
DIE Foo(dwarf::DW_TAG_structure_type); DIE Foo(dwarf::DW_TAG_structure_type);
DIEInteger Eight(8); 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"); 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<DIE>(dwarf::DW_TAG_member); auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr = getString("mem"); 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); 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); 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); 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); DIE FooRefConst(dwarf::DW_TAG_const_type);
DIEEntry FooRefRef(FooRef); 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); 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)); Foo.addChild(std::move(Mem));
@ -255,27 +263,29 @@ TEST_F(DIEHashTest, Reference) {
TEST_F(DIEHashTest, RValueReference) { TEST_F(DIEHashTest, RValueReference) {
DIE Foo(dwarf::DW_TAG_structure_type); DIE Foo(dwarf::DW_TAG_structure_type);
DIEInteger Eight(8); 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"); 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<DIE>(dwarf::DW_TAG_member); auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr = getString("mem"); 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); 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); 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); 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); DIE FooRefConst(dwarf::DW_TAG_const_type);
DIEEntry FooRefRef(FooRef); 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); 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)); Foo.addChild(std::move(Mem));
@ -288,24 +298,25 @@ TEST_F(DIEHashTest, RValueReference) {
TEST_F(DIEHashTest, PtrToMember) { TEST_F(DIEHashTest, PtrToMember) {
DIE Foo(dwarf::DW_TAG_structure_type); DIE Foo(dwarf::DW_TAG_structure_type);
DIEInteger Eight(8); 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"); 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<DIE>(dwarf::DW_TAG_member); auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr = getString("mem"); 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); 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); DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry FooEntry(Foo); DIEEntry FooEntry(Foo);
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooEntry); PtrToFooMem.addValue(Alloc, 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_containing_type, dwarf::DW_FORM_ref4,
FooEntry); FooEntry);
DIEEntry PtrToFooMemRef(PtrToFooMem); 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)); Foo.addChild(std::move(Mem));
@ -329,27 +340,30 @@ TEST_F(DIEHashTest, PtrToMemberDeclDefMatch) {
uint64_t MD5ResDecl; uint64_t MD5ResDecl;
{ {
DIE Bar(dwarf::DW_TAG_structure_type); DIE Bar(dwarf::DW_TAG_structure_type);
Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, BarStr); Bar.addValue(Alloc, 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_declaration, dwarf::DW_FORM_flag_present,
One);
DIE Foo(dwarf::DW_TAG_structure_type); DIE Foo(dwarf::DW_TAG_structure_type);
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);
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<DIE>(dwarf::DW_TAG_member); auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); Mem->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, Mem->addValue(Alloc, dwarf::DW_AT_data_member_location,
Zero); dwarf::DW_FORM_data1, Zero);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type); DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry BarEntry(Bar); 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); DIEEntry FooEntry(Foo);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, PtrToFooMem.addValue(Alloc, dwarf::DW_AT_containing_type,
FooEntry); dwarf::DW_FORM_ref4, FooEntry);
DIEEntry PtrToFooMemRef(PtrToFooMem); 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)); Foo.addChild(std::move(Mem));
@ -358,27 +372,29 @@ TEST_F(DIEHashTest, PtrToMemberDeclDefMatch) {
uint64_t MD5ResDef; uint64_t MD5ResDef;
{ {
DIE Bar(dwarf::DW_TAG_structure_type); DIE Bar(dwarf::DW_TAG_structure_type);
Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, BarStr); Bar.addValue(Alloc, 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_byte_size, dwarf::DW_FORM_data1, One);
DIE Foo(dwarf::DW_TAG_structure_type); DIE Foo(dwarf::DW_TAG_structure_type);
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);
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<DIE>(dwarf::DW_TAG_member); auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); Mem->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, Mem->addValue(Alloc, dwarf::DW_AT_data_member_location,
Zero); dwarf::DW_FORM_data1, Zero);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type); DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry BarEntry(Bar); 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); DIEEntry FooEntry(Foo);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, PtrToFooMem.addValue(Alloc, dwarf::DW_AT_containing_type,
FooEntry); dwarf::DW_FORM_ref4, FooEntry);
DIEEntry PtrToFooMemRef(PtrToFooMem); 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)); Foo.addChild(std::move(Mem));
@ -402,26 +418,29 @@ TEST_F(DIEHashTest, PtrToMemberDeclDefMisMatch) {
uint64_t MD5ResDecl; uint64_t MD5ResDecl;
{ {
DIE Bar(dwarf::DW_TAG_structure_type); DIE Bar(dwarf::DW_TAG_structure_type);
Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, BarStr); Bar.addValue(Alloc, 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_declaration, dwarf::DW_FORM_flag_present,
One);
DIE Foo(dwarf::DW_TAG_structure_type); DIE Foo(dwarf::DW_TAG_structure_type);
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);
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<DIE>(dwarf::DW_TAG_member); auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); Mem->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, Mem->addValue(Alloc, dwarf::DW_AT_data_member_location,
Zero); dwarf::DW_FORM_data1, Zero);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type); DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry BarEntry(Bar); 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,
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
BarEntry); BarEntry);
PtrToFooMem.addValue(Alloc, dwarf::DW_AT_containing_type,
dwarf::DW_FORM_ref4, BarEntry);
DIEEntry PtrToFooMemRef(PtrToFooMem); 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)); Foo.addChild(std::move(Mem));
@ -430,26 +449,28 @@ TEST_F(DIEHashTest, PtrToMemberDeclDefMisMatch) {
uint64_t MD5ResDef; uint64_t MD5ResDef;
{ {
DIE Bar(dwarf::DW_TAG_structure_type); DIE Bar(dwarf::DW_TAG_structure_type);
Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, BarStr); Bar.addValue(Alloc, 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_byte_size, dwarf::DW_FORM_data1, One);
DIE Foo(dwarf::DW_TAG_structure_type); DIE Foo(dwarf::DW_TAG_structure_type);
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);
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<DIE>(dwarf::DW_TAG_member); auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); Mem->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, Mem->addValue(Alloc, dwarf::DW_AT_data_member_location,
Zero); dwarf::DW_FORM_data1, Zero);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type); DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry BarEntry(Bar); 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,
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
BarEntry); BarEntry);
PtrToFooMem.addValue(Alloc, dwarf::DW_AT_containing_type,
dwarf::DW_FORM_ref4, BarEntry);
DIEEntry PtrToFooMemRef(PtrToFooMem); 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)); Foo.addChild(std::move(Mem));
@ -473,23 +494,26 @@ TEST_F(DIEHashTest, RefUnnamedType) {
DIEString MemStr = getString("mem"); DIEString MemStr = getString("mem");
DIE Unnamed(dwarf::DW_TAG_structure_type); 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); DIE Foo(dwarf::DW_TAG_structure_type);
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);
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<DIE>(dwarf::DW_TAG_member); auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr); Mem->addValue(Alloc, 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_data_member_location, dwarf::DW_FORM_data1,
Zero);
DIE UnnamedPtr(dwarf::DW_TAG_pointer_type); 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); 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); 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)); Foo.addChild(std::move(Mem));
@ -502,12 +526,12 @@ TEST_F(DIEHashTest, RefUnnamedType) {
TEST_F(DIEHashTest, NestedType) { TEST_F(DIEHashTest, NestedType) {
DIE Unnamed(dwarf::DW_TAG_structure_type); DIE Unnamed(dwarf::DW_TAG_structure_type);
DIEInteger One(1); 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<DIE>(dwarf::DW_TAG_structure_type); auto Foo = make_unique<DIE>(dwarf::DW_TAG_structure_type);
DIEString FooStr = getString("foo"); 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);
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);
Unnamed.addChild(std::move(Foo)); Unnamed.addChild(std::move(Foo));
@ -521,11 +545,11 @@ TEST_F(DIEHashTest, NestedType) {
TEST_F(DIEHashTest, MemberFunc) { TEST_F(DIEHashTest, MemberFunc) {
DIE Unnamed(dwarf::DW_TAG_structure_type); DIE Unnamed(dwarf::DW_TAG_structure_type);
DIEInteger One(1); 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<DIE>(dwarf::DW_TAG_subprogram); auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram);
DIEString FuncStr = getString("func"); 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)); Unnamed.addChild(std::move(Func));
@ -542,21 +566,24 @@ TEST_F(DIEHashTest, MemberFuncFlag) {
DIE A(dwarf::DW_TAG_structure_type); DIE A(dwarf::DW_TAG_structure_type);
DIEInteger One(1); DIEInteger One(1);
DIEString AStr = getString("A"); DIEString AStr = getString("A");
A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, AStr); A.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, AStr);
A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); A.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); A.addValue(Alloc, 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_decl_line, dwarf::DW_FORM_data1, One);
auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram); auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram);
DIEString FuncStr = getString("func"); DIEString FuncStr = getString("func");
DIEString FuncLinkage = getString("_ZN1A4funcEv"); DIEString FuncLinkage = getString("_ZN1A4funcEv");
DIEInteger Two(2); DIEInteger Two(2);
Func->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, One); Func->addValue(Alloc, dwarf::DW_AT_external, dwarf::DW_FORM_flag_present,
Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FuncStr); One);
Func->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); Func->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FuncStr);
Func->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, Two); Func->addValue(Alloc, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One);
Func->addValue(dwarf::DW_AT_linkage_name, dwarf::DW_FORM_strp, FuncLinkage); Func->addValue(Alloc, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, Two);
Func->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, One); 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)); A.addChild(std::move(Func));
@ -575,35 +602,36 @@ TEST_F(DIEHashTest, MemberSdata) {
DIE A(dwarf::DW_TAG_structure_type); DIE A(dwarf::DW_TAG_structure_type);
DIEInteger One(1); DIEInteger One(1);
DIEString AStr = getString("A"); DIEString AStr = getString("A");
A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, AStr); A.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, AStr);
A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); A.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); A.addValue(Alloc, 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_decl_line, dwarf::DW_FORM_data1, One);
DIEInteger Four(4); DIEInteger Four(4);
DIEInteger Five(5); DIEInteger Five(5);
DIEString FStr = getString("int"); DIEString FStr = getString("int");
DIE IntTyDIE(dwarf::DW_TAG_base_type); DIE IntTyDIE(dwarf::DW_TAG_base_type);
IntTyDIE.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four); IntTyDIE.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four);
IntTyDIE.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Five); IntTyDIE.addValue(Alloc, 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_name, dwarf::DW_FORM_strp, FStr);
DIEEntry IntTy(IntTyDIE); DIEEntry IntTy(IntTyDIE);
auto PITyDIE = make_unique<DIE>(dwarf::DW_TAG_const_type); auto PITyDIE = make_unique<DIE>(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); DIEEntry PITy(*PITyDIE);
auto PI = make_unique<DIE>(dwarf::DW_TAG_member); auto PI = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString PIStr = getString("PI"); DIEString PIStr = getString("PI");
DIEInteger Two(2); DIEInteger Two(2);
DIEInteger NegThree(-3); DIEInteger NegThree(-3);
PI->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, PIStr); PI->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, PIStr);
PI->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); PI->addValue(Alloc, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One);
PI->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, Two); PI->addValue(Alloc, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, Two);
PI->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PITy); PI->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PITy);
PI->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, One); PI->addValue(Alloc, 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_declaration, dwarf::DW_FORM_flag_present,
PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, NegThree); One);
PI->addValue(Alloc, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, NegThree);
A.addChild(std::move(PI)); A.addChild(std::move(PI));
@ -620,32 +648,35 @@ TEST_F(DIEHashTest, MemberBlock) {
DIE A(dwarf::DW_TAG_structure_type); DIE A(dwarf::DW_TAG_structure_type);
DIEInteger One(1); DIEInteger One(1);
DIEString AStr = getString("A"); DIEString AStr = getString("A");
A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, AStr); A.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, AStr);
A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One); A.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); A.addValue(Alloc, 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_decl_line, dwarf::DW_FORM_data1, One);
DIEInteger Four(4); DIEInteger Four(4);
DIEString FStr = getString("float"); DIEString FStr = getString("float");
auto FloatTyDIE = make_unique<DIE>(dwarf::DW_TAG_base_type); auto FloatTyDIE = make_unique<DIE>(dwarf::DW_TAG_base_type);
FloatTyDIE->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four); FloatTyDIE->addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1,
FloatTyDIE->addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Four); Four);
FloatTyDIE->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FStr); 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); DIEEntry FloatTy(*FloatTyDIE);
auto PITyDIE = make_unique<DIE>(dwarf::DW_TAG_const_type); auto PITyDIE = make_unique<DIE>(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); DIEEntry PITy(*PITyDIE);
auto PI = make_unique<DIE>(dwarf::DW_TAG_member); auto PI = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString PIStr = getString("PI"); DIEString PIStr = getString("PI");
DIEInteger Two(2); DIEInteger Two(2);
PI->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, PIStr); PI->addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, PIStr);
PI->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One); PI->addValue(Alloc, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One);
PI->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, Two); PI->addValue(Alloc, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, Two);
PI->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PITy); PI->addValue(Alloc, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PITy);
PI->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, One); PI->addValue(Alloc, 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_declaration, dwarf::DW_FORM_flag_present,
One);
DIEBlock PIBlock; DIEBlock PIBlock;
DIEInteger Blk1(0xc3); DIEInteger Blk1(0xc3);
@ -653,12 +684,13 @@ TEST_F(DIEHashTest, MemberBlock) {
DIEInteger Blk3(0x48); DIEInteger Blk3(0x48);
DIEInteger Blk4(0x40); DIEInteger Blk4(0x40);
PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk1); PIBlock.addValue(Alloc, (dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk1);
PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk2); PIBlock.addValue(Alloc, (dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk2);
PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk3); PIBlock.addValue(Alloc, (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, 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)); A.addChild(std::move(PI));