forked from OSchip/llvm-project
490 lines
16 KiB
C++
490 lines
16 KiB
C++
//===-- SymbolVendor.cpp ----------------------------------------*- C++ -*-===//
|
|
//
|
|
// 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 "lldb/Symbol/SymbolVendor.h"
|
|
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Symbol/CompileUnit.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
#include "lldb/Symbol/SymbolFile.h"
|
|
#include "lldb/Utility/Stream.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
// FindPlugin
|
|
//
|
|
// Platforms can register a callback to use when creating symbol vendors to
|
|
// allow for complex debug information file setups, and to also allow for
|
|
// finding separate debug information files.
|
|
SymbolVendor *SymbolVendor::FindPlugin(const lldb::ModuleSP &module_sp,
|
|
lldb_private::Stream *feedback_strm) {
|
|
std::unique_ptr<SymbolVendor> instance_up;
|
|
SymbolVendorCreateInstance create_callback;
|
|
|
|
for (size_t idx = 0;
|
|
(create_callback = PluginManager::GetSymbolVendorCreateCallbackAtIndex(
|
|
idx)) != nullptr;
|
|
++idx) {
|
|
instance_up.reset(create_callback(module_sp, feedback_strm));
|
|
|
|
if (instance_up) {
|
|
return instance_up.release();
|
|
}
|
|
}
|
|
// The default implementation just tries to create debug information using
|
|
// the file representation for the module.
|
|
ObjectFileSP sym_objfile_sp;
|
|
FileSpec sym_spec = module_sp->GetSymbolFileFileSpec();
|
|
if (sym_spec && sym_spec != module_sp->GetObjectFile()->GetFileSpec()) {
|
|
DataBufferSP data_sp;
|
|
offset_t data_offset = 0;
|
|
sym_objfile_sp = ObjectFile::FindPlugin(
|
|
module_sp, &sym_spec, 0, FileSystem::Instance().GetByteSize(sym_spec),
|
|
data_sp, data_offset);
|
|
}
|
|
if (!sym_objfile_sp)
|
|
sym_objfile_sp = module_sp->GetObjectFile()->shared_from_this();
|
|
instance_up.reset(new SymbolVendor(module_sp));
|
|
instance_up->AddSymbolFileRepresentation(sym_objfile_sp);
|
|
return instance_up.release();
|
|
}
|
|
|
|
// SymbolVendor constructor
|
|
SymbolVendor::SymbolVendor(const lldb::ModuleSP &module_sp)
|
|
: ModuleChild(module_sp), m_type_list(), m_compile_units(), m_sym_file_up(),
|
|
m_symtab() {}
|
|
|
|
// Destructor
|
|
SymbolVendor::~SymbolVendor() {}
|
|
|
|
// Add a representation given an object file.
|
|
void SymbolVendor::AddSymbolFileRepresentation(const ObjectFileSP &objfile_sp) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (objfile_sp) {
|
|
m_objfile_sp = objfile_sp;
|
|
m_sym_file_up.reset(SymbolFile::FindPlugin(objfile_sp.get()));
|
|
}
|
|
}
|
|
}
|
|
|
|
bool SymbolVendor::SetCompileUnitAtIndex(size_t idx, const CompUnitSP &cu_sp) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
const size_t num_compile_units = GetNumCompileUnits();
|
|
if (idx < num_compile_units) {
|
|
// Fire off an assertion if this compile unit already exists for now. The
|
|
// partial parsing should take care of only setting the compile unit
|
|
// once, so if this assertion fails, we need to make sure that we don't
|
|
// have a race condition, or have a second parse of the same compile
|
|
// unit.
|
|
assert(m_compile_units[idx].get() == nullptr);
|
|
m_compile_units[idx] = cu_sp;
|
|
return true;
|
|
} else {
|
|
// This should NOT happen, and if it does, we want to crash and know
|
|
// about it
|
|
assert(idx < num_compile_units);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
size_t SymbolVendor::GetNumCompileUnits() {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_compile_units.empty()) {
|
|
if (m_sym_file_up) {
|
|
// Resize our array of compile unit shared pointers -- which will each
|
|
// remain NULL until someone asks for the actual compile unit
|
|
// information. When this happens, the symbol file will be asked to
|
|
// parse this compile unit information.
|
|
m_compile_units.resize(m_sym_file_up->GetNumCompileUnits());
|
|
}
|
|
}
|
|
}
|
|
return m_compile_units.size();
|
|
}
|
|
|
|
lldb::LanguageType SymbolVendor::ParseLanguage(CompileUnit &comp_unit) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ParseLanguage(comp_unit);
|
|
}
|
|
return eLanguageTypeUnknown;
|
|
}
|
|
|
|
size_t SymbolVendor::ParseFunctions(CompileUnit &comp_unit) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ParseFunctions(comp_unit);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool SymbolVendor::ParseLineTable(CompileUnit &comp_unit) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ParseLineTable(comp_unit);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool SymbolVendor::ParseDebugMacros(CompileUnit &comp_unit) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ParseDebugMacros(comp_unit);
|
|
}
|
|
return false;
|
|
}
|
|
bool SymbolVendor::ParseSupportFiles(CompileUnit &comp_unit,
|
|
FileSpecList &support_files) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ParseSupportFiles(comp_unit, support_files);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool SymbolVendor::ParseIsOptimized(CompileUnit &comp_unit) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ParseIsOptimized(comp_unit);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool SymbolVendor::ParseImportedModules(
|
|
const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ParseImportedModules(sc, imported_modules);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
size_t SymbolVendor::ParseBlocksRecursive(Function &func) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ParseBlocksRecursive(func);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t SymbolVendor::ParseTypes(CompileUnit &comp_unit) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ParseTypes(comp_unit);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t SymbolVendor::ParseVariablesForContext(const SymbolContext &sc) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ParseVariablesForContext(sc);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
Type *SymbolVendor::ResolveTypeUID(lldb::user_id_t type_uid) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ResolveTypeUID(type_uid);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
uint32_t SymbolVendor::ResolveSymbolContext(const Address &so_addr,
|
|
SymbolContextItem resolve_scope,
|
|
SymbolContext &sc) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ResolveSymbolContext(so_addr, resolve_scope, sc);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint32_t SymbolVendor::ResolveSymbolContext(const FileSpec &file_spec,
|
|
uint32_t line, bool check_inlines,
|
|
SymbolContextItem resolve_scope,
|
|
SymbolContextList &sc_list) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->ResolveSymbolContext(file_spec, line, check_inlines,
|
|
resolve_scope, sc_list);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t
|
|
SymbolVendor::FindGlobalVariables(ConstString name,
|
|
const CompilerDeclContext *parent_decl_ctx,
|
|
size_t max_matches, VariableList &variables) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->FindGlobalVariables(name, parent_decl_ctx,
|
|
max_matches, variables);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t SymbolVendor::FindGlobalVariables(const RegularExpression ®ex,
|
|
size_t max_matches,
|
|
VariableList &variables) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->FindGlobalVariables(regex, max_matches, variables);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t SymbolVendor::FindFunctions(ConstString name,
|
|
const CompilerDeclContext *parent_decl_ctx,
|
|
FunctionNameType name_type_mask,
|
|
bool include_inlines, bool append,
|
|
SymbolContextList &sc_list) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->FindFunctions(name, parent_decl_ctx, name_type_mask,
|
|
include_inlines, append, sc_list);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t SymbolVendor::FindFunctions(const RegularExpression ®ex,
|
|
bool include_inlines, bool append,
|
|
SymbolContextList &sc_list) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->FindFunctions(regex, include_inlines, append,
|
|
sc_list);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t SymbolVendor::FindTypes(
|
|
ConstString name, const CompilerDeclContext *parent_decl_ctx,
|
|
bool append, size_t max_matches,
|
|
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
|
|
TypeMap &types) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->FindTypes(name, parent_decl_ctx, append,
|
|
max_matches, searched_symbol_files,
|
|
types);
|
|
}
|
|
if (!append)
|
|
types.Clear();
|
|
return 0;
|
|
}
|
|
|
|
size_t SymbolVendor::FindTypes(const std::vector<CompilerContext> &context,
|
|
bool append, TypeMap &types) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->FindTypes(context, append, types);
|
|
}
|
|
if (!append)
|
|
types.Clear();
|
|
return 0;
|
|
}
|
|
|
|
size_t SymbolVendor::GetTypes(SymbolContextScope *sc_scope, TypeClass type_mask,
|
|
lldb_private::TypeList &type_list) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
return m_sym_file_up->GetTypes(sc_scope, type_mask, type_list);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
CompilerDeclContext
|
|
SymbolVendor::FindNamespace(ConstString name,
|
|
const CompilerDeclContext *parent_decl_ctx) {
|
|
CompilerDeclContext namespace_decl_ctx;
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_up)
|
|
namespace_decl_ctx = m_sym_file_up->FindNamespace(name, parent_decl_ctx);
|
|
}
|
|
return namespace_decl_ctx;
|
|
}
|
|
|
|
void SymbolVendor::Dump(Stream *s) {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
|
|
bool show_context = false;
|
|
|
|
s->Printf("%p: ", static_cast<void *>(this));
|
|
s->Indent();
|
|
s->PutCString("SymbolVendor");
|
|
if (m_sym_file_up) {
|
|
*s << " " << m_sym_file_up->GetPluginName();
|
|
ObjectFile *objfile = m_sym_file_up->GetObjectFile();
|
|
if (objfile) {
|
|
const FileSpec &objfile_file_spec = objfile->GetFileSpec();
|
|
if (objfile_file_spec) {
|
|
s->PutCString(" (");
|
|
objfile_file_spec.Dump(s);
|
|
s->PutChar(')');
|
|
}
|
|
}
|
|
}
|
|
s->EOL();
|
|
if (m_sym_file_up)
|
|
m_sym_file_up->Dump(*s);
|
|
s->IndentMore();
|
|
m_type_list.Dump(s, show_context);
|
|
|
|
CompileUnitConstIter cu_pos, cu_end;
|
|
cu_end = m_compile_units.end();
|
|
for (cu_pos = m_compile_units.begin(); cu_pos != cu_end; ++cu_pos) {
|
|
// We currently only dump the compile units that have been parsed
|
|
if (*cu_pos)
|
|
(*cu_pos)->Dump(s, show_context);
|
|
}
|
|
|
|
if (Symtab *symtab = GetSymtab())
|
|
symtab->Dump(s, nullptr, eSortOrderNone);
|
|
|
|
s->IndentLess();
|
|
}
|
|
}
|
|
|
|
CompUnitSP SymbolVendor::GetCompileUnitAtIndex(size_t idx) {
|
|
CompUnitSP cu_sp;
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
const size_t num_compile_units = GetNumCompileUnits();
|
|
if (idx < num_compile_units) {
|
|
cu_sp = m_compile_units[idx];
|
|
if (cu_sp.get() == nullptr) {
|
|
m_compile_units[idx] = m_sym_file_up->ParseCompileUnitAtIndex(idx);
|
|
cu_sp = m_compile_units[idx];
|
|
}
|
|
}
|
|
}
|
|
return cu_sp;
|
|
}
|
|
|
|
FileSpec SymbolVendor::GetMainFileSpec() const {
|
|
if (m_sym_file_up) {
|
|
const ObjectFile *symfile_objfile = m_sym_file_up->GetObjectFile();
|
|
if (symfile_objfile)
|
|
return symfile_objfile->GetFileSpec();
|
|
}
|
|
|
|
return FileSpec();
|
|
}
|
|
|
|
Symtab *SymbolVendor::GetSymtab() {
|
|
ModuleSP module_sp(GetModule());
|
|
if (!module_sp)
|
|
return nullptr;
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
|
|
if (m_symtab)
|
|
return m_symtab;
|
|
|
|
ObjectFile *objfile = module_sp->GetObjectFile();
|
|
if (!objfile)
|
|
return nullptr;
|
|
|
|
m_symtab = objfile->GetSymtab();
|
|
if (m_symtab && m_sym_file_up)
|
|
m_sym_file_up->AddSymbols(*m_symtab);
|
|
|
|
return m_symtab;
|
|
}
|
|
|
|
void SymbolVendor::ClearSymtab() {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
ObjectFile *objfile = module_sp->GetObjectFile();
|
|
if (objfile) {
|
|
// Clear symbol table from unified section list.
|
|
objfile->ClearSymtab();
|
|
}
|
|
}
|
|
}
|
|
|
|
void SymbolVendor::SectionFileAddressesChanged() {
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp) {
|
|
ObjectFile *module_objfile = module_sp->GetObjectFile();
|
|
if (m_sym_file_up) {
|
|
ObjectFile *symfile_objfile = m_sym_file_up->GetObjectFile();
|
|
if (symfile_objfile != module_objfile)
|
|
symfile_objfile->SectionFileAddressesChanged();
|
|
}
|
|
Symtab *symtab = GetSymtab();
|
|
if (symtab) {
|
|
symtab->SectionFileAddressesChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
// PluginInterface protocol
|
|
lldb_private::ConstString SymbolVendor::GetPluginName() {
|
|
static ConstString g_name("vendor-default");
|
|
return g_name;
|
|
}
|
|
|
|
uint32_t SymbolVendor::GetPluginVersion() { return 1; }
|