OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 6
Code Issues Packages Projects Releases Wiki Activity
llvm-project/lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

469 lines
13 KiB
C++
Raw Blame History

//===-- DWARFDIE.cpp --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "DWARFDIE.h"
#include "DWARFASTParser.h"
#include "DWARFCompileUnit.h"
#include "DWARFDIECollection.h"
#include "DWARFDebugAbbrev.h"
#include "DWARFDebugAranges.h"
#include "DWARFDebugInfo.h"
#include "DWARFDebugInfoEntry.h"
#include "DWARFDebugRanges.h"
#include "DWARFDeclContext.h"
#include "DWARFFormValue.h"
#include "SymbolFileDWARF.h"
#include "lldb/Core/Module.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeSystem.h"
using namespace lldb_private;
DIERef DWARFDIE::GetDIERef() const {
if (!IsValid())
return DIERef();
dw_offset_t cu_offset = m_cu->GetOffset();
if (m_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
cu_offset = m_cu->GetBaseObjOffset();
return DIERef(cu_offset, m_die->GetOffset());
}
dw_tag_t DWARFDIE::Tag() const {
if (m_die)
return m_die->Tag();
else
return 0;
}
const char *DWARFDIE::GetTagAsCString() const {
return lldb_private::DW_TAG_value_to_name(Tag());
}
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 {
const dw_offset_t die_offset =
GetAttributeValueAsReference(attr, DW_INVALID_OFFSET);
if (die_offset != DW_INVALID_OFFSET)
return GetDIE(die_offset);
else
return DWARFDIE();
}
DWARFDIE
DWARFDIE::GetDIE(dw_offset_t die_offset) const {
if (IsValid())
return m_cu->GetDIE(die_offset);
else
return DWARFDIE();
}
const char *DWARFDIE::GetAttributeValueAsString(const dw_attr_t attr,
const char *fail_value) const {
if (IsValid())
return m_die->GetAttributeValueAsString(GetDWARF(), GetCU(), attr,
fail_value);
else
return fail_value;
}
uint64_t DWARFDIE::GetAttributeValueAsUnsigned(const dw_attr_t attr,
uint64_t fail_value) const {
if (IsValid())
return m_die->GetAttributeValueAsUnsigned(GetDWARF(), GetCU(), attr,
fail_value);
else
return fail_value;
}
int64_t DWARFDIE::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;
}
DWARFDIE
DWARFDIE::GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const {
if (IsValid()) {
DWARFCompileUnit *cu = GetCU();
SymbolFileDWARF *dwarf = cu->GetSymbolFileDWARF();
const bool check_specification_or_abstract_origin = true;
DWARFFormValue form_value;
if (m_die->GetAttributeValue(dwarf, cu, attr, form_value, nullptr,
check_specification_or_abstract_origin))
return dwarf->GetDIE(DIERef(form_value));
}
return DWARFDIE();
}
uint64_t DWARFDIE::GetAttributeValueAsReference(const dw_attr_t attr,
uint64_t fail_value) const {
if (IsValid())
return m_die->GetAttributeValueAsReference(GetDWARF(), GetCU(), attr,
fail_value);
else
return fail_value;
}
uint64_t DWARFDIE::GetAttributeValueAsAddress(const dw_attr_t attr,
uint64_t fail_value) const {
if (IsValid())
return m_die->GetAttributeValueAsAddress(GetDWARF(), GetCU(), attr,
fail_value);
else
return fail_value;
}
DWARFDIE
DWARFDIE::LookupDeepestBlock(lldb::addr_t file_addr) const {
if (IsValid()) {
SymbolFileDWARF *dwarf = GetDWARF();
DWARFCompileUnit *cu = GetCU();
DWARFDebugInfoEntry *function_die = nullptr;
DWARFDebugInfoEntry *block_die = nullptr;
if (m_die->LookupAddress(file_addr, dwarf, cu, &function_die, &block_die)) {
if (block_die && block_die != function_die) {
if (cu->ContainsDIEOffset(block_die->GetOffset()))
return DWARFDIE(cu, block_die);
else
return DWARFDIE(dwarf->DebugInfo()->GetCompileUnit(
DIERef(cu->GetOffset(), block_die->GetOffset())),
block_die);
}
}
}
return DWARFDIE();
}
lldb::user_id_t DWARFDIE::GetID() const {
return GetDIERef().GetUID(GetDWARF());
}
const char *DWARFDIE::GetName() const {
if (IsValid())
return m_die->GetName(GetDWARF(), m_cu);
else
return nullptr;
}
const char *DWARFDIE::GetMangledName() const {
if (IsValid())
return m_die->GetMangledName(GetDWARF(), m_cu);
else
return nullptr;
}
const char *DWARFDIE::GetPubname() const {
if (IsValid())
return m_die->GetPubname(GetDWARF(), m_cu);
else
return nullptr;
}
const char *DWARFDIE::GetQualifiedName(std::string &storage) const {
if (IsValid())
return m_die->GetQualifiedName(GetDWARF(), m_cu, storage);
else
return nullptr;
}
lldb::LanguageType DWARFDIE::GetLanguage() const {
if (IsValid())
return m_cu->GetLanguageType();
else
return lldb::eLanguageTypeUnknown;
}
lldb::ModuleSP DWARFDIE::GetModule() const {
SymbolFileDWARF *dwarf = GetDWARF();
if (dwarf)
return dwarf->GetObjectFile()->GetModule();
else
return lldb::ModuleSP();
}
lldb_private::CompileUnit *DWARFDIE::GetLLDBCompileUnit() const {
if (IsValid())
return GetDWARF()->GetCompUnitForDWARFCompUnit(GetCU());
else
return nullptr;
}
lldb_private::Type *DWARFDIE::ResolveType() const {
if (IsValid())
return GetDWARF()->ResolveType(*this, true);
else
return nullptr;
}
lldb_private::Type *DWARFDIE::ResolveTypeUID(const DIERef &die_ref) const {
SymbolFileDWARF *dwarf = GetDWARF();
if (dwarf)
return dwarf->ResolveTypeUID(dwarf->GetDIE(die_ref), true);
else
return nullptr;
}
void DWARFDIE::GetDeclContextDIEs(DWARFDIECollection &decl_context_dies) const {
if (IsValid()) {
DWARFDIE parent_decl_ctx_die =
m_die->GetParentDeclContextDIE(GetDWARF(), GetCU());
if (parent_decl_ctx_die && parent_decl_ctx_die.GetDIE() != GetDIE()) {
decl_context_dies.Append(parent_decl_ctx_die);
parent_decl_ctx_die.GetDeclContextDIEs(decl_context_dies);
}
}
}
void DWARFDIE::GetDWARFDeclContext(DWARFDeclContext &dwarf_decl_ctx) const {
if (IsValid()) {
dwarf_decl_ctx.SetLanguage(GetLanguage());
m_die->GetDWARFDeclContext(GetDWARF(), GetCU(), dwarf_decl_ctx);
} else {
dwarf_decl_ctx.Clear();
}
}
void DWARFDIE::GetDWOContext(std::vector<CompilerContext> &context) const {
const dw_tag_t tag = Tag();
if (tag == DW_TAG_compile_unit)
return;
DWARFDIE parent = GetParent();
if (parent)
parent.GetDWOContext(context);
switch (tag) {
case DW_TAG_module:
context.push_back(
CompilerContext(CompilerContextKind::Module, ConstString(GetName())));
break;
case DW_TAG_namespace:
context.push_back(CompilerContext(CompilerContextKind::Namespace,
ConstString(GetName())));
break;
case DW_TAG_structure_type:
context.push_back(CompilerContext(CompilerContextKind::Structure,
ConstString(GetName())));
break;
case DW_TAG_union_type:
context.push_back(
CompilerContext(CompilerContextKind::Union, ConstString(GetName())));
break;
case DW_TAG_class_type:
context.push_back(
CompilerContext(CompilerContextKind::Class, ConstString(GetName())));
break;
case DW_TAG_enumeration_type:
context.push_back(CompilerContext(CompilerContextKind::Enumeration,
ConstString(GetName())));
break;
case DW_TAG_subprogram:
context.push_back(CompilerContext(CompilerContextKind::Function,
ConstString(GetPubname())));
break;
case DW_TAG_variable:
context.push_back(CompilerContext(CompilerContextKind::Variable,
ConstString(GetPubname())));
break;
case DW_TAG_typedef:
context.push_back(
CompilerContext(CompilerContextKind::Typedef, ConstString(GetName())));
break;
default:
break;
}
}
DWARFDIE
DWARFDIE::GetParentDeclContextDIE() const {
if (IsValid())
return m_die->GetParentDeclContextDIE(GetDWARF(), m_cu);
else
return DWARFDIE();
}
dw_offset_t DWARFDIE::GetOffset() const {
if (IsValid())
return m_die->GetOffset();
else
return DW_INVALID_OFFSET;
}
dw_offset_t DWARFDIE::GetCompileUnitRelativeOffset() const {
if (IsValid())
return m_die->GetOffset() - m_cu->GetOffset();
else
return DW_INVALID_OFFSET;
}
SymbolFileDWARF *DWARFDIE::GetDWARF() const {
if (m_cu)
return m_cu->GetSymbolFileDWARF();
else
return nullptr;
}
lldb_private::TypeSystem *DWARFDIE::GetTypeSystem() const {
if (m_cu)
return m_cu->GetTypeSystem();
else
return nullptr;
}
DWARFASTParser *DWARFDIE::GetDWARFParser() const {
lldb_private::TypeSystem *type_system = GetTypeSystem();
if (type_system)
return type_system->GetDWARFParser();
else
return nullptr;
}
bool DWARFDIE::IsStructOrClass() const {
const dw_tag_t tag = Tag();
return tag == DW_TAG_class_type || tag == DW_TAG_structure_type;
}
DWARFDIE
DWARFDIE::GetContainingDWOModuleDIE() const {
if (IsValid()) {
DWARFDIE top_module_die;
// Now make sure this DIE is scoped in a DW_TAG_module tag and return true
// if so
for (DWARFDIE parent = GetParent(); parent.IsValid();
parent = parent.GetParent()) {
const dw_tag_t tag = parent.Tag();
if (tag == DW_TAG_module)
top_module_die = parent;
else if (tag == DW_TAG_compile_unit)
break;
}
return top_module_die;
}
return DWARFDIE();
}
lldb::ModuleSP DWARFDIE::GetContainingDWOModule() const {
if (IsValid()) {
DWARFDIE dwo_module_die = GetContainingDWOModuleDIE();
if (dwo_module_die) {
const char *module_name = dwo_module_die.GetName();
if (module_name)
return GetDWARF()->GetDWOModule(lldb_private::ConstString(module_name));
}
}
return lldb::ModuleSP();
}
bool DWARFDIE::HasChildren() const {
if (m_die)
return m_die->HasChildren();
else
return false;
}
bool DWARFDIE::Supports_DW_AT_APPLE_objc_complete_type() const {
if (IsValid())
return GetDWARF()->Supports_DW_AT_APPLE_objc_complete_type(m_cu);
else
return false;
}
size_t DWARFDIE::GetAttributes(DWARFAttributes &attributes,
uint32_t depth) const {
if (IsValid()) {
return m_die->GetAttributes(m_cu, m_cu->GetFixedFormSizes(), attributes,
depth);
}
if (depth == 0)
attributes.Clear();
return 0;
}
bool DWARFDIE::GetDIENamesAndRanges(
const char *&name, const char *&mangled, DWARFRangeList &ranges,
int &decl_file, int &decl_line, int &decl_column, int &call_file,
int &call_line, int &call_column,
lldb_private::DWARFExpression *frame_base) const {
if (IsValid()) {
return m_die->GetDIENamesAndRanges(
GetDWARF(), GetCU(), name, mangled, ranges, decl_file, decl_line,
decl_column, call_file, call_line, call_column, frame_base);
} else
return false;
}
void DWARFDIE::Dump(lldb_private::Stream *s,
const uint32_t recurse_depth) const {
if (s && IsValid())
m_die->Dump(GetDWARF(), GetCU(), *s, recurse_depth);
}
CompilerDecl DWARFDIE::GetDecl() const {
DWARFASTParser *dwarf_ast = GetDWARFParser();
if (dwarf_ast)
return dwarf_ast->GetDeclForUIDFromDWARF(*this);
else
return CompilerDecl();
}
CompilerDeclContext DWARFDIE::GetDeclContext() const {
DWARFASTParser *dwarf_ast = GetDWARFParser();
if (dwarf_ast)
return dwarf_ast->GetDeclContextForUIDFromDWARF(*this);
else
return CompilerDeclContext();
}
CompilerDeclContext DWARFDIE::GetContainingDeclContext() const {
DWARFASTParser *dwarf_ast = GetDWARFParser();
if (dwarf_ast)
return dwarf_ast->GetDeclContextContainingUIDFromDWARF(*this);
else
return CompilerDeclContext();
}
bool operator==(const DWARFDIE &lhs, const DWARFDIE &rhs) {
return lhs.GetDIE() == rhs.GetDIE() && lhs.GetCU() == rhs.GetCU();
}
bool operator!=(const DWARFDIE &lhs, const DWARFDIE &rhs) {
return lhs.GetDIE() != rhs.GetDIE() || lhs.GetCU() != rhs.GetCU();
}
Reference in New Issue View Git Blame Copy Permalink