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
88 lines
3.2 KiB
C++
88 lines
3.2 KiB
C++
//===-- DWARFIndex.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 "Plugins/SymbolFile/DWARF/DWARFIndex.h"
|
|
#include "Plugins/Language/ObjC/ObjCLanguage.h"
|
|
#include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
|
|
#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
|
|
|
|
#include "lldb/Core/Module.h"
|
|
|
|
using namespace lldb_private;
|
|
using namespace lldb;
|
|
|
|
DWARFIndex::~DWARFIndex() = default;
|
|
|
|
bool DWARFIndex::ProcessFunctionDIE(
|
|
llvm::StringRef name, DIERef ref, SymbolFileDWARF &dwarf,
|
|
const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
|
|
llvm::function_ref<bool(DWARFDIE die)> callback) {
|
|
DWARFDIE die = dwarf.GetDIE(ref);
|
|
if (!die) {
|
|
ReportInvalidDIERef(ref, name);
|
|
return true;
|
|
}
|
|
|
|
// Exit early if we're searching exclusively for methods or selectors and
|
|
// we have a context specified (no methods in namespaces).
|
|
uint32_t looking_for_nonmethods =
|
|
name_type_mask & ~(eFunctionNameTypeMethod | eFunctionNameTypeSelector);
|
|
if (!looking_for_nonmethods && parent_decl_ctx.IsValid())
|
|
return true;
|
|
|
|
// Otherwise, we need to also check that the context matches. If it does not
|
|
// match, we do nothing.
|
|
if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
|
|
return true;
|
|
|
|
// In case of a full match, we just insert everything we find.
|
|
if (name_type_mask & eFunctionNameTypeFull && die.GetMangledName() == name)
|
|
return callback(die);
|
|
|
|
// If looking for ObjC selectors, we need to also check if the name is a
|
|
// possible selector.
|
|
if (name_type_mask & eFunctionNameTypeSelector &&
|
|
ObjCLanguage::IsPossibleObjCMethodName(die.GetName()))
|
|
return callback(die);
|
|
|
|
bool looking_for_methods = name_type_mask & lldb::eFunctionNameTypeMethod;
|
|
bool looking_for_functions = name_type_mask & lldb::eFunctionNameTypeBase;
|
|
if (looking_for_methods || looking_for_functions) {
|
|
// If we're looking for either methods or functions, we definitely want this
|
|
// die. Otherwise, only keep it if the die type matches what we are
|
|
// searching for.
|
|
if ((looking_for_methods && looking_for_functions) ||
|
|
looking_for_methods == die.IsMethod())
|
|
return callback(die);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
DWARFIndex::DIERefCallbackImpl::DIERefCallbackImpl(
|
|
const DWARFIndex &index, llvm::function_ref<bool(DWARFDIE die)> callback,
|
|
llvm::StringRef name)
|
|
: m_index(index),
|
|
m_dwarf(*llvm::cast<SymbolFileDWARF>(
|
|
index.m_module.GetSymbolFile()->GetBackingSymbolFile())),
|
|
m_callback(callback), m_name(name) {}
|
|
|
|
bool DWARFIndex::DIERefCallbackImpl::operator()(DIERef ref) const {
|
|
if (DWARFDIE die = m_dwarf.GetDIE(ref))
|
|
return m_callback(die);
|
|
m_index.ReportInvalidDIERef(ref, m_name);
|
|
return true;
|
|
}
|
|
|
|
void DWARFIndex::ReportInvalidDIERef(DIERef ref, llvm::StringRef name) const {
|
|
m_module.ReportErrorIfModifyDetected(
|
|
"the DWARF debug information has been modified (accelerator table had "
|
|
"bad die 0x%8.8x for '%s')\n",
|
|
ref.die_offset(), name.str().c_str());
|
|
}
|