b9c1b51e45
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
254 lines
8.1 KiB
C++
254 lines
8.1 KiB
C++
//===-- DWARFDebugPubnames.cpp ----------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "DWARFDebugPubnames.h"
|
|
|
|
#include "lldb/Core/Stream.h"
|
|
#include "lldb/Core/Timer.h"
|
|
|
|
#include "DWARFCompileUnit.h"
|
|
#include "DWARFDIECollection.h"
|
|
#include "DWARFDebugInfo.h"
|
|
#include "DWARFFormValue.h"
|
|
#include "LogChannelDWARF.h"
|
|
#include "SymbolFileDWARF.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
DWARFDebugPubnames::DWARFDebugPubnames() : m_sets() {}
|
|
|
|
bool DWARFDebugPubnames::Extract(const DWARFDataExtractor &data) {
|
|
Timer scoped_timer(LLVM_PRETTY_FUNCTION,
|
|
"DWARFDebugPubnames::Extract (byte_size = %" PRIu64 ")",
|
|
(uint64_t)data.GetByteSize());
|
|
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_PUBNAMES));
|
|
if (log)
|
|
log->Printf("DWARFDebugPubnames::Extract (byte_size = %" PRIu64 ")",
|
|
(uint64_t)data.GetByteSize());
|
|
|
|
if (data.ValidOffset(0)) {
|
|
lldb::offset_t offset = 0;
|
|
|
|
DWARFDebugPubnamesSet set;
|
|
while (data.ValidOffset(offset)) {
|
|
if (set.Extract(data, &offset)) {
|
|
m_sets.push_back(set);
|
|
offset = set.GetOffsetOfNextEntry();
|
|
} else
|
|
break;
|
|
}
|
|
if (log)
|
|
Dump(log);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool DWARFDebugPubnames::GeneratePubnames(SymbolFileDWARF *dwarf2Data) {
|
|
Timer scoped_timer(LLVM_PRETTY_FUNCTION,
|
|
"DWARFDebugPubnames::GeneratePubnames (data = %p)",
|
|
static_cast<void *>(dwarf2Data));
|
|
|
|
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_PUBNAMES));
|
|
if (log)
|
|
log->Printf("DWARFDebugPubnames::GeneratePubnames (data = %p)",
|
|
static_cast<void *>(dwarf2Data));
|
|
|
|
m_sets.clear();
|
|
DWARFDebugInfo *debug_info = dwarf2Data->DebugInfo();
|
|
if (debug_info) {
|
|
uint32_t cu_idx = 0;
|
|
const uint32_t num_compile_units = dwarf2Data->GetNumCompileUnits();
|
|
for (cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
|
|
|
|
DWARFCompileUnit *cu = debug_info->GetCompileUnitAtIndex(cu_idx);
|
|
|
|
DWARFFormValue::FixedFormSizes fixed_form_sizes =
|
|
DWARFFormValue::GetFixedFormSizesForAddressSize(
|
|
cu->GetAddressByteSize(), cu->IsDWARF64());
|
|
|
|
bool clear_dies = cu->ExtractDIEsIfNeeded(false) > 1;
|
|
|
|
DWARFDIECollection dies;
|
|
const size_t die_count = cu->AppendDIEsWithTag(DW_TAG_subprogram, dies) +
|
|
cu->AppendDIEsWithTag(DW_TAG_variable, dies);
|
|
|
|
dw_offset_t cu_offset = cu->GetOffset();
|
|
DWARFDebugPubnamesSet pubnames_set(DW_INVALID_OFFSET, cu_offset,
|
|
cu->GetNextCompileUnitOffset() -
|
|
cu_offset);
|
|
|
|
size_t die_idx;
|
|
for (die_idx = 0; die_idx < die_count; ++die_idx) {
|
|
DWARFDIE die = dies.GetDIEAtIndex(die_idx);
|
|
DWARFAttributes attributes;
|
|
const char *name = NULL;
|
|
const char *mangled = NULL;
|
|
bool add_die = false;
|
|
const size_t num_attributes = die.GetDIE()->GetAttributes(
|
|
die.GetCU(), fixed_form_sizes, attributes);
|
|
if (num_attributes > 0) {
|
|
uint32_t i;
|
|
|
|
dw_tag_t tag = die.Tag();
|
|
|
|
for (i = 0; i < num_attributes; ++i) {
|
|
dw_attr_t attr = attributes.AttributeAtIndex(i);
|
|
DWARFFormValue form_value;
|
|
switch (attr) {
|
|
case DW_AT_name:
|
|
if (attributes.ExtractFormValueAtIndex(i, form_value))
|
|
name = form_value.AsCString();
|
|
break;
|
|
|
|
case DW_AT_MIPS_linkage_name:
|
|
case DW_AT_linkage_name:
|
|
if (attributes.ExtractFormValueAtIndex(i, form_value))
|
|
mangled = form_value.AsCString();
|
|
break;
|
|
|
|
case DW_AT_low_pc:
|
|
case DW_AT_ranges:
|
|
case DW_AT_entry_pc:
|
|
if (tag == DW_TAG_subprogram)
|
|
add_die = true;
|
|
break;
|
|
|
|
case DW_AT_location:
|
|
if (tag == DW_TAG_variable) {
|
|
DWARFDIE parent_die = die.GetParent();
|
|
while (parent_die) {
|
|
switch (parent_die.Tag()) {
|
|
case DW_TAG_subprogram:
|
|
case DW_TAG_lexical_block:
|
|
case DW_TAG_inlined_subroutine:
|
|
// Even if this is a function level static, we don't add it.
|
|
// We could theoretically
|
|
// add these if we wanted to by introspecting into the
|
|
// DW_AT_location and seeing
|
|
// if the location describes a hard coded address, but we
|
|
// don't want the performance
|
|
// penalty of that right now.
|
|
add_die = false;
|
|
parent_die.Clear(); // Terminate the while loop.
|
|
break;
|
|
|
|
case DW_TAG_compile_unit:
|
|
add_die = true;
|
|
parent_die.Clear(); // Terminate the while loop.
|
|
break;
|
|
|
|
default:
|
|
parent_die =
|
|
parent_die.GetParent(); // Keep going in the while loop.
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (add_die && (name || mangled)) {
|
|
pubnames_set.AddDescriptor(die.GetCompileUnitRelativeOffset(),
|
|
mangled ? mangled : name);
|
|
}
|
|
}
|
|
|
|
if (pubnames_set.NumDescriptors() > 0) {
|
|
m_sets.push_back(pubnames_set);
|
|
}
|
|
|
|
// Keep memory down by clearing DIEs if this generate function
|
|
// caused them to be parsed
|
|
if (clear_dies)
|
|
cu->ClearDIEs(true);
|
|
}
|
|
}
|
|
if (m_sets.empty())
|
|
return false;
|
|
if (log)
|
|
Dump(log);
|
|
return true;
|
|
}
|
|
|
|
bool DWARFDebugPubnames::GeneratePubBaseTypes(SymbolFileDWARF *dwarf2Data) {
|
|
m_sets.clear();
|
|
DWARFDebugInfo *debug_info = dwarf2Data->DebugInfo();
|
|
if (debug_info) {
|
|
uint32_t cu_idx = 0;
|
|
const uint32_t num_compile_units = dwarf2Data->GetNumCompileUnits();
|
|
for (cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
|
|
DWARFCompileUnit *cu = debug_info->GetCompileUnitAtIndex(cu_idx);
|
|
DWARFDIECollection dies;
|
|
const size_t die_count = cu->AppendDIEsWithTag(DW_TAG_base_type, dies);
|
|
dw_offset_t cu_offset = cu->GetOffset();
|
|
DWARFDebugPubnamesSet pubnames_set(DW_INVALID_OFFSET, cu_offset,
|
|
cu->GetNextCompileUnitOffset() -
|
|
cu_offset);
|
|
|
|
size_t die_idx;
|
|
for (die_idx = 0; die_idx < die_count; ++die_idx) {
|
|
DWARFDIE die = dies.GetDIEAtIndex(die_idx);
|
|
const char *name = die.GetName();
|
|
|
|
if (name)
|
|
pubnames_set.AddDescriptor(die.GetCompileUnitRelativeOffset(), name);
|
|
}
|
|
|
|
if (pubnames_set.NumDescriptors() > 0) {
|
|
m_sets.push_back(pubnames_set);
|
|
}
|
|
}
|
|
}
|
|
return !m_sets.empty();
|
|
}
|
|
|
|
void DWARFDebugPubnames::Dump(Log *s) const {
|
|
if (m_sets.empty())
|
|
s->PutCString("< EMPTY >\n");
|
|
else {
|
|
const_iterator pos;
|
|
const_iterator end = m_sets.end();
|
|
|
|
for (pos = m_sets.begin(); pos != end; ++pos)
|
|
(*pos).Dump(s);
|
|
}
|
|
}
|
|
|
|
bool DWARFDebugPubnames::Find(const char *name, bool ignore_case,
|
|
std::vector<dw_offset_t> &die_offsets) const {
|
|
const_iterator pos;
|
|
const_iterator end = m_sets.end();
|
|
|
|
die_offsets.clear();
|
|
|
|
for (pos = m_sets.begin(); pos != end; ++pos) {
|
|
(*pos).Find(name, ignore_case, die_offsets);
|
|
}
|
|
|
|
return !die_offsets.empty();
|
|
}
|
|
|
|
bool DWARFDebugPubnames::Find(const RegularExpression ®ex,
|
|
std::vector<dw_offset_t> &die_offsets) const {
|
|
const_iterator pos;
|
|
const_iterator end = m_sets.end();
|
|
|
|
die_offsets.clear();
|
|
|
|
for (pos = m_sets.begin(); pos != end; ++pos) {
|
|
(*pos).Find(regex, die_offsets);
|
|
}
|
|
|
|
return !die_offsets.empty();
|
|
}
|