You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
432 lines
15 KiB
432 lines
15 KiB
//===-- BreakpointResolverName.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/Breakpoint/BreakpointResolverName.h"
|
|
|
|
#include "lldb/Breakpoint/BreakpointLocation.h"
|
|
#include "lldb/Core/Architecture.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Symbol/Block.h"
|
|
#include "lldb/Symbol/Function.h"
|
|
#include "lldb/Symbol/Symbol.h"
|
|
#include "lldb/Symbol/SymbolContext.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/Language.h"
|
|
#include "lldb/Utility/Log.h"
|
|
#include "lldb/Utility/StreamString.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
BreakpointResolverName::BreakpointResolverName(const BreakpointSP &bkpt,
|
|
const char *name_cstr, FunctionNameType name_type_mask,
|
|
LanguageType language, Breakpoint::MatchType type, lldb::addr_t offset,
|
|
bool skip_prologue)
|
|
: BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
|
|
m_class_name(), m_regex(), m_match_type(type), m_language(language),
|
|
m_skip_prologue(skip_prologue) {
|
|
if (m_match_type == Breakpoint::Regexp) {
|
|
m_regex = RegularExpression(llvm::StringRef::withNullAsEmpty(name_cstr));
|
|
if (!m_regex.IsValid()) {
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
|
|
|
|
if (log)
|
|
log->Warning("function name regexp: \"%s\" did not compile.",
|
|
name_cstr);
|
|
}
|
|
} else {
|
|
AddNameLookup(ConstString(name_cstr), name_type_mask);
|
|
}
|
|
}
|
|
|
|
BreakpointResolverName::BreakpointResolverName(
|
|
const BreakpointSP &bkpt, const char *names[], size_t num_names,
|
|
FunctionNameType name_type_mask, LanguageType language, lldb::addr_t offset,
|
|
bool skip_prologue)
|
|
: BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
|
|
m_match_type(Breakpoint::Exact), m_language(language),
|
|
m_skip_prologue(skip_prologue) {
|
|
for (size_t i = 0; i < num_names; i++) {
|
|
AddNameLookup(ConstString(names[i]), name_type_mask);
|
|
}
|
|
}
|
|
|
|
BreakpointResolverName::BreakpointResolverName(const BreakpointSP &bkpt,
|
|
std::vector<std::string> names,
|
|
FunctionNameType name_type_mask,
|
|
LanguageType language,
|
|
lldb::addr_t offset,
|
|
bool skip_prologue)
|
|
: BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
|
|
m_match_type(Breakpoint::Exact), m_language(language),
|
|
m_skip_prologue(skip_prologue) {
|
|
for (const std::string &name : names) {
|
|
AddNameLookup(ConstString(name.c_str(), name.size()), name_type_mask);
|
|
}
|
|
}
|
|
|
|
BreakpointResolverName::BreakpointResolverName(const BreakpointSP &bkpt,
|
|
RegularExpression func_regex,
|
|
lldb::LanguageType language,
|
|
lldb::addr_t offset,
|
|
bool skip_prologue)
|
|
: BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
|
|
m_class_name(nullptr), m_regex(std::move(func_regex)),
|
|
m_match_type(Breakpoint::Regexp), m_language(language),
|
|
m_skip_prologue(skip_prologue) {}
|
|
|
|
BreakpointResolverName::BreakpointResolverName(
|
|
const BreakpointResolverName &rhs)
|
|
: BreakpointResolver(rhs.GetBreakpoint(), BreakpointResolver::NameResolver,
|
|
rhs.GetOffset()),
|
|
m_lookups(rhs.m_lookups), m_class_name(rhs.m_class_name),
|
|
m_regex(rhs.m_regex), m_match_type(rhs.m_match_type),
|
|
m_language(rhs.m_language), m_skip_prologue(rhs.m_skip_prologue) {}
|
|
|
|
BreakpointResolver *BreakpointResolverName::CreateFromStructuredData(
|
|
const BreakpointSP &bkpt, const StructuredData::Dictionary &options_dict,
|
|
Status &error) {
|
|
LanguageType language = eLanguageTypeUnknown;
|
|
llvm::StringRef language_name;
|
|
bool success = options_dict.GetValueForKeyAsString(
|
|
GetKey(OptionNames::LanguageName), language_name);
|
|
if (success) {
|
|
language = Language::GetLanguageTypeFromString(language_name);
|
|
if (language == eLanguageTypeUnknown) {
|
|
error.SetErrorStringWithFormatv("BRN::CFSD: Unknown language: {0}.",
|
|
language_name);
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
lldb::addr_t offset = 0;
|
|
success =
|
|
options_dict.GetValueForKeyAsInteger(GetKey(OptionNames::Offset), offset);
|
|
if (!success) {
|
|
error.SetErrorString("BRN::CFSD: Missing offset entry.");
|
|
return nullptr;
|
|
}
|
|
|
|
bool skip_prologue;
|
|
success = options_dict.GetValueForKeyAsBoolean(
|
|
GetKey(OptionNames::SkipPrologue), skip_prologue);
|
|
if (!success) {
|
|
error.SetErrorString("BRN::CFSD: Missing Skip prologue entry.");
|
|
return nullptr;
|
|
}
|
|
|
|
llvm::StringRef regex_text;
|
|
success = options_dict.GetValueForKeyAsString(
|
|
GetKey(OptionNames::RegexString), regex_text);
|
|
if (success) {
|
|
return new BreakpointResolverName(bkpt, RegularExpression(regex_text),
|
|
language, offset, skip_prologue);
|
|
} else {
|
|
StructuredData::Array *names_array;
|
|
success = options_dict.GetValueForKeyAsArray(
|
|
GetKey(OptionNames::SymbolNameArray), names_array);
|
|
if (!success) {
|
|
error.SetErrorString("BRN::CFSD: Missing symbol names entry.");
|
|
return nullptr;
|
|
}
|
|
StructuredData::Array *names_mask_array;
|
|
success = options_dict.GetValueForKeyAsArray(
|
|
GetKey(OptionNames::NameMaskArray), names_mask_array);
|
|
if (!success) {
|
|
error.SetErrorString("BRN::CFSD: Missing symbol names mask entry.");
|
|
return nullptr;
|
|
}
|
|
|
|
size_t num_elem = names_array->GetSize();
|
|
if (num_elem != names_mask_array->GetSize()) {
|
|
error.SetErrorString(
|
|
"BRN::CFSD: names and names mask arrays have different sizes.");
|
|
return nullptr;
|
|
}
|
|
|
|
if (num_elem == 0) {
|
|
error.SetErrorString(
|
|
"BRN::CFSD: no name entry in a breakpoint by name breakpoint.");
|
|
return nullptr;
|
|
}
|
|
std::vector<std::string> names;
|
|
std::vector<FunctionNameType> name_masks;
|
|
for (size_t i = 0; i < num_elem; i++) {
|
|
llvm::StringRef name;
|
|
|
|
success = names_array->GetItemAtIndexAsString(i, name);
|
|
if (!success) {
|
|
error.SetErrorString("BRN::CFSD: name entry is not a string.");
|
|
return nullptr;
|
|
}
|
|
std::underlying_type<FunctionNameType>::type fnt;
|
|
success = names_mask_array->GetItemAtIndexAsInteger(i, fnt);
|
|
if (!success) {
|
|
error.SetErrorString("BRN::CFSD: name mask entry is not an integer.");
|
|
return nullptr;
|
|
}
|
|
names.push_back(std::string(name));
|
|
name_masks.push_back(static_cast<FunctionNameType>(fnt));
|
|
}
|
|
|
|
BreakpointResolverName *resolver = new BreakpointResolverName(
|
|
bkpt, names[0].c_str(), name_masks[0], language,
|
|
Breakpoint::MatchType::Exact, offset, skip_prologue);
|
|
for (size_t i = 1; i < num_elem; i++) {
|
|
resolver->AddNameLookup(ConstString(names[i]), name_masks[i]);
|
|
}
|
|
return resolver;
|
|
}
|
|
}
|
|
|
|
StructuredData::ObjectSP BreakpointResolverName::SerializeToStructuredData() {
|
|
StructuredData::DictionarySP options_dict_sp(
|
|
new StructuredData::Dictionary());
|
|
|
|
if (m_regex.IsValid()) {
|
|
options_dict_sp->AddStringItem(GetKey(OptionNames::RegexString),
|
|
m_regex.GetText());
|
|
} else {
|
|
StructuredData::ArraySP names_sp(new StructuredData::Array());
|
|
StructuredData::ArraySP name_masks_sp(new StructuredData::Array());
|
|
for (auto lookup : m_lookups) {
|
|
names_sp->AddItem(StructuredData::StringSP(
|
|
new StructuredData::String(lookup.GetName().GetStringRef())));
|
|
name_masks_sp->AddItem(StructuredData::IntegerSP(
|
|
new StructuredData::Integer(lookup.GetNameTypeMask())));
|
|
}
|
|
options_dict_sp->AddItem(GetKey(OptionNames::SymbolNameArray), names_sp);
|
|
options_dict_sp->AddItem(GetKey(OptionNames::NameMaskArray), name_masks_sp);
|
|
}
|
|
if (m_language != eLanguageTypeUnknown)
|
|
options_dict_sp->AddStringItem(
|
|
GetKey(OptionNames::LanguageName),
|
|
Language::GetNameForLanguageType(m_language));
|
|
options_dict_sp->AddBooleanItem(GetKey(OptionNames::SkipPrologue),
|
|
m_skip_prologue);
|
|
|
|
return WrapOptionsDict(options_dict_sp);
|
|
}
|
|
|
|
void BreakpointResolverName::AddNameLookup(ConstString name,
|
|
FunctionNameType name_type_mask) {
|
|
|
|
Module::LookupInfo lookup(name, name_type_mask, m_language);
|
|
m_lookups.emplace_back(lookup);
|
|
|
|
auto add_variant_funcs = [&](Language *lang) {
|
|
for (ConstString variant_name : lang->GetMethodNameVariants(name)) {
|
|
Module::LookupInfo variant_lookup(name, name_type_mask,
|
|
lang->GetLanguageType());
|
|
variant_lookup.SetLookupName(variant_name);
|
|
m_lookups.emplace_back(variant_lookup);
|
|
}
|
|
return true;
|
|
};
|
|
|
|
if (Language *lang = Language::FindPlugin(m_language)) {
|
|
add_variant_funcs(lang);
|
|
} else {
|
|
// Most likely m_language is eLanguageTypeUnknown. We check each language for
|
|
// possible variants or more qualified names and create lookups for those as
|
|
// well.
|
|
Language::ForEach(add_variant_funcs);
|
|
}
|
|
}
|
|
|
|
// FIXME: Right now we look at the module level, and call the module's
|
|
// "FindFunctions".
|
|
// Greg says he will add function tables, maybe at the CompileUnit level to
|
|
// accelerate function lookup. At that point, we should switch the depth to
|
|
// CompileUnit, and look in these tables.
|
|
|
|
Searcher::CallbackReturn
|
|
BreakpointResolverName::SearchCallback(SearchFilter &filter,
|
|
SymbolContext &context, Address *addr) {
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
|
|
|
|
if (m_class_name) {
|
|
if (log)
|
|
log->Warning("Class/method function specification not supported yet.\n");
|
|
return Searcher::eCallbackReturnStop;
|
|
}
|
|
|
|
SymbolContextList func_list;
|
|
bool filter_by_cu =
|
|
(filter.GetFilterRequiredItems() & eSymbolContextCompUnit) != 0;
|
|
bool filter_by_language = (m_language != eLanguageTypeUnknown);
|
|
const bool include_symbols = !filter_by_cu;
|
|
const bool include_inlines = true;
|
|
|
|
switch (m_match_type) {
|
|
case Breakpoint::Exact:
|
|
if (context.module_sp) {
|
|
for (const auto &lookup : m_lookups) {
|
|
const size_t start_func_idx = func_list.GetSize();
|
|
context.module_sp->FindFunctions(
|
|
lookup.GetLookupName(), CompilerDeclContext(),
|
|
lookup.GetNameTypeMask(), include_symbols, include_inlines,
|
|
func_list);
|
|
|
|
const size_t end_func_idx = func_list.GetSize();
|
|
|
|
if (start_func_idx < end_func_idx)
|
|
lookup.Prune(func_list, start_func_idx);
|
|
}
|
|
}
|
|
break;
|
|
case Breakpoint::Regexp:
|
|
if (context.module_sp) {
|
|
context.module_sp->FindFunctions(
|
|
m_regex,
|
|
!filter_by_cu, // include symbols only if we aren't filtering by CU
|
|
include_inlines, func_list);
|
|
}
|
|
break;
|
|
case Breakpoint::Glob:
|
|
if (log)
|
|
log->Warning("glob is not supported yet.");
|
|
break;
|
|
}
|
|
|
|
// If the filter specifies a Compilation Unit, remove the ones that don't
|
|
// pass at this point.
|
|
if (filter_by_cu || filter_by_language) {
|
|
uint32_t num_functions = func_list.GetSize();
|
|
|
|
for (size_t idx = 0; idx < num_functions; idx++) {
|
|
bool remove_it = false;
|
|
SymbolContext sc;
|
|
func_list.GetContextAtIndex(idx, sc);
|
|
if (filter_by_cu) {
|
|
if (!sc.comp_unit || !filter.CompUnitPasses(*sc.comp_unit))
|
|
remove_it = true;
|
|
}
|
|
|
|
if (filter_by_language) {
|
|
LanguageType sym_language = sc.GetLanguage();
|
|
if ((Language::GetPrimaryLanguage(sym_language) !=
|
|
Language::GetPrimaryLanguage(m_language)) &&
|
|
(sym_language != eLanguageTypeUnknown)) {
|
|
remove_it = true;
|
|
}
|
|
}
|
|
|
|
if (remove_it) {
|
|
func_list.RemoveContextAtIndex(idx);
|
|
num_functions--;
|
|
idx--;
|
|
}
|
|
}
|
|
}
|
|
|
|
BreakpointSP breakpoint_sp = GetBreakpoint();
|
|
Breakpoint &breakpoint = *breakpoint_sp;
|
|
Address break_addr;
|
|
|
|
// Remove any duplicates between the function list and the symbol list
|
|
SymbolContext sc;
|
|
if (!func_list.GetSize())
|
|
return Searcher::eCallbackReturnContinue;
|
|
|
|
for (uint32_t i = 0; i < func_list.GetSize(); i++) {
|
|
if (!func_list.GetContextAtIndex(i, sc))
|
|
continue;
|
|
|
|
bool is_reexported = false;
|
|
|
|
if (sc.block && sc.block->GetInlinedFunctionInfo()) {
|
|
if (!sc.block->GetStartAddress(break_addr))
|
|
break_addr.Clear();
|
|
} else if (sc.function) {
|
|
break_addr = sc.function->GetAddressRange().GetBaseAddress();
|
|
if (m_skip_prologue && break_addr.IsValid()) {
|
|
const uint32_t prologue_byte_size = sc.function->GetPrologueByteSize();
|
|
if (prologue_byte_size)
|
|
break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size);
|
|
}
|
|
} else if (sc.symbol) {
|
|
if (sc.symbol->GetType() == eSymbolTypeReExported) {
|
|
const Symbol *actual_symbol =
|
|
sc.symbol->ResolveReExportedSymbol(breakpoint.GetTarget());
|
|
if (actual_symbol) {
|
|
is_reexported = true;
|
|
break_addr = actual_symbol->GetAddress();
|
|
}
|
|
} else {
|
|
break_addr = sc.symbol->GetAddress();
|
|
}
|
|
|
|
if (m_skip_prologue && break_addr.IsValid()) {
|
|
const uint32_t prologue_byte_size = sc.symbol->GetPrologueByteSize();
|
|
if (prologue_byte_size)
|
|
break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size);
|
|
else {
|
|
const Architecture *arch =
|
|
breakpoint.GetTarget().GetArchitecturePlugin();
|
|
if (arch)
|
|
arch->AdjustBreakpointAddress(*sc.symbol, break_addr);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!break_addr.IsValid())
|
|
continue;
|
|
|
|
if (!filter.AddressPasses(break_addr))
|
|
continue;
|
|
|
|
bool new_location;
|
|
BreakpointLocationSP bp_loc_sp(AddLocation(break_addr, &new_location));
|
|
bp_loc_sp->SetIsReExported(is_reexported);
|
|
if (bp_loc_sp && new_location && !breakpoint.IsInternal()) {
|
|
if (log) {
|
|
StreamString s;
|
|
bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
|
|
LLDB_LOGF(log, "Added location: %s\n", s.GetData());
|
|
}
|
|
}
|
|
}
|
|
|
|
return Searcher::eCallbackReturnContinue;
|
|
}
|
|
|
|
lldb::SearchDepth BreakpointResolverName::GetDepth() {
|
|
return lldb::eSearchDepthModule;
|
|
}
|
|
|
|
void BreakpointResolverName::GetDescription(Stream *s) {
|
|
if (m_match_type == Breakpoint::Regexp)
|
|
s->Printf("regex = '%s'", m_regex.GetText().str().c_str());
|
|
else {
|
|
size_t num_names = m_lookups.size();
|
|
if (num_names == 1)
|
|
s->Printf("name = '%s'", m_lookups[0].GetName().GetCString());
|
|
else {
|
|
s->Printf("names = {");
|
|
for (size_t i = 0; i < num_names; i++) {
|
|
s->Printf("%s'%s'", (i == 0 ? "" : ", "),
|
|
m_lookups[i].GetName().GetCString());
|
|
}
|
|
s->Printf("}");
|
|
}
|
|
}
|
|
if (m_language != eLanguageTypeUnknown) {
|
|
s->Printf(", language = %s", Language::GetNameForLanguageType(m_language));
|
|
}
|
|
}
|
|
|
|
void BreakpointResolverName::Dump(Stream *s) const {}
|
|
|
|
lldb::BreakpointResolverSP
|
|
BreakpointResolverName::CopyForBreakpoint(BreakpointSP &breakpoint) {
|
|
lldb::BreakpointResolverSP ret_sp(new BreakpointResolverName(*this));
|
|
ret_sp->SetBreakpoint(breakpoint);
|
|
return ret_sp;
|
|
}
|