global
? SEARCH_GLOBAL_BLOCK
: SEARCH_STATIC_BLOCK,
- domain, ALL_DOMAIN);
+ domain, SEARCH_ALL);
const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
for (compunit_symtab *symtab : objfile->compunits ())
},
NULL,
SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
- VARIABLES_DOMAIN);
+ SEARCH_VAR_DOMAIN);
/* Iterate over all objfiles irrespective of scope or linker namespaces
so we get all exceptions anywhere in the progspace. */
NULL,
NULL,
SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
- ALL_DOMAIN);
+ SEARCH_ALL);
/* At this point scan through the misc symbol vectors and add each
symbol you find to the list. Eventually we want to ignore
symbol_searcher searcher;
searcher.find_all_symbols (identifier, current_language,
- ALL_DOMAIN, nullptr, nullptr);
+ SEARCH_ALL, nullptr, nullptr);
/* Convert any found symbols. */
for (const auto &it : searcher.matching_symbols ())
/* See cooked-index.h. */
+bool
+cooked_index_entry::matches (domain_search_flags kind) const
+{
+ /* Just reject type declarations. */
+ if ((flags & IS_TYPE_DECLARATION) != 0)
+ return false;
+
+ if ((kind & SEARCH_VAR_DOMAIN) != 0
+ && (tag == DW_TAG_variable
+ || tag == DW_TAG_constant
+ || tag == DW_TAG_enumerator))
+ return true;
+
+ if ((kind & SEARCH_STRUCT_DOMAIN) != 0
+ && (tag == DW_TAG_structure_type
+ || tag == DW_TAG_class_type
+ || tag == DW_TAG_union_type
+ || tag == DW_TAG_enumeration_type))
+ return true;
+
+ if ((kind & SEARCH_MODULE_DOMAIN) != 0 && tag == DW_TAG_module)
+ return true;
+
+ if ((kind & SEARCH_TYPE_DOMAIN) != 0 && tag_is_type (tag))
+ return true;
+
+ if ((kind & SEARCH_FUNCTION_DOMAIN) != 0
+ && (tag == DW_TAG_subprogram
+ || tag == DW_TAG_entry_point))
+ return true;
+
+ return false;
+}
+
+/* See cooked-index.h. */
+
const char *
cooked_index_entry::full_name (struct obstack *storage, bool for_main) const
{
}
/* Return true if this entry matches KIND. */
- bool matches (enum search_domain kind) const
- {
- /* Just reject type declarations. */
- if ((flags & IS_TYPE_DECLARATION) != 0)
- return false;
-
- switch (kind)
- {
- case VARIABLES_DOMAIN:
- return (tag == DW_TAG_variable
- || tag == DW_TAG_constant
- || tag == DW_TAG_enumerator);
- case FUNCTIONS_DOMAIN:
- return (tag == DW_TAG_subprogram
- || tag == DW_TAG_entry_point);
- case TYPES_DOMAIN:
- return tag_is_type (tag);
- case MODULES_DOMAIN:
- return tag == DW_TAG_module;
- }
-
- return true;
- }
+ bool matches (domain_search_flags kind) const;
/* Construct the fully-qualified name of this entry and return a
pointer to it. If allocation is needed, it will be done on
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
domain_enum domain,
- enum search_domain kind) override;
+ domain_search_flags kind) override;
struct compunit_symtab *find_pc_sect_compunit_symtab
(struct objfile *objfile, struct bound_minimal_symbol msymbol,
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
domain_enum domain,
- enum search_domain kind) override;
+ domain_search_flags kind) override;
};
/* This dumps minimal information about the index.
gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
- search_domain kind)
+ domain_search_flags kind)
{
offset_type vec_len, vec_idx;
bool global_seen = false;
continue;
}
- switch (kind)
+ domain_search_flags mask = 0;
+ switch (symbol_kind)
{
- case VARIABLES_DOMAIN:
- if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
- continue;
- break;
- case FUNCTIONS_DOMAIN:
- if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
- continue;
+ case GDB_INDEX_SYMBOL_KIND_VARIABLE:
+ mask = SEARCH_VAR_DOMAIN;
break;
- case TYPES_DOMAIN:
- if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
- continue;
+ case GDB_INDEX_SYMBOL_KIND_FUNCTION:
+ mask = SEARCH_FUNCTION_DOMAIN;
break;
- case MODULES_DOMAIN:
- if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
- continue;
+ case GDB_INDEX_SYMBOL_KIND_TYPE:
+ mask = SEARCH_TYPE_DOMAIN;
break;
- default:
+ case GDB_INDEX_SYMBOL_KIND_OTHER:
+ mask = SEARCH_MODULE_DOMAIN;
break;
}
+ if ((kind & mask) == 0)
+ continue;
}
/* Don't crash on bad data. */
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
domain_enum domain,
- enum search_domain kind)
+ domain_search_flags kind)
{
dwarf2_per_objfile *per_objfile = get_dwarf2_per_objfile (objfile);
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
domain_enum domain,
- enum search_domain kind) override
+ domain_search_flags kind) override
{
return true;
}
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
domain_enum domain,
- enum search_domain kind)
+ domain_search_flags kind)
{
dwarf2_per_objfile *per_objfile = get_dwarf2_per_objfile (objfile);
static void add_matching_symbols_to_info (const char *name,
symbol_name_match_type name_match_type,
- enum search_domain search_domain,
+ domain_search_flags domain_search_flags,
struct collect_info *info,
struct program_space *pspace);
static void add_all_symbol_names_from_pspace
(struct collect_info *info, struct program_space *pspace,
- const std::vector<const char *> &names, enum search_domain search_domain);
+ const std::vector<const char *> &names, domain_search_flags domain_search_flags);
static std::vector<symtab *>
collect_symtabs_from_filename (const char *file,
(struct linespec_state *state,
const lookup_name_info &lookup_name,
const domain_enum name_domain,
- enum search_domain search_domain,
+ domain_search_flags domain_search_flags,
struct program_space *search_pspace, bool include_inline,
gdb::function_view<symbol_found_callback_ftype> callback)
{
(SEARCH_GLOBAL_BLOCK
| SEARCH_STATIC_BLOCK),
UNDEF_DOMAIN,
- search_domain);
+ domain_search_flags);
for (compunit_symtab *cu : objfile->compunits ())
{
return {};
add_all_symbol_names_from_pspace (&info, NULL, symbol_names,
- FUNCTIONS_DOMAIN);
+ SEARCH_FUNCTION_DOMAIN);
std::vector<symtab_and_line> values;
if (!symbols.empty () || !minimal_symbols.empty ())
if (elt == nullptr)
{
iterate_over_all_matching_symtabs (state, lookup_name,
- STRUCT_DOMAIN, ALL_DOMAIN,
+ STRUCT_DOMAIN, SEARCH_ALL,
NULL, false, collector);
iterate_over_all_matching_symtabs (state, lookup_name,
- VAR_DOMAIN, ALL_DOMAIN,
+ VAR_DOMAIN, SEARCH_ALL,
NULL, false, collector);
}
else
add_all_symbol_names_from_pspace (struct collect_info *info,
struct program_space *pspace,
const std::vector<const char *> &names,
- enum search_domain search_domain)
+ domain_search_flags domain_search_flags)
{
for (const char *iter : names)
add_matching_symbols_to_info (iter,
symbol_name_match_type::FULL,
- search_domain, info, pspace);
+ domain_search_flags, info, pspace);
}
static void
iterate over the symbol tables looking for all
matches in this pspace. */
add_all_symbol_names_from_pspace (&info, pspace, result_names,
- FUNCTIONS_DOMAIN);
+ SEARCH_FUNCTION_DOMAIN);
superclass_vec.clear ();
last_result_len = result_names.size ();
void
symbol_searcher::find_all_symbols (const std::string &name,
const struct language_defn *language,
- enum search_domain search_domain,
+ domain_search_flags domain_search_flags,
std::vector<symtab *> *search_symtabs,
struct program_space *search_pspace)
{
info.file_symtabs = search_symtabs;
add_matching_symbols_to_info (name.c_str (), symbol_name_match_type::WILD,
- search_domain, &info, search_pspace);
+ domain_search_flags, &info, search_pspace);
}
/* Look up a function symbol named NAME in symtabs FILE_SYMTABS. Matching
find_imps (name, &symbol_names);
if (!symbol_names.empty ())
add_all_symbol_names_from_pspace (&info, state->search_pspace,
- symbol_names, FUNCTIONS_DOMAIN);
+ symbol_names, SEARCH_FUNCTION_DOMAIN);
else
- add_matching_symbols_to_info (name, name_match_type, FUNCTIONS_DOMAIN,
+ add_matching_symbols_to_info (name, name_match_type,
+ SEARCH_FUNCTION_DOMAIN,
&info, state->search_pspace);
}
static void
add_matching_symbols_to_info (const char *name,
symbol_name_match_type name_match_type,
- enum search_domain search_domain,
+ domain_search_flags domain_search_flags,
struct collect_info *info,
struct program_space *pspace)
{
if (elt == nullptr)
{
iterate_over_all_matching_symtabs (info->state, lookup_name,
- VAR_DOMAIN, search_domain,
+ VAR_DOMAIN, domain_search_flags,
pspace, true,
[&] (block_symbol *bsym)
{ return info->add_symbol (bsym); });
results. */
static void
-output_debug_symbol (ui_out *uiout, enum search_domain kind,
+output_debug_symbol (ui_out *uiout, domain_search_flags kind,
struct symbol *sym, int block)
{
ui_out_emit_tuple tuple_emitter (uiout, NULL);
uiout->field_unsigned ("line", sym->line ());
uiout->field_string ("name", sym->print_name ());
- if (kind == FUNCTIONS_DOMAIN || kind == VARIABLES_DOMAIN)
+ if ((kind & (SEARCH_FUNCTION_DOMAIN | SEARCH_VAR_DOMAIN)) != 0)
{
string_file tmp_stream;
type_print (sym->type (), "", &tmp_stream, -1);
and then prints the matching [m]symbols in an MI structured format. */
static void
-mi_symbol_info (enum search_domain kind, const char *name_regexp,
+mi_symbol_info (domain_search_flags kind, const char *name_regexp,
const char *type_regexp, bool exclude_minsyms,
size_t max_results)
{
Processes command line options from ARGV and ARGC. */
static void
-mi_info_functions_or_variables (enum search_domain kind,
+mi_info_functions_or_variables (domain_search_flags kind,
const char *const *argv, int argc)
{
size_t max_results = SIZE_MAX;
while (1)
{
const char *cmd_string
- = ((kind == FUNCTIONS_DOMAIN)
+ = ((kind == SEARCH_FUNCTION_DOMAIN)
? "-symbol-info-functions" : "-symbol-info-variables");
int opt = mi_getopt (cmd_string, argc, argv, opts, &oind, &oarg);
if (opt < 0)
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, enum search_domain kind)
+ const module_symbol_search_iterator end, domain_search_flags kind)
{
/* The symbol for the module in which the first result resides. */
const symbol *first_module_symbol = iter->first.symbol;
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, enum search_domain kind)
+ const module_symbol_search_iterator end, domain_search_flags kind)
{
gdb_assert (iter->first.symbol != nullptr);
gdb_assert (iter->second.symbol != nullptr);
command line options passed to the MI command. */
static void
-mi_info_module_functions_or_variables (enum search_domain kind,
- const char *const *argv, int argc)
+mi_info_module_functions_or_variables (domain_search_flags kind,
+ const char *const *argv, int argc)
{
const char *module_regexp = nullptr;
const char *regexp = nullptr;
while (1)
{
const char *cmd_string
- = ((kind == FUNCTIONS_DOMAIN)
+ = ((kind == SEARCH_FUNCTION_DOMAIN)
? "-symbol-info-module-functions"
: "-symbol-info-module-variables");
int opt = mi_getopt (cmd_string, argc, argv, opts, &oind, &oarg);
mi_cmd_symbol_info_functions (const char *command, const char *const *argv,
int argc)
{
- mi_info_functions_or_variables (FUNCTIONS_DOMAIN, argv, argc);
+ mi_info_functions_or_variables (SEARCH_FUNCTION_DOMAIN, argv, argc);
}
/* Implement -symbol-info-module-functions command. */
mi_cmd_symbol_info_module_functions (const char *command,
const char *const *argv, int argc)
{
- mi_info_module_functions_or_variables (FUNCTIONS_DOMAIN, argv, argc);
+ mi_info_module_functions_or_variables (SEARCH_FUNCTION_DOMAIN, argv, argc);
}
/* Implement -symbol-info-module-variables command. */
mi_cmd_symbol_info_module_variables (const char *command,
const char *const *argv, int argc)
{
- mi_info_module_functions_or_variables (VARIABLES_DOMAIN, argv, argc);
+ mi_info_module_functions_or_variables (SEARCH_VAR_DOMAIN, argv, argc);
}
/* Implement -symbol-inf-modules command. */
}
}
- mi_symbol_info (MODULES_DOMAIN, regexp, nullptr, true, max_results);
+ mi_symbol_info (SEARCH_MODULE_DOMAIN, regexp, nullptr, true, max_results);
}
/* Implement -symbol-info-types command. */
}
}
- mi_symbol_info (TYPES_DOMAIN, regexp, nullptr, true, max_results);
+ mi_symbol_info (SEARCH_TYPE_DOMAIN | SEARCH_STRUCT_DOMAIN, regexp, nullptr,
+ true, max_results);
}
/* Implement -symbol-info-variables command. */
mi_cmd_symbol_info_variables (const char *command, const char *const *argv,
int argc)
{
- mi_info_functions_or_variables (VARIABLES_DOMAIN, argv, argc);
+ mi_info_functions_or_variables (SEARCH_VAR_DOMAIN, argv, argc);
}
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
domain_enum domain,
- enum search_domain kind);
+ domain_search_flags kind);
/* See quick_symbol_functions. */
struct compunit_symtab *find_pc_sect_compunit_symtab
struct objfile *objfile,
block_search_flags search_flags,
domain_enum domain,
- enum search_domain search,
+ domain_search_flags search,
const lookup_name_info &lookup_name,
gdb::function_view<expand_symtabs_symbol_matcher_ftype> sym_matcher)
{
if ((domain == UNDEF_DOMAIN
|| symbol_matches_domain ((*psym)->ginfo.language (),
(*psym)->domain, domain))
- && (search == ALL_DOMAIN
- || (search == MODULES_DOMAIN
+ && (search == SEARCH_ALL
+ || (search == SEARCH_MODULE_DOMAIN
&& (*psym)->domain == MODULE_DOMAIN)
- || (search == VARIABLES_DOMAIN
+ || (search == SEARCH_VAR_DOMAIN
&& (*psym)->aclass != LOC_TYPEDEF
&& (*psym)->aclass != LOC_BLOCK)
- || (search == FUNCTIONS_DOMAIN
+ || (search == SEARCH_FUNCTION_DOMAIN
&& (*psym)->aclass == LOC_BLOCK)
- || (search == TYPES_DOMAIN
+ || (search == SEARCH_TYPE_DOMAIN
&& (*psym)->aclass == LOC_TYPEDEF))
&& psymbol_name_matches (*psym, lookup_name)
&& (sym_matcher == NULL
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
domain_enum domain,
- enum search_domain search)
+ domain_search_flags search)
{
/* Clear the search flags. */
for (partial_symtab *ps : partial_symbols (objfile))
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
domain_enum domain,
- enum search_domain kind) override;
+ domain_search_flags kind) override;
struct compunit_symtab *find_pc_sect_compunit_symtab
(struct objfile *objfile, struct bound_minimal_symbol msymbol,
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
expand_symtabs_matching (NULL, lookup_name, NULL, NULL,
SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
- ALL_DOMAIN);
+ SEARCH_ALL);
for (objfile *objfile : current_program_space->objfiles ())
{
minsyms_p = cmp;
}
- global_symbol_searcher spec (FUNCTIONS_DOMAIN, regex);
+ global_symbol_searcher spec (SEARCH_FUNCTION_DOMAIN, regex);
SCOPE_EXIT {
for (const char *elem : spec.filenames)
xfree ((void *) elem);
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
domain_enum domain,
- enum search_domain kind) = 0;
+ domain_search_flags kind) = 0;
/* Return the comp unit from OBJFILE that contains PC and
SECTION. Return NULL if there is no such compunit. This
(SEARCH_GLOBAL_BLOCK
| SEARCH_STATIC_BLOCK),
UNDEF_DOMAIN,
- ALL_DOMAIN))
+ SEARCH_ALL))
{
retval = false;
break;
? SEARCH_GLOBAL_BLOCK
: SEARCH_STATIC_BLOCK,
domain,
- ALL_DOMAIN))
+ SEARCH_ALL))
break;
}
(SEARCH_GLOBAL_BLOCK
| SEARCH_STATIC_BLOCK),
VAR_DOMAIN,
- ALL_DOMAIN);
+ SEARCH_ALL);
}
void
(SEARCH_GLOBAL_BLOCK
| SEARCH_STATIC_BLOCK),
UNDEF_DOMAIN,
- ALL_DOMAIN);
+ SEARCH_ALL);
}
bool
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
domain_enum domain,
- enum search_domain kind)
+ domain_search_flags kind)
{
/* This invariant is documented in quick-functions.h. */
gdb_assert (lookup_name != nullptr || symbol_matcher == nullptr);
host_address_to_string (&file_matcher),
host_address_to_string (&symbol_matcher),
host_address_to_string (&expansion_notify),
- search_domain_name (kind));
+ domain_name (kind).c_str ());
for (const auto &iter : qf)
if (!iter->expand_symtabs_matching (this, file_matcher, lookup_name,
gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
- enum search_domain kind)
+ domain_search_flags kind)
{
for (objfile *objfile : current_program_space->objfiles ())
if (!objfile->expand_symtabs_matching (file_matcher,
gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
block_search_flags search_flags,
- enum search_domain kind);
+ domain_search_flags kind);
void map_symbol_filenames (gdb::function_view<symbol_filename_ftype> fun,
bool need_fullname);
NULL,
SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
UNDEF_DOMAIN,
- ALL_DOMAIN);
+ SEARCH_ALL);
}
\f
}
}
-/* Return the name of a search_domain . */
-
-const char *
-search_domain_name (enum search_domain e)
-{
- switch (e)
- {
- case VARIABLES_DOMAIN: return "VARIABLES_DOMAIN";
- case FUNCTIONS_DOMAIN: return "FUNCTIONS_DOMAIN";
- case TYPES_DOMAIN: return "TYPES_DOMAIN";
- case MODULES_DOMAIN: return "MODULES_DOMAIN";
- case ALL_DOMAIN: return "ALL_DOMAIN";
- default: gdb_assert_not_reached ("bad search_domain");
- }
-}
-
/* See symtab.h. */
std::string
bool
global_symbol_searcher::is_suitable_msymbol
- (const enum search_domain kind, const minimal_symbol *msymbol)
+ (const domain_search_flags kind, const minimal_symbol *msymbol)
{
switch (msymbol->type ())
{
case mst_bss:
case mst_file_data:
case mst_file_bss:
- return kind == VARIABLES_DOMAIN;
+ return (kind & SEARCH_VAR_DOMAIN) != 0;
case mst_text:
case mst_file_text:
case mst_solib_trampoline:
case mst_text_gnu_ifunc:
- return kind == FUNCTIONS_DOMAIN;
+ return (kind & SEARCH_FUNCTION_DOMAIN) != 0;
default:
return false;
}
global_symbol_searcher::expand_symtabs
(objfile *objfile, const std::optional<compiled_regex> &preg) const
{
- enum search_domain kind = m_kind;
+ domain_search_flags kind = m_kind;
bool found_msymbol = false;
auto do_file_match = [&] (const char *filename, bool basenames)
all objfiles. In large programs (1000s of shared libs) searching all
objfiles is not worth the pain. */
if (filenames.empty ()
- && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
+ && (kind & (SEARCH_VAR_DOMAIN | SEARCH_FUNCTION_DOMAIN)) != 0)
{
for (minimal_symbol *msymbol : objfile->msymbols ())
{
in the process we will add matching symbols or
msymbols to the results list, and that requires that
the symbols tables are expanded. */
- if (kind == FUNCTIONS_DOMAIN
+ if ((kind & SEARCH_FUNCTION_DOMAIN) != 0
? (find_pc_compunit_symtab
(msymbol->value_address (objfile)) == NULL)
: (lookup_symbol_in_objfile_from_linkage_name
const std::optional<compiled_regex> &treg,
std::set<symbol_search> *result_set) const
{
- enum search_domain kind = m_kind;
+ domain_search_flags kind = m_kind;
/* Add matching symbols (if not already present). */
for (compunit_symtab *cust : objfile->compunits ())
continue;
bool matches = false;
- if (!matches && kind == VARIABLES_DOMAIN)
+ if (!matches && (kind & SEARCH_VAR_DOMAIN) != 0)
{
if (sym->aclass () != LOC_TYPEDEF
&& sym->aclass () != LOC_UNRESOLVED
|| treg_matches_sym_type_name (*treg, sym)))
matches = true;
}
- if (!matches && kind == FUNCTIONS_DOMAIN)
+ if (!matches && (kind & SEARCH_FUNCTION_DOMAIN) != 0)
{
if (sym->aclass () == LOC_BLOCK
&& (!treg.has_value ()
sym)))
matches = true;
}
- if (!matches && kind == TYPES_DOMAIN)
+ if (!matches && (kind & SEARCH_TYPE_DOMAIN) != 0)
{
if (sym->aclass () == LOC_TYPEDEF
&& sym->domain () != MODULE_DOMAIN)
matches = true;
}
- if (!matches && kind == MODULES_DOMAIN)
+ if (!matches && (kind & SEARCH_MODULE_DOMAIN) != 0)
{
if (sym->domain () == MODULE_DOMAIN
&& sym->line () != 0)
(objfile *objfile, const std::optional<compiled_regex> &preg,
std::vector<symbol_search> *results) const
{
- enum search_domain kind = m_kind;
+ domain_search_flags kind = m_kind;
for (minimal_symbol *msymbol : objfile->msymbols ())
{
{
/* For functions we can do a quick check of whether the
symbol might be found via find_pc_symtab. */
- if (kind != FUNCTIONS_DOMAIN
+ if ((kind & SEARCH_FUNCTION_DOMAIN) == 0
|| (find_pc_compunit_symtab
(msymbol->value_address (objfile)) == NULL))
{
std::optional<compiled_regex> preg;
std::optional<compiled_regex> treg;
- gdb_assert (m_kind != ALL_DOMAIN);
-
if (m_symbol_name_regexp != NULL)
{
const char *symbol_name_regexp = m_symbol_name_regexp;
user wants to see symbols matching a type regexp, then never give a
minimal symbol, as we assume that a minimal symbol does not have a
type. */
- if ((found_msymbol || (filenames.empty () && m_kind == VARIABLES_DOMAIN))
+ if ((found_msymbol
+ || (filenames.empty () && (m_kind & SEARCH_VAR_DOMAIN) != 0))
&& !m_exclude_minsyms
&& !treg.has_value ())
{
- gdb_assert (m_kind == VARIABLES_DOMAIN || m_kind == FUNCTIONS_DOMAIN);
+ gdb_assert ((m_kind & (SEARCH_VAR_DOMAIN | SEARCH_FUNCTION_DOMAIN))
+ != 0);
for (objfile *objfile : current_program_space->objfiles ())
if (!add_matching_msymbols (objfile, preg, &result))
break;
static void
symtab_symbol_info (bool quiet, bool exclude_minsyms,
- const char *regexp, enum search_domain kind,
+ const char *regexp, domain_enum kind,
const char *t_regexp, int from_tty)
{
- static const char * const classnames[] =
- {"variable", "function", "type", "module"};
const char *last_filename = "";
int first = 1;
- gdb_assert (kind != ALL_DOMAIN);
-
if (regexp != nullptr && *regexp == '\0')
regexp = nullptr;
- global_symbol_searcher spec (kind, regexp);
+ domain_search_flags flags = to_search_flags (kind);
+ if (kind == TYPE_DOMAIN)
+ flags |= SEARCH_STRUCT_DOMAIN;
+
+ global_symbol_searcher spec (flags, regexp);
spec.set_symbol_type_regexp (t_regexp);
spec.set_exclude_minsyms (exclude_minsyms);
std::vector<symbol_search> symbols = spec.search ();
if (!quiet)
{
+ const char *classname;
+ switch (kind)
+ {
+ case VAR_DOMAIN:
+ classname = "variable";
+ break;
+ case FUNCTION_DOMAIN:
+ classname = "function";
+ break;
+ case TYPE_DOMAIN:
+ classname = "type";
+ break;
+ case MODULE_DOMAIN:
+ classname = "module";
+ break;
+ default:
+ gdb_assert_not_reached ("invalid domain enum");
+ }
+
if (regexp != NULL)
{
if (t_regexp != NULL)
gdb_printf
(_("All %ss matching regular expression \"%s\""
" with type matching regular expression \"%s\":\n"),
- classnames[kind], regexp, t_regexp);
+ classname, regexp, t_regexp);
else
gdb_printf (_("All %ss matching regular expression \"%s\":\n"),
- classnames[kind], regexp);
+ classname, regexp);
}
else
{
gdb_printf
(_("All defined %ss"
" with type matching regular expression \"%s\" :\n"),
- classnames[kind], t_regexp);
+ classname, t_regexp);
else
- gdb_printf (_("All defined %ss:\n"), classnames[kind]);
+ gdb_printf (_("All defined %ss:\n"), classname);
}
}
args = nullptr;
symtab_symbol_info
- (opts.quiet, opts.exclude_minsyms, args, VARIABLES_DOMAIN,
+ (opts.quiet, opts.exclude_minsyms, args, VAR_DOMAIN,
opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
from_tty);
}
args = nullptr;
symtab_symbol_info
- (opts.quiet, opts.exclude_minsyms, args, FUNCTIONS_DOMAIN,
+ (opts.quiet, opts.exclude_minsyms, args, FUNCTION_DOMAIN,
opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
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, TYPES_DOMAIN, NULL, from_tty);
+ symtab_symbol_info (opts.quiet, false, args, TYPE_DOMAIN, nullptr,
+ from_tty);
}
/* Command completer for 'info types' command. */
(&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
if (args != nullptr && *args == '\0')
args = nullptr;
- symtab_symbol_info (opts.quiet, true, args, MODULES_DOMAIN, NULL,
+ symtab_symbol_info (opts.quiet, true, args, MODULE_DOMAIN, nullptr,
from_tty);
}
}
}
- global_symbol_searcher spec (FUNCTIONS_DOMAIN, regexp);
+ global_symbol_searcher spec (SEARCH_FUNCTION_DOMAIN, regexp);
if (file_name != nullptr)
spec.filenames.push_back (file_name);
std::vector<symbol_search> symbols = spec.search ();
return true;
},
SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
- ALL_DOMAIN);
+ SEARCH_ALL);
/* Search upwards from currently selected frame (so that we can
complete on local vars). Also catch fields of types defined in
std::vector<module_symbol_search>
search_module_symbols (const char *module_regexp, const char *regexp,
- const char *type_regexp, search_domain kind)
+ const char *type_regexp, domain_search_flags kind)
{
std::vector<module_symbol_search> results;
/* Search for all modules matching MODULE_REGEXP. */
- global_symbol_searcher spec1 (MODULES_DOMAIN, module_regexp);
+ global_symbol_searcher spec1 (SEARCH_MODULE_DOMAIN, module_regexp);
spec1.set_exclude_minsyms (true);
std::vector<symbol_search> modules = spec1.search ();
static void
info_module_subcommand (bool quiet, const char *module_regexp,
const char *regexp, const char *type_regexp,
- search_domain kind)
+ domain_search_flags kind)
{
+ gdb_assert (kind == SEARCH_FUNCTION_DOMAIN || kind == SEARCH_VAR_DOMAIN);
+
/* Print a header line. Don't build the header line bit by bit as this
prevents internationalisation. */
if (!quiet)
if (type_regexp == nullptr)
{
if (regexp == nullptr)
- gdb_printf ((kind == VARIABLES_DOMAIN
+ gdb_printf ((kind == SEARCH_VAR_DOMAIN
? _("All variables in all modules:")
: _("All functions in all modules:")));
else
gdb_printf
- ((kind == VARIABLES_DOMAIN
+ ((kind == SEARCH_VAR_DOMAIN
? _("All variables matching regular expression"
" \"%s\" in all modules:")
: _("All functions matching regular expression"
{
if (regexp == nullptr)
gdb_printf
- ((kind == VARIABLES_DOMAIN
+ ((kind == SEARCH_VAR_DOMAIN
? _("All variables with type matching regular "
"expression \"%s\" in all modules:")
: _("All functions with type matching regular "
type_regexp);
else
gdb_printf
- ((kind == VARIABLES_DOMAIN
+ ((kind == SEARCH_VAR_DOMAIN
? _("All variables matching regular expression "
"\"%s\",\n\twith type matching regular "
"expression \"%s\" in all modules:")
{
if (regexp == nullptr)
gdb_printf
- ((kind == VARIABLES_DOMAIN
+ ((kind == SEARCH_VAR_DOMAIN
? _("All variables in all modules matching regular "
"expression \"%s\":")
: _("All functions in all modules matching regular "
module_regexp);
else
gdb_printf
- ((kind == VARIABLES_DOMAIN
+ ((kind == SEARCH_VAR_DOMAIN
? _("All variables matching regular expression "
"\"%s\",\n\tin all modules matching regular "
"expression \"%s\":")
{
if (regexp == nullptr)
gdb_printf
- ((kind == VARIABLES_DOMAIN
+ ((kind == SEARCH_VAR_DOMAIN
? _("All variables with type matching regular "
"expression \"%s\"\n\tin all modules matching "
"regular expression \"%s\":")
type_regexp, module_regexp);
else
gdb_printf
- ((kind == VARIABLES_DOMAIN
+ ((kind == SEARCH_VAR_DOMAIN
? _("All variables matching regular expression "
"\"%s\",\n\twith type matching regular expression "
"\"%s\",\n\tin all modules matching regular "
(opts.quiet,
opts.module_regexp.empty () ? nullptr : opts.module_regexp.c_str (), args,
opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
- FUNCTIONS_DOMAIN);
+ SEARCH_FUNCTION_DOMAIN);
}
/* Implements the 'info module variables' command. */
(opts.quiet,
opts.module_regexp.empty () ? nullptr : opts.module_regexp.c_str (), args,
opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
- VARIABLES_DOMAIN);
+ SEARCH_VAR_DOMAIN);
}
/* Command completer for 'info module ...' sub-commands. */
return (flags & to_search_flags (domain)) != 0;
}
-/* Searching domains, used when searching for symbols. Element numbers are
- hardcoded in GDB, check all enum uses before changing it. */
-
-enum search_domain
-{
- /* Everything in VAR_DOMAIN minus FUNCTIONS_DOMAIN and
- TYPES_DOMAIN. */
- VARIABLES_DOMAIN = 0,
-
- /* All functions -- for some reason not methods, though. */
- FUNCTIONS_DOMAIN = 1,
-
- /* All defined types */
- TYPES_DOMAIN = 2,
-
- /* All modules. */
- MODULES_DOMAIN = 3,
-
- /* Any type. */
- ALL_DOMAIN = 4
-};
-
-extern const char *search_domain_name (enum search_domain);
-
/* An address-class says where to find the value of a symbol. */
enum address_class
public:
/* Constructor. */
- global_symbol_searcher (enum search_domain kind,
+ global_symbol_searcher (domain_search_flags kind,
const char *symbol_name_regexp)
: m_kind (kind),
m_symbol_name_regexp (symbol_name_regexp)
{
- /* The symbol searching is designed to only find one kind of thing. */
- gdb_assert (m_kind != ALL_DOMAIN);
}
/* Set the optional regexp that matches against the symbol type. */
TYPES_DOMAIN - Search all type names.
MODULES_DOMAIN - Search all Fortran modules.
ALL_DOMAIN - Not valid for this function. */
- enum search_domain m_kind;
+ domain_search_flags m_kind;
/* Regular expression to match against the symbol name. */
const char *m_symbol_name_regexp = nullptr;
std::vector<symbol_search> *results) const;
/* Return true if MSYMBOL is of type KIND. */
- static bool is_suitable_msymbol (const enum search_domain kind,
+ static bool is_suitable_msymbol (const domain_search_flags kind,
const minimal_symbol *msymbol);
};
within the module. */
extern std::vector<module_symbol_search> search_module_symbols
(const char *module_regexp, const char *regexp,
- const char *type_regexp, search_domain kind);
+ const char *type_regexp, domain_search_flags 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'
to search all symtabs and program spaces. */
void find_all_symbols (const std::string &name,
const struct language_defn *language,
- enum search_domain search_domain,
+ domain_search_flags domain_search_flags,
std::vector<symtab *> *search_symtabs,
struct program_space *search_pspace);
projects / thirdparty / binutils-gdb.git / commitdiff
