346afb8572
Currently, the method `GetAttributeAddressRanges` takes a DWARFRangeList as a parameter, just to immediately clear it. The method also returns the size of this list. Such an API was obfuscating the intent of the call sites (it's not clear from the method name what it returns) and it was obfuscating redundant checks on the size of the list. This commit refactors the method to return the list and to also make the call sites use the more explicit `IsEmpty` method. Differential Revision: https://reviews.llvm.org/D151451
456 lines
12 KiB
C++
456 lines
12 KiB
C++
//===-- DWARFDIE.cpp ------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "DWARFDIE.h"
|
|
|
|
#include "DWARFASTParser.h"
|
|
#include "DWARFDebugInfo.h"
|
|
#include "DWARFDebugInfoEntry.h"
|
|
#include "DWARFDeclContext.h"
|
|
#include "DWARFUnit.h"
|
|
|
|
#include "llvm/ADT/iterator.h"
|
|
|
|
using namespace lldb_private;
|
|
using namespace lldb_private::dwarf;
|
|
|
|
namespace {
|
|
|
|
/// Iterate through all DIEs elaborating (i.e. reachable by a chain of
|
|
/// DW_AT_specification and DW_AT_abstract_origin attributes) a given DIE. For
|
|
/// convenience, the starting die is included in the sequence as the first
|
|
/// item.
|
|
class ElaboratingDIEIterator
|
|
: public llvm::iterator_facade_base<
|
|
ElaboratingDIEIterator, std::input_iterator_tag, DWARFDIE,
|
|
std::ptrdiff_t, DWARFDIE *, DWARFDIE *> {
|
|
|
|
// The operating invariant is: top of m_worklist contains the "current" item
|
|
// and the rest of the list are items yet to be visited. An empty worklist
|
|
// means we've reached the end.
|
|
// Infinite recursion is prevented by maintaining a list of seen DIEs.
|
|
// Container sizes are optimized for the case of following DW_AT_specification
|
|
// and DW_AT_abstract_origin just once.
|
|
llvm::SmallVector<DWARFDIE, 2> m_worklist;
|
|
llvm::SmallSet<DWARFDebugInfoEntry *, 3> m_seen;
|
|
|
|
void Next() {
|
|
assert(!m_worklist.empty() && "Incrementing end iterator?");
|
|
|
|
// Pop the current item from the list.
|
|
DWARFDIE die = m_worklist.back();
|
|
m_worklist.pop_back();
|
|
|
|
// And add back any items that elaborate it.
|
|
for (dw_attr_t attr : {DW_AT_specification, DW_AT_abstract_origin}) {
|
|
if (DWARFDIE d = die.GetReferencedDIE(attr))
|
|
if (m_seen.insert(die.GetDIE()).second)
|
|
m_worklist.push_back(d);
|
|
}
|
|
}
|
|
|
|
public:
|
|
/// An iterator starting at die d.
|
|
explicit ElaboratingDIEIterator(DWARFDIE d) : m_worklist(1, d) {}
|
|
|
|
/// End marker
|
|
ElaboratingDIEIterator() = default;
|
|
|
|
const DWARFDIE &operator*() const { return m_worklist.back(); }
|
|
ElaboratingDIEIterator &operator++() {
|
|
Next();
|
|
return *this;
|
|
}
|
|
|
|
friend bool operator==(const ElaboratingDIEIterator &a,
|
|
const ElaboratingDIEIterator &b) {
|
|
if (a.m_worklist.empty() || b.m_worklist.empty())
|
|
return a.m_worklist.empty() == b.m_worklist.empty();
|
|
return a.m_worklist.back() == b.m_worklist.back();
|
|
}
|
|
};
|
|
|
|
llvm::iterator_range<ElaboratingDIEIterator>
|
|
elaborating_dies(const DWARFDIE &die) {
|
|
return llvm::make_range(ElaboratingDIEIterator(die),
|
|
ElaboratingDIEIterator());
|
|
}
|
|
} // namespace
|
|
|
|
DWARFDIE
|
|
DWARFDIE::GetParent() const {
|
|
if (IsValid())
|
|
return DWARFDIE(m_cu, m_die->GetParent());
|
|
else
|
|
return DWARFDIE();
|
|
}
|
|
|
|
DWARFDIE
|
|
DWARFDIE::GetFirstChild() const {
|
|
if (IsValid())
|
|
return DWARFDIE(m_cu, m_die->GetFirstChild());
|
|
else
|
|
return DWARFDIE();
|
|
}
|
|
|
|
DWARFDIE
|
|
DWARFDIE::GetSibling() const {
|
|
if (IsValid())
|
|
return DWARFDIE(m_cu, m_die->GetSibling());
|
|
else
|
|
return DWARFDIE();
|
|
}
|
|
|
|
DWARFDIE
|
|
DWARFDIE::GetReferencedDIE(const dw_attr_t attr) const {
|
|
if (IsValid())
|
|
return m_die->GetAttributeValueAsReference(GetCU(), attr);
|
|
else
|
|
return {};
|
|
}
|
|
|
|
DWARFDIE
|
|
DWARFDIE::GetDIE(dw_offset_t die_offset) const {
|
|
if (IsValid())
|
|
return m_cu->GetDIE(die_offset);
|
|
else
|
|
return DWARFDIE();
|
|
}
|
|
|
|
DWARFDIE
|
|
DWARFDIE::GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const {
|
|
if (IsValid()) {
|
|
DWARFUnit *cu = GetCU();
|
|
const bool check_specification_or_abstract_origin = true;
|
|
DWARFFormValue form_value;
|
|
if (m_die->GetAttributeValue(cu, attr, form_value, nullptr,
|
|
check_specification_or_abstract_origin))
|
|
return form_value.Reference();
|
|
}
|
|
return DWARFDIE();
|
|
}
|
|
|
|
DWARFDIE
|
|
DWARFDIE::LookupDeepestBlock(lldb::addr_t address) const {
|
|
if (!IsValid())
|
|
return DWARFDIE();
|
|
|
|
DWARFDIE result;
|
|
bool check_children = false;
|
|
bool match_addr_range = false;
|
|
switch (Tag()) {
|
|
case DW_TAG_class_type:
|
|
case DW_TAG_namespace:
|
|
case DW_TAG_structure_type:
|
|
case DW_TAG_common_block:
|
|
check_children = true;
|
|
break;
|
|
case DW_TAG_compile_unit:
|
|
case DW_TAG_module:
|
|
case DW_TAG_catch_block:
|
|
case DW_TAG_subprogram:
|
|
case DW_TAG_try_block:
|
|
case DW_TAG_partial_unit:
|
|
match_addr_range = true;
|
|
break;
|
|
case DW_TAG_lexical_block:
|
|
case DW_TAG_inlined_subroutine:
|
|
check_children = true;
|
|
match_addr_range = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (match_addr_range) {
|
|
DWARFRangeList ranges =
|
|
m_die->GetAttributeAddressRanges(m_cu, /*check_hi_lo_pc=*/true);
|
|
if (ranges.FindEntryThatContains(address)) {
|
|
check_children = true;
|
|
switch (Tag()) {
|
|
default:
|
|
break;
|
|
|
|
case DW_TAG_inlined_subroutine: // Inlined Function
|
|
case DW_TAG_lexical_block: // Block { } in code
|
|
result = *this;
|
|
break;
|
|
}
|
|
} else {
|
|
check_children = false;
|
|
}
|
|
}
|
|
|
|
if (check_children) {
|
|
for (DWARFDIE child : children()) {
|
|
if (DWARFDIE child_result = child.LookupDeepestBlock(address))
|
|
return child_result;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const char *DWARFDIE::GetMangledName() const {
|
|
if (IsValid())
|
|
return m_die->GetMangledName(m_cu);
|
|
else
|
|
return nullptr;
|
|
}
|
|
|
|
const char *DWARFDIE::GetPubname() const {
|
|
if (IsValid())
|
|
return m_die->GetPubname(m_cu);
|
|
else
|
|
return nullptr;
|
|
}
|
|
|
|
// GetName
|
|
//
|
|
// Get value of the DW_AT_name attribute and place that value into the supplied
|
|
// stream object. If the DIE is a NULL object "NULL" is placed into the stream,
|
|
// and if no DW_AT_name attribute exists for the DIE then nothing is printed.
|
|
void DWARFDIE::GetName(Stream &s) const {
|
|
if (!IsValid())
|
|
return;
|
|
if (GetDIE()->IsNULL()) {
|
|
s.PutCString("NULL");
|
|
return;
|
|
}
|
|
const char *name = GetDIE()->GetAttributeValueAsString(GetCU(), DW_AT_name, nullptr, true);
|
|
if (!name)
|
|
return;
|
|
s.PutCString(name);
|
|
}
|
|
|
|
// AppendTypeName
|
|
//
|
|
// Follows the type name definition down through all needed tags to end up with
|
|
// a fully qualified type name and dump the results to the supplied stream.
|
|
// This is used to show the name of types given a type identifier.
|
|
void DWARFDIE::AppendTypeName(Stream &s) const {
|
|
if (!IsValid())
|
|
return;
|
|
if (GetDIE()->IsNULL()) {
|
|
s.PutCString("NULL");
|
|
return;
|
|
}
|
|
if (const char *name = GetPubname()) {
|
|
s.PutCString(name);
|
|
return;
|
|
}
|
|
switch (Tag()) {
|
|
case DW_TAG_array_type:
|
|
break; // print out a "[]" after printing the full type of the element
|
|
// below
|
|
case DW_TAG_base_type:
|
|
s.PutCString("base ");
|
|
break;
|
|
case DW_TAG_class_type:
|
|
s.PutCString("class ");
|
|
break;
|
|
case DW_TAG_const_type:
|
|
s.PutCString("const ");
|
|
break;
|
|
case DW_TAG_enumeration_type:
|
|
s.PutCString("enum ");
|
|
break;
|
|
case DW_TAG_file_type:
|
|
s.PutCString("file ");
|
|
break;
|
|
case DW_TAG_interface_type:
|
|
s.PutCString("interface ");
|
|
break;
|
|
case DW_TAG_packed_type:
|
|
s.PutCString("packed ");
|
|
break;
|
|
case DW_TAG_pointer_type:
|
|
break; // print out a '*' after printing the full type below
|
|
case DW_TAG_ptr_to_member_type:
|
|
break; // print out a '*' after printing the full type below
|
|
case DW_TAG_reference_type:
|
|
break; // print out a '&' after printing the full type below
|
|
case DW_TAG_restrict_type:
|
|
s.PutCString("restrict ");
|
|
break;
|
|
case DW_TAG_set_type:
|
|
s.PutCString("set ");
|
|
break;
|
|
case DW_TAG_shared_type:
|
|
s.PutCString("shared ");
|
|
break;
|
|
case DW_TAG_string_type:
|
|
s.PutCString("string ");
|
|
break;
|
|
case DW_TAG_structure_type:
|
|
s.PutCString("struct ");
|
|
break;
|
|
case DW_TAG_subrange_type:
|
|
s.PutCString("subrange ");
|
|
break;
|
|
case DW_TAG_subroutine_type:
|
|
s.PutCString("function ");
|
|
break;
|
|
case DW_TAG_thrown_type:
|
|
s.PutCString("thrown ");
|
|
break;
|
|
case DW_TAG_union_type:
|
|
s.PutCString("union ");
|
|
break;
|
|
case DW_TAG_unspecified_type:
|
|
s.PutCString("unspecified ");
|
|
break;
|
|
case DW_TAG_volatile_type:
|
|
s.PutCString("volatile ");
|
|
break;
|
|
case DW_TAG_LLVM_ptrauth_type: {
|
|
unsigned key = GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_key, 0);
|
|
bool isAddressDiscriminated = GetAttributeValueAsUnsigned(
|
|
DW_AT_LLVM_ptrauth_address_discriminated, 0);
|
|
unsigned extraDiscriminator =
|
|
GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_extra_discriminator, 0);
|
|
bool isaPointer =
|
|
GetAttributeValueAsUnsigned(DW_AT_LLVM_ptrauth_isa_pointer, 0);
|
|
s.Printf("__ptrauth(%d, %d, 0x0%x, %d)", key, isAddressDiscriminated,
|
|
extraDiscriminator, isaPointer);
|
|
break;
|
|
}
|
|
default:
|
|
return;
|
|
}
|
|
|
|
// Follow the DW_AT_type if possible
|
|
if (DWARFDIE next_die = GetAttributeValueAsReferenceDIE(DW_AT_type))
|
|
next_die.AppendTypeName(s);
|
|
|
|
switch (Tag()) {
|
|
case DW_TAG_array_type:
|
|
s.PutCString("[]");
|
|
break;
|
|
case DW_TAG_pointer_type:
|
|
s.PutChar('*');
|
|
break;
|
|
case DW_TAG_ptr_to_member_type:
|
|
s.PutChar('*');
|
|
break;
|
|
case DW_TAG_reference_type:
|
|
s.PutChar('&');
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
lldb_private::Type *DWARFDIE::ResolveType() const {
|
|
if (IsValid())
|
|
return GetDWARF()->ResolveType(*this, true);
|
|
else
|
|
return nullptr;
|
|
}
|
|
|
|
lldb_private::Type *DWARFDIE::ResolveTypeUID(const DWARFDIE &die) const {
|
|
if (SymbolFileDWARF *dwarf = GetDWARF())
|
|
return dwarf->ResolveTypeUID(die, true);
|
|
return nullptr;
|
|
}
|
|
|
|
std::vector<DWARFDIE> DWARFDIE::GetDeclContextDIEs() const {
|
|
if (!IsValid())
|
|
return {};
|
|
|
|
std::vector<DWARFDIE> result;
|
|
DWARFDIE parent = GetParentDeclContextDIE();
|
|
while (parent.IsValid() && parent.GetDIE() != GetDIE()) {
|
|
result.push_back(std::move(parent));
|
|
parent = parent.GetParentDeclContextDIE();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void DWARFDIE::GetDeclContext(
|
|
llvm::SmallVectorImpl<lldb_private::CompilerContext> &context) const {
|
|
const dw_tag_t tag = Tag();
|
|
if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit)
|
|
return;
|
|
DWARFDIE parent = GetParent();
|
|
if (parent)
|
|
parent.GetDeclContext(context);
|
|
switch (tag) {
|
|
case DW_TAG_module:
|
|
context.push_back({CompilerContextKind::Module, ConstString(GetName())});
|
|
break;
|
|
case DW_TAG_namespace:
|
|
context.push_back({CompilerContextKind::Namespace, ConstString(GetName())});
|
|
break;
|
|
case DW_TAG_structure_type:
|
|
context.push_back({CompilerContextKind::Struct, ConstString(GetName())});
|
|
break;
|
|
case DW_TAG_union_type:
|
|
context.push_back({CompilerContextKind::Union, ConstString(GetName())});
|
|
break;
|
|
case DW_TAG_class_type:
|
|
context.push_back({CompilerContextKind::Class, ConstString(GetName())});
|
|
break;
|
|
case DW_TAG_enumeration_type:
|
|
context.push_back({CompilerContextKind::Enum, ConstString(GetName())});
|
|
break;
|
|
case DW_TAG_subprogram:
|
|
context.push_back(
|
|
{CompilerContextKind::Function, ConstString(GetPubname())});
|
|
break;
|
|
case DW_TAG_variable:
|
|
context.push_back(
|
|
{CompilerContextKind::Variable, ConstString(GetPubname())});
|
|
break;
|
|
case DW_TAG_typedef:
|
|
context.push_back({CompilerContextKind::Typedef, ConstString(GetName())});
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
DWARFDIE
|
|
DWARFDIE::GetParentDeclContextDIE() const {
|
|
if (IsValid())
|
|
return m_die->GetParentDeclContextDIE(m_cu);
|
|
else
|
|
return DWARFDIE();
|
|
}
|
|
|
|
bool DWARFDIE::IsStructUnionOrClass() const {
|
|
const dw_tag_t tag = Tag();
|
|
return tag == DW_TAG_class_type || tag == DW_TAG_structure_type ||
|
|
tag == DW_TAG_union_type;
|
|
}
|
|
|
|
bool DWARFDIE::IsMethod() const {
|
|
for (DWARFDIE d : elaborating_dies(*this))
|
|
if (d.GetParent().IsStructUnionOrClass())
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool DWARFDIE::GetDIENamesAndRanges(
|
|
const char *&name, const char *&mangled, DWARFRangeList &ranges,
|
|
std::optional<int> &decl_file, std::optional<int> &decl_line,
|
|
std::optional<int> &decl_column, std::optional<int> &call_file,
|
|
std::optional<int> &call_line, std::optional<int> &call_column,
|
|
lldb_private::DWARFExpressionList *frame_base) const {
|
|
if (IsValid()) {
|
|
return m_die->GetDIENamesAndRanges(
|
|
GetCU(), name, mangled, ranges, decl_file, decl_line, decl_column,
|
|
call_file, call_line, call_column, frame_base);
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
llvm::iterator_range<DWARFDIE::child_iterator> DWARFDIE::children() const {
|
|
return llvm::make_range(child_iterator(*this), child_iterator());
|
|
}
|