7b81192d46
This diff introduces a new symbol on-demand which skips loading a module's debug info unless explicitly asked on demand. This provides significant performance improvement for application with dynamic linking mode which has large number of modules. The feature can be turned on with: "settings set symbols.load-on-demand true" The feature works by creating a new SymbolFileOnDemand class for each module which wraps the actual SymbolFIle subclass as member variable. By default, most virtual methods on SymbolFileOnDemand are skipped so that it looks like there is no debug info for that module. But once the module's debug info is explicitly requested to be enabled (in the conditions mentioned below) SymbolFileOnDemand will allow all methods to pass through and forward to the actual SymbolFile which would hydrate module's debug info on-demand. In an internal benchmark, we are seeing more than 95% improvement for a 3000 modules application. Currently we are providing several ways to on demand hydrate a module's debug info: * Source line breakpoint: matching in supported files * Stack trace: resolving symbol context for an address * Symbolic breakpoint: symbol table match guided promotion * Global variable: symbol table match guided promotion In all above situations the module's debug info will be on-demand parsed and indexed. Some follow-ups for this feature: * Add a command that allows users to load debug info explicitly while using a new or existing command when this feature is enabled * Add settings for "never load any of these executables in Symbols On Demand" that takes a list of globs * Add settings for "always load the the debug info for executables in Symbols On Demand" that takes a list of globs * Add a new column in "image list" that shows up by default when Symbols On Demand is enable to show the status for each shlib like "not enabled for this", "debug info off" and "debug info on" (with a single character to short string, not the ones I just typed) Differential Revision: https://reviews.llvm.org/D121631
591 lines
20 KiB
C++
591 lines
20 KiB
C++
//===-- SymbolFileDWARFDebugMap.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 "lldb/Symbol/SymbolFileOnDemand.h"
|
|
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Symbol/SymbolFile.h"
|
|
|
|
#include <memory>
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
char SymbolFileOnDemand::ID;
|
|
|
|
SymbolFileOnDemand::SymbolFileOnDemand(
|
|
std::unique_ptr<SymbolFile> &&symbol_file)
|
|
: m_sym_file_impl(std::move(symbol_file)) {}
|
|
|
|
SymbolFileOnDemand::~SymbolFileOnDemand() {}
|
|
|
|
uint32_t SymbolFileOnDemand::CalculateAbilities() {
|
|
// Explicitly allow ability checking to pass though.
|
|
// This should be a cheap operation.
|
|
return m_sym_file_impl->CalculateAbilities();
|
|
}
|
|
|
|
std::recursive_mutex &SymbolFileOnDemand::GetModuleMutex() const {
|
|
return m_sym_file_impl->GetModuleMutex();
|
|
}
|
|
|
|
void SymbolFileOnDemand::InitializeObject() {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return;
|
|
}
|
|
return m_sym_file_impl->InitializeObject();
|
|
}
|
|
|
|
lldb::LanguageType SymbolFileOnDemand::ParseLanguage(CompileUnit &comp_unit) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
|
|
if (log) {
|
|
lldb::LanguageType langType = m_sym_file_impl->ParseLanguage(comp_unit);
|
|
if (langType != eLanguageTypeUnknown)
|
|
LLDB_LOG(log, "Language {0} would return if hydrated.", langType);
|
|
}
|
|
return eLanguageTypeUnknown;
|
|
}
|
|
return m_sym_file_impl->ParseLanguage(comp_unit);
|
|
}
|
|
|
|
XcodeSDK SymbolFileOnDemand::ParseXcodeSDK(CompileUnit &comp_unit) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
|
|
XcodeSDK defaultValue{};
|
|
if (log) {
|
|
XcodeSDK sdk = m_sym_file_impl->ParseXcodeSDK(comp_unit);
|
|
if (!(sdk == defaultValue))
|
|
LLDB_LOG(log, "SDK {0} would return if hydrated.", sdk.GetString());
|
|
}
|
|
return defaultValue;
|
|
}
|
|
return m_sym_file_impl->ParseXcodeSDK(comp_unit);
|
|
}
|
|
|
|
size_t SymbolFileOnDemand::ParseFunctions(CompileUnit &comp_unit) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return 0;
|
|
}
|
|
return m_sym_file_impl->ParseFunctions(comp_unit);
|
|
}
|
|
|
|
bool SymbolFileOnDemand::ParseLineTable(CompileUnit &comp_unit) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return false;
|
|
}
|
|
return m_sym_file_impl->ParseLineTable(comp_unit);
|
|
}
|
|
|
|
bool SymbolFileOnDemand::ParseDebugMacros(CompileUnit &comp_unit) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return false;
|
|
}
|
|
return m_sym_file_impl->ParseDebugMacros(comp_unit);
|
|
}
|
|
|
|
bool SymbolFileOnDemand::ForEachExternalModule(
|
|
CompileUnit &comp_unit,
|
|
llvm::DenseSet<lldb_private::SymbolFile *> &visited_symbol_files,
|
|
llvm::function_ref<bool(Module &)> lambda) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
// Return false to not early exit.
|
|
return false;
|
|
}
|
|
return m_sym_file_impl->ForEachExternalModule(comp_unit, visited_symbol_files,
|
|
lambda);
|
|
}
|
|
|
|
bool SymbolFileOnDemand::ParseSupportFiles(CompileUnit &comp_unit,
|
|
FileSpecList &support_files) {
|
|
LLDB_LOG(GetLog(),
|
|
"[{0}] {1} is not skipped: explicitly allowed to support breakpoint",
|
|
GetSymbolFileName(), __FUNCTION__);
|
|
// Explicitly allow this API through to support source line breakpoint.
|
|
return m_sym_file_impl->ParseSupportFiles(comp_unit, support_files);
|
|
}
|
|
|
|
bool SymbolFileOnDemand::ParseIsOptimized(CompileUnit &comp_unit) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
|
|
if (log) {
|
|
bool optimized = m_sym_file_impl->ParseIsOptimized(comp_unit);
|
|
if (optimized) {
|
|
LLDB_LOG(log, "Would return optimized if hydrated.");
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
return m_sym_file_impl->ParseIsOptimized(comp_unit);
|
|
}
|
|
|
|
size_t SymbolFileOnDemand::ParseTypes(CompileUnit &comp_unit) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return 0;
|
|
}
|
|
return m_sym_file_impl->ParseTypes(comp_unit);
|
|
}
|
|
|
|
bool SymbolFileOnDemand::ParseImportedModules(
|
|
const lldb_private::SymbolContext &sc,
|
|
std::vector<SourceModule> &imported_modules) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
|
|
if (log) {
|
|
std::vector<SourceModule> tmp_imported_modules;
|
|
bool succeed =
|
|
m_sym_file_impl->ParseImportedModules(sc, tmp_imported_modules);
|
|
if (succeed)
|
|
LLDB_LOG(log, "{0} imported modules would be parsed if hydrated.",
|
|
tmp_imported_modules.size());
|
|
}
|
|
return false;
|
|
}
|
|
return m_sym_file_impl->ParseImportedModules(sc, imported_modules);
|
|
}
|
|
|
|
size_t SymbolFileOnDemand::ParseBlocksRecursive(Function &func) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return 0;
|
|
}
|
|
return m_sym_file_impl->ParseBlocksRecursive(func);
|
|
}
|
|
|
|
size_t SymbolFileOnDemand::ParseVariablesForContext(const SymbolContext &sc) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return 0;
|
|
}
|
|
return m_sym_file_impl->ParseVariablesForContext(sc);
|
|
}
|
|
|
|
Type *SymbolFileOnDemand::ResolveTypeUID(lldb::user_id_t type_uid) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
|
|
if (log) {
|
|
Type *resolved_type = m_sym_file_impl->ResolveTypeUID(type_uid);
|
|
if (resolved_type)
|
|
LLDB_LOG(log, "Type would be parsed for {0} if hydrated.", type_uid);
|
|
}
|
|
return nullptr;
|
|
}
|
|
return m_sym_file_impl->ResolveTypeUID(type_uid);
|
|
}
|
|
|
|
llvm::Optional<SymbolFile::ArrayInfo>
|
|
SymbolFileOnDemand::GetDynamicArrayInfoForUID(
|
|
lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return llvm::None;
|
|
}
|
|
return m_sym_file_impl->GetDynamicArrayInfoForUID(type_uid, exe_ctx);
|
|
}
|
|
|
|
bool SymbolFileOnDemand::CompleteType(CompilerType &compiler_type) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return false;
|
|
}
|
|
return m_sym_file_impl->CompleteType(compiler_type);
|
|
}
|
|
|
|
CompilerDecl SymbolFileOnDemand::GetDeclForUID(lldb::user_id_t type_uid) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
|
|
if (log) {
|
|
CompilerDecl parsed_decl = m_sym_file_impl->GetDeclForUID(type_uid);
|
|
if (parsed_decl != CompilerDecl()) {
|
|
LLDB_LOG(log, "CompilerDecl {0} would be parsed for {1} if hydrated.",
|
|
parsed_decl.GetName(), type_uid);
|
|
}
|
|
}
|
|
return CompilerDecl();
|
|
}
|
|
return m_sym_file_impl->GetDeclForUID(type_uid);
|
|
}
|
|
|
|
CompilerDeclContext
|
|
SymbolFileOnDemand::GetDeclContextForUID(lldb::user_id_t type_uid) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return CompilerDeclContext();
|
|
}
|
|
return m_sym_file_impl->GetDeclContextForUID(type_uid);
|
|
}
|
|
|
|
CompilerDeclContext
|
|
SymbolFileOnDemand::GetDeclContextContainingUID(lldb::user_id_t type_uid) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return CompilerDeclContext();
|
|
}
|
|
return m_sym_file_impl->GetDeclContextContainingUID(type_uid);
|
|
}
|
|
|
|
void SymbolFileOnDemand::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return;
|
|
}
|
|
return m_sym_file_impl->ParseDeclsForContext(decl_ctx);
|
|
}
|
|
|
|
uint32_t
|
|
SymbolFileOnDemand::ResolveSymbolContext(const Address &so_addr,
|
|
SymbolContextItem resolve_scope,
|
|
SymbolContext &sc) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return 0;
|
|
}
|
|
return m_sym_file_impl->ResolveSymbolContext(so_addr, resolve_scope, sc);
|
|
}
|
|
|
|
uint32_t SymbolFileOnDemand::ResolveSymbolContext(
|
|
const SourceLocationSpec &src_location_spec,
|
|
SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return 0;
|
|
}
|
|
return m_sym_file_impl->ResolveSymbolContext(src_location_spec, resolve_scope,
|
|
sc_list);
|
|
}
|
|
|
|
void SymbolFileOnDemand::Dump(lldb_private::Stream &s) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return;
|
|
}
|
|
return m_sym_file_impl->Dump(s);
|
|
}
|
|
|
|
void SymbolFileOnDemand::DumpClangAST(lldb_private::Stream &s) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return;
|
|
}
|
|
return m_sym_file_impl->DumpClangAST(s);
|
|
}
|
|
|
|
void SymbolFileOnDemand::FindGlobalVariables(const RegularExpression ®ex,
|
|
uint32_t max_matches,
|
|
VariableList &variables) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return;
|
|
}
|
|
return m_sym_file_impl->FindGlobalVariables(regex, max_matches, variables);
|
|
}
|
|
|
|
void SymbolFileOnDemand::FindGlobalVariables(
|
|
ConstString name, const CompilerDeclContext &parent_decl_ctx,
|
|
uint32_t max_matches, VariableList &variables) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
Symtab *symtab = GetSymtab();
|
|
if (!symtab) {
|
|
LLDB_LOG(log, "[{0}] {1} is skipped - fail to get symtab",
|
|
GetSymbolFileName(), __FUNCTION__);
|
|
return;
|
|
}
|
|
Symbol *sym = symtab->FindFirstSymbolWithNameAndType(
|
|
name, eSymbolTypeData, Symtab::eDebugAny, Symtab::eVisibilityAny);
|
|
if (!sym) {
|
|
LLDB_LOG(log, "[{0}] {1} is skipped - fail to find match in symtab",
|
|
GetSymbolFileName(), __FUNCTION__);
|
|
return;
|
|
}
|
|
LLDB_LOG(log, "[{0}] {1} is NOT skipped - found match in symtab",
|
|
GetSymbolFileName(), __FUNCTION__);
|
|
|
|
// Found match in symbol table hydrate debug info and
|
|
// allow the FindGlobalVariables to go through.
|
|
SetLoadDebugInfoEnabled();
|
|
}
|
|
return m_sym_file_impl->FindGlobalVariables(name, parent_decl_ctx,
|
|
max_matches, variables);
|
|
}
|
|
|
|
void SymbolFileOnDemand::FindFunctions(const RegularExpression ®ex,
|
|
bool include_inlines,
|
|
SymbolContextList &sc_list) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
Symtab *symtab = GetSymtab();
|
|
if (!symtab) {
|
|
LLDB_LOG(log, "[{0}] {1} is skipped - fail to get symtab",
|
|
GetSymbolFileName(), __FUNCTION__);
|
|
return;
|
|
}
|
|
std::vector<uint32_t> symbol_indexes;
|
|
symtab->AppendSymbolIndexesMatchingRegExAndType(
|
|
regex, eSymbolTypeAny, Symtab::eDebugAny, Symtab::eVisibilityAny,
|
|
symbol_indexes);
|
|
if (symbol_indexes.empty()) {
|
|
LLDB_LOG(log, "[{0}] {1} is skipped - fail to find match in symtab",
|
|
GetSymbolFileName(), __FUNCTION__);
|
|
return;
|
|
}
|
|
LLDB_LOG(log, "[{0}] {1} is NOT skipped - found match in symtab",
|
|
GetSymbolFileName(), __FUNCTION__);
|
|
|
|
// Found match in symbol table hydrate debug info and
|
|
// allow the FindFucntions to go through.
|
|
SetLoadDebugInfoEnabled();
|
|
}
|
|
return m_sym_file_impl->FindFunctions(regex, include_inlines, sc_list);
|
|
}
|
|
|
|
void SymbolFileOnDemand::FindFunctions(
|
|
ConstString name, const CompilerDeclContext &parent_decl_ctx,
|
|
FunctionNameType name_type_mask, bool include_inlines,
|
|
SymbolContextList &sc_list) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
|
|
Symtab *symtab = GetSymtab();
|
|
if (!symtab) {
|
|
LLDB_LOG(log, "[{0}] {1}({2}) is skipped - fail to get symtab",
|
|
GetSymbolFileName(), __FUNCTION__, name);
|
|
return;
|
|
}
|
|
|
|
SymbolContextList sc_list_helper;
|
|
symtab->FindFunctionSymbols(name, name_type_mask, sc_list_helper);
|
|
if (sc_list_helper.GetSize() == 0) {
|
|
LLDB_LOG(log, "[{0}] {1}({2}) is skipped - fail to find match in symtab",
|
|
GetSymbolFileName(), __FUNCTION__, name);
|
|
return;
|
|
}
|
|
LLDB_LOG(log, "[{0}] {1}({2}) is NOT skipped - found match in symtab",
|
|
GetSymbolFileName(), __FUNCTION__, name);
|
|
|
|
// Found match in symbol table hydrate debug info and
|
|
// allow the FindFucntions to go through.
|
|
SetLoadDebugInfoEnabled();
|
|
}
|
|
return m_sym_file_impl->FindFunctions(name, parent_decl_ctx, name_type_mask,
|
|
include_inlines, sc_list);
|
|
}
|
|
|
|
void SymbolFileOnDemand::GetMangledNamesForFunction(
|
|
const std::string &scope_qualified_name,
|
|
std::vector<ConstString> &mangled_names) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
LLDB_LOG(log, "[{0}] {1}({2}) is skipped", GetSymbolFileName(),
|
|
__FUNCTION__, scope_qualified_name);
|
|
return;
|
|
}
|
|
return m_sym_file_impl->GetMangledNamesForFunction(scope_qualified_name,
|
|
mangled_names);
|
|
}
|
|
|
|
void SymbolFileOnDemand::FindTypes(
|
|
ConstString name, const CompilerDeclContext &parent_decl_ctx,
|
|
uint32_t max_matches,
|
|
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
|
|
TypeMap &types) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
LLDB_LOG(log, "[{0}] {1}({2}) is skipped", GetSymbolFileName(),
|
|
__FUNCTION__, name);
|
|
return;
|
|
}
|
|
return m_sym_file_impl->FindTypes(name, parent_decl_ctx, max_matches,
|
|
searched_symbol_files, types);
|
|
}
|
|
|
|
void SymbolFileOnDemand::FindTypes(
|
|
llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
|
|
llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return;
|
|
}
|
|
return m_sym_file_impl->FindTypes(pattern, languages, searched_symbol_files,
|
|
types);
|
|
}
|
|
|
|
void SymbolFileOnDemand::GetTypes(SymbolContextScope *sc_scope,
|
|
TypeClass type_mask, TypeList &type_list) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return;
|
|
}
|
|
return m_sym_file_impl->GetTypes(sc_scope, type_mask, type_list);
|
|
}
|
|
|
|
llvm::Expected<TypeSystem &>
|
|
SymbolFileOnDemand::GetTypeSystemForLanguage(LanguageType language) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
LLDB_LOG(log, "[{0}] {1} is skipped for language type {2}",
|
|
GetSymbolFileName(), __FUNCTION__, language);
|
|
return llvm::make_error<llvm::StringError>(
|
|
"GetTypeSystemForLanguage is skipped by SymbolFileOnDemand",
|
|
llvm::inconvertibleErrorCode());
|
|
}
|
|
return m_sym_file_impl->GetTypeSystemForLanguage(language);
|
|
}
|
|
|
|
CompilerDeclContext
|
|
SymbolFileOnDemand::FindNamespace(ConstString name,
|
|
const CompilerDeclContext &parent_decl_ctx) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1}({2}) is skipped", GetSymbolFileName(),
|
|
__FUNCTION__, name);
|
|
return SymbolFile::FindNamespace(name, parent_decl_ctx);
|
|
}
|
|
return m_sym_file_impl->FindNamespace(name, parent_decl_ctx);
|
|
}
|
|
|
|
std::vector<std::unique_ptr<lldb_private::CallEdge>>
|
|
SymbolFileOnDemand::ParseCallEdgesInFunction(UserID func_id) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
|
|
if (log) {
|
|
std::vector<std::unique_ptr<lldb_private::CallEdge>> call_edges =
|
|
m_sym_file_impl->ParseCallEdgesInFunction(func_id);
|
|
if (call_edges.size() > 0) {
|
|
LLDB_LOG(log, "{0} call edges would be parsed for {1} if hydrated.",
|
|
call_edges.size(), func_id.GetID());
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
return m_sym_file_impl->ParseCallEdgesInFunction(func_id);
|
|
}
|
|
|
|
lldb::UnwindPlanSP
|
|
SymbolFileOnDemand::GetUnwindPlan(const Address &address,
|
|
const RegisterInfoResolver &resolver) {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return nullptr;
|
|
}
|
|
return m_sym_file_impl->GetUnwindPlan(address, resolver);
|
|
}
|
|
|
|
llvm::Expected<lldb::addr_t>
|
|
SymbolFileOnDemand::GetParameterStackSize(Symbol &symbol) {
|
|
if (!m_debug_info_enabled) {
|
|
Log *log = GetLog();
|
|
LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
|
|
if (log) {
|
|
llvm::Expected<lldb::addr_t> stack_size =
|
|
m_sym_file_impl->GetParameterStackSize(symbol);
|
|
if (stack_size) {
|
|
LLDB_LOG(log, "{0} stack size would return for symbol {1} if hydrated.",
|
|
*stack_size, symbol.GetName());
|
|
}
|
|
}
|
|
return SymbolFile::GetParameterStackSize(symbol);
|
|
}
|
|
return m_sym_file_impl->GetParameterStackSize(symbol);
|
|
}
|
|
|
|
void SymbolFileOnDemand::PreloadSymbols() {
|
|
m_preload_symbols = true;
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return;
|
|
}
|
|
return m_sym_file_impl->PreloadSymbols();
|
|
}
|
|
|
|
uint64_t SymbolFileOnDemand::GetDebugInfoSize() {
|
|
// Always return the real debug info size.
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is not skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return m_sym_file_impl->GetDebugInfoSize();
|
|
}
|
|
|
|
StatsDuration::Duration SymbolFileOnDemand::GetDebugInfoParseTime() {
|
|
// Always return the real parse time.
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is not skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return m_sym_file_impl->GetDebugInfoParseTime();
|
|
}
|
|
|
|
StatsDuration::Duration SymbolFileOnDemand::GetDebugInfoIndexTime() {
|
|
// Always return the real index time.
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is not skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return m_sym_file_impl->GetDebugInfoIndexTime();
|
|
}
|
|
|
|
void SymbolFileOnDemand::SetLoadDebugInfoEnabled() {
|
|
if (m_debug_info_enabled)
|
|
return;
|
|
LLDB_LOG(GetLog(), "[{0}] Hydrate debug info", GetSymbolFileName());
|
|
m_debug_info_enabled = true;
|
|
InitializeObject();
|
|
if (m_preload_symbols)
|
|
PreloadSymbols();
|
|
}
|
|
|
|
uint32_t SymbolFileOnDemand::GetNumCompileUnits() {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is not skipped to support breakpoint hydration",
|
|
GetSymbolFileName(), __FUNCTION__);
|
|
return m_sym_file_impl->GetNumCompileUnits();
|
|
}
|
|
|
|
CompUnitSP SymbolFileOnDemand::GetCompileUnitAtIndex(uint32_t idx) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is not skipped to support breakpoint hydration",
|
|
GetSymbolFileName(), __FUNCTION__);
|
|
return m_sym_file_impl->GetCompileUnitAtIndex(idx);
|
|
}
|
|
|
|
uint32_t SymbolFileOnDemand::GetAbilities() {
|
|
if (!m_debug_info_enabled) {
|
|
LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
|
|
__FUNCTION__);
|
|
return 0;
|
|
}
|
|
return m_sym_file_impl->GetAbilities();
|
|
}
|