maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Delete more dead code. 

All of this is code that is unreferenced.  Removing as much of
this as possible makes it more easy to determine what functionality
is missing and/or shared between LLVM and LLDB's DWARF interfaces.

llvm-svn: 356509
This commit is contained in:
Zachary Turner 2019-03-19 20:08:56 +00:00
parent 6271606969
commit 611d1f98c5
21 changed files with 11 additions and 318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lldb/source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.cpp
View File

@ -85,5 +85,5 @@ DWARFAbbreviationDeclaration::FindAttributeIndex(dw_attr_t attr) const {
bool DWARFAbbreviationDeclaration::
operator==(const DWARFAbbreviationDeclaration &rhs) const {
return Tag() == rhs.Tag() && HasChildren() == rhs.HasChildren() &&
Attributes() == rhs.Attributes();
m_attributes == rhs.m_attributes;
}

7
lldb/source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.h
View File

@ -21,18 +21,12 @@ public:
// For hand crafting an abbreviation declaration
DWARFAbbreviationDeclaration(dw_tag_t tag, uint8_t has_children);
void AddAttribute(const DWARFAttribute &attr) {
m_attributes.push_back(attr);
}
dw_uleb128_t Code() const { return m_code; }
void SetCode(dw_uleb128_t code) { m_code = code; }
dw_tag_t Tag() const { return m_tag; }
bool HasChildren() const { return m_has_children; }
size_t NumAttributes() const { return m_attributes.size(); }
dw_attr_t GetAttrByIndex(uint32_t idx) const {
return m_attributes.size() > idx ? m_attributes[idx].get_attr() : 0;
}
dw_form_t GetFormByIndex(uint32_t idx) const {
return m_attributes.size() > idx ? m_attributes[idx].get_form() : 0;
}
@ -60,7 +54,6 @@ public:
lldb::offset_t *offset_ptr);
bool IsValid();
bool operator==(const DWARFAbbreviationDeclaration &rhs) const;
const DWARFAttribute::collection &Attributes() const { return m_attributes; }
protected:
dw_uleb128_t m_code;

13
lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.cpp
View File

@ -32,19 +32,6 @@ void DWARFAttributes::Append(const DWARFUnit *cu, dw_offset_t attr_die_offset,
m_infos.push_back(attr_value);
}
bool DWARFAttributes::ContainsAttribute(dw_attr_t attr) const {
return FindAttributeIndex(attr) != UINT32_MAX;
}
bool DWARFAttributes::RemoveAttribute(dw_attr_t attr) {
uint32_t attr_index = FindAttributeIndex(attr);
if (attr_index != UINT32_MAX) {
m_infos.erase(m_infos.begin() + attr_index);
return true;
}
return false;
}
bool DWARFAttributes::ExtractFormValueAtIndex(
uint32_t i, DWARFFormValue &form_value) const {
const DWARFUnit *cu = CompileUnitAtIndex(i);

4
lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.h
View File

@ -26,8 +26,6 @@ public:
m_attr = attr;
m_form = form;
}
void set_attr(dw_attr_t attr) { m_attr = attr; }
void set_form(dw_form_t form) { m_form = form; }
dw_attr_t get_attr() const { return m_attr; }
dw_form_t get_form() const { return m_form; }
void get(dw_attr_t &attr, dw_form_t &form,
@ -70,8 +68,6 @@ public:
uint64_t FormValueAsUnsignedAtIndex(uint32_t i, uint64_t fail_value) const;
uint64_t FormValueAsUnsigned(dw_attr_t attr, uint64_t fail_value) const;
uint32_t FindAttributeIndex(dw_attr_t attr) const;
bool ContainsAttribute(dw_attr_t attr) const;
bool RemoveAttribute(dw_attr_t attr);
void Clear() { m_infos.clear(); }
size_t Size() const { return m_infos.size(); }

16
lldb/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp
View File

@ -56,15 +56,6 @@ uint64_t DWARFBaseDIE::GetAttributeValueAsUnsigned(const dw_attr_t attr,
return fail_value;
}
int64_t DWARFBaseDIE::GetAttributeValueAsSigned(const dw_attr_t attr,
int64_t fail_value) const {
if (IsValid())
return m_die->GetAttributeValueAsSigned(GetDWARF(), GetCU(), attr,
fail_value);
else
return fail_value;
}
uint64_t DWARFBaseDIE::GetAttributeValueAsReference(const dw_attr_t attr,
uint64_t fail_value) const {
if (IsValid())
@ -123,13 +114,6 @@ dw_offset_t DWARFBaseDIE::GetOffset() const {
return DW_INVALID_OFFSET;
}
dw_offset_t DWARFBaseDIE::GetCompileUnitRelativeOffset() const {
if (IsValid())
return m_die->GetOffset() - m_cu->GetOffset();
else
return DW_INVALID_OFFSET;
}
SymbolFileDWARF *DWARFBaseDIE::GetDWARF() const {
if (m_cu)
return m_cu->GetSymbolFileDWARF();

5
lldb/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h
View File

@ -96,8 +96,6 @@ public:
dw_offset_t GetOffset() const;
dw_offset_t GetCompileUnitRelativeOffset() const;
//----------------------------------------------------------------------
// Get the LLDB user ID for this DIE. This is often just the DIE offset,
// but it might have a SymbolFileDWARF::GetID() in the high 32 bits if
@ -127,9 +125,6 @@ public:
uint64_t GetAttributeValueAsUnsigned(const dw_attr_t attr,
uint64_t fail_value) const;
int64_t GetAttributeValueAsSigned(const dw_attr_t attr,
int64_t fail_value) const;
uint64_t GetAttributeValueAsReference(const dw_attr_t attr,
uint64_t fail_value) const;

19
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugAbbrev.cpp
View File

@ -75,25 +75,6 @@ DWARFAbbreviationDeclarationSet::GetAbbreviationDeclaration(
return NULL;
}
//----------------------------------------------------------------------
// DWARFAbbreviationDeclarationSet::AppendAbbrevDeclSequential()
//
// Append an abbreviation declaration with a sequential code for O(n) lookups.
// Handy when creating an DWARFAbbreviationDeclarationSet.
//----------------------------------------------------------------------
dw_uleb128_t DWARFAbbreviationDeclarationSet::AppendAbbrevDeclSequential(
const DWARFAbbreviationDeclaration &abbrevDecl) {
// Get the next abbreviation code based on our current array size
dw_uleb128_t code = m_decls.size() + 1;
// Push the new declaration on the back
m_decls.push_back(abbrevDecl);
// Update the code for this new declaration
m_decls.back().SetCode(code);
return code; // return the new abbreviation code!
}
//----------------------------------------------------------------------
// DWARFAbbreviationDeclarationSet::GetUnsupportedForms()

2
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugAbbrev.h
View File

@ -40,8 +40,6 @@ public:
llvm::Error extract(const lldb_private::DWARFDataExtractor &data,
lldb::offset_t *offset_ptr);
// void Encode(BinaryStreamBuf& debug_abbrev_buf) const;
dw_uleb128_t
AppendAbbrevDeclSequential(const DWARFAbbreviationDeclaration &abbrevDecl);
void GetUnsupportedForms(std::set<dw_form_t> &invalid_forms) const;
const DWARFAbbreviationDeclaration *

101
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugArangeSet.cpp
View File

@ -34,103 +34,6 @@ void DWARFDebugArangeSet::Clear() {
m_arange_descriptors.clear();
}
void DWARFDebugArangeSet::SetHeader(uint16_t version, uint32_t cu_offset,
uint8_t addr_size, uint8_t seg_size) {
m_header.version = version;
m_header.cu_offset = cu_offset;
m_header.addr_size = addr_size;
m_header.seg_size = seg_size;
}
void DWARFDebugArangeSet::Compact() {
if (m_arange_descriptors.empty())
return;
// Iterate through all arange descriptors and combine any ranges that overlap
// or have matching boundaries. The m_arange_descriptors are assumed to be in
// ascending order after being built by adding descriptors using the
// AddDescriptor method.
uint32_t i = 0;
while (i + 1 < m_arange_descriptors.size()) {
if (m_arange_descriptors[i].end_address() >=
m_arange_descriptors[i + 1].address) {
// The current range ends at or exceeds the start of the next address
// range. Compute the max end address between the two and use that to
// make the new length.
const dw_addr_t max_end_addr =
std::max(m_arange_descriptors[i].end_address(),
m_arange_descriptors[i + 1].end_address());
m_arange_descriptors[i].length =
max_end_addr - m_arange_descriptors[i].address;
// Now remove the next entry as it was just combined with the previous
// one.
m_arange_descriptors.erase(m_arange_descriptors.begin() + i + 1);
} else {
// Discontiguous address range, just proceed to the next one.
++i;
}
}
}
//----------------------------------------------------------------------
// Compare function DWARFDebugArangeSet::Descriptor structures
//----------------------------------------------------------------------
static bool DescriptorLessThan(const DWARFDebugArangeSet::Descriptor &range1,
const DWARFDebugArangeSet::Descriptor &range2) {
return range1.address < range2.address;
}
//----------------------------------------------------------------------
// Add a range descriptor and keep things sorted so we can easily compact the
// ranges before being saved or used.
//----------------------------------------------------------------------
void DWARFDebugArangeSet::AddDescriptor(
const DWARFDebugArangeSet::Descriptor &range) {
if (m_arange_descriptors.empty()) {
m_arange_descriptors.push_back(range);
return;
}
DescriptorIter end = m_arange_descriptors.end();
DescriptorIter pos =
lower_bound(m_arange_descriptors.begin(), end, range, DescriptorLessThan);
const dw_addr_t range_end_addr = range.end_address();
if (pos != end) {
const dw_addr_t found_end_addr = pos->end_address();
if (range.address < pos->address) {
if (range_end_addr < pos->address) {
// Non-contiguous entries, add this one before the found entry
m_arange_descriptors.insert(pos, range);
} else if (range_end_addr == pos->address) {
// The top end of 'range' is the lower end of the entry pointed to by
// 'pos'. We can combine range with the entry we found by setting the
// starting address and increasing the length since they don't overlap.
pos->address = range.address;
pos->length += range.length;
} else {
// We can combine these two and make sure the largest end address is
// used to make end address.
pos->address = range.address;
pos->length = std::max(found_end_addr, range_end_addr) - pos->address;
}
} else if (range.address == pos->address) {
pos->length = std::max(pos->length, range.length);
}
} else {
// NOTE: 'pos' points to entry past the end which is ok for insert,
// don't use otherwise!!!
const dw_addr_t max_addr = m_arange_descriptors.back().end_address();
if (max_addr < range.address) {
// Non-contiguous entries, add this one before the found entry
m_arange_descriptors.insert(pos, range);
} else if (max_addr == range.address) {
m_arange_descriptors.back().length += range.length;
} else {
m_arange_descriptors.back().length = std::max(max_addr, range_end_addr) -
m_arange_descriptors.back().address;
}
}
}
llvm::Error DWARFDebugArangeSet::extract(const DWARFDataExtractor &data,
lldb::offset_t *offset_ptr) {
assert(data.ValidOffset(*offset_ptr));
@ -215,10 +118,6 @@ llvm::Error DWARFDebugArangeSet::extract(const DWARFDataExtractor &data,
"arange descriptors not terminated by null entry");
}
dw_offset_t DWARFDebugArangeSet::GetOffsetOfNextEntry() const {
return m_offset + m_header.length + 4;
}
class DescriptorContainsAddress {
public:
DescriptorContainsAddress(dw_addr_t address) : m_address(address) {}

11
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugArangeSet.h
View File

@ -40,22 +40,11 @@ public:
DWARFDebugArangeSet();
void Clear();
void SetOffset(uint32_t offset) { m_offset = offset; }
void SetHeader(uint16_t version, uint32_t cu_offset, uint8_t addr_size,
uint8_t seg_size);
void AddDescriptor(const DWARFDebugArangeSet::Descriptor &range);
void Compact();
llvm::Error extract(const lldb_private::DWARFDataExtractor &data,
lldb::offset_t *offset_ptr);
dw_offset_t GetCompileUnitDIEOffset() const { return m_header.cu_offset; }
dw_offset_t GetOffsetOfNextEntry() const;
dw_offset_t FindAddress(dw_addr_t address) const;
size_t NumDescriptors() const { return m_arange_descriptors.size(); }
const Header &GetHeader() const { return m_header; }
const Descriptor *GetDescriptor(uint32_t i) const {
if (i < m_arange_descriptors.size())
return &m_arange_descriptors[i];
return NULL;
}
const Descriptor &GetDescriptorRef(uint32_t i) const {
return m_arange_descriptors[i];

22
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugAranges.cpp
View File

@ -61,7 +61,7 @@ DWARFDebugAranges::extract(const DWARFDataExtractor &debug_aranges_data) {
const uint32_t num_descriptors = set.NumDescriptors();
if (num_descriptors > 0) {
const dw_offset_t cu_offset = set.GetCompileUnitDIEOffset();
const dw_offset_t cu_offset = set.GetHeader().cu_offset;
for (uint32_t i = 0; i < num_descriptors; ++i) {
const DWARFDebugArangeSet::Descriptor &descriptor =
@ -71,26 +71,8 @@ DWARFDebugAranges::extract(const DWARFDataExtractor &debug_aranges_data) {
}
}
set.Clear();
}
return llvm::ErrorSuccess();
}
//----------------------------------------------------------------------
// Generate
//----------------------------------------------------------------------
bool DWARFDebugAranges::Generate(SymbolFileDWARF *dwarf2Data) {
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) {
DWARFUnit *cu = debug_info->GetCompileUnitAtIndex(cu_idx);
if (cu)
cu->BuildAddressRangeTable(dwarf2Data, this);
}
}
return !IsEmpty();
return llvm::ErrorSuccess();
}
void DWARFDebugAranges::Dump(Log *log) const {

6
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugAranges.h
View File

@ -32,17 +32,11 @@ public:
llvm::Error
extract(const lldb_private::DWARFDataExtractor &debug_aranges_data);
bool Generate(SymbolFileDWARF *dwarf2Data);
// Use append range multiple times and then call sort
void AppendRange(dw_offset_t cu_offset, dw_addr_t low_pc, dw_addr_t high_pc);
void Sort(bool minimize);
const Range *RangeAtIndex(uint32_t idx) const {
return m_aranges.GetEntryAtIndex(idx);
}
void Dump(lldb_private::Log *log) const;
dw_offset_t FindAddress(dw_addr_t address) const;

13
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp
View File

@ -121,19 +121,6 @@ DWARFUnit *DWARFDebugInfo::GetCompileUnitAtIndex(uint32_t idx) {
return cu;
}
bool DWARFDebugInfo::ContainsCompileUnit(const DWARFUnit *cu) const {
// Not a verify efficient function, but it is handy for use in assertions to
// make sure that a compile unit comes from a debug information file.
CompileUnitColl::const_iterator end_pos = m_compile_units.end();
CompileUnitColl::const_iterator pos;
for (pos = m_compile_units.begin(); pos != end_pos; ++pos) {
if (pos->get() == cu)
return true;
}
return false;
}
bool DWARFDebugInfo::OffsetLessThanCompileUnitOffset(
dw_offset_t offset, const DWARFUnitSP &cu_sp) {
return offset < cu_sp->GetOffset();

1
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h
View File

@ -36,7 +36,6 @@ public:
void SetDwarfData(SymbolFileDWARF *dwarf2Data);
size_t GetNumCompileUnits();
bool ContainsCompileUnit(const DWARFUnit *cu) const;
DWARFUnit *GetCompileUnitAtIndex(uint32_t idx);
DWARFUnit *GetCompileUnit(dw_offset_t cu_offset, uint32_t *idx_ptr = NULL);
DWARFUnit *GetCompileUnitContainingDIEOffset(dw_offset_t die_offset);

42
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp
View File

@ -206,8 +206,7 @@ bool DWARFDebugInfoEntry::FastExtract(
// .debug_abbrev data within the SymbolFileDWARF class starting at the given
// offset
//----------------------------------------------------------------------
bool DWARFDebugInfoEntry::Extract(SymbolFileDWARF *dwarf2Data,
const DWARFUnit *cu,
bool DWARFDebugInfoEntry::Extract(const DWARFUnit *cu,
lldb::offset_t *offset_ptr) {
const DWARFDataExtractor &debug_info_data = cu->GetData();
// const DWARFDataExtractor& debug_str_data =
@ -933,22 +932,6 @@ uint64_t DWARFDebugInfoEntry::GetAttributeValueAsUnsigned(
return fail_value;
}
//----------------------------------------------------------------------
// GetAttributeValueAsSigned
//
// Get the value of an attribute a signed value and return it.
//----------------------------------------------------------------------
int64_t DWARFDebugInfoEntry::GetAttributeValueAsSigned(
SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
const dw_attr_t attr, int64_t fail_value,
bool check_specification_or_abstract_origin) const {
DWARFFormValue form_value;
if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
check_specification_or_abstract_origin))
return form_value.Signed();
return fail_value;
}
//----------------------------------------------------------------------
// GetAttributeValueAsReference
//
@ -1135,7 +1118,7 @@ bool DWARFDebugInfoEntry::GetName(SymbolFileDWARF *dwarf2Data,
DWARFDebugInfoEntry die;
lldb::offset_t offset = die_offset;
if (die.Extract(dwarf2Data, cu, &offset)) {
if (die.Extract(cu, &offset)) {
if (die.IsNULL()) {
s.PutCString("NULL");
return true;
@ -1169,7 +1152,7 @@ bool DWARFDebugInfoEntry::AppendTypeName(SymbolFileDWARF *dwarf2Data,
DWARFDebugInfoEntry die;
lldb::offset_t offset = die_offset;
if (die.Extract(dwarf2Data, cu, &offset)) {
if (die.Extract(cu, &offset)) {
if (die.IsNULL()) {
s.PutCString("NULL");
return true;
@ -1779,25 +1762,6 @@ bool DWARFDebugInfoEntry::OffsetLessThan(const DWARFDebugInfoEntry &a,
return a.GetOffset() < b.GetOffset();
}
void DWARFDebugInfoEntry::DumpDIECollection(
Stream &strm, DWARFDebugInfoEntry::collection &die_collection) {
DWARFDebugInfoEntry::const_iterator pos;
DWARFDebugInfoEntry::const_iterator end = die_collection.end();
strm.PutCString("\noffset parent sibling child\n");
strm.PutCString("-------- -------- -------- --------\n");
for (pos = die_collection.begin(); pos != end; ++pos) {
const DWARFDebugInfoEntry &die_ref = *pos;
const DWARFDebugInfoEntry *p = die_ref.GetParent();
const DWARFDebugInfoEntry *s = die_ref.GetSibling();
const DWARFDebugInfoEntry *c = die_ref.GetFirstChild();
strm.Printf("%.8x: %.8x %.8x %.8x 0x%4.4x %s%s\n", die_ref.GetOffset(),
p ? p->GetOffset() : 0, s ? s->GetOffset() : 0,
c ? c->GetOffset() : 0, die_ref.Tag(),
DW_TAG_value_to_name(die_ref.Tag()),
die_ref.HasChildren() ? " *" : "");
}
}
bool DWARFDebugInfoEntry::operator==(const DWARFDebugInfoEntry &rhs) const {
return m_offset == rhs.m_offset && m_parent_idx == rhs.m_parent_idx &&
m_sibling_idx == rhs.m_sibling_idx &&

12
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h
View File

@ -74,8 +74,7 @@ public:
const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
lldb::offset_t *offset_ptr);
bool Extract(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
lldb::offset_t *offset_ptr);
bool Extract(const DWARFUnit *cu, lldb::offset_t *offset_ptr);
bool LookupAddress(const dw_addr_t address, SymbolFileDWARF *dwarf2Data,
const DWARFUnit *cu,
@ -109,11 +108,6 @@ public:
const dw_attr_t attr, uint64_t fail_value,
bool check_specification_or_abstract_origin = false) const;
int64_t GetAttributeValueAsSigned(
SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
const dw_attr_t attr, int64_t fail_value,
bool check_specification_or_abstract_origin = false) const;
uint64_t GetAttributeValueAsAddress(
SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
const dw_attr_t attr, uint64_t fail_value,
@ -259,10 +253,6 @@ public:
void SetParentIndex(uint32_t idx) { m_parent_idx = idx; }
static void
DumpDIECollection(lldb_private::Stream &strm,
DWARFDebugInfoEntry::collection &die_collection);
protected:
dw_offset_t
m_offset; // Offset within the .debug_info of the start of this entry

31
lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp
View File

@ -65,8 +65,6 @@ void DWARFUnit::ExtractUnitDIEIfNeeded() {
AddUnitDIE(m_first_die);
return;
}
ExtractDIEsEndCheck(offset);
}
//----------------------------------------------------------------------
@ -164,7 +162,6 @@ void DWARFUnit::ExtractDIEsRWLocked() {
lldb::offset_t next_cu_offset = GetNextCompileUnitOffset();
DWARFDebugInfoEntry die;
// Keep a flat array of the DIE for binary lookup by DIE offset
uint32_t depth = 0;
// We are in our compile unit, parse starting at the offset we were told to
@ -251,40 +248,12 @@ void DWARFUnit::ExtractDIEsRWLocked() {
m_die_array.shrink_to_fit();
ExtractDIEsEndCheck(offset);
if (m_dwo_symbol_file) {
DWARFUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit();
dwo_cu->ExtractDIEsIfNeeded();
}
}
//--------------------------------------------------------------------------
// Final checks for both ExtractUnitDIEIfNeeded() and ExtractDIEsIfNeeded().
//--------------------------------------------------------------------------
void DWARFUnit::ExtractDIEsEndCheck(lldb::offset_t offset) const {
// Give a little bit of info if we encounter corrupt DWARF (our offset should
// always terminate at or before the start of the next compilation unit
// header).
if (offset > GetNextCompileUnitOffset()) {
m_dwarf->GetObjectFile()->GetModule()->ReportWarning(
"DWARF compile unit extends beyond its bounds cu 0x%8.8x at "
"0x%8.8" PRIx64 "\n",
GetOffset(), offset);
}
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
if (log && log->GetVerbose()) {
StreamString strm;
Dump(&strm);
if (m_die_array.empty())
strm.Printf("error: no DIE for compile unit");
else
m_die_array[0].Dump(m_dwarf, this, strm, UINT32_MAX);
log->PutString(strm.GetString());
}
}
// This is used when a split dwarf is enabled.
// A skeleton compilation unit may contain the DW_AT_str_offsets_base attribute
// that points to the first string offset of the CU contribution to the

1
lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h
View File

@ -243,7 +243,6 @@ private:
}
void AddUnitDIE(const DWARFDebugInfoEntry &cu_die);
void ExtractDIEsEndCheck(lldb::offset_t offset) const;
void ComputeCompDirAndGuessPathStyle();

9
lldb/source/Plugins/SymbolFile/DWARF/LogChannelDWARF.cpp
View File

@ -11,9 +11,6 @@
using namespace lldb_private;
static constexpr Log::Category g_categories[] = {
{{"aranges"},
{"log the parsing of .debug_aranges"},
DWARF_LOG_DEBUG_ARANGES},
{{"comp"},
{"log insertions of object files into DWARF debug maps"},
DWARF_LOG_TYPE_COMPLETION},
@ -25,12 +22,6 @@ static constexpr Log::Category g_categories[] = {
{{"map"},
{"log struct/unions/class type completions"},
DWARF_LOG_DEBUG_MAP},
{{"pubnames"},
{"log the parsing of .debug_pubnames"},
DWARF_LOG_DEBUG_PUBNAMES},
{{"pubtypes"},
{"log the parsing of .debug_pubtypes"},
DWARF_LOG_DEBUG_PUBTYPES},
};
Log::Channel LogChannelDWARF::g_channel(g_categories, DWARF_LOG_DEFAULT);

9
lldb/source/Plugins/SymbolFile/DWARF/LogChannelDWARF.h
View File

@ -13,12 +13,9 @@
#define DWARF_LOG_DEBUG_INFO (1u << 1)
#define DWARF_LOG_DEBUG_LINE (1u << 2)
#define DWARF_LOG_DEBUG_PUBNAMES (1u << 3)
#define DWARF_LOG_DEBUG_PUBTYPES (1u << 4)
#define DWARF_LOG_DEBUG_ARANGES (1u << 5)
#define DWARF_LOG_LOOKUPS (1u << 6)
#define DWARF_LOG_TYPE_COMPLETION (1u << 7)
#define DWARF_LOG_DEBUG_MAP (1u << 8)
#define DWARF_LOG_LOOKUPS (1u << 3)
#define DWARF_LOG_TYPE_COMPLETION (1u << 4)
#define DWARF_LOG_DEBUG_MAP (1u << 5)
#define DWARF_LOG_ALL (UINT32_MAX)
#define DWARF_LOG_DEFAULT (DWARF_LOG_DEBUG_INFO)

3
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
View File

@ -1761,8 +1761,7 @@ uint32_t SymbolFileDWARF::ResolveSymbolContext(const Address &so_addr,
llvm::Expected<DWARFDebugAranges &> aranges =
debug_info->GetCompileUnitAranges();
if (!aranges) {
Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO |
DWARF_LOG_DEBUG_ARANGES);
Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
LLDB_LOG_ERROR(log, aranges.takeError(),
"SymbolFileDWARF::ResolveSymbolContext failed to get cu "
"aranges. {0}");