6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-12 13:30:51 +00:00
Code Issues Projects Releases Wiki Activity

Reapply "AsmPrinter: Change DIEValue to be stored by value"

Browse Source 
This reverts commit r238350, effectively reapplying r238349 after fixing
(all?) the problems, all somehow related to how I was using
`AlignedArrayCharUnion<>` inside `DIEValue`:

  - MSVC can only handle `sizeof()` on types, not values.  Change the
    assert.
  - GCC doesn't know the `is_trivially_copyable` type trait.  Instead of
    asserting it, add destructors.
  - Call placement new even when constructing POD (i.e., the pointers).
  - Instead of copying the char buffer, copy the casted classes.

I've left in a couple of `static_assert`s that I think both MSVC and GCC
know how to handle.  If the bots disagree with me, I'll remove them.

  - Check that the constructed type is either standard layout or a
    pointer.  This protects against a programming error: we really want
    the "small" `DIEValue`s to be small and simple, so don't
    accidentally change them not to be.
  - Similarly, check that the size of the buffer is no bigger than a
    `uint64_t` or a pointer.  (I thought checking against
    `sizeof(uint64_t)` would be good enough, but Chandler suggested that
    pointers might sometimes be bigger than that in the context of
    sanitizers.)

I've also committed r238359 in the meantime, which introduces a
DIEValue.def to simplify dispatching between the various types (thanks
to a review comment by David Blaikie).  Without that, this commit would
be almost unintelligible.

Here's the original commit message:
--
Change `DIEValue` to be stored/passed/etc. by value, instead of
reference.  It's now a discriminated union, with a `Val` field storing
the actual type.  The classes that used to inherit from `DIEValue` no
longer do.  There are two categories of these:

  - Small values fit in a single pointer and are stored by value.
  - Large values require auxiliary storage, and are stored by reference.

The only non-mechanical change is to tools/dsymutil/DwarfLinker.cpp.  It
was relying on `DIEInteger`s being passed around by reference, so I
replaced that assumption with a `PatchLocation` type that stores a safe
reference to where the `DIEInteger` lives instead.

This commit causes a temporary regression in memory usage, since I've
left merging `DIEAbbrevData` into `DIEValue` for a follow-up commit.  I
measured an increase from 845 MB to 879 MB, around 3.9%.  The follow-up
drops it lower than the starting point, and I've only recently brought
the memory this low anyway, so I'm committing these changes separately
to keep them incremental.  (I also considered swapping the commits, but
the other one first would cause a lot more code churn.)

(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@238362 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan P. N. Exon Smith 2015-05-27 22:14:58 +00:00
parent 344593ce6c
commit 09fe4bf794
13 changed files with 577 additions and 547 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -104,54 +104,14 @@ public:
#endif
};
//===--------------------------------------------------------------------===//
/// DIEValue - A debug information entry value. Some of these roughly correlate
/// to DWARF attribute classes.
///
class DIEValue {
public:
enum Type {
#define HANDLE_DIEVALUE(T) is##T,
#include "llvm/CodeGen/DIEValue.def"
};
private:
/// Ty - Type of data stored in the value.
///
Type Ty;
protected:
explicit DIEValue(Type T) : Ty(T) {}
~DIEValue() {}
public:
// Accessors
Type getType() const { return Ty; }
/// EmitValue - Emit value via the Dwarf writer.
///
void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
/// SizeOf - Return the size of a value in bytes.
///
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
#ifndef NDEBUG
void print(raw_ostream &O) const;
void dump() const;
#endif
};
//===--------------------------------------------------------------------===//
/// DIEInteger - An integer value DIE.
///
class DIEInteger : public DIEValue {
friend DIEValue;
class DIEInteger {
uint64_t Integer;
public:
explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {}
explicit DIEInteger(uint64_t I) : Integer(I) {}
/// BestForm - Choose the best form for integer.
///
@ -178,120 +138,91 @@ public:
uint64_t getValue() const { return Integer; }
void setValue(uint64_t Val) { Integer = Val; }
// Implement isa/cast/dyncast.
static bool classof(const DIEValue *I) { return I->getType() == isInteger; }
private:
void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
#ifndef NDEBUG
void printImpl(raw_ostream &O) const;
void print(raw_ostream &O) const;
#endif
};
//===--------------------------------------------------------------------===//
/// DIEExpr - An expression DIE.
//
class DIEExpr : public DIEValue {
friend class DIEValue;
class DIEExpr {
const MCExpr *Expr;
public:
explicit DIEExpr(const MCExpr *E) : DIEValue(isExpr), Expr(E) {}
explicit DIEExpr(const MCExpr *E) : Expr(E) {}
/// getValue - Get MCExpr.
///
const MCExpr *getValue() const { return Expr; }
// Implement isa/cast/dyncast.
static bool classof(const DIEValue *E) { return E->getType() == isExpr; }
private:
void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
#ifndef NDEBUG
void printImpl(raw_ostream &O) const;
void print(raw_ostream &O) const;
#endif
};
//===--------------------------------------------------------------------===//
/// DIELabel - A label DIE.
//
class DIELabel : public DIEValue {
friend class DIEValue;
class DIELabel {
const MCSymbol *Label;
public:
explicit DIELabel(const MCSymbol *L) : DIEValue(isLabel), Label(L) {}
explicit DIELabel(const MCSymbol *L) : Label(L) {}
/// getValue - Get MCSymbol.
///
const MCSymbol *getValue() const { return Label; }
// Implement isa/cast/dyncast.
static bool classof(const DIEValue *L) { return L->getType() == isLabel; }
private:
void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
#ifndef NDEBUG
void printImpl(raw_ostream &O) const;
void print(raw_ostream &O) const;
#endif
};
//===--------------------------------------------------------------------===//
/// DIEDelta - A simple label difference DIE.
///
class DIEDelta : public DIEValue {
friend class DIEValue;
class DIEDelta {
const MCSymbol *LabelHi;
const MCSymbol *LabelLo;
public:
DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo)
: DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {}
DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) : LabelHi(Hi), LabelLo(Lo) {}
// Implement isa/cast/dyncast.
static bool classof(const DIEValue *D) { return D->getType() == isDelta; }
private:
void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
#ifndef NDEBUG
void printImpl(raw_ostream &O) const;
void print(raw_ostream &O) const;
#endif
};
//===--------------------------------------------------------------------===//
/// DIEString - A container for string values.
///
class DIEString : public DIEValue {
friend class DIEValue;
class DIEString {
DwarfStringPoolEntryRef S;
public:
DIEString(DwarfStringPoolEntryRef S) : DIEValue(isString), S(S) {}
DIEString(DwarfStringPoolEntryRef S) : S(S) {}
/// getString - Grab the string out of the object.
StringRef getString() const { return S.getString(); }
// Implement isa/cast/dyncast.
static bool classof(const DIEValue *D) { return D->getType() == isString; }
private:
void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
#ifndef NDEBUG
void printImpl(raw_ostream &O) const;
void print(raw_ostream &O) const;
#endif
};
@ -300,60 +231,48 @@ private:
/// this class can also be used as a proxy for a debug information entry not
/// yet defined (ie. types.)
class DIE;
class DIEEntry : public DIEValue {
friend class DIEValue;
class DIEEntry {
DIE *Entry;
DIE &Entry;
DIEEntry() = delete;
public:
explicit DIEEntry(DIE &E) : DIEValue(isEntry), Entry(E) {
}
explicit DIEEntry(DIE &E) : Entry(&E) {}
DIE &getEntry() const { return Entry; }
DIE &getEntry() const { return *Entry; }
/// Returns size of a ref_addr entry.
static unsigned getRefAddrSize(const AsmPrinter *AP);
// Implement isa/cast/dyncast.
static bool classof(const DIEValue *E) { return E->getType() == isEntry; }
private:
void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
return Form == dwarf::DW_FORM_ref_addr ? getRefAddrSize(AP)
: sizeof(int32_t);
}
#ifndef NDEBUG
void printImpl(raw_ostream &O) const;
void print(raw_ostream &O) const;
#endif
};
//===--------------------------------------------------------------------===//
/// \brief A signature reference to a type unit.
class DIETypeSignature : public DIEValue {
friend class DIEValue;
class DIETypeSignature {
const DwarfTypeUnit *Unit;
const DwarfTypeUnit &Unit;
DIETypeSignature() = delete;
public:
explicit DIETypeSignature(const DwarfTypeUnit &Unit)
: DIEValue(isTypeSignature), Unit(Unit) {}
explicit DIETypeSignature(const DwarfTypeUnit &Unit) : Unit(&Unit) {}
// \brief Implement isa/cast/dyncast.
static bool classof(const DIEValue *E) {
return E->getType() == isTypeSignature;
}
private:
void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
assert(Form == dwarf::DW_FORM_ref_sig8);
return 8;
}
#ifndef NDEBUG
void printImpl(raw_ostream &O) const;
void print(raw_ostream &O) const;
#endif
};
@ -361,27 +280,159 @@ private:
/// DIELocList - Represents a pointer to a location list in the debug_loc
/// section.
//
class DIELocList : public DIEValue {
friend class DIEValue;
class DIELocList {
// Index into the .debug_loc vector.
size_t Index;
public:
DIELocList(size_t I) : DIEValue(isLocList), Index(I) {}
DIELocList(size_t I) : Index(I) {}
/// getValue - Grab the current index out.
size_t getValue() const { return Index; }
// Implement isa/cast/dyncast.
static bool classof(const DIEValue *E) { return E->getType() == isLocList; }
private:
void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
#ifndef NDEBUG
void printImpl(raw_ostream &O) const;
void print(raw_ostream &O) const;
#endif
};
//===--------------------------------------------------------------------===//
/// DIEValue - A debug information entry value. Some of these roughly correlate
/// to DWARF attribute classes.
///
class DIEBlock;
class DIELoc;
class DIEValue {
public:
enum Type {
isNone,
#define HANDLE_DIEVALUE(T) is##T,
#include "llvm/CodeGen/DIEValue.def"
};
private:
/// Ty - Type of data stored in the value.
///
Type Ty;
/// Storage for the value.
///
/// All values that aren't standard layout (or are larger than 8 bytes)
/// should be stored by reference instead of by value.
typedef AlignedCharArrayUnion<DIEInteger, DIEString, DIEExpr, DIELabel,
DIEDelta *, DIEEntry, DIETypeSignature,
DIEBlock *, DIELoc *, DIELocList> ValTy;
static_assert(sizeof(ValTy) <= sizeof(uint64_t) ||
sizeof(ValTy) <= sizeof(void *),
"Expected all large types to be stored via pointer");
/// Underlying stored value.
ValTy Val;
template <class T> void construct(T V) {
static_assert(std::is_standard_layout<T>::value ||
std::is_pointer<T>::value,
"Expected standard layout or pointer");
new (reinterpret_cast<void *>(Val.buffer)) T(V);
}
template <class T> T &get() { return *reinterpret_cast<T *>(Val.buffer); }
template <class T> const T &get() const {
return *reinterpret_cast<const T *>(Val.buffer);
}
template <class T> void destruct() { get<T>().~T(); }
/// Destroy the underlying value.
///
/// This should get optimized down to a no-op. We could skip it if we could
/// add a static assert on \a std::is_trivially_copyable(), but we currently
/// support versions of GCC that don't understand that.
void destroyVal() {
switch (Ty) {
case isNone:
return;
#define HANDLE_DIEVALUE_SMALL(T) \
case is##T: \
destruct<DIE##T>();
return;
#define HANDLE_DIEVALUE_LARGE(T) \
case is##T: \
destruct<const DIE##T *>();
return;
#include "llvm/CodeGen/DIEValue.def"
}
}
/// Copy the underlying value.
///
/// This should get optimized down to a simple copy. We need to actually
/// construct the value, rather than calling memcpy, to satisfy strict
/// aliasing rules.
void copyVal(const DIEValue &X) {
switch (Ty) {
case isNone:
return;
#define HANDLE_DIEVALUE_SMALL(T) \
case is##T: \
construct<DIE##T>(X.get<DIE##T>()); \
return;
#define HANDLE_DIEVALUE_LARGE(T) \
case is##T: \
construct<const DIE##T *>(X.get<const DIE##T *>()); \
return;
#include "llvm/CodeGen/DIEValue.def"
}
}
public:
DIEValue() : Ty(isNone) {}
DIEValue(const DIEValue &X) : Ty(X.Ty) { copyVal(X); }
DIEValue &operator=(const DIEValue &X) {
destroyVal();
Ty = X.Ty;
copyVal(X);
return *this;
}
~DIEValue() { destroyVal(); }
#define HANDLE_DIEVALUE_SMALL(T) \
DIEValue(const DIE##T &V) : Ty(is##T) { construct<DIE##T>(V); }
#define HANDLE_DIEVALUE_LARGE(T) \
DIEValue(const DIE##T *V) : Ty(is##T) { \
assert(V && "Expected valid value"); \
construct<const DIE##T *>(V); \
}
#include "llvm/CodeGen/DIEValue.def"
// Accessors
Type getType() const { return Ty; }
explicit operator bool() const { return Ty; }
#define HANDLE_DIEVALUE_SMALL(T) \
const DIE##T &getDIE##T() const { \
assert(getType() == is##T && "Expected " #T); \
return get<DIE##T>(); \
}
#define HANDLE_DIEVALUE_LARGE(T) \
const DIE##T &getDIE##T() const { \
assert(getType() == is##T && "Expected " #T); \
return *get<const DIE##T *>(); \
}
#include "llvm/CodeGen/DIEValue.def"
/// EmitValue - Emit value via the Dwarf writer.
///
void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
/// SizeOf - Return the size of a value in bytes.
///
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
#ifndef NDEBUG
void print(raw_ostream &O) const;
void dump() const;
#endif
};
@ -416,7 +467,7 @@ protected:
/// Attribute values.
///
SmallVector<DIEValue *, 12> Values;
SmallVector<DIEValue, 12> Values;
protected:
DIE()
@ -438,7 +489,11 @@ public:
const std::vector<std::unique_ptr<DIE>> &getChildren() const {
return Children;
}
const SmallVectorImpl<DIEValue *> &getValues() const { return Values; }
const SmallVectorImpl<DIEValue> &getValues() const { return Values; }
void setValue(unsigned I, DIEValue New) {
assert(I < Values.size());
Values[I] = New;
}
DIE *getParent() const { return Parent; }
/// Climb up the parent chain to get the compile or type unit DIE this DIE
/// belongs to.
@ -451,7 +506,7 @@ public:
/// addValue - Add a value and attributes to a DIE.
///
void addValue(dwarf::Attribute Attribute, dwarf::Form Form, DIEValue *Value) {
void addValue(dwarf::Attribute Attribute, dwarf::Form Form, DIEValue Value) {
Abbrev.AddAttribute(Attribute, Form);
Values.push_back(Value);
}
@ -465,9 +520,11 @@ public:
Children.push_back(std::move(Child));
}
/// findAttribute - Find a value in the DIE with the attribute given,
/// returns NULL if no such attribute exists.
DIEValue *findAttribute(dwarf::Attribute Attribute) const;
/// Find a value in the DIE with the attribute given.
///
/// Returns a default-constructed DIEValue (where \a DIEValue::getType()
/// gives \a DIEValue::isNone) if no such attribute exists.
DIEValue findAttribute(dwarf::Attribute Attribute) const;
#ifndef NDEBUG
void print(raw_ostream &O, unsigned IndentCount = 0) const;
@ -478,12 +535,11 @@ public:
//===--------------------------------------------------------------------===//
/// DIELoc - Represents an expression location.
//
class DIELoc : public DIEValue, public DIE {
friend class DIEValue;
class DIELoc : public DIE {
mutable unsigned Size; // Size in bytes excluding size header.
public:
DIELoc() : DIEValue(isLoc), Size(0) {}
DIELoc() : Size(0) {}
/// ComputeSize - Calculate the size of the location expression.
///
@ -504,27 +560,22 @@ public:
return dwarf::DW_FORM_block;
}
// Implement isa/cast/dyncast.
static bool classof(const DIEValue *E) { return E->getType() == isLoc; }
private:
void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
#ifndef NDEBUG
void printImpl(raw_ostream &O) const;
void print(raw_ostream &O) const;
#endif
};
//===--------------------------------------------------------------------===//
/// DIEBlock - Represents a block of values.
//
class DIEBlock : public DIEValue, public DIE {
friend class DIEValue;
class DIEBlock : public DIE {
mutable unsigned Size; // Size in bytes excluding size header.
public:
DIEBlock() : DIEValue(isBlock), Size(0) {}
DIEBlock() : Size(0) {}
/// ComputeSize - Calculate the size of the location expression.
///
@ -542,15 +593,11 @@ public:
return dwarf::DW_FORM_block;
}
// Implement isa/cast/dyncast.
static bool classof(const DIEValue *E) { return E->getType() == isBlock; }
private:
void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
#ifndef NDEBUG
void printImpl(raw_ostream &O) const;
void print(raw_ostream &O) const;
#endif
};

40
include/llvm/CodeGen/DIEValue.def
View File

@ -11,19 +11,37 @@
//
//===----------------------------------------------------------------------===//
#if !(defined HANDLE_DIEVALUE)
#if !(defined HANDLE_DIEVALUE || defined HANDLE_DIEVALUE_SMALL || \
defined HANDLE_DIEVALUE_LARGE)
#error "Missing macro definition of HANDLE_DIEVALUE"
#endif
HANDLE_DIEVALUE(Integer)
HANDLE_DIEVALUE(String)
HANDLE_DIEVALUE(Expr)
HANDLE_DIEVALUE(Label)
HANDLE_DIEVALUE(Delta)
HANDLE_DIEVALUE(Entry)
HANDLE_DIEVALUE(TypeSignature)
HANDLE_DIEVALUE(Block)
HANDLE_DIEVALUE(Loc)
HANDLE_DIEVALUE(LocList)
// Handler for all values.
#ifndef HANDLE_DIEVALUE
#define HANDLE_DIEVALUE(T)
#endif
// Handler for small values.
#ifndef HANDLE_DIEVALUE_SMALL
#define HANDLE_DIEVALUE_SMALL(T) HANDLE_DIEVALUE(T)
#endif
// Handler for large values.
#ifndef HANDLE_DIEVALUE_LARGE
#define HANDLE_DIEVALUE_LARGE(T) HANDLE_DIEVALUE(T)
#endif
HANDLE_DIEVALUE_SMALL(Integer)
HANDLE_DIEVALUE_SMALL(String)
HANDLE_DIEVALUE_SMALL(Expr)
HANDLE_DIEVALUE_SMALL(Label)
HANDLE_DIEVALUE_LARGE(Delta)
HANDLE_DIEVALUE_SMALL(Entry)
HANDLE_DIEVALUE_SMALL(TypeSignature)
HANDLE_DIEVALUE_LARGE(Block)
HANDLE_DIEVALUE_LARGE(Loc)
HANDLE_DIEVALUE_SMALL(LocList)
#undef HANDLE_DIEVALUE
#undef HANDLE_DIEVALUE_SMALL
#undef HANDLE_DIEVALUE_LARGE

8
lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
View File

@ -265,7 +265,7 @@ void AsmPrinter::emitDwarfDIE(const DIE &Die) const {
dwarf::TagString(Abbrev.getTag()));
EmitULEB128(Abbrev.getNumber());
const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
const SmallVectorImpl<DIEValue> &Values = Die.getValues();
const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
// Emit the DIE attribute values.
@ -277,12 +277,12 @@ void AsmPrinter::emitDwarfDIE(const DIE &Die) const {
if (isVerbose()) {
OutStreamer->AddComment(dwarf::AttributeString(Attr));
if (Attr == dwarf::DW_AT_accessibility)
OutStreamer->AddComment(dwarf::AccessibilityString(
cast<DIEInteger>(Values[i])->getValue()));
OutStreamer->AddComment(
dwarf::AccessibilityString(Values[i].getDIEInteger().getValue()));
}
// Emit an attribute using the defined form.
Values[i]->EmitValue(this, Form);
Values[i].EmitValue(this, Form);
}
// Emit the DIE children if any.

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

@ -128,8 +128,8 @@ const DIE *DIE::getUnitOrNull() const {
return nullptr;
}
DIEValue *DIE::findAttribute(dwarf::Attribute Attribute) const {
const SmallVectorImpl<DIEValue *> &Values = getValues();
DIEValue DIE::findAttribute(dwarf::Attribute Attribute) const {
const SmallVectorImpl<DIEValue> &Values = getValues();
const DIEAbbrev &Abbrevs = getAbbrev();
// Iterate through all the attributes until we find the one we're
@ -137,7 +137,7 @@ DIEValue *DIE::findAttribute(dwarf::Attribute Attribute) const {
for (size_t i = 0; i < Values.size(); ++i)
if (Abbrevs.getData()[i].getAttribute() == Attribute)
return Values[i];
return nullptr;
return DIEValue();
}
#ifndef NDEBUG
@ -174,7 +174,7 @@ void DIE::print(raw_ostream &O, unsigned IndentCount) const {
O << " "
<< dwarf::FormEncodingString(Data[i].getForm())
<< " ";
Values[i]->print(O);
Values[i].print(O);
O << "\n";
}
IndentCount -= 2;
@ -193,9 +193,11 @@ void DIE::dump() {
void DIEValue::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
switch (Ty) {
case isNone:
llvm_unreachable("Expected valid DIEValue");
#define HANDLE_DIEVALUE(T) \
case is##T: \
cast<DIE##T>(this)->EmitValueImpl(AP, Form); \
getDIE##T().EmitValue(AP, Form); \
break;
#include "llvm/CodeGen/DIEValue.def"
}
@ -203,9 +205,11 @@ void DIEValue::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
unsigned DIEValue::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
switch (Ty) {
case isNone:
llvm_unreachable("Expected valid DIEValue");
#define HANDLE_DIEVALUE(T) \
case is##T: \
return cast<DIE##T>(this)->SizeOfImpl(AP, Form);
return getDIE##T().SizeOf(AP, Form);
#include "llvm/CodeGen/DIEValue.def"
}
llvm_unreachable("Unknown DIE kind");
@ -214,9 +218,11 @@ unsigned DIEValue::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
#ifndef NDEBUG
void DIEValue::print(raw_ostream &O) const {
switch (Ty) {
case isNone:
llvm_unreachable("Expected valid DIEValue");
#define HANDLE_DIEVALUE(T) \
case is##T: \
cast<DIE##T>(this)->printImpl(O); \
getDIE##T().print(O); \
break;
#include "llvm/CodeGen/DIEValue.def"
}
@ -233,7 +239,7 @@ void DIEValue::dump() const {
/// EmitValue - Emit integer of appropriate size.
///
void DIEInteger::EmitValueImpl(const AsmPrinter *Asm, dwarf::Form Form) const {
void DIEInteger::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
unsigned Size = ~0U;
switch (Form) {
case dwarf::DW_FORM_flag_present:
@ -269,7 +275,7 @@ void DIEInteger::EmitValueImpl(const AsmPrinter *Asm, dwarf::Form Form) const {
/// SizeOf - Determine size of integer value in bytes.
///
unsigned DIEInteger::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
switch (Form) {
case dwarf::DW_FORM_flag_present: return 0;
case dwarf::DW_FORM_flag: // Fall thru
@ -298,7 +304,7 @@ unsigned DIEInteger::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
}
#ifndef NDEBUG
void DIEInteger::printImpl(raw_ostream &O) const {
void DIEInteger::print(raw_ostream &O) const {
O << "Int: " << (int64_t)Integer << " 0x";
O.write_hex(Integer);
}
@ -310,13 +316,13 @@ void DIEInteger::printImpl(raw_ostream &O) const {
/// EmitValue - Emit expression value.
///
void DIEExpr::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
void DIEExpr::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
AP->OutStreamer->EmitValue(Expr, SizeOf(AP, Form));
}
/// SizeOf - Determine size of expression value in bytes.
///
unsigned DIEExpr::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
unsigned DIEExpr::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
if (Form == dwarf::DW_FORM_data4) return 4;
if (Form == dwarf::DW_FORM_sec_offset) return 4;
if (Form == dwarf::DW_FORM_strp) return 4;
@ -324,7 +330,7 @@ unsigned DIEExpr::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
}
#ifndef NDEBUG
void DIEExpr::printImpl(raw_ostream &O) const { O << "Expr: " << *Expr; }
void DIEExpr::print(raw_ostream &O) const { O << "Expr: " << *Expr; }
#endif
//===----------------------------------------------------------------------===//
@ -333,7 +339,7 @@ void DIEExpr::printImpl(raw_ostream &O) const { O << "Expr: " << *Expr; }
/// EmitValue - Emit label value.
///
void DIELabel::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
void DIELabel::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
AP->EmitLabelReference(Label, SizeOf(AP, Form),
Form == dwarf::DW_FORM_strp ||
Form == dwarf::DW_FORM_sec_offset ||
@ -342,7 +348,7 @@ void DIELabel::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
/// SizeOf - Determine size of label value in bytes.
///
unsigned DIELabel::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
unsigned DIELabel::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
if (Form == dwarf::DW_FORM_data4) return 4;
if (Form == dwarf::DW_FORM_sec_offset) return 4;
if (Form == dwarf::DW_FORM_strp) return 4;
@ -350,9 +356,7 @@ unsigned DIELabel::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
}
#ifndef NDEBUG
void DIELabel::printImpl(raw_ostream &O) const {
O << "Lbl: " << Label->getName();
}
void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); }
#endif
//===----------------------------------------------------------------------===//
@ -361,13 +365,13 @@ void DIELabel::printImpl(raw_ostream &O) const {
/// EmitValue - Emit delta value.
///
void DIEDelta::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
void DIEDelta::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
AP->EmitLabelDifference(LabelHi, LabelLo, SizeOf(AP, Form));
}
/// SizeOf - Determine size of delta value in bytes.
///
unsigned DIEDelta::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
unsigned DIEDelta::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
if (Form == dwarf::DW_FORM_data4) return 4;
if (Form == dwarf::DW_FORM_sec_offset) return 4;
if (Form == dwarf::DW_FORM_strp) return 4;
@ -375,7 +379,7 @@ unsigned DIEDelta::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
}
#ifndef NDEBUG
void DIEDelta::printImpl(raw_ostream &O) const {
void DIEDelta::print(raw_ostream &O) const {
O << "Del: " << LabelHi->getName() << "-" << LabelLo->getName();
}
#endif
@ -386,7 +390,7 @@ void DIEDelta::printImpl(raw_ostream &O) const {
/// EmitValue - Emit string value.
///
void DIEString::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
void DIEString::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
assert(
(Form == dwarf::DW_FORM_strp || Form == dwarf::DW_FORM_GNU_str_index) &&
"Expected valid string form");
@ -410,7 +414,7 @@ void DIEString::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
/// SizeOf - Determine size of delta value in bytes.
///
unsigned DIEString::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
unsigned DIEString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
assert(
(Form == dwarf::DW_FORM_strp || Form == dwarf::DW_FORM_GNU_str_index) &&
"Expected valid string form");
@ -428,7 +432,7 @@ unsigned DIEString::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
}
#ifndef NDEBUG
void DIEString::printImpl(raw_ostream &O) const {
void DIEString::print(raw_ostream &O) const {
O << "String: " << S.getString();
}
#endif
@ -439,16 +443,16 @@ void DIEString::printImpl(raw_ostream &O) const {
/// EmitValue - Emit debug information entry offset.
///
void DIEEntry::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
void DIEEntry::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
if (Form == dwarf::DW_FORM_ref_addr) {
const DwarfDebug *DD = AP->getDwarfDebug();
unsigned Addr = Entry.getOffset();
unsigned Addr = Entry->getOffset();
assert(!DD->useSplitDwarf() && "TODO: dwo files can't have relocations.");
// For DW_FORM_ref_addr, output the offset from beginning of debug info
// section. Entry->getOffset() returns the offset from start of the
// compile unit.
DwarfCompileUnit *CU = DD->lookupUnit(Entry.getUnit());
DwarfCompileUnit *CU = DD->lookupUnit(Entry->getUnit());
assert(CU && "CUDie should belong to a CU.");
Addr += CU->getDebugInfoOffset();
if (AP->MAI->doesDwarfUseRelocationsAcrossSections())
@ -457,7 +461,7 @@ void DIEEntry::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
else
AP->OutStreamer->EmitIntValue(Addr, DIEEntry::getRefAddrSize(AP));
} else
AP->EmitInt32(Entry.getOffset());
AP->EmitInt32(Entry->getOffset());
}
unsigned DIEEntry::getRefAddrSize(const AsmPrinter *AP) {
@ -473,7 +477,7 @@ unsigned DIEEntry::getRefAddrSize(const AsmPrinter *AP) {
}
#ifndef NDEBUG
void DIEEntry::printImpl(raw_ostream &O) const {
void DIEEntry::print(raw_ostream &O) const {
O << format("Die: 0x%lx", (long)(intptr_t)&Entry);
}
#endif
@ -481,14 +485,15 @@ void DIEEntry::printImpl(raw_ostream &O) const {
//===----------------------------------------------------------------------===//
// DIETypeSignature Implementation
//===----------------------------------------------------------------------===//
void DIETypeSignature::EmitValueImpl(const AsmPrinter *Asm, dwarf::Form Form) const {
void DIETypeSignature::EmitValue(const AsmPrinter *Asm,
dwarf::Form Form) const {
assert(Form == dwarf::DW_FORM_ref_sig8);
Asm->OutStreamer->EmitIntValue(Unit.getTypeSignature(), 8);
Asm->OutStreamer->EmitIntValue(Unit->getTypeSignature(), 8);
}
#ifndef NDEBUG
void DIETypeSignature::printImpl(raw_ostream &O) const {
O << format("Type Unit: 0x%lx", Unit.getTypeSignature());
void DIETypeSignature::print(raw_ostream &O) const {
O << format("Type Unit: 0x%lx", Unit->getTypeSignature());
}
#endif
@ -502,7 +507,7 @@ unsigned DIELoc::ComputeSize(const AsmPrinter *AP) const {
if (!Size) {
const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
for (unsigned i = 0, N = Values.size(); i < N; ++i)
Size += Values[i]->SizeOf(AP, AbbrevData[i].getForm());
Size += Values[i].SizeOf(AP, AbbrevData[i].getForm());
}
return Size;
@ -510,7 +515,7 @@ unsigned DIELoc::ComputeSize(const AsmPrinter *AP) const {
/// EmitValue - Emit location data.
///
void DIELoc::EmitValueImpl(const AsmPrinter *Asm, dwarf::Form Form) const {
void DIELoc::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
switch (Form) {
default: llvm_unreachable("Improper form for block");
case dwarf::DW_FORM_block1: Asm->EmitInt8(Size); break;
@ -523,12 +528,12 @@ void DIELoc::EmitValueImpl(const AsmPrinter *Asm, dwarf::Form Form) const {
const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
for (unsigned i = 0, N = Values.size(); i < N; ++i)
Values[i]->EmitValue(Asm, AbbrevData[i].getForm());
Values[i].EmitValue(Asm, AbbrevData[i].getForm());
}
/// SizeOf - Determine size of location data in bytes.
///
unsigned DIELoc::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
unsigned DIELoc::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
switch (Form) {
case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
@ -541,7 +546,7 @@ unsigned DIELoc::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
}
#ifndef NDEBUG
void DIELoc::printImpl(raw_ostream &O) const {
void DIELoc::print(raw_ostream &O) const {
O << "ExprLoc: ";
DIE::print(O, 5);
}
@ -557,7 +562,7 @@ unsigned DIEBlock::ComputeSize(const AsmPrinter *AP) const {
if (!Size) {
const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
for (unsigned i = 0, N = Values.size(); i < N; ++i)
Size += Values[i]->SizeOf(AP, AbbrevData[i].getForm());
Size += Values[i].SizeOf(AP, AbbrevData[i].getForm());
}
return Size;
@ -565,7 +570,7 @@ unsigned DIEBlock::ComputeSize(const AsmPrinter *AP) const {
/// EmitValue - Emit block data.
///
void DIEBlock::EmitValueImpl(const AsmPrinter *Asm, dwarf::Form Form) const {
void DIEBlock::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
switch (Form) {
default: llvm_unreachable("Improper form for block");
case dwarf::DW_FORM_block1: Asm->EmitInt8(Size); break;
@ -576,12 +581,12 @@ void DIEBlock::EmitValueImpl(const AsmPrinter *Asm, dwarf::Form Form) const {
const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
for (unsigned i = 0, N = Values.size(); i < N; ++i)
Values[i]->EmitValue(Asm, AbbrevData[i].getForm());
Values[i].EmitValue(Asm, AbbrevData[i].getForm());
}
/// SizeOf - Determine size of block data in bytes.
///
unsigned DIEBlock::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
unsigned DIEBlock::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
switch (Form) {
case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
@ -592,7 +597,7 @@ unsigned DIEBlock::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
}
#ifndef NDEBUG
void DIEBlock::printImpl(raw_ostream &O) const {
void DIEBlock::print(raw_ostream &O) const {
O << "Blk: ";
DIE::print(O, 5);
}
@ -602,7 +607,7 @@ void DIEBlock::printImpl(raw_ostream &O) const {
// DIELocList Implementation
//===----------------------------------------------------------------------===//
unsigned DIELocList::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
unsigned DIELocList::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
if (Form == dwarf::DW_FORM_data4)
return 4;
if (Form == dwarf::DW_FORM_sec_offset)
@ -612,7 +617,7 @@ unsigned DIELocList::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
/// EmitValue - Emit label value.
///
void DIELocList::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
void DIELocList::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
DwarfDebug *DD = AP->getDwarfDebug();
MCSymbol *Label = DD->getDebugLocs().getList(Index).Label;
@ -623,8 +628,5 @@ void DIELocList::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
}
#ifndef NDEBUG
void DIELocList::printImpl(raw_ostream &O) const {
O << "LocList: " << Index;
}
void DIELocList::print(raw_ostream &O) const { O << "LocList: " << Index; }
#endif

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

@ -31,18 +31,14 @@ using namespace llvm;
/// \brief Grabs the string in whichever attribute is passed in and returns
/// a reference to it.
static StringRef getDIEStringAttr(const DIE &Die, uint16_t Attr) {
const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
const auto &Values = Die.getValues();
const DIEAbbrev &Abbrevs = Die.getAbbrev();
// Iterate through all the attributes until we find the one we're
// looking for, if we can't find it return an empty string.
for (size_t i = 0; i < Values.size(); ++i) {
if (Abbrevs.getData()[i].getAttribute() == Attr) {
DIEValue *V = Values[i];
assert(isa<DIEString>(V) && "String requested. Not a string.");
DIEString *S = cast<DIEString>(V);
return S->getString();
}
if (Abbrevs.getData()[i].getAttribute() == Attr)
return Values[i].getDIEString().getString();
}
return StringRef("");
}
@ -123,7 +119,7 @@ void DIEHash::addParentContext(const DIE &Parent) {
// Collect all of the attributes for a particular DIE in single structure.
void DIEHash::collectAttributes(const DIE &Die, DIEAttrs &Attrs) {
const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
const SmallVectorImpl<DIEValue> &Values = Die.getValues();
const DIEAbbrev &Abbrevs = Die.getAbbrev();
#define COLLECT_ATTR(NAME) \
@ -274,11 +270,9 @@ 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 SmallVectorImpl<DIEValue *> &Values) {
for (SmallVectorImpl<DIEValue *>::const_iterator I = Values.begin(),
E = Values.end();
I != E; ++I)
Hash.update((uint64_t)cast<DIEInteger>(*I)->getValue());
void DIEHash::hashBlockData(const SmallVectorImpl<DIEValue> &Values) {
for (auto I = Values.begin(), E = Values.end(); I != E; ++I)
Hash.update((uint64_t)I->getDIEInteger().getValue());
}
// Hash the contents of a loclistptr class.
@ -293,7 +287,7 @@ void DIEHash::hashLocList(const DIELocList &LocList) {
// Hash an individual attribute \param Attr based on the type of attribute and
// the form.
void DIEHash::hashAttribute(AttrEntry Attr, dwarf::Tag Tag) {
const DIEValue *Value = Attr.Val;
const DIEValue &Value = Attr.Val;
const DIEAbbrevData *Desc = Attr.Desc;
dwarf::Attribute Attribute = Desc->getAttribute();
@ -304,12 +298,15 @@ void DIEHash::hashAttribute(AttrEntry Attr, dwarf::Tag Tag) {
// computation is limited to the following: DW_FORM_sdata, DW_FORM_flag,
// DW_FORM_string, and DW_FORM_block.
switch (Value->getType()) {
switch (Value.getType()) {
case DIEValue::isNone:
llvm_unreachable("Expected valid DIEValue");
// 7.27 Step 3
// ... An attribute that refers to another type entry T is processed as
// follows:
case DIEValue::isEntry:
hashDIEEntry(Attribute, Tag, cast<DIEEntry>(Value)->getEntry());
hashDIEEntry(Attribute, Tag, Value.getDIEEntry().getEntry());
break;
case DIEValue::isInteger: {
addULEB128('A');
@ -322,14 +319,14 @@ void DIEHash::hashAttribute(AttrEntry Attr, dwarf::Tag Tag) {
case dwarf::DW_FORM_udata:
case dwarf::DW_FORM_sdata:
addULEB128(dwarf::DW_FORM_sdata);
addSLEB128((int64_t)cast<DIEInteger>(Value)->getValue());
addSLEB128((int64_t)Value.getDIEInteger().getValue());
break;
// DW_FORM_flag_present is just flag with a value of one. We still give it a
// value so just use the value.
case dwarf::DW_FORM_flag_present:
case dwarf::DW_FORM_flag:
addULEB128(dwarf::DW_FORM_flag);
addULEB128((int64_t)cast<DIEInteger>(Value)->getValue());
addULEB128((int64_t)Value.getDIEInteger().getValue());
break;
default:
llvm_unreachable("Unknown integer form!");
@ -340,7 +337,7 @@ void DIEHash::hashAttribute(AttrEntry Attr, dwarf::Tag Tag) {
addULEB128('A');
addULEB128(Attribute);
addULEB128(dwarf::DW_FORM_string);
addString(cast<DIEString>(Value)->getString());
addString(Value.getDIEString().getString());
break;
case DIEValue::isBlock:
case DIEValue::isLoc:
@ -348,17 +345,17 @@ void DIEHash::hashAttribute(AttrEntry Attr, dwarf::Tag Tag) {
addULEB128('A');
addULEB128(Attribute);
addULEB128(dwarf::DW_FORM_block);
if (isa<DIEBlock>(Value)) {
addULEB128(cast<DIEBlock>(Value)->ComputeSize(AP));
hashBlockData(cast<DIEBlock>(Value)->getValues());
} else if (isa<DIELoc>(Value)) {
addULEB128(cast<DIELoc>(Value)->ComputeSize(AP));
hashBlockData(cast<DIELoc>(Value)->getValues());
if (Value.getType() == DIEValue::isBlock) {
addULEB128(Value.getDIEBlock().ComputeSize(AP));
hashBlockData(Value.getDIEBlock().getValues());
} else if (Value.getType() == DIEValue::isLoc) {
addULEB128(Value.getDIELoc().ComputeSize(AP));
hashBlockData(Value.getDIELoc().getValues());
} else {
// We could add the block length, but that would take
// a bit of work and not add a lot of uniqueness
// to the hash in some way we could test.
hashLocList(*cast<DIELocList>(Value));
hashLocList(Value.getDIELocList());
}
break;
// FIXME: It's uncertain whether or not we should handle this at the moment.
@ -375,7 +372,7 @@ void DIEHash::hashAttribute(AttrEntry Attr, dwarf::Tag Tag) {
void DIEHash::hashAttributes(const DIEAttrs &Attrs, dwarf::Tag Tag) {
#define ADD_ATTR(ATTR) \
{ \
if (ATTR.Val != 0) \
if (ATTR.Val) \
hashAttribute(ATTR, Tag); \
}

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

@ -29,7 +29,7 @@ class DIEHash {
// The entry for a particular attribute.
struct AttrEntry {
const DIEValue *Val;
DIEValue Val;
const DIEAbbrevData *Desc;
};
@ -135,7 +135,7 @@ private:
/// \brief Hashes the data in a block like DIEValue, e.g. DW_FORM_block or
/// DW_FORM_exprloc.
void hashBlockData(const SmallVectorImpl<DIEValue *> &Values);
void hashBlockData(const SmallVectorImpl<DIEValue> &Values);
/// \brief Hashes the contents pointed to in the .debug_loc section.
void hashLocList(const DIELocList &LocList);

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

@ -42,8 +42,7 @@ void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
DD->addArangeLabel(SymbolCU(this, Label));
unsigned idx = DD->getAddressPool().getIndex(Label);
DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
Die.addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
Die.addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, DIEInteger(idx));
}
void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
@ -53,8 +52,7 @@ void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
DD->addArangeLabel(SymbolCU(this, Label));
Die.addValue(Attribute, dwarf::DW_FORM_addr,
Label ? (DIEValue *)new (DIEValueAllocator) DIELabel(Label)
: new (DIEValueAllocator) DIEInteger(0));
Label ? DIEValue(DIELabel(Label)) : DIEValue(DIEInteger(0)));
}
unsigned DwarfCompileUnit::getOrCreateSourceID(StringRef FileName,
@ -145,7 +143,7 @@ DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
bool addToAccelTable = false;
if (auto *Global = dyn_cast_or_null<GlobalVariable>(GV->getVariable())) {
addToAccelTable = true;
DIELoc *Loc = new (DIEValueAllocator) DIELoc();
DIELoc *Loc = new (DIEValueAllocator) DIELoc;
const MCSymbol *Sym = Asm->getSymbol(Global);
if (Global->isThreadLocal()) {
// FIXME: Make this work with -gsplit-dwarf.
@ -183,7 +181,7 @@ DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
} else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getVariable())) {
addToAccelTable = true;
// GV is a merged global.
DIELoc *Loc = new (DIEValueAllocator) DIELoc();
DIELoc *Loc = new (DIEValueAllocator) DIELoc;
Value *Ptr = CE->getOperand(0);
MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
DD->addArangeLabel(SymbolCU(this, Sym));
@ -365,10 +363,9 @@ void DwarfCompileUnit::constructScopeDIE(
void DwarfCompileUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
const MCSymbol *Hi, const MCSymbol *Lo) {
DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
Die.addValue(Attribute, DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
: dwarf::DW_FORM_data4,
Value);
new (DIEValueAllocator) DIEDelta(Hi, Lo));
}
void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
@ -515,7 +512,7 @@ DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
return VariableDie;
auto Expr = DV.getExpression().begin();
DIELoc *Loc = new (DIEValueAllocator) DIELoc();
DIELoc *Loc = new (DIEValueAllocator) DIELoc;
DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
for (auto FI : DV.getFrameIndex()) {
unsigned FrameReg = 0;
@ -739,7 +736,7 @@ void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
/// Add an address attribute to a die based on the location provided.
void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
const MachineLocation &Location) {
DIELoc *Loc = new (DIEValueAllocator) DIELoc();
DIELoc *Loc = new (DIEValueAllocator) DIELoc;
bool validReg;
if (Location.isReg())
@ -761,7 +758,7 @@ void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
dwarf::Attribute Attribute,
const MachineLocation &Location) {
DIELoc *Loc = new (DIEValueAllocator) DIELoc();
DIELoc *Loc = new (DIEValueAllocator) DIELoc;
DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
assert(DV.getExpression().size() == 1);
const DIExpression *Expr = DV.getExpression().back();
@ -782,10 +779,9 @@ void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
/// Add a Dwarf loclistptr attribute data and value.
void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
unsigned Index) {
DIEValue *Value = new (DIEValueAllocator) DIELocList(Index);
dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
: dwarf::DW_FORM_data4;
Die.addValue(Attribute, Form, Value);
Die.addValue(Attribute, Form, DIELocList(Index));
}
void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
@ -802,8 +798,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) {
DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
Die.addValue((dwarf::Attribute)0, Form, Value);
Die.addValue((dwarf::Attribute)0, Form, DIEExpr(Expr));
}
void DwarfCompileUnit::applySubprogramAttributesToDefinition(

5
lib/CodeGen/AsmPrinter/DwarfDebug.cpp
View File

@ -1340,9 +1340,8 @@ static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
// We could have a specification DIE that has our most of our knowledge,
// look for that now.
DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
if (SpecVal) {
DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
if (SpecDIE.findAttribute(dwarf::DW_AT_external))
Linkage = dwarf::GIEL_EXTERNAL;
} else if (Die->findAttribute(dwarf::DW_AT_external))

4
lib/CodeGen/AsmPrinter/DwarfFile.cpp
View File

@ -94,13 +94,13 @@ unsigned DwarfFile::computeSizeAndOffset(DIE &Die, unsigned Offset) {
// Start the size with the size of abbreviation code.
Offset += getULEB128Size(Die.getAbbrevNumber());
const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
const SmallVectorImpl<DIEValue> &Values = Die.getValues();
const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
// Size the DIE attribute values.
for (unsigned i = 0, N = Values.size(); i < N; ++i)
// Size attribute value.
Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
Offset += Values[i].SizeOf(Asm, AbbrevData[i].getForm());
// Get the children.
const auto &Children = Die.getChildren();

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

@ -70,7 +70,6 @@ DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag,
DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
assert(UnitTag == dwarf::DW_TAG_compile_unit ||
UnitTag == dwarf::DW_TAG_type_unit);
DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
}
DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
@ -89,11 +88,6 @@ DwarfUnit::~DwarfUnit() {
DIELocs[j]->~DIELoc();
}
DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
return Value;
}
int64_t DwarfUnit::getDefaultLowerBound() const {
switch (getLanguage()) {
default:
@ -190,18 +184,16 @@ 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, DIEIntegerOne);
Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEInteger(1));
else
Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEInteger(1));
}
void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
Optional<dwarf::Form> Form, uint64_t Integer) {
if (!Form)
Form = DIEInteger::BestForm(false, Integer);
DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
DIEInteger(Integer);
Die.addValue(Attribute, *Form, Value);
Die.addValue(Attribute, *Form, DIEInteger(Integer));
}
void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
@ -212,8 +204,7 @@ void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
Optional<dwarf::Form> Form, int64_t Integer) {
if (!Form)
Form = DIEInteger::BestForm(true, Integer);
DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
Die.addValue(Attribute, *Form, Value);
Die.addValue(Attribute, *Form, DIEInteger(Integer));
}
void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
@ -225,14 +216,12 @@ void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
StringRef String) {
Die.addValue(Attribute,
isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp,
new (DIEValueAllocator)
DIEString(DU->getStringPool().getEntry(*Asm, String)));
}
void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
const MCSymbol *Label) {
DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
Die.addValue(Attribute, Form, Value);
Die.addValue(Attribute, Form, DIELabel(Label));
}
void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
@ -265,12 +254,12 @@ void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
const MCSymbol *Hi, const MCSymbol *Lo) {
DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
Die.addValue(Attribute, dwarf::DW_FORM_data4,
new (DIEValueAllocator) DIEDelta(Hi, Lo));
}
void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
addDIEEntry(Die, Attribute, createDIEEntry(Entry));
addDIEEntry(Die, Attribute, DIEEntry(Entry));
}
void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
@ -281,13 +270,13 @@ void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
addFlag(Die, dwarf::DW_AT_declaration);
Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
new (DIEValueAllocator) DIETypeSignature(Type));
DIETypeSignature(Type));
}
void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
DIEEntry *Entry) {
DIEEntry Entry) {
const DIE *DieCU = Die.getUnitOrNull();
const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
const DIE *EntryCU = Entry.getEntry().getUnitOrNull();
if (!DieCU)
// We assume that Die belongs to this CU, if it is not linked to any CU yet.
DieCU = &getUnitDie();
@ -471,7 +460,7 @@ void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
// Decode the original location, and use that as the start of the byref
// variable's location.
DIELoc *Loc = new (DIEValueAllocator) DIELoc();
DIELoc *Loc = new (DIEValueAllocator) DIELoc;
bool validReg;
if (Location.isReg())
@ -588,7 +577,7 @@ static uint64_t getBaseTypeSize(DwarfDebug *DD, const DIDerivedType *Ty) {
void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
assert(MO.isFPImm() && "Invalid machine operand!");
DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
APFloat FPImm = MO.getFPImm()->getValueAPF();
// Get the raw data form of the floating point.
@ -644,7 +633,7 @@ void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
return;
}
DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
// Get the raw data form of the large APInt.
const uint64_t *Ptr64 = Val.getRawData();
@ -777,22 +766,7 @@ void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
dwarf::Attribute Attribute) {
assert(Ty && "Trying to add a type that doesn't exist?");
// Check for pre-existence.
DIEEntry *Entry = getDIEEntry(Ty);
// If it exists then use the existing value.
if (Entry) {
addDIEEntry(Entity, Attribute, Entry);
return;
}
// Construct type.
DIE *Buffer = getOrCreateTypeDIE(Ty);
// Set up proxy.
Entry = createDIEEntry(*Buffer);
insertDIEEntry(Ty, Entry);
addDIEEntry(Entity, Attribute, Entry);
addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
}
std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
@ -969,12 +943,6 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
if (unsigned PropertyAttributes = Property->getAttributes())
addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
PropertyAttributes);
DIEEntry *Entry = getDIEEntry(Element);
if (!Entry) {
Entry = createDIEEntry(ElemDie);
insertDIEEntry(Element, Entry);
}
}
}
@ -1061,7 +1029,7 @@ void DwarfUnit::constructTemplateValueParameterDIE(
else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
// For declaration non-type template parameters (such as global values and
// functions)
DIELoc *Loc = new (DIEValueAllocator) DIELoc();
DIELoc *Loc = new (DIEValueAllocator) DIELoc;
addOpAddress(*Loc, Asm->getSymbol(GV));
// Emit DW_OP_stack_value to use the address as the immediate value of the
// parameter, rather than a pointer to it.
@ -1354,7 +1322,7 @@ void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
// expression to extract appropriate offset from vtable.
// BaseAddr = ObAddr + *((*ObAddr) - Offset)
DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
@ -1393,7 +1361,7 @@ void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
OffsetInBytes = DT->getOffsetInBits() >> 3;
if (DD->getDwarfVersion() <= 2) {
DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
@ -1417,10 +1385,10 @@ void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
dwarf::DW_VIRTUALITY_virtual);
// Objective-C properties.
if (MDNode *PNode = DT->getObjCProperty())
if (DIEEntry *PropertyDie = getDIEEntry(PNode))
if (DINode *PNode = DT->getObjCProperty())
if (DIE *PDie = getDIE(PNode))
MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
PropertyDie);
DIEEntry(*PDie));
if (DT->isArtificial())
addFlag(MemberDie, dwarf::DW_AT_artificial);

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

@ -93,10 +93,6 @@ protected:
/// information entries.
DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
/// Tracks the mapping of unit level debug information descriptors to debug
/// information entries using a DIEEntry proxy.
DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
/// A list of all the DIEBlocks in use.
std::vector<DIEBlock *> DIEBlocks;
@ -111,9 +107,6 @@ protected:
// All DIEValues are allocated through this allocator.
BumpPtrAllocator DIEValueAllocator;
// A preallocated DIEValue because 1 is used frequently.
DIEInteger *DIEIntegerOne;
/// The section this unit will be emitted in.
MCSection *Section;
@ -180,7 +173,7 @@ public:
DIE *getDIE(const DINode *D) const;
/// \brief Returns a fresh newly allocated DIELoc.
DIELoc *getDIELoc() { return new (DIEValueAllocator) DIELoc(); }
DIELoc *getDIELoc() { return new (DIEValueAllocator) DIELoc; }
/// \brief Insert DIE into the map.
///
@ -233,7 +226,7 @@ public:
void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry);
/// \brief Add a DIE attribute data and value.
void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIEEntry *Entry);
void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIEEntry Entry);
void addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type);
@ -369,26 +362,12 @@ private:
/// If the DWARF version doesn't handle the language, return -1.
int64_t getDefaultLowerBound() const;
/// \brief Returns the DIE entry for the specified debug variable.
DIEEntry *getDIEEntry(const MDNode *N) const {
return MDNodeToDIEEntryMap.lookup(N);
}
/// \brief Insert debug information entry into the map.
void insertDIEEntry(const MDNode *N, DIEEntry *E) {
MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
}
/// \brief Get an anonymous type for index type.
DIE *getIndexTyDie();
/// \brief Set D as anonymous type for index which can be reused later.
void setIndexTyDie(DIE *D) { IndexTyDie = D; }
/// \brief Creates a new DIEEntry to be a proxy for a debug information
/// entry.
DIEEntry *createDIEEntry(DIE &Entry);
/// If this is a named finished type then include it in the list of types for
/// the accelerator tables.
void updateAcceleratorTables(const DIScope *Context, const DIType *Ty,

115
tools/dsymutil/DwarfLinker.cpp
View File

@ -60,6 +60,30 @@ using HalfOpenIntervalMap =
typedef HalfOpenIntervalMap<uint64_t, int64_t> FunctionIntervals;
// FIXME: Delete this structure once DIE::Values has a stable iterator we can
// use instead.
struct PatchLocation {
DIE *Die;
unsigned Index;
PatchLocation() : Die(nullptr), Index(0) {}
PatchLocation(DIE &Die, unsigned Index) : Die(&Die), Index(Index) {}
void set(uint64_t New) const {
assert(Die);
assert(Index < Die->getValues().size());
assert(Die->getValues()[Index].getType() == DIEValue::isInteger);
Die->setValue(Index, DIEInteger(New));
}
uint64_t get() const {
assert(Die);
assert(Index < Die->getValues().size());
assert(Die->getValues()[Index].getType() == DIEValue::isInteger);
return Die->getValues()[Index].getDIEInteger().getValue();
}
};
/// \brief Stores all information relating to a compile unit, be it in
/// its original instance in the object file to its brand new cloned
/// and linked DIE tree.
@ -76,7 +100,7 @@ public:
CompileUnit(DWARFUnit &OrigUnit, unsigned ID)
: OrigUnit(OrigUnit), ID(ID), LowPc(UINT64_MAX), HighPc(0), RangeAlloc(),
Ranges(RangeAlloc), UnitRangeAttribute(nullptr) {
Ranges(RangeAlloc) {
Info.resize(OrigUnit.getNumDIEs());
}
@ -106,13 +130,15 @@ public:
uint64_t getLowPc() const { return LowPc; }
uint64_t getHighPc() const { return HighPc; }
DIEInteger *getUnitRangesAttribute() const { return UnitRangeAttribute; }
Optional<PatchLocation> getUnitRangesAttribute() const {
return UnitRangeAttribute;
}
const FunctionIntervals &getFunctionRanges() const { return Ranges; }
const std::vector<DIEInteger *> &getRangesAttributes() const {
const std::vector<PatchLocation> &getRangesAttributes() const {
return RangeAttributes;
}
const std::vector<std::pair<DIEInteger *, int64_t>> &
const std::vector<std::pair<PatchLocation, int64_t>> &
getLocationAttributes() const {
return LocationAttributes;
}
@ -127,7 +153,7 @@ public:
/// RefUnit by \p Attr. The attribute should be fixed up later to
/// point to the absolute offset of \p Die in the debug_info section.
void noteForwardReference(DIE *Die, const CompileUnit *RefUnit,
DIEInteger *Attr);
PatchLocation Attr);
/// \brief Apply all fixups recored by noteForwardReference().
void fixupForwardReferences();
@ -138,11 +164,11 @@ public:
/// \brief Keep track of a DW_AT_range attribute that we will need to
/// patch up later.
void noteRangeAttribute(const DIE &Die, DIEInteger *Attr);
void noteRangeAttribute(const DIE &Die, PatchLocation Attr);
/// \brief Keep track of a location attribute pointing to a location
/// list in the debug_loc section.
void noteLocationAttribute(DIEInteger *Attr, int64_t PcOffset);
void noteLocationAttribute(PatchLocation Attr, int64_t PcOffset);
/// \brief Add a name accelerator entry for \p Die with \p Name
/// which is stored in the string table at \p Offset.
@ -186,7 +212,7 @@ private:
/// The offsets for the attributes in this array couldn't be set while
/// cloning because for cross-cu forward refences the target DIE's
/// offset isn't known you emit the reference attribute.
std::vector<std::tuple<DIE *, const CompileUnit *, DIEInteger *>>
std::vector<std::tuple<DIE *, const CompileUnit *, PatchLocation>>
ForwardDIEReferences;
FunctionIntervals::Allocator RangeAlloc;
@ -198,15 +224,15 @@ private:
/// \brief DW_AT_ranges attributes to patch after we have gathered
/// all the unit's function addresses.
/// @{
std::vector<DIEInteger *> RangeAttributes;
DIEInteger *UnitRangeAttribute;
std::vector<PatchLocation> RangeAttributes;
Optional<PatchLocation> UnitRangeAttribute;
/// @}
/// \brief Location attributes that need to be transfered from th
/// original debug_loc section to the liked one. They are stored
/// along with the PC offset that is to be applied to their
/// function's address.
std::vector<std::pair<DIEInteger *, int64_t>> LocationAttributes;
std::vector<std::pair<PatchLocation, int64_t>> LocationAttributes;
/// \brief Accelerator entries for the unit, both for the pub*
/// sections and the apple* ones.
@ -229,7 +255,7 @@ uint64_t CompileUnit::computeNextUnitOffset() {
/// \brief Keep track of a forward cross-cu reference from this unit
/// to \p Die that lives in \p RefUnit.
void CompileUnit::noteForwardReference(DIE *Die, const CompileUnit *RefUnit,
DIEInteger *Attr) {
PatchLocation Attr) {
ForwardDIEReferences.emplace_back(Die, RefUnit, Attr);
}
@ -238,9 +264,9 @@ void CompileUnit::fixupForwardReferences() {
for (const auto &Ref : ForwardDIEReferences) {
DIE *RefDie;
const CompileUnit *RefUnit;
DIEInteger *Attr;
PatchLocation Attr;
std::tie(RefDie, RefUnit, Attr) = Ref;
Attr->setValue(RefDie->getOffset() + RefUnit->getStartOffset());
Attr.set(RefDie->getOffset() + RefUnit->getStartOffset());
}
}
@ -251,14 +277,14 @@ void CompileUnit::addFunctionRange(uint64_t FuncLowPc, uint64_t FuncHighPc,
this->HighPc = std::max(HighPc, FuncHighPc + PcOffset);
}
void CompileUnit::noteRangeAttribute(const DIE &Die, DIEInteger *Attr) {
void CompileUnit::noteRangeAttribute(const DIE &Die, PatchLocation Attr) {
if (Die.getTag() != dwarf::DW_TAG_compile_unit)
RangeAttributes.push_back(Attr);
else
UnitRangeAttribute = Attr;
}
void CompileUnit::noteLocationAttribute(DIEInteger *Attr, int64_t PcOffset) {
void CompileUnit::noteLocationAttribute(PatchLocation Attr, int64_t PcOffset) {
LocationAttributes.emplace_back(Attr, PcOffset);
}
@ -717,8 +743,7 @@ void DwarfStreamer::emitUnitRangesEntries(CompileUnit &Unit,
/// point to the new entries.
void DwarfStreamer::emitLocationsForUnit(const CompileUnit &Unit,
DWARFContext &Dwarf) {
const std::vector<std::pair<DIEInteger *, int64_t>> &Attributes =
Unit.getLocationAttributes();
const auto &Attributes = Unit.getLocationAttributes();
if (Attributes.empty())
return;
@ -737,8 +762,8 @@ void DwarfStreamer::emitLocationsForUnit(const CompileUnit &Unit,
UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
for (const auto &Attr : Attributes) {
uint32_t Offset = Attr.first->getValue();
Attr.first->setValue(LocSectionSize);
uint32_t Offset = Attr.first.get();
Attr.first.set(LocSectionSize);
// This is the quantity to add to the old location address to get
// the correct address for the new one.
int64_t LocPcOffset = Attr.second + UnitPcOffset;
@ -1760,7 +1785,7 @@ unsigned DwarfLinker::cloneStringAttribute(DIE &Die, AttributeSpec AttrSpec,
const char *String = *Val.getAsCString(&U);
unsigned Offset = StringPool.getStringOffset(String);
Die.addValue(dwarf::Attribute(AttrSpec.Attr), dwarf::DW_FORM_strp,
new (DIEAlloc) DIEInteger(Offset));
DIEInteger(Offset));
return 4;
}
@ -1803,24 +1828,25 @@ unsigned DwarfLinker::cloneDieReferenceAttribute(
// to find the unit offset. (We don't have a DwarfDebug)
// FIXME: we should be able to design DIEEntry reliance on
// DwarfDebug away.
DIEInteger *Attr;
uint64_t Attr;
if (Ref < InputDIE.getOffset()) {
// We must have already cloned that DIE.
uint32_t NewRefOffset =
RefUnit->getStartOffset() + NewRefDie->getOffset();
Attr = new (DIEAlloc) DIEInteger(NewRefOffset);
Attr = NewRefOffset;
} else {
// A forward reference. Note and fixup later.
Attr = new (DIEAlloc) DIEInteger(0xBADDEF);
Unit.noteForwardReference(NewRefDie, RefUnit, Attr);
Attr = 0xBADDEF;
Unit.noteForwardReference(NewRefDie, RefUnit,
PatchLocation(Die, Die.getValues().size()));
}
Die.addValue(dwarf::Attribute(AttrSpec.Attr), dwarf::DW_FORM_ref_addr,
Attr);
DIEInteger(Attr));
return AttrSize;
}
Die.addValue(dwarf::Attribute(AttrSpec.Attr), dwarf::Form(AttrSpec.Form),
new (DIEAlloc) DIEEntry(*NewRefDie));
DIEEntry(*NewRefDie));
return AttrSize;
}
@ -1831,23 +1857,23 @@ unsigned DwarfLinker::cloneBlockAttribute(DIE &Die, AttributeSpec AttrSpec,
const DWARFFormValue &Val,
unsigned AttrSize) {
DIE *Attr;
DIEValue *Value;
DIEValue Value;
DIELoc *Loc = nullptr;
DIEBlock *Block = nullptr;
// Just copy the block data over.
if (AttrSpec.Form == dwarf::DW_FORM_exprloc) {
Loc = new (DIEAlloc) DIELoc();
Loc = new (DIEAlloc) DIELoc;
DIELocs.push_back(Loc);
} else {
Block = new (DIEAlloc) DIEBlock();
Block = new (DIEAlloc) DIEBlock;
DIEBlocks.push_back(Block);
}
Attr = Loc ? static_cast<DIE *>(Loc) : static_cast<DIE *>(Block);
Value = Loc ? static_cast<DIEValue *>(Loc) : static_cast<DIEValue *>(Block);
Value = Loc ? DIEValue(Loc) : DIEValue(Block);
ArrayRef<uint8_t> Bytes = *Val.getAsBlock();
for (auto Byte : Bytes)
Attr->addValue(static_cast<dwarf::Attribute>(0), dwarf::DW_FORM_data1,
new (DIEAlloc) DIEInteger(Byte));
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()).
@ -1893,8 +1919,7 @@ unsigned DwarfLinker::cloneAddressAttribute(DIE &Die, AttributeSpec AttrSpec,
}
Die.addValue(static_cast<dwarf::Attribute>(AttrSpec.Attr),
static_cast<dwarf::Form>(AttrSpec.Form),
new (DIEAlloc) DIEInteger(Addr));
static_cast<dwarf::Form>(AttrSpec.Form), DIEInteger(Addr));
return Unit.getOrigUnit().getAddressByteSize();
}
@ -1922,15 +1947,16 @@ unsigned DwarfLinker::cloneScalarAttribute(
&Unit.getOrigUnit(), &InputDIE);
return 0;
}
DIEInteger *Attr = new (DIEAlloc) DIEInteger(Value);
DIEInteger Attr(Value);
if (AttrSpec.Attr == dwarf::DW_AT_ranges)
Unit.noteRangeAttribute(Die, Attr);
Unit.noteRangeAttribute(Die, PatchLocation(Die, Die.getValues().size()));
// 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(Attr, Info.PCOffset);
Unit.noteLocationAttribute(PatchLocation(Die, Die.getValues().size()),
Info.PCOffset);
else if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
Info.IsDeclaration = true;
@ -2213,8 +2239,8 @@ void DwarfLinker::patchRangesForUnit(const CompileUnit &Unit,
UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
for (const auto &RangeAttribute : Unit.getRangesAttributes()) {
uint32_t Offset = RangeAttribute->getValue();
RangeAttribute->setValue(Streamer->getRangesSectionSize());
uint32_t Offset = RangeAttribute.get();
RangeAttribute.set(Streamer->getRangesSectionSize());
RangeList.extract(RangeExtractor, &Offset);
const auto &Entries = RangeList.getEntries();
const DWARFDebugRangeList::RangeListEntry &First = Entries.front();
@ -2241,10 +2267,10 @@ void DwarfLinker::patchRangesForUnit(const CompileUnit &Unit,
/// but for the sake of initial bit-for-bit compatibility with legacy
/// dsymutil, we have to do it in a delayed pass.
void DwarfLinker::generateUnitRanges(CompileUnit &Unit) const {
DIEInteger *Attr = Unit.getUnitRangesAttribute();
auto Attr = Unit.getUnitRangesAttribute();
if (Attr)
Attr->setValue(Streamer->getRangesSectionSize());
Streamer->emitUnitRangesEntries(Unit, Attr != nullptr);
Attr->set(Streamer->getRangesSectionSize());
Streamer->emitUnitRangesEntries(Unit, static_cast<bool>(Attr));
}
/// \brief Insert the new line info sequence \p Seq into the current
@ -2301,9 +2327,8 @@ void DwarfLinker::patchLineTableForUnit(CompileUnit &Unit,
return AbbrevData.getAttribute() == dwarf::DW_AT_stmt_list;
});
assert(Stmt < Abbrev.end() && "Didn't find DW_AT_stmt_list in cloned DIE!");
DIEInteger *StmtAttr =
cast<DIEInteger>(OutputDIE->getValues()[Stmt - Abbrev.begin()]);
StmtAttr->setValue(Streamer->getLineSectionSize());
OutputDIE->setValue(Stmt - Abbrev.begin(),
DIEInteger(Streamer->getLineSectionSize()));
}
// Parse the original line info for the unit.

306
unittests/CodeGen/DIEHashTest.cpp
View File

@ -36,7 +36,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(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Size);
uint64_t MD5Res = Hash.computeTypeSignature(Die);
ASSERT_EQ(0x1AFE116E83701108ULL, MD5Res);
}
@ -45,11 +45,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(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(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One);
Unnamed.addValue(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 +61,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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
@ -77,15 +77,15 @@ TEST_F(DIEHashTest, NamespacedType) {
auto Space = make_unique<DIE>(dwarf::DW_TAG_namespace);
DIEInteger One(1);
DIEString SpaceStr = getString("space");
Space->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &SpaceStr);
Space->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, SpaceStr);
// DW_AT_declaration is ignored.
Space->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
Space->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, One);
// sibling?
auto Foo = make_unique<DIE>(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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
DIE &N = *Foo;
Space->addChild(std::move(Foo));
@ -101,24 +101,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(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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, IntStr);
Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four);
DIEInteger Five(5);
Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Five);
DIEEntry IntRef(Int);
auto Member = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemberStr = getString("member");
Member->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemberStr);
Member->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemberStr);
DIEInteger Zero(0);
Member->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
Member->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
Zero);
Member->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntRef);
Unnamed.addChild(std::move(Member));
@ -131,34 +131,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(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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, IntStr);
Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Four);
DIEInteger Five(5);
Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Five);
DIEEntry IntRef(Int);
auto Mem1 = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString Mem1Str = getString("mem1");
Mem1->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem1Str);
Mem1->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, Mem1Str);
DIEInteger Zero(0);
Mem1->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
Mem1->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
Zero);
Mem1->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntRef);
Unnamed.addChild(std::move(Mem1));
auto Mem2 = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString Mem2Str = getString("mem2");
Mem2->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem2Str);
Mem2->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, Mem2Str);
Mem2->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Four);
Mem2->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
Four);
Mem2->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntRef);
Unnamed.addChild(std::move(Mem2));
@ -171,15 +171,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(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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr = getString("mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
DIEEntry FooRef(Foo);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRef);
// DW_AT_external and DW_AT_declaration are ignored anyway, so skip them.
Foo.addChild(std::move(Mem));
@ -193,23 +193,23 @@ 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(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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr = getString("mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
DIEInteger Zero(0);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, Zero);
DIE FooPtr(dwarf::DW_TAG_pointer_type);
FooPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
FooPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight);
DIEEntry FooRef(Foo);
FooPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef);
FooPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRef);
DIEEntry FooPtrRef(FooPtr);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooPtrRef);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooPtrRef);
Foo.addChild(std::move(Mem));
@ -222,27 +222,27 @@ 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(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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr = getString("mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
DIEInteger Zero(0);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, Zero);
DIE FooRef(dwarf::DW_TAG_reference_type);
FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight);
DIEEntry FooEntry(Foo);
FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooEntry);
DIE FooRefConst(dwarf::DW_TAG_const_type);
DIEEntry FooRefRef(FooRef);
FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRefRef);
DIEEntry FooRefConstRef(FooRefConst);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRefConstRef);
Foo.addChild(std::move(Mem));
@ -255,27 +255,27 @@ 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(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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr = getString("mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
DIEInteger Zero(0);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, Zero);
DIE FooRef(dwarf::DW_TAG_rvalue_reference_type);
FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight);
DIEEntry FooEntry(Foo);
FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooEntry);
DIE FooRefConst(dwarf::DW_TAG_const_type);
DIEEntry FooRefRef(FooRef);
FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRefRef);
DIEEntry FooRefConstRef(FooRefConst);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooRefConstRef);
Foo.addChild(std::move(Mem));
@ -288,24 +288,24 @@ 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(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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
DIEString MemStr = getString("mem");
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
DIEInteger Zero(0);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, Zero);
DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
DIEEntry FooEntry(Foo);
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FooEntry);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&FooEntry);
FooEntry);
DIEEntry PtrToFooMemRef(PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PtrToFooMemRef);
Foo.addChild(std::move(Mem));
@ -329,27 +329,27 @@ 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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, BarStr);
Bar.addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, One);
DIE Foo(dwarf::DW_TAG_structure_type);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
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_type, dwarf::DW_FORM_ref4, BarEntry);
DIEEntry FooEntry(Foo);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&FooEntry);
FooEntry);
DIEEntry PtrToFooMemRef(PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PtrToFooMemRef);
Foo.addChild(std::move(Mem));
@ -358,27 +358,27 @@ 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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, BarStr);
Bar.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
DIE Foo(dwarf::DW_TAG_structure_type);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
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_type, dwarf::DW_FORM_ref4, BarEntry);
DIEEntry FooEntry(Foo);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&FooEntry);
FooEntry);
DIEEntry PtrToFooMemRef(PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PtrToFooMemRef);
Foo.addChild(std::move(Mem));
@ -402,26 +402,26 @@ 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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, BarStr);
Bar.addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, One);
DIE Foo(dwarf::DW_TAG_structure_type);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
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_type, dwarf::DW_FORM_ref4, BarEntry);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&BarEntry);
BarEntry);
DIEEntry PtrToFooMemRef(PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PtrToFooMemRef);
Foo.addChild(std::move(Mem));
@ -430,26 +430,26 @@ 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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, BarStr);
Bar.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
DIE Foo(dwarf::DW_TAG_structure_type);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
&Zero);
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_type, dwarf::DW_FORM_ref4, BarEntry);
PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
&BarEntry);
BarEntry);
DIEEntry PtrToFooMemRef(PtrToFooMem);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PtrToFooMemRef);
Foo.addChild(std::move(Mem));
@ -473,23 +473,23 @@ 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(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(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight);
Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
auto Mem = make_unique<DIE>(dwarf::DW_TAG_member);
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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, MemStr);
Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, Zero);
DIE UnnamedPtr(dwarf::DW_TAG_pointer_type);
UnnamedPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
UnnamedPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, Eight);
DIEEntry UnnamedRef(Unnamed);
UnnamedPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedRef);
UnnamedPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, UnnamedRef);
DIEEntry UnnamedPtrRef(UnnamedPtr);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedPtrRef);
Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, UnnamedPtrRef);
Foo.addChild(std::move(Mem));
@ -502,12 +502,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(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
auto Foo = make_unique<DIE>(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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
Unnamed.addChild(std::move(Foo));
@ -521,11 +521,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(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram);
DIEString FuncStr = getString("func");
Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FuncStr);
Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FuncStr);
Unnamed.addChild(std::move(Func));
@ -542,21 +542,21 @@ 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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, AStr);
A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One);
A.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, One);
auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram);
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(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, One);
Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, FuncStr);
Func->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One);
Func->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, Two);
Func->addValue(dwarf::DW_AT_linkage_name, dwarf::DW_FORM_strp, FuncLinkage);
Func->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, One);
A.addChild(std::move(Func));
@ -575,35 +575,35 @@ 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(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);
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(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);
DIEEntry IntTy(IntTyDIE);
auto PITyDIE = make_unique<DIE>(dwarf::DW_TAG_const_type);
PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntTy);
PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IntTy);
DIEEntry PITy(*PITyDIE);
auto PI = make_unique<DIE>(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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, PIStr);
PI->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One);
PI->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, Two);
PI->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PITy);
PI->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, One);
PI->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, One);
PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, NegThree);
A.addChild(std::move(PI));
@ -620,32 +620,32 @@ 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(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);
DIEInteger Four(4);
DIEString FStr = getString("float");
auto FloatTyDIE = make_unique<DIE>(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(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);
DIEEntry FloatTy(*FloatTyDIE);
auto PITyDIE = make_unique<DIE>(dwarf::DW_TAG_const_type);
PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FloatTy);
PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, FloatTy);
DIEEntry PITy(*PITyDIE);
auto PI = make_unique<DIE>(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(dwarf::DW_AT_name, dwarf::DW_FORM_strp, PIStr);
PI->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One);
PI->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, Two);
PI->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, PITy);
PI->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, One);
PI->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, One);
DIEBlock PIBlock;
DIEInteger Blk1(0xc3);
@ -653,10 +653,10 @@ 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((dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk1);
PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk2);
PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk3);
PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk4);
PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_block1, &PIBlock);