2013-08-09 07:45:55 +08:00
|
|
|
//===-- llvm/CodeGen/DIEHash.cpp - Dwarf Hashing Framework ----------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file contains support for DWARF4 hashing of DIEs.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "DIEHash.h"
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "ByteStreamer.h"
|
2014-03-08 08:29:41 +08:00
|
|
|
#include "DwarfDebug.h"
|
2013-08-09 07:45:55 +08:00
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/Dwarf.h"
|
2014-02-20 10:50:45 +08:00
|
|
|
#include "llvm/CodeGen/AsmPrinter.h"
|
2015-01-06 05:29:41 +08:00
|
|
|
#include "llvm/CodeGen/DIE.h"
|
2013-08-09 07:45:55 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
|
|
|
#include "llvm/Support/Endian.h"
|
|
|
|
#include "llvm/Support/MD5.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-22 10:02:50 +08:00
|
|
|
#define DEBUG_TYPE "dwarfdebug"
|
|
|
|
|
2013-08-09 07:45:55 +08:00
|
|
|
/// \brief Grabs the string in whichever attribute is passed in and returns
|
|
|
|
/// a reference to it.
|
2013-10-25 01:51:43 +08:00
|
|
|
static StringRef getDIEStringAttr(const DIE &Die, uint16_t Attr) {
|
2013-08-09 07:45:55 +08:00
|
|
|
// Iterate through all the attributes until we find the one we're
|
|
|
|
// looking for, if we can't find it return an empty string.
|
2015-05-28 06:44:06 +08:00
|
|
|
for (const auto &V : Die.values())
|
|
|
|
if (V.getAttribute() == Attr)
|
|
|
|
return V.getDIEString().getString();
|
|
|
|
|
2013-08-09 07:45:55 +08:00
|
|
|
return StringRef("");
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Adds the string in \p Str to the hash. This also hashes
|
|
|
|
/// a trailing NULL with the string.
|
|
|
|
void DIEHash::addString(StringRef Str) {
|
|
|
|
DEBUG(dbgs() << "Adding string " << Str << " to hash.\n");
|
|
|
|
Hash.update(Str);
|
|
|
|
Hash.update(makeArrayRef((uint8_t)'\0'));
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: The LEB128 routines are copied and only slightly modified out of
|
|
|
|
// LEB128.h.
|
|
|
|
|
|
|
|
/// \brief Adds the unsigned in \p Value to the hash encoded as a ULEB128.
|
|
|
|
void DIEHash::addULEB128(uint64_t Value) {
|
|
|
|
DEBUG(dbgs() << "Adding ULEB128 " << Value << " to hash.\n");
|
|
|
|
do {
|
|
|
|
uint8_t Byte = Value & 0x7f;
|
|
|
|
Value >>= 7;
|
|
|
|
if (Value != 0)
|
|
|
|
Byte |= 0x80; // Mark this byte to show that more bytes will follow.
|
|
|
|
Hash.update(Byte);
|
|
|
|
} while (Value != 0);
|
|
|
|
}
|
|
|
|
|
2013-10-17 07:36:20 +08:00
|
|
|
void DIEHash::addSLEB128(int64_t Value) {
|
|
|
|
DEBUG(dbgs() << "Adding ULEB128 " << Value << " to hash.\n");
|
|
|
|
bool More;
|
|
|
|
do {
|
|
|
|
uint8_t Byte = Value & 0x7f;
|
|
|
|
Value >>= 7;
|
2014-02-20 10:40:41 +08:00
|
|
|
More = !((((Value == 0) && ((Byte & 0x40) == 0)) ||
|
2013-10-17 07:36:20 +08:00
|
|
|
((Value == -1) && ((Byte & 0x40) != 0))));
|
|
|
|
if (More)
|
|
|
|
Byte |= 0x80; // Mark this byte to show that more bytes will follow.
|
|
|
|
Hash.update(Byte);
|
|
|
|
} while (More);
|
|
|
|
}
|
|
|
|
|
2013-08-09 07:45:55 +08:00
|
|
|
/// \brief Including \p Parent adds the context of Parent to the hash..
|
2013-10-25 02:29:03 +08:00
|
|
|
void DIEHash::addParentContext(const DIE &Parent) {
|
2013-08-09 07:45:55 +08:00
|
|
|
|
|
|
|
DEBUG(dbgs() << "Adding parent context to hash...\n");
|
|
|
|
|
|
|
|
// [7.27.2] For each surrounding type or namespace beginning with the
|
|
|
|
// outermost such construct...
|
2013-10-25 02:29:03 +08:00
|
|
|
SmallVector<const DIE *, 1> Parents;
|
|
|
|
const DIE *Cur = &Parent;
|
2013-11-20 07:08:21 +08:00
|
|
|
while (Cur->getParent()) {
|
2013-10-25 02:29:03 +08:00
|
|
|
Parents.push_back(Cur);
|
|
|
|
Cur = Cur->getParent();
|
2013-08-09 07:45:55 +08:00
|
|
|
}
|
2013-11-20 07:08:21 +08:00
|
|
|
assert(Cur->getTag() == dwarf::DW_TAG_compile_unit ||
|
|
|
|
Cur->getTag() == dwarf::DW_TAG_type_unit);
|
2013-08-09 07:45:55 +08:00
|
|
|
|
|
|
|
// Reverse iterate over our list to go from the outermost construct to the
|
|
|
|
// innermost.
|
2013-10-25 02:29:03 +08:00
|
|
|
for (SmallVectorImpl<const DIE *>::reverse_iterator I = Parents.rbegin(),
|
|
|
|
E = Parents.rend();
|
2013-08-09 07:45:55 +08:00
|
|
|
I != E; ++I) {
|
2013-10-25 02:29:03 +08:00
|
|
|
const DIE &Die = **I;
|
2013-08-09 07:45:55 +08:00
|
|
|
|
|
|
|
// ... Append the letter "C" to the sequence...
|
|
|
|
addULEB128('C');
|
|
|
|
|
|
|
|
// ... Followed by the DWARF tag of the construct...
|
2013-10-25 02:29:03 +08:00
|
|
|
addULEB128(Die.getTag());
|
2013-08-09 07:45:55 +08:00
|
|
|
|
|
|
|
// ... Then the name, taken from the DW_AT_name attribute.
|
2013-10-25 02:29:03 +08:00
|
|
|
StringRef Name = getDIEStringAttr(Die, dwarf::DW_AT_name);
|
2013-08-09 07:45:55 +08:00
|
|
|
DEBUG(dbgs() << "... adding context: " << Name << "\n");
|
|
|
|
if (!Name.empty())
|
|
|
|
addString(Name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-13 09:21:55 +08:00
|
|
|
// Collect all of the attributes for a particular DIE in single structure.
|
2013-10-25 02:29:03 +08:00
|
|
|
void DIEHash::collectAttributes(const DIE &Die, DIEAttrs &Attrs) {
|
2013-08-13 09:21:55 +08:00
|
|
|
|
2015-05-28 06:44:06 +08:00
|
|
|
for (const auto &V : Die.values()) {
|
2013-08-13 09:21:55 +08:00
|
|
|
DEBUG(dbgs() << "Attribute: "
|
2015-05-28 06:44:06 +08:00
|
|
|
<< dwarf::AttributeString(V.getAttribute())
|
2013-08-13 09:21:55 +08:00
|
|
|
<< " added.\n");
|
2015-05-28 06:44:06 +08:00
|
|
|
switch (V.getAttribute()) {
|
2017-05-24 02:27:09 +08:00
|
|
|
#define HANDLE_DIE_HASH_ATTR(NAME) \
|
|
|
|
case dwarf::NAME: \
|
|
|
|
Attrs.NAME = V; \
|
|
|
|
break;
|
|
|
|
#include "DIEHashAttributes.def"
|
2013-08-13 09:21:55 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-25 01:51:43 +08:00
|
|
|
void DIEHash::hashShallowTypeReference(dwarf::Attribute Attribute,
|
|
|
|
const DIE &Entry, StringRef Name) {
|
|
|
|
// append the letter 'N'
|
|
|
|
addULEB128('N');
|
|
|
|
|
|
|
|
// the DWARF attribute code (DW_AT_type or DW_AT_friend),
|
|
|
|
addULEB128(Attribute);
|
|
|
|
|
|
|
|
// the context of the tag,
|
2013-10-25 02:29:03 +08:00
|
|
|
if (const DIE *Parent = Entry.getParent())
|
|
|
|
addParentContext(*Parent);
|
2013-10-25 01:51:43 +08:00
|
|
|
|
|
|
|
// the letter 'E',
|
|
|
|
addULEB128('E');
|
|
|
|
|
|
|
|
// and the name of the type.
|
|
|
|
addString(Name);
|
|
|
|
|
|
|
|
// Currently DW_TAG_friends are not used by Clang, but if they do become so,
|
|
|
|
// here's the relevant spec text to implement:
|
|
|
|
//
|
|
|
|
// For DW_TAG_friend, if the referenced entry is the DW_TAG_subprogram,
|
|
|
|
// the context is omitted and the name to be used is the ABI-specific name
|
|
|
|
// of the subprogram (e.g., the mangled linker name).
|
|
|
|
}
|
|
|
|
|
|
|
|
void DIEHash::hashRepeatedTypeReference(dwarf::Attribute Attribute,
|
|
|
|
unsigned DieNumber) {
|
|
|
|
// a) If T is in the list of [previously hashed types], use the letter
|
|
|
|
// 'R' as the marker
|
|
|
|
addULEB128('R');
|
|
|
|
|
|
|
|
addULEB128(Attribute);
|
|
|
|
|
|
|
|
// and use the unsigned LEB128 encoding of [the index of T in the
|
|
|
|
// list] as the attribute value;
|
|
|
|
addULEB128(DieNumber);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DIEHash::hashDIEEntry(dwarf::Attribute Attribute, dwarf::Tag Tag,
|
2013-10-25 02:29:03 +08:00
|
|
|
const DIE &Entry) {
|
2013-10-25 01:51:43 +08:00
|
|
|
assert(Tag != dwarf::DW_TAG_friend && "No current LLVM clients emit friend "
|
|
|
|
"tags. Add support here when there's "
|
|
|
|
"a use case");
|
|
|
|
// Step 5
|
|
|
|
// If the tag in Step 3 is one of [the below tags]
|
|
|
|
if ((Tag == dwarf::DW_TAG_pointer_type ||
|
|
|
|
Tag == dwarf::DW_TAG_reference_type ||
|
|
|
|
Tag == dwarf::DW_TAG_rvalue_reference_type ||
|
|
|
|
Tag == dwarf::DW_TAG_ptr_to_member_type) &&
|
|
|
|
// and the referenced type (via the [below attributes])
|
|
|
|
// FIXME: This seems overly restrictive, and causes hash mismatches
|
|
|
|
// there's a decl/def difference in the containing type of a
|
|
|
|
// ptr_to_member_type, but it's what DWARF says, for some reason.
|
|
|
|
Attribute == dwarf::DW_AT_type) {
|
2013-10-25 01:53:58 +08:00
|
|
|
// ... has a DW_AT_name attribute,
|
|
|
|
StringRef Name = getDIEStringAttr(Entry, dwarf::DW_AT_name);
|
|
|
|
if (!Name.empty()) {
|
|
|
|
hashShallowTypeReference(Attribute, Entry, Name);
|
|
|
|
return;
|
|
|
|
}
|
2013-10-25 01:51:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned &DieNumber = Numbering[&Entry];
|
|
|
|
if (DieNumber) {
|
|
|
|
hashRepeatedTypeReference(Attribute, DieNumber);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-08-30 05:53:01 +08:00
|
|
|
// otherwise, b) use the letter 'T' as the marker, ...
|
2013-10-25 01:51:43 +08:00
|
|
|
addULEB128('T');
|
|
|
|
|
|
|
|
addULEB128(Attribute);
|
|
|
|
|
|
|
|
// ... process the type T recursively by performing Steps 2 through 7, and
|
|
|
|
// use the result as the attribute value.
|
|
|
|
DieNumber = Numbering.size();
|
2013-10-25 02:29:03 +08:00
|
|
|
computeHash(Entry);
|
2013-10-25 01:51:43 +08:00
|
|
|
}
|
|
|
|
|
2014-02-20 10:50:45 +08:00
|
|
|
// 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.
|
2015-06-26 07:46:41 +08:00
|
|
|
void DIEHash::hashBlockData(const DIE::const_value_range &Values) {
|
2015-05-28 06:44:06 +08:00
|
|
|
for (const auto &V : Values)
|
|
|
|
Hash.update((uint64_t)V.getDIEInteger().getValue());
|
2014-02-20 10:50:45 +08:00
|
|
|
}
|
|
|
|
|
2014-03-08 08:29:41 +08:00
|
|
|
// Hash the contents of a loclistptr class.
|
|
|
|
void DIEHash::hashLocList(const DIELocList &LocList) {
|
|
|
|
HashingByteStreamer Streamer(*this);
|
2014-04-02 09:43:18 +08:00
|
|
|
DwarfDebug &DD = *AP->getDwarfDebug();
|
AsmPrinter: Create a unified .debug_loc stream
This commit removes `DebugLocList` and replaces it with
`DebugLocStream`.
- `DebugLocEntry` no longer contains its byte/comment streams.
- The `DebugLocEntry` list for a variable/inlined-at pair is allocated
on the stack, and released right after `DebugLocEntry::finalize()`
(possible because of the refactoring in r231023). Now, only one
list is in memory at a time now.
- There's a single unified stream for the `.debug_loc` section that
persists, stored in the new `DebugLocStream` data structure.
The last point is important: this collapses the nested `SmallVector<>`s
from `DebugLocList` into unified streams. We previously had something
like the following:
vec<tuple<Label, CU,
vec<tuple<BeginSym, EndSym,
vec<Value>,
vec<char>,
vec<string>>>>>
A `SmallVector` can avoid allocations, but is statically fairly large
for a vector: three pointers plus the size of the small storage, which
is the number of elements in small mode times the element size).
Nesting these is expensive, since an inner vector's size contributes to
the element size of an outer one. (Nesting any vector is expensive...)
In the old data structure, the outer vector's *element* size was 632B,
excluding allocation costs for when the middle and inner vectors
exceeded their small sizes. 312B of this was for the "three" pointers
in the vector-tree beneath it. If you assume 1M functions with an
average of 10 variable/inlined-at pairs each (in an LTO scenario),
that's almost 6GB (besides inner allocations), with almost 3GB for the
"three" pointers.
This came up in a heap profile a little while ago of a `clang -flto -g`
bootstrap, with `DwarfDebug::collectVariableInfo()` using something like
10-15% of the total memory.
With this commit, we have:
tuple<vec<tuple<Label, CU, Offset>>,
vec<tuple<BeginSym, EndSym, Offset, Offset>>,
vec<char>,
vec<string>>
The offsets are used to create `ArrayRef` slices of adjacent
`SmallVector`s. This reduces the number of vectors to four (unrelated
to the number of variable/inlined-at pairs), and caps the number of
allocations at the same number.
Besides saving memory and limiting allocations, this is NFC.
I don't know my way around this code very well yet, but I wonder if we
could go further: why stream to a side-table, instead of directly to the
output stream?
llvm-svn: 235229
2015-04-18 05:34:47 +08:00
|
|
|
const DebugLocStream &Locs = DD.getDebugLocs();
|
|
|
|
for (const auto &Entry : Locs.getEntries(Locs.getList(LocList.getValue())))
|
2014-04-02 09:43:18 +08:00
|
|
|
DD.emitDebugLocEntry(Streamer, Entry);
|
2014-03-08 08:29:41 +08:00
|
|
|
}
|
|
|
|
|
2013-08-13 09:21:55 +08:00
|
|
|
// Hash an individual attribute \param Attr based on the type of attribute and
|
|
|
|
// the form.
|
2016-06-18 04:41:14 +08:00
|
|
|
void DIEHash::hashAttribute(const DIEValue &Value, dwarf::Tag Tag) {
|
2015-05-28 06:31:41 +08:00
|
|
|
dwarf::Attribute Attribute = Value.getAttribute();
|
2013-08-13 09:21:55 +08:00
|
|
|
|
2014-02-01 04:02:58 +08:00
|
|
|
// Other attribute values use the letter 'A' as the marker, and the value
|
|
|
|
// consists of the form code (encoded as an unsigned LEB128 value) followed by
|
|
|
|
// the encoding of the value according to the form code. To ensure
|
|
|
|
// reproducibility of the signature, the set of forms used in the signature
|
|
|
|
// computation is limited to the following: DW_FORM_sdata, DW_FORM_flag,
|
|
|
|
// DW_FORM_string, and DW_FORM_block.
|
2014-03-06 08:38:32 +08:00
|
|
|
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
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.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
switch (Value.getType()) {
|
|
|
|
case DIEValue::isNone:
|
|
|
|
llvm_unreachable("Expected valid DIEValue");
|
|
|
|
|
2014-03-07 02:59:42 +08:00
|
|
|
// 7.27 Step 3
|
|
|
|
// ... An attribute that refers to another type entry T is processed as
|
|
|
|
// follows:
|
|
|
|
case DIEValue::isEntry:
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
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.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
hashDIEEntry(Attribute, Tag, Value.getDIEEntry().getEntry());
|
2014-03-07 02:59:42 +08:00
|
|
|
break;
|
2014-03-06 08:38:32 +08:00
|
|
|
case DIEValue::isInteger: {
|
2014-02-01 04:02:58 +08:00
|
|
|
addULEB128('A');
|
|
|
|
addULEB128(Attribute);
|
2015-05-28 06:31:41 +08:00
|
|
|
switch (Value.getForm()) {
|
2014-03-06 08:38:32 +08:00
|
|
|
case dwarf::DW_FORM_data1:
|
|
|
|
case dwarf::DW_FORM_data2:
|
|
|
|
case dwarf::DW_FORM_data4:
|
|
|
|
case dwarf::DW_FORM_data8:
|
|
|
|
case dwarf::DW_FORM_udata:
|
|
|
|
case dwarf::DW_FORM_sdata:
|
|
|
|
addULEB128(dwarf::DW_FORM_sdata);
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
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.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
addSLEB128((int64_t)Value.getDIEInteger().getValue());
|
2014-03-06 08:38:32 +08:00
|
|
|
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);
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
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.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
addULEB128((int64_t)Value.getDIEInteger().getValue());
|
2014-03-06 08:38:32 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Unknown integer form!");
|
|
|
|
}
|
2013-08-28 08:10:38 +08:00
|
|
|
break;
|
2014-03-06 08:38:32 +08:00
|
|
|
}
|
|
|
|
case DIEValue::isString:
|
2014-02-01 04:02:58 +08:00
|
|
|
addULEB128('A');
|
|
|
|
addULEB128(Attribute);
|
2014-03-06 08:38:32 +08:00
|
|
|
addULEB128(dwarf::DW_FORM_string);
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
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.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
addString(Value.getDIEString().getString());
|
2014-02-01 04:02:58 +08:00
|
|
|
break;
|
Make a DWARF generator so we can unit test DWARF APIs with gtest.
The only tests we have for the DWARF parser are the tests that use llvm-dwarfdump and expect output from textual dumps.
More DWARF parser modification are coming in the next few weeks and I wanted to add tests that can verify that we can encode and decode all form types, as well as test some other basic DWARF APIs where we ask DIE objects for their children and siblings.
DwarfGenerator.cpp was added in the lib/CodeGen directory. This file contains the code necessary to easily create DWARF for tests:
dwarfgen::Generator DG;
Triple Triple("x86_64--");
bool success = DG.init(Triple, Version);
if (!success)
return;
dwarfgen::CompileUnit &CU = DG.addCompileUnit();
dwarfgen::DIE CUDie = CU.getUnitDIE();
CUDie.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/main.c");
CUDie.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C);
dwarfgen::DIE SubprogramDie = CUDie.addChild(DW_TAG_subprogram);
SubprogramDie.addAttribute(DW_AT_name, DW_FORM_strp, "main");
SubprogramDie.addAttribute(DW_AT_low_pc, DW_FORM_addr, 0x1000U);
SubprogramDie.addAttribute(DW_AT_high_pc, DW_FORM_addr, 0x2000U);
dwarfgen::DIE IntDie = CUDie.addChild(DW_TAG_base_type);
IntDie.addAttribute(DW_AT_name, DW_FORM_strp, "int");
IntDie.addAttribute(DW_AT_encoding, DW_FORM_data1, DW_ATE_signed);
IntDie.addAttribute(DW_AT_byte_size, DW_FORM_data1, 4);
dwarfgen::DIE ArgcDie = SubprogramDie.addChild(DW_TAG_formal_parameter);
ArgcDie.addAttribute(DW_AT_name, DW_FORM_strp, "argc");
// ArgcDie.addAttribute(DW_AT_type, DW_FORM_ref4, IntDie);
ArgcDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, IntDie);
StringRef FileBytes = DG.generate();
MemoryBufferRef FileBuffer(FileBytes, "dwarf");
auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
EXPECT_TRUE((bool)Obj);
DWARFContextInMemory DwarfContext(*Obj.get());
This code is backed by the AsmPrinter code that emits DWARF for the actual compiler.
While adding unit tests it was discovered that DIEValue that used DIEEntry as their values had bugs where DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref8, and DW_FORM_ref_udata forms were not supported. These are all now supported. Added support for DW_FORM_string so we can emit inlined C strings.
Centralized the code to unique abbreviations into a new DIEAbbrevSet class and made both the dwarfgen::Generator and the llvm::DwarfFile classes use the new class.
Fixed comments in the llvm::DIE class so that the Offset is known to be the compile/type unit offset.
DIEInteger now supports more DW_FORM values.
There are also unit tests that cover:
Encoding and decoding all form types and values
Encoding and decoding all reference types (DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref4, DW_FORM_ref8, DW_FORM_ref_udata, DW_FORM_ref_addr) including cross compile unit references with that go forward one compile unit and backward on compile unit.
Differential Revision: https://reviews.llvm.org/D27326
llvm-svn: 289010
2016-12-08 09:03:48 +08:00
|
|
|
case DIEValue::isInlineString:
|
|
|
|
addULEB128('A');
|
|
|
|
addULEB128(Attribute);
|
|
|
|
addULEB128(dwarf::DW_FORM_string);
|
|
|
|
addString(Value.getDIEInlineString().getString());
|
|
|
|
break;
|
2014-03-06 08:38:32 +08:00
|
|
|
case DIEValue::isBlock:
|
|
|
|
case DIEValue::isLoc:
|
2014-03-08 08:29:41 +08:00
|
|
|
case DIEValue::isLocList:
|
2014-02-20 10:50:45 +08:00
|
|
|
addULEB128('A');
|
|
|
|
addULEB128(Attribute);
|
|
|
|
addULEB128(dwarf::DW_FORM_block);
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
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.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
if (Value.getType() == DIEValue::isBlock) {
|
|
|
|
addULEB128(Value.getDIEBlock().ComputeSize(AP));
|
2015-05-28 06:44:06 +08:00
|
|
|
hashBlockData(Value.getDIEBlock().values());
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
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.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
} else if (Value.getType() == DIEValue::isLoc) {
|
|
|
|
addULEB128(Value.getDIELoc().ComputeSize(AP));
|
2015-05-28 06:44:06 +08:00
|
|
|
hashBlockData(Value.getDIELoc().values());
|
2014-03-08 08:29:41 +08:00
|
|
|
} 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.
|
Reapply "AsmPrinter: Change DIEValue to be stored by value"
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.)
--
llvm-svn: 238362
2015-05-28 06:14:58 +08:00
|
|
|
hashLocList(Value.getDIELocList());
|
2014-02-20 10:50:45 +08:00
|
|
|
}
|
|
|
|
break;
|
2014-03-06 09:32:56 +08:00
|
|
|
// FIXME: It's uncertain whether or not we should handle this at the moment.
|
2014-03-06 08:38:32 +08:00
|
|
|
case DIEValue::isExpr:
|
|
|
|
case DIEValue::isLabel:
|
|
|
|
case DIEValue::isDelta:
|
|
|
|
llvm_unreachable("Add support for additional value types.");
|
2013-08-13 09:21:55 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Go through the attributes from \param Attrs in the order specified in 7.27.4
|
|
|
|
// and hash them.
|
2013-10-22 06:36:50 +08:00
|
|
|
void DIEHash::hashAttributes(const DIEAttrs &Attrs, dwarf::Tag Tag) {
|
2017-05-24 02:27:09 +08:00
|
|
|
#define HANDLE_DIE_HASH_ATTR(NAME) \
|
2013-08-13 09:21:55 +08:00
|
|
|
{ \
|
2017-05-24 02:27:09 +08:00
|
|
|
if (Attrs.NAME) \
|
|
|
|
hashAttribute(Attrs.NAME, Tag); \
|
2013-08-13 09:21:55 +08:00
|
|
|
}
|
2017-05-24 02:27:09 +08:00
|
|
|
#include "DIEHashAttributes.def"
|
2013-09-04 04:00:20 +08:00
|
|
|
// FIXME: Add the extended attributes.
|
2013-08-13 09:21:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Add all of the attributes for \param Die to the hash.
|
2013-10-25 02:29:03 +08:00
|
|
|
void DIEHash::addAttributes(const DIE &Die) {
|
2013-10-16 08:47:21 +08:00
|
|
|
DIEAttrs Attrs = {};
|
2013-08-15 06:23:05 +08:00
|
|
|
collectAttributes(Die, Attrs);
|
2013-10-25 02:29:03 +08:00
|
|
|
hashAttributes(Attrs, Die.getTag());
|
2013-08-13 09:21:55 +08:00
|
|
|
}
|
|
|
|
|
2013-10-26 02:38:43 +08:00
|
|
|
void DIEHash::hashNestedType(const DIE &Die, StringRef Name) {
|
|
|
|
// 7.27 Step 7
|
|
|
|
// ... append the letter 'S',
|
|
|
|
addULEB128('S');
|
|
|
|
|
|
|
|
// the tag of C,
|
|
|
|
addULEB128(Die.getTag());
|
|
|
|
|
|
|
|
// and the name.
|
|
|
|
addString(Name);
|
|
|
|
}
|
|
|
|
|
2013-08-13 09:21:55 +08:00
|
|
|
// Compute the hash of a DIE. This is based on the type signature computation
|
|
|
|
// given in section 7.27 of the DWARF4 standard. It is the md5 hash of a
|
|
|
|
// flattened description of the DIE.
|
2013-10-25 02:29:03 +08:00
|
|
|
void DIEHash::computeHash(const DIE &Die) {
|
2013-08-13 09:21:55 +08:00
|
|
|
// Append the letter 'D', followed by the DWARF tag of the DIE.
|
|
|
|
addULEB128('D');
|
2013-10-25 02:29:03 +08:00
|
|
|
addULEB128(Die.getTag());
|
2013-08-13 09:21:55 +08:00
|
|
|
|
|
|
|
// Add each of the attributes of the DIE.
|
|
|
|
addAttributes(Die);
|
|
|
|
|
|
|
|
// Then hash each of the children of the DIE.
|
2015-05-29 03:56:34 +08:00
|
|
|
for (auto &C : Die.children()) {
|
2013-10-26 02:38:43 +08:00
|
|
|
// 7.27 Step 7
|
|
|
|
// If C is a nested type entry or a member function entry, ...
|
2015-06-26 07:52:10 +08:00
|
|
|
if (isType(C.getTag()) || C.getTag() == dwarf::DW_TAG_subprogram) {
|
|
|
|
StringRef Name = getDIEStringAttr(C, dwarf::DW_AT_name);
|
2013-10-26 02:38:43 +08:00
|
|
|
// ... and has a DW_AT_name attribute
|
|
|
|
if (!Name.empty()) {
|
2015-06-26 07:52:10 +08:00
|
|
|
hashNestedType(C, Name);
|
2013-10-26 02:38:43 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2015-06-26 07:52:10 +08:00
|
|
|
computeHash(C);
|
2013-10-26 02:38:43 +08:00
|
|
|
}
|
2013-10-17 04:29:06 +08:00
|
|
|
|
|
|
|
// Following the last (or if there are no children), append a zero byte.
|
2013-10-17 04:40:46 +08:00
|
|
|
Hash.update(makeArrayRef((uint8_t)'\0'));
|
2013-08-13 09:21:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// This is based on the type signature computation given in section 7.27 of the
|
|
|
|
/// DWARF4 standard. It is an md5 hash of the flattened description of the DIE
|
|
|
|
/// with the inclusion of the full CU and all top level CU entities.
|
2013-09-04 05:57:57 +08:00
|
|
|
// TODO: Initialize the type chain at 0 instead of 1 for CU signatures.
|
2017-05-29 14:32:34 +08:00
|
|
|
uint64_t DIEHash::computeCUSignature(StringRef DWOName, const DIE &Die) {
|
2013-10-22 02:59:40 +08:00
|
|
|
Numbering.clear();
|
2013-10-25 02:29:03 +08:00
|
|
|
Numbering[&Die] = 1;
|
2013-08-13 09:21:55 +08:00
|
|
|
|
2017-05-29 14:32:34 +08:00
|
|
|
if (!DWOName.empty())
|
|
|
|
Hash.update(DWOName);
|
2013-08-13 09:21:55 +08:00
|
|
|
// Hash the DIE.
|
|
|
|
computeHash(Die);
|
|
|
|
|
|
|
|
// Now return the result.
|
|
|
|
MD5::MD5Result Result;
|
|
|
|
Hash.final(Result);
|
|
|
|
|
|
|
|
// ... take the least significant 8 bytes and return those. Our MD5
|
2017-03-21 07:33:18 +08:00
|
|
|
// implementation always returns its results in little endian, so we actually
|
|
|
|
// need the "high" word.
|
|
|
|
return Result.high();
|
2013-08-13 09:21:55 +08:00
|
|
|
}
|
2013-09-04 05:57:57 +08:00
|
|
|
|
|
|
|
/// This is based on the type signature computation given in section 7.27 of the
|
|
|
|
/// DWARF4 standard. It is an md5 hash of the flattened description of the DIE
|
|
|
|
/// with the inclusion of additional forms not specifically called out in the
|
|
|
|
/// standard.
|
2013-10-25 02:29:03 +08:00
|
|
|
uint64_t DIEHash::computeTypeSignature(const DIE &Die) {
|
2013-10-22 02:59:40 +08:00
|
|
|
Numbering.clear();
|
2013-10-25 02:29:03 +08:00
|
|
|
Numbering[&Die] = 1;
|
2013-09-04 05:57:57 +08:00
|
|
|
|
2013-10-25 02:29:03 +08:00
|
|
|
if (const DIE *Parent = Die.getParent())
|
|
|
|
addParentContext(*Parent);
|
2013-10-17 08:10:34 +08:00
|
|
|
|
2013-09-04 05:57:57 +08:00
|
|
|
// Hash the DIE.
|
|
|
|
computeHash(Die);
|
|
|
|
|
|
|
|
// Now return the result.
|
|
|
|
MD5::MD5Result Result;
|
|
|
|
Hash.final(Result);
|
|
|
|
|
|
|
|
// ... take the least significant 8 bytes and return those. Our MD5
|
2017-03-21 07:33:18 +08:00
|
|
|
// implementation always returns its results in little endian, so we actually
|
|
|
|
// need the "high" word.
|
|
|
|
return Result.high();
|
2013-09-04 05:57:57 +08:00
|
|
|
}
|