* [PATCH 1/9] gdb: add symbol_search_kind enum for global_symbol_searcher
2026-09-29 19:39 [PATCH 0/9] Cleanups in global_symbol_searcher Simon Marchi
@ 2026-09-29 19:39 ` Simon Marchi
2026-09-29 19:39 ` [PATCH 2/9] gdb: factor out regexp compilation from global_symbol_searcher::search Simon Marchi
` (7 subsequent siblings)
8 siblings, 0 replies; 10+ messages in thread
From: Simon Marchi @ 2026-09-29 19:39 UTC (permalink / raw)
To: gdb-patches; +Cc: Simon Marchi
While reading the global_symbol_searcher code, something that was not
clear to me was that despite accepting a domain_search_flags, searches
are mutually exclusive between types, variables and functions.
One snippet of code that really confused me was (now removed by a
previous commit):
if ((kind & SEARCH_FUNCTION_DOMAIN) != 0
? (find_compunit_symtab_for_pc
(msymbol->value_address (objfile)) == NULL)
: (lookup_symbol_in_objfile_from_linkage_name
(objfile, msymbol->linkage_name (),
SEARCH_VFT)
.symbol == NULL))
I kept thinking: what if you search for both functions and variables,
this will take the "function" path, this can't work. The answer is that
it's not supposed to happen.
This patch adds the symbol_search_kind enum and uses it in
global_symbol_searcher (and a few caller functions), making it clear
that you search just one kind at a time.
The new enum has a certain overlap with enum domain_search_flag, but I
think that having the more scoped enum makes global_symbol_searcher
easier to understand, by specifying clearly what it needs to handle.
Change-Id: I4a3f4752c7be51a4da5831f9780d21e6e7271b38
---
gdb/mi/mi-symbol-cmds.c | 36 +++++++------
gdb/python/python.c | 2 +-
gdb/symtab.c | 112 ++++++++++++++++++++++------------------
gdb/symtab.h | 33 ++++++++----
4 files changed, 106 insertions(+), 77 deletions(-)
diff --git a/gdb/mi/mi-symbol-cmds.c b/gdb/mi/mi-symbol-cmds.c
index 58f2feef5533..30b8ec495e8f 100644
--- a/gdb/mi/mi-symbol-cmds.c
+++ b/gdb/mi/mi-symbol-cmds.c
@@ -71,7 +71,7 @@ mi_cmd_symbol_list_lines (const char *command, const char *const *argv,
results. */
static void
-output_debug_symbol (ui_out *uiout, domain_search_flags kind,
+output_debug_symbol (ui_out *uiout, symbol_search_kind kind,
struct symbol *sym, int block)
{
ui_out_emit_tuple tuple_emitter (uiout);
@@ -80,7 +80,8 @@ output_debug_symbol (ui_out *uiout, domain_search_flags kind,
uiout->field_unsigned ("line", sym->line ());
uiout->field_string ("name", sym->print_name ());
- if ((kind & (SEARCH_FUNCTION_DOMAIN | SEARCH_VAR_DOMAIN)) != 0)
+ if (kind == symbol_search_kind::FUNCTION
+ || kind == symbol_search_kind::VARIABLE)
{
string_file tmp_stream;
type_print (sym->type (), "", &tmp_stream, -1);
@@ -111,7 +112,7 @@ output_nondebug_symbol (ui_out *uiout, const bound_minimal_symbol &msymbol)
and then prints the matching [m]symbols in an MI structured format. */
static void
-mi_symbol_info (domain_search_flags kind, const char *name_regexp,
+mi_symbol_info (symbol_search_kind kind, const char *name_regexp,
const char *type_regexp, bool exclude_minsyms,
size_t max_results)
{
@@ -188,7 +189,7 @@ parse_max_results_option (const char *arg)
Processes command line options from ARGV and ARGC. */
static void
-mi_info_functions_or_variables (domain_search_flags kind,
+mi_info_functions_or_variables (symbol_search_kind kind,
const char *const *argv, int argc)
{
size_t max_results = SIZE_MAX;
@@ -215,7 +216,7 @@ mi_info_functions_or_variables (domain_search_flags kind,
while (1)
{
const char *cmd_string
- = ((kind == SEARCH_FUNCTION_DOMAIN)
+ = ((kind == symbol_search_kind::FUNCTION)
? "-symbol-info-functions" : "-symbol-info-variables");
int opt = mi_getopt (cmd_string, argc, argv, opts, &oind, &oarg);
if (opt < 0)
@@ -251,7 +252,7 @@ using module_symbol_search_iterator
static module_symbol_search_iterator
output_module_symbols_in_single_module_and_file
(struct ui_out *uiout, module_symbol_search_iterator iter,
- const module_symbol_search_iterator end, domain_search_flags kind)
+ const module_symbol_search_iterator end, symbol_search_kind kind)
{
/* The symbol for the module in which the first result resides. */
const symbol *first_module_symbol = iter->first.symbol;
@@ -286,7 +287,7 @@ output_module_symbols_in_single_module_and_file
static module_symbol_search_iterator
output_module_symbols_in_single_module
(struct ui_out *uiout, module_symbol_search_iterator iter,
- const module_symbol_search_iterator end, domain_search_flags kind)
+ const module_symbol_search_iterator end, symbol_search_kind kind)
{
gdb_assert (iter->first.symbol != nullptr);
gdb_assert (iter->second.symbol != nullptr);
@@ -314,7 +315,7 @@ output_module_symbols_in_single_module
command line options passed to the MI command. */
static void
-mi_info_module_functions_or_variables (domain_search_flags kind,
+mi_info_module_functions_or_variables (symbol_search_kind kind,
const char *const *argv, int argc)
{
const char *module_regexp = nullptr;
@@ -341,7 +342,7 @@ mi_info_module_functions_or_variables (domain_search_flags kind,
while (1)
{
const char *cmd_string
- = ((kind == SEARCH_FUNCTION_DOMAIN)
+ = ((kind == symbol_search_kind::FUNCTION)
? "-symbol-info-module-functions"
: "-symbol-info-module-variables");
int opt = mi_getopt (cmd_string, argc, argv, opts, &oind, &oarg);
@@ -383,7 +384,7 @@ void
mi_cmd_symbol_info_functions (const char *command, const char *const *argv,
int argc)
{
- mi_info_functions_or_variables (SEARCH_FUNCTION_DOMAIN, argv, argc);
+ mi_info_functions_or_variables (symbol_search_kind::FUNCTION, argv, argc);
}
/* Implement -symbol-info-module-functions command. */
@@ -392,7 +393,8 @@ void
mi_cmd_symbol_info_module_functions (const char *command,
const char *const *argv, int argc)
{
- mi_info_module_functions_or_variables (SEARCH_FUNCTION_DOMAIN, argv, argc);
+ mi_info_module_functions_or_variables (symbol_search_kind::FUNCTION,
+ argv, argc);
}
/* Implement -symbol-info-module-variables command. */
@@ -401,7 +403,8 @@ void
mi_cmd_symbol_info_module_variables (const char *command,
const char *const *argv, int argc)
{
- mi_info_module_functions_or_variables (SEARCH_VAR_DOMAIN, argv, argc);
+ mi_info_module_functions_or_variables (symbol_search_kind::VARIABLE,
+ argv, argc);
}
/* Implement -symbol-inf-modules command. */
@@ -444,7 +447,8 @@ mi_cmd_symbol_info_modules (const char *command, const char *const *argv,
}
}
- mi_symbol_info (SEARCH_MODULE_DOMAIN, regexp, nullptr, true, max_results);
+ mi_symbol_info (symbol_search_kind::MODULE, regexp, nullptr, true,
+ max_results);
}
/* Implement -symbol-info-types command. */
@@ -487,8 +491,8 @@ mi_cmd_symbol_info_types (const char *command, const char *const *argv,
}
}
- mi_symbol_info (SEARCH_TYPE_DOMAIN | SEARCH_STRUCT_DOMAIN, regexp, nullptr,
- true, max_results);
+ mi_symbol_info (symbol_search_kind::TYPE, regexp, nullptr, true,
+ max_results);
}
/* Implement -symbol-info-variables command. */
@@ -497,5 +501,5 @@ void
mi_cmd_symbol_info_variables (const char *command, const char *const *argv,
int argc)
{
- mi_info_functions_or_variables (SEARCH_VAR_DOMAIN, argv, argc);
+ mi_info_functions_or_variables (symbol_search_kind::VARIABLE, argv, argc);
}
diff --git a/gdb/python/python.c b/gdb/python/python.c
index d51cd83966be..467317b7996e 100644
--- a/gdb/python/python.c
+++ b/gdb/python/python.c
@@ -848,7 +848,7 @@ gdbpy_rbreak (PyObject *self, PyObject *args, PyObject *kw)
minsyms_p = cmp;
}
- global_symbol_searcher spec (SEARCH_FUNCTION_DOMAIN, regex);
+ global_symbol_searcher spec (symbol_search_kind::FUNCTION, regex);
/* The "symtabs" keyword is any Python iterable object that returns
a gdb.Symtab on each iteration. If specified, iterate through
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 27070f74f83e..708df078e2ea 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -4698,11 +4698,31 @@ treg_matches_sym_type_name (const compiled_regex &treg,
return treg.exec (printed_sym_type_name.c_str (), 0, NULL, 0) == 0;
}
+/* Return the domain search flags matching symbols of kind KIND. */
+
+static domain_search_flags
+to_search_flags (symbol_search_kind kind)
+{
+ switch (kind)
+ {
+ case symbol_search_kind::VARIABLE:
+ return SEARCH_VAR_DOMAIN;
+ case symbol_search_kind::FUNCTION:
+ return SEARCH_FUNCTION_DOMAIN;
+ case symbol_search_kind::TYPE:
+ return SEARCH_TYPE_DOMAIN | SEARCH_STRUCT_DOMAIN;
+ case symbol_search_kind::MODULE:
+ return SEARCH_MODULE_DOMAIN;
+ }
+
+ gdb_assert_not_reached ("invalid symbol_search_kind");
+}
+
/* See symtab.h. */
bool
global_symbol_searcher::is_suitable_msymbol
- (const domain_search_flags kind, const minimal_symbol *msymbol)
+ (symbol_search_kind kind, const minimal_symbol *msymbol)
{
switch (msymbol->type ())
{
@@ -4710,12 +4730,12 @@ global_symbol_searcher::is_suitable_msymbol
case mst_bss:
case mst_file_data:
case mst_file_bss:
- return (kind & SEARCH_VAR_DOMAIN) != 0;
+ return kind == symbol_search_kind::VARIABLE;
case mst_text:
case mst_file_text:
case mst_solib_trampoline:
case mst_text_gnu_ifunc:
- return (kind & SEARCH_FUNCTION_DOMAIN) != 0;
+ return kind == symbol_search_kind::FUNCTION;
default:
return false;
}
@@ -4727,7 +4747,6 @@ bool
global_symbol_searcher::expand_symtabs
(objfile *objfile, const std::optional<compiled_regex> &preg) const
{
- domain_search_flags kind = m_kind;
bool found_func_msymbol_without_debug_info = false;
auto do_file_match = [&] (const char *filename, bool basenames)
@@ -4748,7 +4767,7 @@ global_symbol_searcher::expand_symtabs
},
NULL,
SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
- kind);
+ to_search_flags (m_kind));
/* Here, we search through the minimal symbol tables for functions that
match, and force their symbols to be read. The symbol will then be found
@@ -4764,7 +4783,7 @@ global_symbol_searcher::expand_symtabs
symtab. When no file names were given the caller unconditionally rescans
the minimal symbols for SEARCH_VAR_DOMAIN. */
if (m_filenames.empty ()
- && (kind & SEARCH_FUNCTION_DOMAIN) != 0)
+ && m_kind == symbol_search_kind::FUNCTION)
{
for (minimal_symbol *msymbol : objfile->msymbols ())
{
@@ -4773,7 +4792,7 @@ global_symbol_searcher::expand_symtabs
if (msymbol->created_by_gdb)
continue;
- if (is_suitable_msymbol (kind, msymbol))
+ if (is_suitable_msymbol (m_kind, msymbol))
{
if (!preg.has_value ()
|| preg->exec (msymbol->natural_name (), 0,
@@ -4804,7 +4823,7 @@ global_symbol_searcher::add_matching_symbols
const std::optional<compiled_regex> &treg,
std::set<symbol_search> *result_set) const
{
- domain_search_flags kind = m_kind;
+ domain_search_flags domain = to_search_flags (m_kind);
/* Add matching symbols (if not already present). */
for (compunit_symtab &cust : objfile->compunits ())
@@ -4832,7 +4851,7 @@ global_symbol_searcher::add_matching_symbols
m_filenames, false))))
continue;
- if (!sym->matches (kind))
+ if (!sym->matches (domain))
continue;
if (preg.has_value () && preg->exec (sym->natural_name (), 0,
@@ -4845,7 +4864,7 @@ global_symbol_searcher::add_matching_symbols
&& !treg_matches_sym_type_name (*treg, sym)))
continue;
- if ((kind & SEARCH_VAR_DOMAIN) != 0)
+ if (m_kind == symbol_search_kind::VARIABLE)
{
if (sym->loc_class () == LOC_UNRESOLVED
/* LOC_CONST can be used for more than
@@ -4882,8 +4901,6 @@ global_symbol_searcher::add_matching_msymbols
(objfile *objfile, const std::optional<compiled_regex> &preg,
std::vector<symbol_search> *results) const
{
- domain_search_flags kind = m_kind;
-
for (minimal_symbol *msymbol : objfile->msymbols ())
{
QUIT;
@@ -4891,7 +4908,7 @@ global_symbol_searcher::add_matching_msymbols
if (msymbol->created_by_gdb)
continue;
- if (is_suitable_msymbol (kind, msymbol))
+ if (is_suitable_msymbol (m_kind, msymbol))
{
if (!preg.has_value ()
|| preg->exec (msymbol->natural_name (), 0,
@@ -4899,7 +4916,7 @@ global_symbol_searcher::add_matching_msymbols
{
/* For functions we can do a quick check of whether the
symbol might be found via find_pc_symtab. */
- if ((kind & SEARCH_FUNCTION_DOMAIN) == 0
+ if (m_kind != symbol_search_kind::FUNCTION
|| (find_compunit_symtab_for_pc
(msymbol->value_address (objfile)) == NULL))
{
@@ -5006,12 +5023,12 @@ global_symbol_searcher::search () const
minimal symbol, as we assume that a minimal symbol does not have a
type. */
if ((found_func_msymbol_without_debug_info
- || (m_filenames.empty () && (m_kind & SEARCH_VAR_DOMAIN) != 0))
+ || (m_filenames.empty () && m_kind == symbol_search_kind::VARIABLE))
&& !m_exclude_minsyms
&& !treg.has_value ())
{
- gdb_assert ((m_kind & (SEARCH_VAR_DOMAIN | SEARCH_FUNCTION_DOMAIN))
- != 0);
+ gdb_assert (m_kind == symbol_search_kind::VARIABLE
+ || m_kind == symbol_search_kind::FUNCTION);
for (objfile &objfile : current_program_space->objfiles ())
if (!add_matching_msymbols (&objfile, preg, &result))
break;
@@ -5143,7 +5160,7 @@ print_msymbol_info (bound_minimal_symbol msymbol)
static void
symtab_symbol_info (bool quiet, bool exclude_minsyms,
- const char *regexp, domain_enum kind,
+ const char *regexp, symbol_search_kind kind,
const char *t_regexp, int from_tty)
{
const char *last_filename = "";
@@ -5152,11 +5169,7 @@ symtab_symbol_info (bool quiet, bool exclude_minsyms,
if (regexp != nullptr && *regexp == '\0')
regexp = nullptr;
- domain_search_flags flags = to_search_flags (kind);
- if (kind == TYPE_DOMAIN)
- flags |= SEARCH_STRUCT_DOMAIN;
-
- global_symbol_searcher spec (flags, regexp);
+ global_symbol_searcher spec (kind, regexp);
spec.set_symbol_type_regexp (t_regexp);
spec.set_exclude_minsyms (exclude_minsyms);
std::vector<symbol_search> symbols = spec.search ();
@@ -5166,20 +5179,20 @@ symtab_symbol_info (bool quiet, bool exclude_minsyms,
const char *classname;
switch (kind)
{
- case VAR_DOMAIN:
+ case symbol_search_kind::VARIABLE:
classname = "variable";
break;
- case FUNCTION_DOMAIN:
+ case symbol_search_kind::FUNCTION:
classname = "function";
break;
- case TYPE_DOMAIN:
+ case symbol_search_kind::TYPE:
classname = "type";
break;
- case MODULE_DOMAIN:
+ case symbol_search_kind::MODULE:
classname = "module";
break;
default:
- gdb_assert_not_reached ("invalid domain enum");
+ gdb_assert_not_reached ("invalid symbol_search_kind");
}
if (regexp != NULL)
@@ -5304,7 +5317,7 @@ info_variables_command (const char *args, int from_tty)
args = nullptr;
symtab_symbol_info
- (opts.quiet, opts.exclude_minsyms, args, VAR_DOMAIN,
+ (opts.quiet, opts.exclude_minsyms, args, symbol_search_kind::VARIABLE,
opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
from_tty);
}
@@ -5323,7 +5336,7 @@ info_functions_command (const char *args, int from_tty)
args = nullptr;
symtab_symbol_info
- (opts.quiet, opts.exclude_minsyms, args, FUNCTION_DOMAIN,
+ (opts.quiet, opts.exclude_minsyms, args, symbol_search_kind::FUNCTION,
opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
from_tty);
}
@@ -5366,8 +5379,8 @@ info_types_command (const char *args, int from_tty)
(&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
if (args != nullptr && *args == '\0')
args = nullptr;
- symtab_symbol_info (opts.quiet, false, args, TYPE_DOMAIN, nullptr,
- from_tty);
+ symtab_symbol_info (opts.quiet, false, args, symbol_search_kind::TYPE,
+ nullptr, from_tty);
}
/* Command completer for 'info types' command. */
@@ -5399,8 +5412,8 @@ info_modules_command (const char *args, int from_tty)
(&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
if (args != nullptr && *args == '\0')
args = nullptr;
- symtab_symbol_info (opts.quiet, true, args, MODULE_DOMAIN, nullptr,
- from_tty);
+ symtab_symbol_info (opts.quiet, true, args, symbol_search_kind::MODULE,
+ nullptr, from_tty);
}
/* Implement the 'info main' command. */
@@ -5441,7 +5454,7 @@ rbreak_command (const char *regexp, int from_tty)
because the std::move nullifies file_name. */
bool file_name_p = file_name != nullptr;
- global_symbol_searcher spec (SEARCH_FUNCTION_DOMAIN, regexp);
+ global_symbol_searcher spec (symbol_search_kind::FUNCTION, regexp);
if (file_name_p)
spec.add_filename (std::move (file_name));
std::vector<symbol_search> symbols = spec.search ();
@@ -6654,12 +6667,12 @@ static struct cmd_list_element *info_module_cmdlist = NULL;
std::vector<module_symbol_search>
search_module_symbols (const char *module_regexp, const char *regexp,
- const char *type_regexp, domain_search_flags kind)
+ const char *type_regexp, symbol_search_kind kind)
{
std::vector<module_symbol_search> results;
/* Search for all modules matching MODULE_REGEXP. */
- global_symbol_searcher spec1 (SEARCH_MODULE_DOMAIN, module_regexp);
+ global_symbol_searcher spec1 (symbol_search_kind::MODULE, module_regexp);
spec1.set_exclude_minsyms (true);
std::vector<symbol_search> modules = spec1.search ();
@@ -6705,9 +6718,10 @@ search_module_symbols (const char *module_regexp, const char *regexp,
static void
info_module_subcommand (bool quiet, const char *module_regexp,
const char *regexp, const char *type_regexp,
- domain_search_flags kind)
+ symbol_search_kind kind)
{
- gdb_assert (kind == SEARCH_FUNCTION_DOMAIN || kind == SEARCH_VAR_DOMAIN);
+ gdb_assert (kind == symbol_search_kind::FUNCTION
+ || kind == symbol_search_kind::VARIABLE);
/* Print a header line. Don't build the header line bit by bit as this
prevents internationalisation. */
@@ -6718,12 +6732,12 @@ info_module_subcommand (bool quiet, const char *module_regexp,
if (type_regexp == nullptr)
{
if (regexp == nullptr)
- gdb_printf ((kind == SEARCH_VAR_DOMAIN
+ gdb_printf ((kind == symbol_search_kind::VARIABLE
? _("All variables in all modules:")
: _("All functions in all modules:")));
else
gdb_printf
- ((kind == SEARCH_VAR_DOMAIN
+ ((kind == symbol_search_kind::VARIABLE
? _("All variables matching regular expression"
" \"%s\" in all modules:")
: _("All functions matching regular expression"
@@ -6734,7 +6748,7 @@ info_module_subcommand (bool quiet, const char *module_regexp,
{
if (regexp == nullptr)
gdb_printf
- ((kind == SEARCH_VAR_DOMAIN
+ ((kind == symbol_search_kind::VARIABLE
? _("All variables with type matching regular "
"expression \"%s\" in all modules:")
: _("All functions with type matching regular "
@@ -6742,7 +6756,7 @@ info_module_subcommand (bool quiet, const char *module_regexp,
type_regexp);
else
gdb_printf
- ((kind == SEARCH_VAR_DOMAIN
+ ((kind == symbol_search_kind::VARIABLE
? _("All variables matching regular expression "
"\"%s\",\n\twith type matching regular "
"expression \"%s\" in all modules:")
@@ -6758,7 +6772,7 @@ info_module_subcommand (bool quiet, const char *module_regexp,
{
if (regexp == nullptr)
gdb_printf
- ((kind == SEARCH_VAR_DOMAIN
+ ((kind == symbol_search_kind::VARIABLE
? _("All variables in all modules matching regular "
"expression \"%s\":")
: _("All functions in all modules matching regular "
@@ -6766,7 +6780,7 @@ info_module_subcommand (bool quiet, const char *module_regexp,
module_regexp);
else
gdb_printf
- ((kind == SEARCH_VAR_DOMAIN
+ ((kind == symbol_search_kind::VARIABLE
? _("All variables matching regular expression "
"\"%s\",\n\tin all modules matching regular "
"expression \"%s\":")
@@ -6779,7 +6793,7 @@ info_module_subcommand (bool quiet, const char *module_regexp,
{
if (regexp == nullptr)
gdb_printf
- ((kind == SEARCH_VAR_DOMAIN
+ ((kind == symbol_search_kind::VARIABLE
? _("All variables with type matching regular "
"expression \"%s\"\n\tin all modules matching "
"regular expression \"%s\":")
@@ -6789,7 +6803,7 @@ info_module_subcommand (bool quiet, const char *module_regexp,
type_regexp, module_regexp);
else
gdb_printf
- ((kind == SEARCH_VAR_DOMAIN
+ ((kind == symbol_search_kind::VARIABLE
? _("All variables matching regular expression "
"\"%s\",\n\twith type matching regular expression "
"\"%s\",\n\tin all modules matching regular "
@@ -6901,7 +6915,7 @@ info_module_functions_command (const char *args, int from_tty)
(opts.quiet,
opts.module_regexp.empty () ? nullptr : opts.module_regexp.c_str (), args,
opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
- SEARCH_FUNCTION_DOMAIN);
+ symbol_search_kind::FUNCTION);
}
/* Implements the 'info module variables' command. */
@@ -6920,7 +6934,7 @@ info_module_variables_command (const char *args, int from_tty)
(opts.quiet,
opts.module_regexp.empty () ? nullptr : opts.module_regexp.c_str (), args,
opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
- SEARCH_VAR_DOMAIN);
+ symbol_search_kind::VARIABLE);
}
/* Command completer for 'info module ...' sub-commands. */
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 6443216fd7f0..a35449fbeeda 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -2586,6 +2586,23 @@ struct symbol_search
const symbol_search &sym_b);
};
+/* The kind of symbols searched for by global_symbol_searcher. */
+
+enum class symbol_search_kind
+{
+ /* Variables, excluding enum constants. */
+ VARIABLE,
+
+ /* Functions. */
+ FUNCTION,
+
+ /* Type names. */
+ TYPE,
+
+ /* Fortran modules. */
+ MODULE,
+};
+
/* In order to search for global symbols of a particular kind matching
particular regular expressions, create an instance of this structure and
call the SEARCH member function. */
@@ -2594,7 +2611,7 @@ class global_symbol_searcher
public:
/* Constructor. */
- global_symbol_searcher (domain_search_flags kind,
+ global_symbol_searcher (symbol_search_kind kind,
const char *symbol_name_regexp)
: m_kind (kind),
m_symbol_name_regexp (symbol_name_regexp)
@@ -2635,14 +2652,8 @@ class global_symbol_searcher
/* The set of source files to search in for matching symbols. */
std::vector<gdb::unique_xmalloc_ptr<char>> m_filenames;
- /* The kind of symbols are we searching for.
- VARIABLES_DOMAIN - Search all symbols, excluding functions, type
- names, and constants (enums).
- FUNCTIONS_DOMAIN - Search all functions..
- TYPES_DOMAIN - Search all type names.
- MODULES_DOMAIN - Search all Fortran modules.
- ALL_DOMAIN - Not valid for this function. */
- domain_search_flags m_kind;
+ /* The kind of symbols we are searching for. */
+ symbol_search_kind m_kind;
/* Regular expression to match against the symbol name. */
const char *m_symbol_name_regexp = nullptr;
@@ -2686,7 +2697,7 @@ class global_symbol_searcher
std::vector<symbol_search> *results) const;
/* Return true if MSYMBOL is of type KIND. */
- static bool is_suitable_msymbol (const domain_search_flags kind,
+ static bool is_suitable_msymbol (symbol_search_kind kind,
const minimal_symbol *msymbol);
};
@@ -2703,7 +2714,7 @@ using module_symbol_search = std::pair<symbol_search, symbol_search>;
within the module. */
extern std::vector<module_symbol_search> search_module_symbols
(const char *module_regexp, const char *regexp,
- const char *type_regexp, domain_search_flags kind);
+ const char *type_regexp, symbol_search_kind kind);
/* Convert a global or static symbol SYM (based on BLOCK, which should be
either GLOBAL_BLOCK or STATIC_BLOCK) into a string for use in 'info'
--
2.55.0
^ permalink raw reply [flat|nested] 10+ messages in thread* [PATCH 2/9] gdb: factor out regexp compilation from global_symbol_searcher::search
2026-09-29 19:39 [PATCH 0/9] Cleanups in global_symbol_searcher Simon Marchi
2026-09-29 19:39 ` [PATCH 1/9] gdb: add symbol_search_kind enum for global_symbol_searcher Simon Marchi
@ 2026-09-29 19:39 ` Simon Marchi
2026-09-29 19:39 ` [PATCH 3/9] gdb: simplify insertion in global_symbol_searcher::add_matching_symbols Simon Marchi
` (6 subsequent siblings)
8 siblings, 0 replies; 10+ messages in thread
From: Simon Marchi @ 2026-09-29 19:39 UTC (permalink / raw)
To: gdb-patches; +Cc: Simon Marchi
Factor out the scopes that compile the regexps, in order to make
global_symbol_searcher::search itself simpler to read.
Also, I found the names "preg" and "treg" very unclear, so replace them
with "name_regex" and "type_regex".
Change-Id: Ie4485b2eb593967069ac635c933df817bc5304e6
---
gdb/symtab.c | 171 +++++++++++++++++++++++++++++----------------------
gdb/symtab.h | 43 +++++++------
2 files changed, 122 insertions(+), 92 deletions(-)
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 708df078e2ea..c4f76a494abd 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -4745,7 +4745,8 @@ global_symbol_searcher::is_suitable_msymbol
bool
global_symbol_searcher::expand_symtabs
- (objfile *objfile, const std::optional<compiled_regex> &preg) const
+ (objfile *objfile,
+ const std::optional<compiled_regex> &name_regex) const
{
bool found_func_msymbol_without_debug_info = false;
@@ -4762,8 +4763,8 @@ global_symbol_searcher::expand_symtabs
&lookup_name_info::match_any (),
[&] (const char *symname)
{
- return (!preg.has_value ()
- || preg->exec (symname, 0, NULL, 0) == 0);
+ return (!name_regex.has_value ()
+ || name_regex->exec (symname, 0, NULL, 0) == 0);
},
NULL,
SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
@@ -4794,9 +4795,9 @@ global_symbol_searcher::expand_symtabs
if (is_suitable_msymbol (m_kind, msymbol))
{
- if (!preg.has_value ()
- || preg->exec (msymbol->natural_name (), 0,
- NULL, 0) == 0)
+ if (!name_regex.has_value ()
+ || name_regex->exec (msymbol->natural_name (), 0,
+ NULL, 0) == 0)
{
/* An important side-effect of this lookup function is
to expand the symbol table if msymbol is found, later
@@ -4819,8 +4820,8 @@ global_symbol_searcher::expand_symtabs
bool
global_symbol_searcher::add_matching_symbols
(objfile *objfile,
- const std::optional<compiled_regex> &preg,
- const std::optional<compiled_regex> &treg,
+ const std::optional<compiled_regex> &name_regex,
+ const std::optional<compiled_regex> &type_regex,
std::set<symbol_search> *result_set) const
{
domain_search_flags domain = to_search_flags (m_kind);
@@ -4854,14 +4855,15 @@ global_symbol_searcher::add_matching_symbols
if (!sym->matches (domain))
continue;
- if (preg.has_value () && preg->exec (sym->natural_name (), 0,
- nullptr, 0) != 0)
+ if (name_regex.has_value ()
+ && name_regex->exec (sym->natural_name (), 0,
+ nullptr, 0) != 0)
continue;
if (((sym->domain () == VAR_DOMAIN
|| sym->domain () == FUNCTION_DOMAIN)
- && treg.has_value ()
- && !treg_matches_sym_type_name (*treg, sym)))
+ && type_regex.has_value ()
+ && !treg_matches_sym_type_name (*type_regex, sym)))
continue;
if (m_kind == symbol_search_kind::VARIABLE)
@@ -4898,7 +4900,7 @@ global_symbol_searcher::add_matching_symbols
bool
global_symbol_searcher::add_matching_msymbols
- (objfile *objfile, const std::optional<compiled_regex> &preg,
+ (objfile *objfile, const std::optional<compiled_regex> &name_regex,
std::vector<symbol_search> *results) const
{
for (minimal_symbol *msymbol : objfile->msymbols ())
@@ -4910,9 +4912,9 @@ global_symbol_searcher::add_matching_msymbols
if (is_suitable_msymbol (m_kind, msymbol))
{
- if (!preg.has_value ()
- || preg->exec (msymbol->natural_name (), 0,
- NULL, 0) == 0)
+ if (!name_regex.has_value ()
+ || name_regex->exec (msymbol->natural_name (), 0,
+ NULL, 0) == 0)
{
/* For functions we can do a quick check of whether the
symbol might be found via find_pc_symtab. */
@@ -4938,65 +4940,84 @@ global_symbol_searcher::add_matching_msymbols
return true;
}
+/* Return the regcomp flags to use for the symbol name and symbol type
+ regexps. */
+
+static int
+search_regex_cflags ()
+{
+ return REG_NOSUB | (case_sensitivity == case_sensitive_off ? REG_ICASE : 0);
+}
+
+/* See symtab.h. */
+
+std::optional<compiled_regex>
+global_symbol_searcher::compile_name_regex () const
+{
+ if (m_symbol_name_regexp == nullptr)
+ return {};
+
+ const char *symbol_name_regexp = m_symbol_name_regexp;
+ std::string symbol_name_regexp_holder;
+
+ /* Make sure spacing is right for C++ operators.
+ This is just a courtesy to make the matching less sensitive
+ to how many spaces the user leaves between 'operator'
+ and <TYPENAME> or <OPERATOR>. */
+ const char *op_end;
+ const char *opname = operator_chars (symbol_name_regexp, &op_end);
+
+ if (*opname)
+ {
+ /* -1 means ok; otherwise number of spaces needed. */
+ int fix = -1;
+
+ if (c_isalpha (*opname) || *opname == '_' || *opname == '$')
+ {
+ /* There should 1 space between 'operator' and 'TYPENAME'. */
+ if (opname[-1] != ' ' || opname[-2] == ' ')
+ fix = 1;
+ }
+ else
+ {
+ /* There should 0 spaces between 'operator' and 'OPERATOR'. */
+ if (opname[-1] == ' ')
+ fix = 0;
+ }
+ /* If wrong number of spaces, fix it. */
+ if (fix >= 0)
+ {
+ symbol_name_regexp_holder
+ = string_printf ("operator%.*s%s", fix, " ", opname);
+ symbol_name_regexp = symbol_name_regexp_holder.c_str ();
+ }
+ }
+
+ return std::optional<compiled_regex> (std::in_place, symbol_name_regexp,
+ search_regex_cflags (),
+ _("Invalid regexp"));
+}
+
+/* See symtab.h. */
+
+std::optional<compiled_regex>
+global_symbol_searcher::compile_type_regex () const
+{
+ if (m_symbol_type_regexp == nullptr)
+ return {};
+
+ return std::optional<compiled_regex> (std::in_place, m_symbol_type_regexp,
+ search_regex_cflags (),
+ _("Invalid regexp"));
+}
+
/* See symtab.h. */
std::vector<symbol_search>
global_symbol_searcher::search () const
{
- std::optional<compiled_regex> preg;
- std::optional<compiled_regex> treg;
-
- if (m_symbol_name_regexp != NULL)
- {
- const char *symbol_name_regexp = m_symbol_name_regexp;
- std::string symbol_name_regexp_holder;
-
- /* Make sure spacing is right for C++ operators.
- This is just a courtesy to make the matching less sensitive
- to how many spaces the user leaves between 'operator'
- and <TYPENAME> or <OPERATOR>. */
- const char *op_end;
- const char *opname = operator_chars (symbol_name_regexp, &op_end);
-
- if (*opname)
- {
- int fix = -1; /* -1 means ok; otherwise number of
- spaces needed. */
-
- if (c_isalpha (*opname) || *opname == '_' || *opname == '$')
- {
- /* There should 1 space between 'operator' and 'TYPENAME'. */
- if (opname[-1] != ' ' || opname[-2] == ' ')
- fix = 1;
- }
- else
- {
- /* There should 0 spaces between 'operator' and 'OPERATOR'. */
- if (opname[-1] == ' ')
- fix = 0;
- }
- /* If wrong number of spaces, fix it. */
- if (fix >= 0)
- {
- symbol_name_regexp_holder
- = string_printf ("operator%.*s%s", fix, " ", opname);
- symbol_name_regexp = symbol_name_regexp_holder.c_str ();
- }
- }
-
- int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off
- ? REG_ICASE : 0);
- preg.emplace (symbol_name_regexp, cflags,
- _("Invalid regexp"));
- }
-
- if (m_symbol_type_regexp != NULL)
- {
- int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off
- ? REG_ICASE : 0);
- treg.emplace (m_symbol_type_regexp, cflags,
- _("Invalid regexp"));
- }
+ std::optional<compiled_regex> name_regex = compile_name_regex ();
+ std::optional<compiled_regex> type_regex = compile_type_regex ();
bool found_func_msymbol_without_debug_info = false;
std::set<symbol_search> result_set;
@@ -5004,13 +5025,15 @@ global_symbol_searcher::search () const
{
/* Expand symtabs within objfile that possibly contain matching
symbols. */
- found_func_msymbol_without_debug_info |= expand_symtabs (&objfile, preg);
+ found_func_msymbol_without_debug_info
+ |= expand_symtabs (&objfile, name_regex);
/* Find matching symbols within OBJFILE and add them in to the
RESULT_SET set. Use a set here so that we can easily detect
duplicates as we go, and can therefore track how many unique
matches we have found so far. */
- if (!add_matching_symbols (&objfile, preg, treg, &result_set))
+ if (!add_matching_symbols (&objfile, name_regex, type_regex,
+ &result_set))
break;
}
@@ -5025,12 +5048,12 @@ global_symbol_searcher::search () const
if ((found_func_msymbol_without_debug_info
|| (m_filenames.empty () && m_kind == symbol_search_kind::VARIABLE))
&& !m_exclude_minsyms
- && !treg.has_value ())
+ && !type_regex.has_value ())
{
gdb_assert (m_kind == symbol_search_kind::VARIABLE
|| m_kind == symbol_search_kind::FUNCTION);
for (objfile &objfile : current_program_space->objfiles ())
- if (!add_matching_msymbols (&objfile, preg, &result))
+ if (!add_matching_msymbols (&objfile, name_regex, &result))
break;
}
diff --git a/gdb/symtab.h b/gdb/symtab.h
index a35449fbeeda..1675b126b19d 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -2669,31 +2669,38 @@ class global_symbol_searcher
of SIZE_MAX, there is no "unlimited". */
size_t m_max_search_results = SIZE_MAX;
- /* Expand symtabs in OBJFILE that match PREG, are of type M_KIND. Return
- true if any msymbols were seen that we should later consider adding to
- the results list. */
- bool expand_symtabs (objfile *objfile,
- const std::optional<compiled_regex> &preg) const;
+ /* Compile M_SYMBOL_NAME_REGEXP, if set. */
+ std::optional<compiled_regex> compile_name_regex () const;
- /* Add symbols from symtabs in OBJFILE that match PREG, and TREG, and are
- of type M_KIND, to the results set RESULTS_SET. Return false if we
- stop adding results early due to having already found too many results
- (based on M_MAX_SEARCH_RESULTS limit), otherwise return true.
+ /* Compile M_SYMBOL_TYPE_REGEXP, if set. */
+ std::optional<compiled_regex> compile_type_regex () const;
+
+ /* Expand symtabs in OBJFILE that match NAME_REGEX, are of type M_KIND.
+ Return true if any msymbols were seen that we should later consider
+ adding to the results list. */
+ bool expand_symtabs (objfile *objfile,
+ const std::optional<compiled_regex> &name_regex) const;
+
+ /* Add symbols from symtabs in OBJFILE that match NAME_REGEX, and
+ TYPE_REGEX, and are of type M_KIND, to the results set RESULTS_SET.
+ Return false if we stop adding results early due to having already
+ found too many results (based on M_MAX_SEARCH_RESULTS limit),
+ otherwise return true.
Returning true does not indicate that any results were added, just
that we didn't _not_ add a result due to reaching MAX_SEARCH_RESULTS. */
bool add_matching_symbols (objfile *objfile,
- const std::optional<compiled_regex> &preg,
- const std::optional<compiled_regex> &treg,
+ const std::optional<compiled_regex> &name_regex,
+ const std::optional<compiled_regex> &type_regex,
std::set<symbol_search> *result_set) const;
- /* Add msymbols from OBJFILE that match PREG and M_KIND, to the results
- vector RESULTS. Return false if we stop adding results early due to
- having already found too many results (based on max search results
- limit M_MAX_SEARCH_RESULTS), otherwise return true. Returning true
- does not indicate that any results were added, just that we didn't
- _not_ add a result due to reaching MAX_SEARCH_RESULTS. */
+ /* Add msymbols from OBJFILE that match NAME_REGEX and M_KIND, to the
+ results vector RESULTS. Return false if we stop adding results early
+ due to having already found too many results (based on max search
+ results limit M_MAX_SEARCH_RESULTS), otherwise return true. Returning
+ true does not indicate that any results were added, just that we
+ didn't _not_ add a result due to reaching MAX_SEARCH_RESULTS. */
bool add_matching_msymbols (objfile *objfile,
- const std::optional<compiled_regex> &preg,
+ const std::optional<compiled_regex> &name_regex,
std::vector<symbol_search> *results) const;
/* Return true if MSYMBOL is of type KIND. */
--
2.55.0
^ permalink raw reply [flat|nested] 10+ messages in thread* [PATCH 7/9] gdb: add matching helpers to global_symbol_searcher
2026-09-29 19:39 [PATCH 0/9] Cleanups in global_symbol_searcher Simon Marchi
` (5 preceding siblings ...)
2026-09-29 19:39 ` [PATCH 6/9] gdb: update comment of global_symbol_searcher::expand_symtabs Simon Marchi
@ 2026-09-29 19:39 ` Simon Marchi
2026-09-29 19:39 ` [PATCH 8/9] gdb: pass result containers by reference in global_symbol_searcher Simon Marchi
2026-09-29 19:39 ` [PATCH 9/9] gdb: fix some comments " Simon Marchi
8 siblings, 0 replies; 10+ messages in thread
From: Simon Marchi @ 2026-09-29 19:39 UTC (permalink / raw)
To: gdb-patches; +Cc: Simon Marchi
The methods of global_symbol_searcher repeat the same checks in several
places. Add some helpers to make the code easier to follow:
- name_matches: check a name against the (optional) name regexp
- symtab_matches_filenames: check a symtab against the searched file
names
- symbol_matches: all the filtering done on full symbols in
add_matching_symbols
- msymbol_matches: the filtering done on minimal symbols, shared by
expand_symtabs and add_matching_msymbols
Switch expand_symtabs, add_matching_symbols and add_matching_msymbols to
use early continues to avoid deeply nested ifs.
Change-Id: I553f70fb8ea9c7e55b89bb1204a402938c116c3b
---
gdb/symtab.c | 205 ++++++++++++++++++++++++++++-----------------------
gdb/symtab.h | 13 ++++
2 files changed, 127 insertions(+), 91 deletions(-)
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 9ce6911666c6..79e43eafde18 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -4741,6 +4741,93 @@ global_symbol_searcher::is_suitable_msymbol
}
}
+/* Return true if NAME matches NAME_REGEX, or if NAME_REGEX is empty. */
+
+static bool
+name_matches (const std::optional<compiled_regex> &name_regex,
+ const char *name)
+{
+ return (!name_regex.has_value ()
+ || name_regex->exec (name, 0, nullptr, 0) == 0);
+}
+
+/* See symtab.h. */
+
+bool
+global_symbol_searcher::symtab_matches_filenames (symtab *symtab) const
+{
+ /* Check first sole SYMTAB->FILENAME. It does not need to be a substring
+ of symtab_to_fullname as it may contain "./" etc. */
+ if (file_matches (symtab->filename (), m_filenames, false))
+ return true;
+
+ if (!basenames_may_differ
+ && !file_matches (lbasename (symtab->filename ()), m_filenames, true))
+ return false;
+
+ return file_matches (symtab_to_fullname (symtab), m_filenames, false);
+}
+
+/* See symtab.h. */
+
+bool
+global_symbol_searcher::symbol_matches
+ (const symbol *sym,
+ const std::optional<compiled_regex> &name_regex,
+ const std::optional<compiled_regex> &type_regex) const
+{
+ if (!symtab_matches_filenames (sym->symtab ()))
+ return false;
+
+ if (!sym->matches (to_search_flags (m_kind)))
+ return false;
+
+ if (!name_matches (name_regex, sym->natural_name ()))
+ return false;
+
+ switch (m_kind)
+ {
+ case symbol_search_kind::VARIABLE:
+ /* LOC_CONST can be used for more than just enums, e.g., C++ static
+ const members. We only want to skip enums here. */
+ if (sym->loc_class () == LOC_UNRESOLVED
+ || (sym->loc_class () == LOC_CONST
+ && sym->type ()->code () == TYPE_CODE_ENUM))
+ return false;
+ [[fallthrough]];
+
+ case symbol_search_kind::FUNCTION:
+ if (type_regex.has_value ()
+ && !treg_matches_sym_type_name (*type_regex, sym))
+ return false;
+ break;
+
+ case symbol_search_kind::MODULE:
+ /* Skip module declarations, keep only definitions. */
+ if (sym->line () == 0)
+ return false;
+ break;
+ }
+
+ return true;
+}
+
+/* See symtab.h. */
+
+bool
+global_symbol_searcher::msymbol_matches
+ (const minimal_symbol *msymbol,
+ const std::optional<compiled_regex> &name_regex) const
+{
+ if (msymbol->created_by_gdb)
+ return false;
+
+ if (!is_suitable_msymbol (msymbol))
+ return false;
+
+ return name_matches (name_regex, msymbol->natural_name ());
+}
+
/* See symtab.h. */
bool
@@ -4763,8 +4850,7 @@ global_symbol_searcher::expand_symtabs
&lookup_name_info::match_any (),
[&] (const char *symname)
{
- return (!name_regex.has_value ()
- || name_regex->exec (symname, 0, NULL, 0) == 0);
+ return name_matches (name_regex, symname);
},
NULL,
SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
@@ -4790,25 +4876,16 @@ global_symbol_searcher::expand_symtabs
{
QUIT;
- if (msymbol->created_by_gdb)
+ if (!msymbol_matches (msymbol, name_regex))
continue;
- if (is_suitable_msymbol (msymbol))
- {
- if (!name_regex.has_value ()
- || name_regex->exec (msymbol->natural_name (), 0,
- NULL, 0) == 0)
- {
- /* An important side-effect of this lookup function is
- to expand the symbol table if msymbol is found, later
- in the process we will add matching symbols or
- msymbols to the results list, and that requires that
- the symbols tables are expanded. */
- if (find_compunit_symtab_for_pc
- (msymbol->value_address (objfile)) == nullptr)
- found_func_msymbol_without_debug_info = true;
- }
- }
+ /* An important side-effect of this lookup function is to expand
+ the symbol table if msymbol is found, later in the process we
+ will add matching symbols or msymbols to the results list, and
+ that requires that the symbols tables are expanded. */
+ if (find_compunit_symtab_for_pc
+ (msymbol->value_address (objfile)) == nullptr)
+ found_func_msymbol_without_debug_info = true;
}
}
@@ -4824,8 +4901,6 @@ global_symbol_searcher::add_matching_symbols
const std::optional<compiled_regex> &type_regex,
std::set<symbol_search> *result_set) const
{
- domain_search_flags domain = to_search_flags (m_kind);
-
/* Add matching symbols (if not already present). */
for (compunit_symtab &cust : objfile->compunits ())
{
@@ -4837,54 +4912,11 @@ global_symbol_searcher::add_matching_symbols
for (struct symbol *sym : block_iterator_range (b))
{
- struct symtab *real_symtab = sym->symtab ();
-
QUIT;
- /* Check first sole REAL_SYMTAB->FILENAME. It does
- not need to be a substring of symtab_to_fullname as
- it may contain "./" etc. */
- if (!(file_matches (real_symtab->filename (), m_filenames, false)
- || ((basenames_may_differ
- || file_matches (lbasename (real_symtab->filename ()),
- m_filenames, true))
- && file_matches (symtab_to_fullname (real_symtab),
- m_filenames, false))))
+ if (!symbol_matches (sym, name_regex, type_regex))
continue;
- if (!sym->matches (domain))
- continue;
-
- if (name_regex.has_value ()
- && name_regex->exec (sym->natural_name (), 0,
- nullptr, 0) != 0)
- continue;
-
- switch (m_kind)
- {
- case symbol_search_kind::VARIABLE:
- /* LOC_CONST can be used for more than just enums, e.g.,
- C++ static const members. We only want to skip enums
- here. */
- if (sym->loc_class () == LOC_UNRESOLVED
- || (sym->loc_class () == LOC_CONST
- && sym->type ()->code () == TYPE_CODE_ENUM))
- continue;
- [[fallthrough]];
-
- case symbol_search_kind::FUNCTION:
- if (type_regex.has_value ()
- && !treg_matches_sym_type_name (*type_regex, sym))
- continue;
- break;
-
- case symbol_search_kind::MODULE:
- /* Skip module declarations, keep only definitions. */
- if (sym->line () == 0)
- continue;
- break;
- }
-
/* Match, insert if not already in the results. */
if (result_set->size () < m_max_search_results)
result_set->emplace (block, sym);
@@ -4908,34 +4940,25 @@ global_symbol_searcher::add_matching_msymbols
{
QUIT;
- if (msymbol->created_by_gdb)
+ if (!msymbol_matches (msymbol, name_regex))
continue;
- if (is_suitable_msymbol (msymbol))
- {
- if (!name_regex.has_value ()
- || name_regex->exec (msymbol->natural_name (), 0,
- NULL, 0) == 0)
- {
- /* For functions we can do a quick check of whether the
- symbol might be found via find_pc_symtab. */
- if (m_kind != symbol_search_kind::FUNCTION
- || (find_compunit_symtab_for_pc
- (msymbol->value_address (objfile)) == NULL))
- {
- if (lookup_symbol_in_objfile_from_linkage_name
- (objfile, msymbol->linkage_name (),
- SEARCH_VFT).symbol == NULL)
- {
- /* Matching msymbol, add it to the results list. */
- if (results->size () < m_max_search_results)
- results->emplace_back (GLOBAL_BLOCK, msymbol, objfile);
- else
- return false;
- }
- }
- }
- }
+ /* For functions we can do a quick check of whether the
+ symbol might be found via find_pc_symtab. */
+ if (m_kind == symbol_search_kind::FUNCTION
+ && (find_compunit_symtab_for_pc
+ (msymbol->value_address (objfile)) != NULL))
+ continue;
+
+ if (lookup_symbol_in_objfile_from_linkage_name
+ (objfile, msymbol->linkage_name (), SEARCH_VFT).symbol != NULL)
+ continue;
+
+ /* Matching msymbol, add it to the results list. */
+ if (results->size () < m_max_search_results)
+ results->emplace_back (GLOBAL_BLOCK, msymbol, objfile);
+ else
+ return false;
}
return true;
diff --git a/gdb/symtab.h b/gdb/symtab.h
index acbe41d131b7..5dd0475e4491 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -2675,6 +2675,19 @@ class global_symbol_searcher
/* Compile M_SYMBOL_TYPE_REGEXP, if set. */
std::optional<compiled_regex> compile_type_regex () const;
+ /* Return true if SYMTAB matches one of M_FILENAMES. */
+ bool symtab_matches_filenames (symtab *symtab) const;
+
+ /* Return true if SYM is of type M_KIND, is in a file matching
+ M_FILENAMES, and matches NAME_REGEX and TYPE_REGEX. */
+ bool symbol_matches (const symbol *sym,
+ const std::optional<compiled_regex> &name_regex,
+ const std::optional<compiled_regex> &type_regex) const;
+
+ /* Return true if MSYMBOL is of type M_KIND and matches NAME_REGEX. */
+ bool msymbol_matches (const minimal_symbol *msymbol,
+ const std::optional<compiled_regex> &name_regex) const;
+
/* Expand symtabs in OBJFILE that match NAME_REGEX, are of type M_KIND.
Return true if a matching function msymbol without debug info was
seen, meaning that msymbols should later be considered for the results
--
2.55.0
^ permalink raw reply [flat|nested] 10+ messages in thread