yggdrasil/binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use gdb::function_view in iterate_over_symtabs & co

Browse Source 
I wanted to pass a lambda to iterate_over_symtabs (see following
patch), so I converted it to function_view, and then the rest is
cascaded from that.

This gets rid of a bunch of single-use callback functions and
corresponding manually managed callback capture types
(add_partial_datum, search_symbols_data, etc.) in favor of letting the
compiler generate them for us by using lambdas with a capture.  In a
couple cases, it was more natural to convert the existing function
callbacks to function objects (i.e., operator(), e.g.,
decode_compound_collector).

gdb/ChangeLog:
2017-02-23  Pedro Alves  <palves@redhat.com>

	* ada-lang.c: Include "common/function-view.h".
	(ada_iterate_over_symbols): Adjust to use function_view as
	callback type.
	(struct add_partial_datum, ada_complete_symbol_matcher): Delete.
	(ada_make_symbol_completion_list): Use a lambda.
	(ada_exc_search_name_matches): Delete.
	(name_matches_regex): New.
	(ada_add_global_exceptions): Use a lambda and name_matches_regex.
	* compile/compile-c-support.c: Include "common/function-view.h".
	(print_one_macro): Change prototype to accept a ui_file pointer.
	(write_macro_definitions): Use a lambda.
	* dwarf2read.c: Include "common/function-view.h".
	(dw2_map_expand_apply, dw2_map_symtabs_matching_filename)
	(dw2_expand_symtabs_matching): Adjust to use function_view as
	callback type.
	* language.h: Include "common/function-view.h".
	(struct language_defn) <la_iterate_over_symbols>: Adjust to use
	function_view as callback type.
	(LA_ITERATE_OVER_SYMBOLS): Remove DATA parameter.
	* linespec.c: Include "common/function-view.h".
	(collect_info::add_symbol): New method.
	(struct symbol_and_data_callback, iterate_inline_only, struct
	symbol_matcher_data, iterate_name_matcher): Delete.
	(iterate_over_all_matching_symtabs): Adjust to use function_view
	as callback type and lambdas.
	(iterate_over_file_blocks): Adjust to use function_view as
	callback type.
	(decode_compound_collector): Now a class with private fields.
	(decode_compound_collector::release_symbols): New method.
	(collect_one_symbol): Rename to...
	(decode_compound_collector::operator()): ... this and adjust.
	(lookup_prefix_sym): decode_compound_collector construction bits
	move to decode_compound_collector ctor.  Pass the
	decode_compound_collector object directly as callback.  Remove
	cleanups and use decode_compound_collector::release_symbols
	instead.
	(symtab_collector): Now a class with private fields.
	(symtab_collector::release_symtabs): New method.
	(add_symtabs_to_list): Rename to...
	(symtab_collector::operator()): ... this and adjust.
	(collect_symtabs_from_filename): symtab_collector construction
	bits move to symtab_collector ctor.  Pass the symtab_collector
	object directly as callback.  Remove cleanups and use
	symtab_collector::release_symtabs instead.
	(collect_symbols): Delete.
	(add_matching_symbols_to_info): Use lambdas.
	* macrocmd.c (print_macro_callback): Delete.
	(info_macro_command): Use a lambda.
	(info_macros_command): Pass print_macro_definition as callable
	directly.
	(print_one_macro): Remove 'ignore' parameter.
	(macro_list_command): Adjust.
	* macrotab.c (macro_for_each_data::fn): Now a function_view.
	(macro_for_each_data::user_data): Delete field.
	(foreach_macro): Adjust to call the function_view.
	(macro_for_each): Adjust to use function_view as callback type.
	(foreach_macro_in_scope): Adjust to call the function_view.
	(macro_for_each_in_scope): Adjust to use function_view as callback
	type.
	* macrotab.h: Include "common/function-view.h".
	(macro_callback_fn): Declare a prototype instead of a pointer.
	Remove "user_data" parameter.
	(macro_for_each, macro_for_each_in_scope): Adjust to use
	function_view as callback type.
	* psymtab.c (partial_map_expand_apply)
	(psym_map_symtabs_matching_filename, recursively_search_psymtabs):
	Adjust to use function_view as callback type and to return bool.
	(psym_expand_symtabs_matching): Adjust to use function_view as
	callback types.
	* symfile-debug.c (debug_qf_map_symtabs_matching_filename): Adjust
	to use function_view as callback type and to return bool.
	(debug_qf_expand_symtabs_matching): Adjust to use function_view as
	callback types.
	* symfile.c (expand_symtabs_matching): Adjust to use function_view
	as callback types.
	* symfile.h: Include "common/function-view.h".
	(expand_symtabs_file_matcher_ftype)
	(expand_symtabs_symbol_matcher_ftype)
	(expand_symtabs_exp_notify_ftype): Remove "data" parameter and
	return bool.
	(quick_symbol_functions::map_symtabs_matching_filename)
	(quick_symbol_functions::expand_symtabs_matching): Adjust to use
	function_view as callback type and return bool.
	(expand_symtabs_matching): Adjust to use function_view as callback
	type.
	(maintenance_expand_name_matcher)
	(maintenance_expand_file_matcher): Delete.
	(maintenance_expand_symtabs): Use lambdas.
	* symtab.c (iterate_over_some_symtabs): Adjust to use
	function_view as callback types and return bool.
	(iterate_over_symtabs): Likewise.  Use unique_xmalloc_ptr instead
	of a cleanup.
	(lookup_symtab_callback): Delete.
	(lookup_symtab): Use a lambda.
	(iterate_over_symbols): Adjust to use function_view as callback
	type.
	(struct search_symbols_data, search_symbols_file_matches)
	(search_symbols_name_matches): Delete.
	(search_symbols): Use a pair of lambdas.
	(struct add_name_data, add_macro_name, symbol_completion_matcher)
	(symtab_expansion_callback): Delete.
	(default_make_symbol_completion_list_break_on_1): Use lambdas.
	* symtab.h: Include "common/function-view.h".
	(iterate_over_some_symtabs): Adjust to use function_view as
	callback type and return bool.
	(iterate_over_symtabs): Adjust to use function_view as callback
	type.
	(symbol_found_callback_ftype): Remove 'data' parameter and return
	bool.
	(iterate_over_symbols): Adjust to use function_view as callback
	type.
This commit is contained in:
Pedro Alves 2017-02-22 14:43:35 +00:00
parent 07e253aa3b
commit 14bc53a814
16 changed files with 579 additions and 688 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
gdb/ChangeLog
View File

@ -1,3 +1,117 @@
2017-02-23 Pedro Alves <palves@redhat.com>
* ada-lang.c: Include "common/function-view.h".
(ada_iterate_over_symbols): Adjust to use function_view as
callback type.
(struct add_partial_datum, ada_complete_symbol_matcher): Delete.
(ada_make_symbol_completion_list): Use a lambda.
(ada_exc_search_name_matches): Delete.
(name_matches_regex): New.
(ada_add_global_exceptions): Use a lambda and name_matches_regex.
* compile/compile-c-support.c: Include "common/function-view.h".
(print_one_macro): Change prototype to accept a ui_file pointer.
(write_macro_definitions): Use a lambda.
* dwarf2read.c: Include "common/function-view.h".
(dw2_map_expand_apply, dw2_map_symtabs_matching_filename)
(dw2_expand_symtabs_matching): Adjust to use function_view as
callback type.
* language.h: Include "common/function-view.h".
(struct language_defn) <la_iterate_over_symbols>: Adjust to use
function_view as callback type.
(LA_ITERATE_OVER_SYMBOLS): Remove DATA parameter.
* linespec.c: Include "common/function-view.h".
(collect_info::add_symbol): New method.
(struct symbol_and_data_callback, iterate_inline_only, struct
symbol_matcher_data, iterate_name_matcher): Delete.
(iterate_over_all_matching_symtabs): Adjust to use function_view
as callback type and lambdas.
(iterate_over_file_blocks): Adjust to use function_view as
callback type.
(decode_compound_collector): Now a class with private fields.
(decode_compound_collector::release_symbols): New method.
(collect_one_symbol): Rename to...
(decode_compound_collector::operator()): ... this and adjust.
(lookup_prefix_sym): decode_compound_collector construction bits
move to decode_compound_collector ctor. Pass the
decode_compound_collector object directly as callback. Remove
cleanups and use decode_compound_collector::release_symbols
instead.
(symtab_collector): Now a class with private fields.
(symtab_collector::release_symtabs): New method.
(add_symtabs_to_list): Rename to...
(symtab_collector::operator()): ... this and adjust.
(collect_symtabs_from_filename): symtab_collector construction
bits move to symtab_collector ctor. Pass the symtab_collector
object directly as callback. Remove cleanups and use
symtab_collector::release_symtabs instead.
(collect_symbols): Delete.
(add_matching_symbols_to_info): Use lambdas.
* macrocmd.c (print_macro_callback): Delete.
(info_macro_command): Use a lambda.
(info_macros_command): Pass print_macro_definition as callable
directly.
(print_one_macro): Remove 'ignore' parameter.
(macro_list_command): Adjust.
* macrotab.c (macro_for_each_data::fn): Now a function_view.
(macro_for_each_data::user_data): Delete field.
(foreach_macro): Adjust to call the function_view.
(macro_for_each): Adjust to use function_view as callback type.
(foreach_macro_in_scope): Adjust to call the function_view.
(macro_for_each_in_scope): Adjust to use function_view as callback
type.
* macrotab.h: Include "common/function-view.h".
(macro_callback_fn): Declare a prototype instead of a pointer.
Remove "user_data" parameter.
(macro_for_each, macro_for_each_in_scope): Adjust to use
function_view as callback type.
* psymtab.c (partial_map_expand_apply)
(psym_map_symtabs_matching_filename, recursively_search_psymtabs):
Adjust to use function_view as callback type and to return bool.
(psym_expand_symtabs_matching): Adjust to use function_view as
callback types.
* symfile-debug.c (debug_qf_map_symtabs_matching_filename): Adjust
to use function_view as callback type and to return bool.
(debug_qf_expand_symtabs_matching): Adjust to use function_view as
callback types.
* symfile.c (expand_symtabs_matching): Adjust to use function_view
as callback types.
* symfile.h: Include "common/function-view.h".
(expand_symtabs_file_matcher_ftype)
(expand_symtabs_symbol_matcher_ftype)
(expand_symtabs_exp_notify_ftype): Remove "data" parameter and
return bool.
(quick_symbol_functions::map_symtabs_matching_filename)
(quick_symbol_functions::expand_symtabs_matching): Adjust to use
function_view as callback type and return bool.
(expand_symtabs_matching): Adjust to use function_view as callback
type.
(maintenance_expand_name_matcher)
(maintenance_expand_file_matcher): Delete.
(maintenance_expand_symtabs): Use lambdas.
* symtab.c (iterate_over_some_symtabs): Adjust to use
function_view as callback types and return bool.
(iterate_over_symtabs): Likewise. Use unique_xmalloc_ptr instead
of a cleanup.
(lookup_symtab_callback): Delete.
(lookup_symtab): Use a lambda.
(iterate_over_symbols): Adjust to use function_view as callback
type.
(struct search_symbols_data, search_symbols_file_matches)
(search_symbols_name_matches): Delete.
(search_symbols): Use a pair of lambdas.
(struct add_name_data, add_macro_name, symbol_completion_matcher)
(symtab_expansion_callback): Delete.
(default_make_symbol_completion_list_break_on_1): Use lambdas.
* symtab.h: Include "common/function-view.h".
(iterate_over_some_symtabs): Adjust to use function_view as
callback type and return bool.
(iterate_over_symtabs): Adjust to use function_view as callback
type.
(symbol_found_callback_ftype): Remove 'data' parameter and return
bool.
(iterate_over_symbols): Adjust to use function_view as callback
type.
2017-02-23 Pedro Alves <palves@redhat.com>
* Makefile.in (SUBDIR_UNITTESTS_SRCS, SUBDIR_UNITTESTS_OBS): New.

107
gdb/ada-lang.c
View File

@ -60,6 +60,7 @@
#include "mi/mi-common.h"
#include "arch-utils.h"
#include "cli/cli-utils.h"
#include "common/function-view.h"
/* Define whether or not the C operator '/' truncates towards zero for
differently signed operands (truncation direction is undefined in C).
@ -5850,10 +5851,9 @@ ada_lookup_symbol_list (const char *name0, const struct block *block0,
/* Implementation of the la_iterate_over_symbols method. */
static void
ada_iterate_over_symbols (const struct block *block,
const char *name, domain_enum domain,
symbol_found_callback_ftype *callback,
void *data)
ada_iterate_over_symbols
(const struct block *block, const char *name, domain_enum domain,
gdb::function_view<symbol_found_callback_ftype> callback)
{
int ndefs, i;
struct block_symbol *results;
@ -5861,7 +5861,7 @@ ada_iterate_over_symbols (const struct block *block,
ndefs = ada_lookup_symbol_list_worker (name, block, domain, &results, 0);
for (i = 0; i < ndefs; ++i)
{
if (! (*callback) (results[i].symbol, data))
if (!callback (results[i].symbol))
break;
}
}
@ -6497,30 +6497,6 @@ symbol_completion_add (VEC(char_ptr) **sv,
VEC_safe_push (char_ptr, *sv, completion);
}
/* An object of this type is passed as the user_data argument to the
expand_symtabs_matching method. */
struct add_partial_datum
{
VEC(char_ptr) **completions;
const char *text;
int text_len;
const char *text0;
const char *word;
int wild_match;
int encoded;
};
/* A callback for expand_symtabs_matching. */
static int
ada_complete_symbol_matcher (const char *name, void *user_data)
{
struct add_partial_datum *data = (struct add_partial_datum *) user_data;
return symbol_completion_match (name, data->text, data->text_len,
data->wild_match, data->encoded) != NULL;
}
/* Return a list of possible symbol names completing TEXT0. WORD is
the entire command on which completion is made. */
@ -6569,19 +6545,16 @@ ada_make_symbol_completion_list (const char *text0, const char *word,
}
/* First, look at the partial symtab symbols. */
{
struct add_partial_datum data;
data.completions = &completions;
data.text = text;
data.text_len = text_len;
data.text0 = text0;
data.word = word;
data.wild_match = wild_match_p;
data.encoded = encoded_p;
expand_symtabs_matching (NULL, ada_complete_symbol_matcher, NULL,
ALL_DOMAIN, &data);
}
expand_symtabs_matching (NULL,
[&] (const char *symname)
{
return symbol_completion_match (symname,
text, text_len,
wild_match_p,
encoded_p);
},
NULL,
ALL_DOMAIN);
/* At this point scan through the misc symbol vectors and add each
symbol you find to the list. Eventually we want to ignore
@ -13267,30 +13240,6 @@ sort_remove_dups_ada_exceptions_list (VEC(ada_exc_info) **exceptions,
VEC_truncate(ada_exc_info, *exceptions, skip + to_sort_len);
}
/* A function intended as the "name_matcher" callback in the struct
quick_symbol_functions' expand_symtabs_matching method.
SEARCH_NAME is the symbol's search name.
If USER_DATA is not NULL, it is a pointer to a regext_t object
used to match the symbol (by natural name). Otherwise, when USER_DATA
is null, no filtering is performed, and all symbols are a positive
match. */
static int
ada_exc_search_name_matches (const char *search_name, void *user_data)
{
regex_t *preg = (regex_t *) user_data;
if (preg == NULL)
return 1;
/* In Ada, the symbol "search name" is a linkage name, whereas
the regular expression used to do the matching refers to
the natural name. So match against the decoded name. */
return (regexec (preg, ada_decode (search_name), 0, NULL, 0) == 0);
}
/* Add all exceptions defined by the Ada standard whose name match
a regular expression.
@ -13370,6 +13319,15 @@ ada_add_exceptions_from_frame (regex_t *preg, struct frame_info *frame,
}
}
/* Return true if NAME matches PREG or if PREG is NULL. */
static bool
name_matches_regex (const char *name, regex_t *preg)
{
return (preg == NULL
|| regexec (preg, ada_decode (name), 0, NULL, 0) == 0);
}
/* Add all exceptions defined globally whose name name match
a regular expression, excluding standard exceptions.
@ -13395,8 +13353,17 @@ ada_add_global_exceptions (regex_t *preg, VEC(ada_exc_info) **exceptions)
struct objfile *objfile;
struct compunit_symtab *s;
expand_symtabs_matching (NULL, ada_exc_search_name_matches, NULL,
VARIABLES_DOMAIN, preg);
/* In Ada, the symbol "search name" is a linkage name, whereas the
regular expression used to do the matching refers to the natural
name. So match against the decoded name. */
expand_symtabs_matching (NULL,
[&] (const char *search_name)
{
const char *decoded = ada_decode (search_name);
return name_matches_regex (decoded, preg);
},
NULL,
VARIABLES_DOMAIN);
ALL_COMPUNITS (objfile, s)
{
@ -13411,9 +13378,7 @@ ada_add_global_exceptions (regex_t *preg, VEC(ada_exc_info) **exceptions)
ALL_BLOCK_SYMBOLS (b, iter, sym)
if (ada_is_non_standard_exception_sym (sym)
&& (preg == NULL
|| regexec (preg, SYMBOL_NATURAL_NAME (sym),
0, NULL, 0) == 0))
&& name_matches_regex (SYMBOL_NATURAL_NAME (sym), preg))
{
struct ada_exc_info info
= {SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE_ADDRESS (sym)};

16
gdb/compile/compile-c-support.c
View File

@ -25,6 +25,7 @@
#include "macrotab.h"
#include "macroscope.h"
#include "regcache.h"
#include "common/function-view.h"
/* See compile-internal.h. */
@ -122,10 +123,8 @@ c_get_compile_context (void)
static void
print_one_macro (const char *name, const struct macro_definition *macro,
struct macro_source_file *source, int line,
void *user_data)
ui_file *file)
{
struct ui_file *file = (struct ui_file *) user_data;
/* Don't print command-line defines. They will be supplied another
way. */
if (line == 0)
@ -168,7 +167,16 @@ write_macro_definitions (const struct block *block, CORE_ADDR pc,
scope = user_macro_scope ();
if (scope != NULL && scope->file != NULL && scope->file->table != NULL)
macro_for_each_in_scope (scope->file, scope->line, print_one_macro, file);
{
macro_for_each_in_scope (scope->file, scope->line,
[&] (const char *name,
const macro_definition *macro,
macro_source_file *source,
int line)
{
print_one_macro (name, macro, source, line, file);
});
}
}
/* Helper function to construct a header scope for a block of code.

51
gdb/dwarf2read.c
View File

@ -70,6 +70,7 @@
#include "build-id.h"
#include "namespace.h"
#include "common/gdb_unlinker.h"
#include "common/function-view.h"
#include <fcntl.h>
#include <sys/types.h>
@ -3490,8 +3491,7 @@ static int
dw2_map_expand_apply (struct objfile *objfile,
struct dwarf2_per_cu_data *per_cu,
const char *name, const char *real_path,
int (*callback) (struct symtab *, void *),
void *data)
gdb::function_view<bool (symtab *)> callback)
{
struct compunit_symtab *last_made = objfile->compunit_symtabs;
@ -3503,17 +3503,16 @@ dw2_map_expand_apply (struct objfile *objfile,
all of them. */
dw2_instantiate_symtab (per_cu);
return iterate_over_some_symtabs (name, real_path, callback, data,
objfile->compunit_symtabs, last_made);
return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
last_made, callback);
}
/* Implementation of the map_symtabs_matching_filename method. */
static int
dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
const char *real_path,
int (*callback) (struct symtab *, void *),
void *data)
static bool
dw2_map_symtabs_matching_filename
(struct objfile *objfile, const char *name, const char *real_path,
gdb::function_view<bool (symtab *)> callback)
{
int i;
const char *name_basename = lbasename (name);
@ -3545,8 +3544,8 @@ dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
if (compare_filenames_for_search (this_name, name))
{
if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
callback, data))
return 1;
callback))
return true;
continue;
}
@ -3560,8 +3559,8 @@ dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
if (compare_filenames_for_search (this_real_name, name))
{
if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
callback, data))
return 1;
callback))
return true;
continue;
}
@ -3573,15 +3572,15 @@ dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
&& FILENAME_CMP (real_path, this_real_name) == 0)
{
if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
callback, data))
return 1;
callback))
return true;
continue;
}
}
}
}
return 0;
return false;
}
/* Struct used to manage iterating over all CUs looking for a symbol. */
@ -3919,11 +3918,10 @@ dw2_map_matching_symbols (struct objfile *objfile,
static void
dw2_expand_symtabs_matching
(struct objfile *objfile,
expand_symtabs_file_matcher_ftype *file_matcher,
expand_symtabs_symbol_matcher_ftype *symbol_matcher,
expand_symtabs_exp_notify_ftype *expansion_notify,
enum search_domain kind,
void *data)
gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
enum search_domain kind)
{
int i;
offset_type iter;
@ -3979,7 +3977,7 @@ dw2_expand_symtabs_matching
{
const char *this_real_name;
if (file_matcher (file_data->file_names[j], data, 0))
if (file_matcher (file_data->file_names[j], false))
{
per_cu->v.quick->mark = 1;
break;
@ -3989,11 +3987,11 @@ dw2_expand_symtabs_matching
files are involved, do a quick comparison of the basenames. */
if (!basenames_may_differ
&& !file_matcher (lbasename (file_data->file_names[j]),
data, 1))
true))
continue;
this_real_name = dw2_get_real_path (objfile, file_data, j);
if (file_matcher (this_real_name, data, 0))
if (file_matcher (this_real_name, false))
{
per_cu->v.quick->mark = 1;
break;
@ -4022,7 +4020,7 @@ dw2_expand_symtabs_matching
name = index->constant_pool + MAYBE_SWAP (index->symbol_table[idx]);
if (! (*symbol_matcher) (name, data))
if (!symbol_matcher (name))
continue;
/* The name was matched, now expand corresponding CUs that were
@ -4100,8 +4098,7 @@ dw2_expand_symtabs_matching
&& symtab_was_null
&& per_cu->v.quick->compunit_symtab != NULL)
{
expansion_notify (per_cu->v.quick->compunit_symtab,
data);
expansion_notify (per_cu->v.quick->compunit_symtab);
}
}
}

19
gdb/language.h
View File

@ -24,6 +24,7 @@
#define LANGUAGE_H 1
#include "symtab.h"
#include "common/function-view.h"
/* Forward decls for prototypes. */
struct value;
@ -372,18 +373,15 @@ struct language_defn
The caller is responsible for iterating up through superblocks
if desired.
For each one, call CALLBACK with the symbol and the DATA
argument. If CALLBACK returns zero, the iteration ends at that
point.
For each one, call CALLBACK with the symbol. If CALLBACK
returns false, the iteration ends at that point.
This field may not be NULL. If the language does not need any
special processing here, 'iterate_over_symbols' should be
used as the definition. */
void (*la_iterate_over_symbols) (const struct block *block,
const char *name,
domain_enum domain,
symbol_found_callback_ftype *callback,
void *data);
void (*la_iterate_over_symbols)
(const struct block *block, const char *name, domain_enum domain,
gdb::function_view<symbol_found_callback_ftype> callback);
/* Various operations on varobj. */
const struct lang_varobj_ops *la_varobj_ops;
@ -527,9 +525,8 @@ extern enum language set_language (enum language);
#define LA_PRINT_ARRAY_INDEX(index_value, stream, options) \
(current_language->la_print_array_index(index_value, stream, options))
#define LA_ITERATE_OVER_SYMBOLS(BLOCK, NAME, DOMAIN, CALLBACK, DATA) \
(current_language->la_iterate_over_symbols (BLOCK, NAME, DOMAIN, CALLBACK, \
DATA))
#define LA_ITERATE_OVER_SYMBOLS(BLOCK, NAME, DOMAIN, CALLBACK) \
(current_language->la_iterate_over_symbols (BLOCK, NAME, DOMAIN, CALLBACK))
/* Test a character to decide whether it can be printed in literal form
or needs to be printed in another representation. For example,

313
gdb/linespec.c
View File

@ -44,6 +44,7 @@
#include "ada-lang.h"
#include "stack.h"
#include "location.h"
#include "common/function-view.h"
typedef struct symbol *symbolp;
DEF_VEC_P (symbolp);
@ -171,8 +172,23 @@ struct collect_info
VEC (symbolp) *symbols;
VEC (bound_minimal_symbol_d) *minimal_symbols;
} result;
/* Possibly add a symbol to the results. */
bool add_symbol (symbol *sym);
};
bool
collect_info::add_symbol (symbol *sym)
{
/* In list mode, add all matching symbols, regardless of class.
This allows the user to type "list a_global_variable". */
if (SYMBOL_CLASS (sym) == LOC_BLOCK || this->state->list_mode)
VEC_safe_push (symbolp, this->result.symbols, sym);
/* Continue iterating. */
return true;
}
/* Token types */
enum ls_token_type
@ -264,10 +280,9 @@ typedef struct ls_parser linespec_parser;
/* Prototypes for local functions. */
static void iterate_over_file_blocks (struct symtab *symtab,
const char *name, domain_enum domain,
symbol_found_callback_ftype *callback,
void *data);
static void iterate_over_file_blocks
(struct symtab *symtab, const char *name, domain_enum domain,
gdb::function_view<symbol_found_callback_ftype> callback);
static void initialize_defaults (struct symtab **default_symtab,
int *default_line);
@ -916,83 +931,26 @@ maybe_add_address (htab_t set, struct program_space *pspace, CORE_ADDR addr)
return 1;
}
/* A callback function and the additional data to call it with. */
struct symbol_and_data_callback
{
/* The callback to use. */
symbol_found_callback_ftype *callback;
/* Data to be passed to the callback. */
void *data;
};
/* A helper for iterate_over_all_matching_symtabs that is used to
restrict calls to another callback to symbols representing inline
symbols only. */
static int
iterate_inline_only (struct symbol *sym, void *d)
{
if (SYMBOL_INLINED (sym))
{
struct symbol_and_data_callback *cad
= (struct symbol_and_data_callback *) d;
return cad->callback (sym, cad->data);
}
return 1; /* Continue iterating. */
}
/* Some data for the expand_symtabs_matching callback. */
struct symbol_matcher_data
{
/* The lookup name against which symbol name should be compared. */
const char *lookup_name;
/* The routine to be used for comparison. */
symbol_name_cmp_ftype symbol_name_cmp;
};
/* A helper for iterate_over_all_matching_symtabs that is passed as a
callback to the expand_symtabs_matching method. */
static int
iterate_name_matcher (const char *name, void *d)
{
const struct symbol_matcher_data *data
= (const struct symbol_matcher_data *) d;
if (data->symbol_name_cmp (name, data->lookup_name) == 0)
return 1; /* Expand this symbol's symbol table. */
return 0; /* Skip this symbol. */
}
/* A helper that walks over all matching symtabs in all objfiles and
calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
not NULL, then the search is restricted to just that program
space. If INCLUDE_INLINE is nonzero then symbols representing
space. If INCLUDE_INLINE is true then symbols representing
inlined instances of functions will be included in the result. */
static void
iterate_over_all_matching_symtabs (struct linespec_state *state,
const char *name,
const domain_enum domain,
symbol_found_callback_ftype *callback,
void *data,
struct program_space *search_pspace,
int include_inline)
iterate_over_all_matching_symtabs
(struct linespec_state *state, const char *name, const domain_enum domain,
struct program_space *search_pspace, bool include_inline,
gdb::function_view<symbol_found_callback_ftype> callback)
{
struct objfile *objfile;
struct program_space *pspace;
struct symbol_matcher_data matcher_data;
matcher_data.lookup_name = name;
matcher_data.symbol_name_cmp =
state->language->la_get_symbol_name_cmp != NULL
? state->language->la_get_symbol_name_cmp (name)
: strcmp_iw;
/* The routine to be used for comparison. */
symbol_name_cmp_ftype symbol_name_cmp
= (state->language->la_get_symbol_name_cmp != NULL
? state->language->la_get_symbol_name_cmp (name)
: strcmp_iw);
ALL_PSPACES (pspace)
{
@ -1008,20 +966,24 @@ iterate_over_all_matching_symtabs (struct linespec_state *state,
struct compunit_symtab *cu;
if (objfile->sf)
objfile->sf->qf->expand_symtabs_matching (objfile, NULL,
iterate_name_matcher,
NULL, ALL_DOMAIN,
&matcher_data);
objfile->sf->qf->expand_symtabs_matching
(objfile,
NULL,
[&] (const char *symbol_name)
{
return symbol_name_cmp (symbol_name, name) == 0;
},
NULL,
ALL_DOMAIN);
ALL_OBJFILE_COMPUNITS (objfile, cu)
{
struct symtab *symtab = COMPUNIT_FILETABS (cu);
iterate_over_file_blocks (symtab, name, domain, callback, data);
iterate_over_file_blocks (symtab, name, domain, callback);
if (include_inline)
{
struct symbol_and_data_callback cad = { callback, data };
struct block *block;
int i;
@ -1031,7 +993,14 @@ iterate_over_all_matching_symtabs (struct linespec_state *state,
{
block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), i);
state->language->la_iterate_over_symbols
(block, name, domain, iterate_inline_only, &cad);
(block, name, domain, [&] (symbol *sym)
{
/* Restrict calls to CALLBACK to symbols
representing inline symbols only. */
if (SYMBOL_INLINED (sym))
return callback (sym);
return true;
});
}
}
}
@ -1060,16 +1029,16 @@ get_current_search_block (void)
/* Iterate over static and global blocks. */
static void
iterate_over_file_blocks (struct symtab *symtab,
const char *name, domain_enum domain,
symbol_found_callback_ftype *callback, void *data)
iterate_over_file_blocks
(struct symtab *symtab, const char *name, domain_enum domain,
gdb::function_view<symbol_found_callback_ftype> callback)
{
struct block *block;
for (block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), STATIC_BLOCK);
block != NULL;
block = BLOCK_SUPERBLOCK (block))
LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback, data);
LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback);
}
/* A helper for find_method. This finds all methods in type T which
@ -2824,60 +2793,70 @@ decode_objc (struct linespec_state *self, linespec_p ls, const char *arg)
return values;
}
/* An instance of this type is used when collecting prefix symbols for
decode_compound. */
struct decode_compound_collector
/* A function object that serves as symbol_found_callback_ftype
callback for iterate_over_symbols. This is used by
lookup_prefix_sym to collect type symbols. */
class decode_compound_collector
{
/* The result vector. */
VEC (symbolp) *symbols;
/* A hash table of all symbols we found. We use this to avoid
adding any symbol more than once. */
htab_t unique_syms;
public:
decode_compound_collector ()
: symbols (NULL),
unique_syms (NULL)
: m_symbols (NULL)
{
m_unique_syms = htab_create_alloc (1, htab_hash_pointer,
htab_eq_pointer, NULL,
xcalloc, xfree);
}
~decode_compound_collector ()
{
if (unique_syms != NULL)
htab_delete (unique_syms);
if (m_unique_syms != NULL)
htab_delete (m_unique_syms);
}
/* Releases ownership of the collected symbols and returns them. */
VEC (symbolp) *release_symbols ()
{
VEC (symbolp) *res = m_symbols;
m_symbols = NULL;
return res;
}
/* Callable as a symbol_found_callback_ftype callback. */
bool operator () (symbol *sym);
private:
/* A hash table of all symbols we found. We use this to avoid
adding any symbol more than once. */
htab_t m_unique_syms;
/* The result vector. */
VEC (symbolp) *m_symbols;
};
/* A callback for iterate_over_symbols that is used by
lookup_prefix_sym to collect type symbols. */
static int
collect_one_symbol (struct symbol *sym, void *d)
bool
decode_compound_collector::operator () (symbol *sym)
{
struct decode_compound_collector *collector
= (struct decode_compound_collector *) d;
void **slot;
struct type *t;
if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
return 1; /* Continue iterating. */
return true; /* Continue iterating. */
t = SYMBOL_TYPE (sym);
t = check_typedef (t);
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION
&& TYPE_CODE (t) != TYPE_CODE_NAMESPACE)
return 1; /* Continue iterating. */
return true; /* Continue iterating. */
slot = htab_find_slot (collector->unique_syms, sym, INSERT);
slot = htab_find_slot (m_unique_syms, sym, INSERT);
if (!*slot)
{
*slot = sym;
VEC_safe_push (symbolp, collector->symbols, sym);
VEC_safe_push (symbolp, m_symbols, sym);
}
return 1; /* Continue iterating. */
return true; /* Continue iterating. */
}
/* Return any symbols corresponding to CLASS_NAME in FILE_SYMTABS. */
@ -2888,27 +2867,16 @@ lookup_prefix_sym (struct linespec_state *state, VEC (symtab_ptr) *file_symtabs,
{
int ix;
struct symtab *elt;
struct decode_compound_collector collector;
struct cleanup *outer;
struct cleanup *cleanup;
collector.symbols = NULL;
outer = make_cleanup (VEC_cleanup (symbolp), &collector.symbols);
collector.unique_syms = htab_create_alloc (1, htab_hash_pointer,
htab_eq_pointer, NULL,
xcalloc, xfree);
decode_compound_collector collector;
for (ix = 0; VEC_iterate (symtab_ptr, file_symtabs, ix, elt); ++ix)
{
if (elt == NULL)
{
iterate_over_all_matching_symtabs (state, class_name, STRUCT_DOMAIN,
collect_one_symbol, &collector,
NULL, 0);
NULL, false, collector);
iterate_over_all_matching_symtabs (state, class_name, VAR_DOMAIN,
collect_one_symbol, &collector,
NULL, 0);
NULL, false, collector);
}
else
{
@ -2916,15 +2884,12 @@ lookup_prefix_sym (struct linespec_state *state, VEC (symtab_ptr) *file_symtabs,
been filtered out earlier. */
gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
set_current_program_space (SYMTAB_PSPACE (elt));
iterate_over_file_blocks (elt, class_name, STRUCT_DOMAIN,
collect_one_symbol, &collector);
iterate_over_file_blocks (elt, class_name, VAR_DOMAIN,
collect_one_symbol, &collector);
iterate_over_file_blocks (elt, class_name, STRUCT_DOMAIN, collector);
iterate_over_file_blocks (elt, class_name, VAR_DOMAIN, collector);
}
}
discard_cleanups (outer);
return collector.symbols;
return collector.release_symbols ();
}
/* A qsort comparison function for symbols. The resulting order does
@ -3130,45 +3095,57 @@ find_method (struct linespec_state *self, VEC (symtab_ptr) *file_symtabs,
/* This object is used when collecting all matching symtabs. */
/* This function object is a callback for iterate_over_symtabs, used
when collecting all matching symtabs. */
struct symtab_collector
class symtab_collector
{
/* The result vector of symtabs. */
VEC (symtab_ptr) *symtabs;
/* This is used to ensure the symtabs are unique. */
htab_t symtab_table;
public:
symtab_collector ()
: symtabs (NULL),
symtab_table (NULL)
{
m_symtabs = NULL;
m_symtab_table = htab_create (1, htab_hash_pointer, htab_eq_pointer,
NULL);
}
~symtab_collector ()
{
if (symtab_table != NULL)
htab_delete (symtab_table);
if (m_symtab_table != NULL)
htab_delete (m_symtab_table);
}
/* Callable as a symbol_found_callback_ftype callback. */
bool operator () (symtab *sym);
/* Releases ownership of the collected symtabs and returns them. */
VEC (symtab_ptr) *release_symtabs ()
{
VEC (symtab_ptr) *res = m_symtabs;
m_symtabs = NULL;
return res;
}
private:
/* The result vector of symtabs. */
VEC (symtab_ptr) *m_symtabs;
/* This is used to ensure the symtabs are unique. */
htab_t m_symtab_table;
};
/* Callback for iterate_over_symtabs. */
static int
add_symtabs_to_list (struct symtab *symtab, void *d)
bool
symtab_collector::operator () (struct symtab *symtab)
{
struct symtab_collector *data = (struct symtab_collector *) d;
void **slot;
slot = htab_find_slot (data->symtab_table, symtab, INSERT);
slot = htab_find_slot (m_symtab_table, symtab, INSERT);
if (!*slot)
{
*slot = symtab;
VEC_safe_push (symtab_ptr, data->symtabs, symtab);
VEC_safe_push (symtab_ptr, m_symtabs, symtab);
}
return 0;
return false;
}
/* Given a file name, return a VEC of all matching symtabs. If
@ -3179,33 +3156,29 @@ static VEC (symtab_ptr) *
collect_symtabs_from_filename (const char *file,
struct program_space *search_pspace)
{
struct symtab_collector collector;
struct cleanup *cleanups;
struct program_space *pspace;
collector.symtabs = NULL;
collector.symtab_table = htab_create (1, htab_hash_pointer, htab_eq_pointer,
NULL);
symtab_collector collector;
/* Find that file's data. */
if (search_pspace == NULL)
{
struct program_space *pspace;
ALL_PSPACES (pspace)
{
if (pspace->executing_startup)
continue;
set_current_program_space (pspace);
iterate_over_symtabs (file, add_symtabs_to_list, &collector);
iterate_over_symtabs (file, collector);
}
}
else
{
set_current_program_space (search_pspace);
iterate_over_symtabs (file, add_symtabs_to_list, &collector);
iterate_over_symtabs (file, collector);
}
return collector.symtabs;
return collector.release_symtabs ();
}
/* Return all the symtabs associated to the FILENAME. If SEARCH_PSPACE is
@ -3577,20 +3550,6 @@ linespec_parse_variable (struct linespec_state *self, const char *variable)
}
/* A callback used to possibly add a symbol to the results. */
static int
collect_symbols (struct symbol *sym, void *data)
{
struct collect_info *info = (struct collect_info *) data;
/* In list mode, add all matching symbols, regardless of class.
This allows the user to type "list a_global_variable". */
if (SYMBOL_CLASS (sym) == LOC_BLOCK || info->state->list_mode)
VEC_safe_push (symbolp, info->result.symbols, sym);
return 1; /* Continue iterating. */
}
/* We've found a minimal symbol MSYMBOL in OBJFILE to associate with our
linespec; return the SAL in RESULT. This function should return SALs
matching those from find_function_start_sal, otherwise false
@ -3858,8 +3817,8 @@ add_matching_symbols_to_info (const char *name,
if (elt == NULL)
{
iterate_over_all_matching_symtabs (info->state, name, VAR_DOMAIN,
collect_symbols, info,
pspace, 1);
pspace, true, [&] (symbol *sym)
{ return info->add_symbol (sym); });
search_minsyms_for_name (info, name, pspace, NULL);
}
else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt))
@ -3870,8 +3829,8 @@ add_matching_symbols_to_info (const char *name,
been filtered out earlier. */
gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
set_current_program_space (SYMTAB_PSPACE (elt));
iterate_over_file_blocks (elt, name, VAR_DOMAIN,
collect_symbols, info);
iterate_over_file_blocks (elt, name, VAR_DOMAIN, [&] (symbol *sym)
{ return info->add_symbol (sym); });
/* If no new symbols were found in this iteration and this symtab
is in assembler, we might actually be looking for a label for

30
gdb/macrocmd.c
View File

@ -186,20 +186,6 @@ print_macro_definition (const char *name,
fprintf_filtered (gdb_stdout, "=%s\n", d->replacement);
}
/* A callback function for usage with macro_for_each and friends.
If USER_DATA is null all macros will be printed.
Otherwise USER_DATA is considered to be a string, printing
only macros who's NAME matches USER_DATA. Other arguments are
routed to print_macro_definition. */
static void
print_macro_callback (const char *name, const struct macro_definition *macro,
struct macro_source_file *source, int line,
void *user_data)
{
if (! user_data || strcmp ((const char *) user_data, name) == 0)
print_macro_definition (name, macro, source, line);
}
/* The implementation of the `info macro' command. */
static void
info_macro_command (char *args, int from_tty)
@ -248,7 +234,14 @@ info_macro_command (char *args, int from_tty)
if (! ms)
macro_inform_no_debuginfo ();
else if (show_all_macros_named)
macro_for_each (ms->file->table, print_macro_callback, name);
macro_for_each (ms->file->table, [&] (const char *macro_name,
const macro_definition *macro,
macro_source_file *source,
int line)
{
if (strcmp (name, macro_name) == 0)
print_macro_definition (name, macro, source, line);
});
else
{
struct macro_definition *d;
@ -296,7 +289,7 @@ info_macros_command (char *args, int from_tty)
if (! ms || ! ms->file || ! ms->file->table)
macro_inform_no_debuginfo ();
else
macro_for_each_in_scope (ms->file, ms->line, print_macro_callback, NULL);
macro_for_each_in_scope (ms->file, ms->line, print_macro_definition);
do_cleanups (cleanup_chain);
}
@ -465,8 +458,7 @@ macro_undef_command (char *exp, int from_tty)
static void
print_one_macro (const char *name, const struct macro_definition *macro,
struct macro_source_file *source, int line,
void *ignore)
struct macro_source_file *source, int line)
{
fprintf_filtered (gdb_stdout, "macro define %s", name);
if (macro->kind == macro_function_like)
@ -486,7 +478,7 @@ print_one_macro (const char *name, const struct macro_definition *macro,
static void
macro_list_command (char *exp, int from_tty)
{
macro_for_each (macro_user_macros, print_one_macro, NULL);
macro_for_each (macro_user_macros, print_one_macro);
}

17
gdb/macrotab.c
View File

@ -965,8 +965,7 @@ macro_definition_location (struct macro_source_file *source,
the FILE and LINE fields. */
struct macro_for_each_data
{
macro_callback_fn fn;
void *user_data;
gdb::function_view<macro_callback_fn> fn;
struct macro_source_file *file;
int line;
};
@ -985,20 +984,18 @@ foreach_macro (splay_tree_node node, void *arg)
(struct macro_definition *) node->value);
xfree (key_fullname);
(*datum->fn) (key->name, def, key->start_file, key->start_line,
datum->user_data);
datum->fn (key->name, def, key->start_file, key->start_line);
return 0;
}
/* Call FN for every macro in TABLE. */
void
macro_for_each (struct macro_table *table, macro_callback_fn fn,
void *user_data)
macro_for_each (struct macro_table *table,
gdb::function_view<macro_callback_fn> fn)
{
struct macro_for_each_data datum;
datum.fn = fn;
datum.user_data = user_data;
datum.file = NULL;
datum.line = 0;
splay_tree_foreach (table->definitions, foreach_macro, &datum);
@ -1024,20 +1021,18 @@ foreach_macro_in_scope (splay_tree_node node, void *info)
&& (!key->end_file
|| compare_locations (key->end_file, key->end_line,
datum->file, datum->line) >= 0))
(*datum->fn) (key->name, def, key->start_file, key->start_line,
datum->user_data);
datum->fn (key->name, def, key->start_file, key->start_line);
return 0;
}
/* Call FN for every macro is visible in SCOPE. */
void
macro_for_each_in_scope (struct macro_source_file *file, int line,
macro_callback_fn fn, void *user_data)
gdb::function_view<macro_callback_fn> fn)
{
struct macro_for_each_data datum;
datum.fn = fn;
datum.user_data = user_data;
datum.file = file;
datum.line = line;
splay_tree_foreach (file->table->definitions,

35
gdb/macrotab.h
View File

@ -20,6 +20,8 @@
#ifndef MACROTAB_H
#define MACROTAB_H
#include "common/function-view.h"
struct obstack;
struct bcache;
struct compunit_symtab;
@ -329,28 +331,23 @@ struct macro_source_file *(macro_definition_location
const char *name,
int *definition_line));
/* Callback function when walking a macro table. NAME is the name of
the macro, and DEFINITION is the definition. SOURCE is the file at the
start of the include path, and LINE is the line number of the SOURCE file
where the macro was defined. USER_DATA is an arbitrary pointer which is
passed by the caller to macro_for_each or macro_for_each_in_scope. */
typedef void (*macro_callback_fn) (const char *name,
const struct macro_definition *definition,
struct macro_source_file *source,
int line,
void *user_data);
/* Prototype for a callback callable when walking a macro table. NAME
is the name of the macro, and DEFINITION is the definition. SOURCE
is the file at the start of the include path, and LINE is the line
number of the SOURCE file where the macro was defined. */
typedef void (macro_callback_fn) (const char *name,
const struct macro_definition *definition,
struct macro_source_file *source,
int line);
/* Call the function FN for each macro in the macro table TABLE.
USER_DATA is passed, untranslated, to FN. */
void macro_for_each (struct macro_table *table, macro_callback_fn fn,
void *user_data);
/* Call the callable FN for each macro in the macro table TABLE. */
void macro_for_each (struct macro_table *table,
gdb::function_view<macro_callback_fn> fn);
/* Call the function FN for each macro that is visible in a given
scope. The scope is represented by FILE and LINE. USER_DATA is
passed, untranslated, to FN. */
/* Call FN for each macro that is visible in a given scope. The scope
is represented by FILE and LINE. */
void macro_for_each_in_scope (struct macro_source_file *file, int line,
macro_callback_fn fn,
void *user_data);
gdb::function_view<macro_callback_fn> fn);
/* Return FILE->filename with possibly prepended compilation directory name.
This is raw concatenation without the "set substitute-path" and gdb_realpath

79
gdb/psymtab.c
View File

@ -123,13 +123,12 @@ require_partial_symbols (struct objfile *objfile, int verbose)
/* Helper function for psym_map_symtabs_matching_filename that
expands the symtabs and calls the iterator. */
static int
static bool
partial_map_expand_apply (struct objfile *objfile,
const char *name,
const char *real_path,
struct partial_symtab *pst,
int (*callback) (struct symtab *, void *),
void *data)
gdb::function_view<bool (symtab *)> callback)
{
struct compunit_symtab *last_made = objfile->compunit_symtabs;
@ -145,20 +144,19 @@ partial_map_expand_apply (struct objfile *objfile,
all of them. */
psymtab_to_symtab (objfile, pst);
return iterate_over_some_symtabs (name, real_path, callback, data,
objfile->compunit_symtabs, last_made);
return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
last_made, callback);
}
/* Psymtab version of map_symtabs_matching_filename. See its definition in
the definition of quick_symbol_functions in symfile.h. */
static int
psym_map_symtabs_matching_filename (struct objfile *objfile,
const char *name,
const char *real_path,
int (*callback) (struct symtab *,
void *),
void *data)
static bool
psym_map_symtabs_matching_filename
(struct objfile *objfile,
const char *name,
const char *real_path,
gdb::function_view<bool (symtab *)> callback)
{
struct partial_symtab *pst;
const char *name_basename = lbasename (name);
@ -177,8 +175,8 @@ psym_map_symtabs_matching_filename (struct objfile *objfile,
if (compare_filenames_for_search (pst->filename, name))
{
if (partial_map_expand_apply (objfile, name, real_path,
pst, callback, data))
return 1;
pst, callback))
return true;
continue;
}
@ -191,8 +189,8 @@ psym_map_symtabs_matching_filename (struct objfile *objfile,
if (compare_filenames_for_search (psymtab_to_fullname (pst), name))
{
if (partial_map_expand_apply (objfile, name, real_path,
pst, callback, data))
return 1;
pst, callback))
return true;
continue;
}
@ -205,14 +203,14 @@ psym_map_symtabs_matching_filename (struct objfile *objfile,
if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0)
{
if (partial_map_expand_apply (objfile, name, real_path,
pst, callback, data))
return 1;
pst, callback))
return true;
continue;
}
}
}
return 0;
return false;
}
/* Find which partial symtab contains PC and SECTION starting at psymtab PST.
@ -1291,17 +1289,15 @@ psym_map_matching_symbols (struct objfile *objfile,
}
}
/* A helper for psym_expand_symtabs_matching that handles
searching included psymtabs. This returns 1 if a symbol is found,
and zero otherwise. It also updates the 'searched_flag' on the
/* A helper for psym_expand_symtabs_matching that handles searching
included psymtabs. This returns true if a symbol is found, and
false otherwise. It also updates the 'searched_flag' on the
various psymtabs that it searches. */
static int
recursively_search_psymtabs (struct partial_symtab *ps,
struct objfile *objfile,
enum search_domain kind,
expand_symtabs_symbol_matcher_ftype *sym_matcher,
void *data)
static bool
recursively_search_psymtabs
(struct partial_symtab *ps, struct objfile *objfile, enum search_domain kind,
gdb::function_view<expand_symtabs_symbol_matcher_ftype> sym_matcher)
{
struct partial_symbol **psym;
struct partial_symbol **bound, **gbound, **sbound;
@ -1323,11 +1319,11 @@ recursively_search_psymtabs (struct partial_symtab *ps,
continue;
r = recursively_search_psymtabs (ps->dependencies[i],
objfile, kind, sym_matcher, data);
objfile, kind, sym_matcher);
if (r != 0)
{
ps->searched_flag = PST_SEARCHED_AND_FOUND;
return 1;
return true;
}
}
@ -1365,7 +1361,7 @@ recursively_search_psymtabs (struct partial_symtab *ps,
&& PSYMBOL_CLASS (*psym) == LOC_BLOCK)
|| (kind == TYPES_DOMAIN
&& PSYMBOL_CLASS (*psym) == LOC_TYPEDEF))
&& (*sym_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
&& sym_matcher (SYMBOL_SEARCH_NAME (*psym)))
{
/* Found a match, so notify our caller. */
result = PST_SEARCHED_AND_FOUND;
@ -1385,11 +1381,10 @@ recursively_search_psymtabs (struct partial_symtab *ps,
static void
psym_expand_symtabs_matching
(struct objfile *objfile,
expand_symtabs_file_matcher_ftype *file_matcher,
expand_symtabs_symbol_matcher_ftype *symbol_matcher,
expand_symtabs_exp_notify_ftype *expansion_notify,
enum search_domain kind,
void *data)
gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
enum search_domain kind)
{
struct partial_symtab *ps;
@ -1413,31 +1408,31 @@ psym_expand_symtabs_matching
if (file_matcher)
{
int match;
bool match;
if (ps->anonymous)
continue;
match = (*file_matcher) (ps->filename, data, 0);
match = file_matcher (ps->filename, false);
if (!match)
{
/* Before we invoke realpath, which can get expensive when many
files are involved, do a quick comparison of the basenames. */
if (basenames_may_differ
|| (*file_matcher) (lbasename (ps->filename), data, 1))
match = (*file_matcher) (psymtab_to_fullname (ps), data, 0);
|| file_matcher (lbasename (ps->filename), true))
match = file_matcher (psymtab_to_fullname (ps), false);
}
if (!match)
continue;
}
if (recursively_search_psymtabs (ps, objfile, kind, symbol_matcher, data))
if (recursively_search_psymtabs (ps, objfile, kind, symbol_matcher))
{
struct compunit_symtab *symtab =
psymtab_to_symtab (objfile, ps);
if (expansion_notify != NULL)
expansion_notify (symtab, data);
expansion_notify (symtab);
}
}
}

42
gdb/symfile-debug.c
View File

@ -117,28 +117,23 @@ debug_qf_forget_cached_source_info (struct objfile *objfile)
debug_data->real_sf->qf->forget_cached_source_info (objfile);
}
static int
debug_qf_map_symtabs_matching_filename (struct objfile *objfile,
const char *name,
const char *real_path,
int (*callback) (struct symtab *,
void *),
void *data)
static bool
debug_qf_map_symtabs_matching_filename
(struct objfile *objfile, const char *name, const char *real_path,
gdb::function_view<bool (symtab *)> callback)
{
const struct debug_sym_fns_data *debug_data
= ((const struct debug_sym_fns_data *)
objfile_data (objfile, symfile_debug_objfile_data_key));
int retval;
fprintf_filtered (gdb_stdlog,
"qf->map_symtabs_matching_filename (%s, \"%s\", \"%s\", %s, %s)\n",
"qf->map_symtabs_matching_filename (%s, \"%s\", \"%s\", %s)\n",
objfile_debug_name (objfile), name,
real_path ? real_path : NULL,
host_address_to_string (callback),
host_address_to_string (data));
host_address_to_string (&callback));
retval = debug_data->real_sf->qf->map_symtabs_matching_filename
(objfile, name, real_path, callback, data);
bool retval = (debug_data->real_sf->qf->map_symtabs_matching_filename
(objfile, name, real_path, callback));
fprintf_filtered (gdb_stdlog,
"qf->map_symtabs_matching_filename (...) = %d\n",
@ -291,29 +286,28 @@ debug_qf_map_matching_symbols (struct objfile *objfile,
static void
debug_qf_expand_symtabs_matching
(struct objfile *objfile,
expand_symtabs_file_matcher_ftype *file_matcher,
expand_symtabs_symbol_matcher_ftype *symbol_matcher,
expand_symtabs_exp_notify_ftype *expansion_notify,
enum search_domain kind, void *data)
gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
enum search_domain kind)
{
const struct debug_sym_fns_data *debug_data
= ((const struct debug_sym_fns_data *)
objfile_data (objfile, symfile_debug_objfile_data_key));
fprintf_filtered (gdb_stdlog,
"qf->expand_symtabs_matching (%s, %s, %s, %s, %s, %s)\n",
"qf->expand_symtabs_matching (%s, %s, %s, %s, %s)\n",
objfile_debug_name (objfile),
host_address_to_string (file_matcher),
host_address_to_string (symbol_matcher),
host_address_to_string (expansion_notify),
search_domain_name (kind),
host_address_to_string (data));
host_address_to_string (&file_matcher),
host_address_to_string (&symbol_matcher),
host_address_to_string (&expansion_notify),
search_domain_name (kind));
debug_data->real_sf->qf->expand_symtabs_matching (objfile,
file_matcher,
symbol_matcher,
expansion_notify,
kind, data);
kind);
}
static struct compunit_symtab *

13
gdb/symfile.c
View File

@ -3856,11 +3856,11 @@ symfile_free_objfile (struct objfile *objfile)
See quick_symbol_functions.expand_symtabs_matching for details. */
void
expand_symtabs_matching (expand_symtabs_file_matcher_ftype *file_matcher,
expand_symtabs_symbol_matcher_ftype *symbol_matcher,
expand_symtabs_exp_notify_ftype *expansion_notify,
enum search_domain kind,
void *data)
expand_symtabs_matching
(gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
enum search_domain kind)
{
struct objfile *objfile;
@ -3869,8 +3869,7 @@ expand_symtabs_matching (expand_symtabs_file_matcher_ftype *file_matcher,
if (objfile->sf)
objfile->sf->qf->expand_symtabs_matching (objfile, file_matcher,
symbol_matcher,
expansion_notify, kind,
data);
expansion_notify, kind);
}
}

64
gdb/symfile.h
View File

@ -26,6 +26,7 @@
#include "symfile-add-flags.h"
#include "objfile-flags.h"
#include "gdb_bfd.h"
#include "common/function-view.h"
/* Opaque declarations. */
struct target_section;
@ -133,20 +134,18 @@ typedef void (symbol_filename_ftype) (const char *filename,
/* Callback for quick_symbol_functions->expand_symtabs_matching
to match a file name. */
typedef int (expand_symtabs_file_matcher_ftype) (const char *filename,
void *data, int basenames);
typedef bool (expand_symtabs_file_matcher_ftype) (const char *filename,
bool basenames);
/* Callback for quick_symbol_functions->expand_symtabs_matching
to match a symbol name. */
typedef int (expand_symtabs_symbol_matcher_ftype) (const char *name,
void *data);
typedef bool (expand_symtabs_symbol_matcher_ftype) (const char *name);
/* Callback for quick_symbol_functions->expand_symtabs_matching
to be called after a symtab has been expanded. */
typedef void (expand_symtabs_exp_notify_ftype) \
(struct compunit_symtab *symtab, void *data);
typedef void (expand_symtabs_exp_notify_ftype) (compunit_symtab *symtab);
/* The "quick" symbol functions exist so that symbol readers can
avoiding an initial read of all the symbols. For example, symbol
@ -189,14 +188,11 @@ struct quick_symbol_functions
If a match is found, the "partial" symbol table is expanded.
Then, this calls iterate_over_some_symtabs (or equivalent) over
all newly-created symbol tables, passing CALLBACK and DATA to it.
all newly-created symbol tables, passing CALLBACK to it.
The result of this call is returned. */
int (*map_symtabs_matching_filename) (struct objfile *objfile,
const char *name,
const char *real_path,
int (*callback) (struct symtab *,
void *),
void *data);
bool (*map_symtabs_matching_filename)
(struct objfile *objfile, const char *name, const char *real_path,
gdb::function_view<bool (symtab *)> callback);
/* Check to see if the symbol is defined in a "partial" symbol table
of OBJFILE. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
@ -272,30 +268,27 @@ struct quick_symbol_functions
/* Expand all symbol tables in OBJFILE matching some criteria.
FILE_MATCHER is called for each file in OBJFILE. The file name
and the DATA argument are passed to it. If it returns zero, this
file is skipped. If FILE_MATCHER is NULL such file is not skipped.
If BASENAMES is non-zero the function should consider only base name of
DATA (passed file name is already only the lbasename part).
is passed to it. If the matcher returns false, the file is
skipped. If FILE_MATCHER is NULL the file is not skipped. If
BASENAMES is true the matcher should consider only file base
names (the passed file name is already only the lbasename'd
part).
Otherwise, if KIND does not match this symbol is skipped.
Otherwise, if KIND does not match, this symbol is skipped.
If even KIND matches, then SYMBOL_MATCHER is called for each symbol
defined in the file. The symbol "search" name and DATA are passed
to SYMBOL_MATCHER.
If even KIND matches, SYMBOL_MATCHER is called for each symbol
defined in the file. The symbol "search" name is passed to
SYMBOL_MATCHER.
If SYMBOL_MATCHER returns zero, then this symbol is skipped.
If SYMBOL_MATCHER returns false, then the symbol is skipped.
Otherwise, this symbol's symbol table is expanded.
DATA is user data that is passed unmodified to the callback
functions. */
Otherwise, the symbol's symbol table is expanded. */
void (*expand_symtabs_matching)
(struct objfile *objfile,
expand_symtabs_file_matcher_ftype *file_matcher,
expand_symtabs_symbol_matcher_ftype *symbol_matcher,
expand_symtabs_exp_notify_ftype *expansion_notify,
enum search_domain kind,
void *data);
gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
enum search_domain kind);
/* Return the comp unit from OBJFILE that contains PC and
SECTION. Return NULL if there is no such compunit. This
@ -565,10 +558,11 @@ void free_symfile_segment_data (struct symfile_segment_data *data);
extern struct cleanup *increment_reading_symtab (void);
void expand_symtabs_matching (expand_symtabs_file_matcher_ftype *,
expand_symtabs_symbol_matcher_ftype *,
expand_symtabs_exp_notify_ftype *,
enum search_domain kind, void *data);
void expand_symtabs_matching
(gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
enum search_domain kind);
void map_symbol_filenames (symbol_filename_ftype *fun, void *data,
int need_fullname);

47
gdb/symmisc.c
View File

@ -937,37 +937,6 @@ maintenance_check_symtabs (char *ignore, int from_tty)
}
}
/* Helper function for maintenance_expand_symtabs.
This is the name_matcher function for expand_symtabs_matching. */
static int
maintenance_expand_name_matcher (const char *symname, void *data)
{
/* Since we're not searching on symbols, just return TRUE. */
return 1;
}
/* Helper function for maintenance_expand_symtabs.
This is the file_matcher function for expand_symtabs_matching. */
static int
maintenance_expand_file_matcher (const char *filename, void *data,
int basenames)
{
const char *regexp = (const char *) data;
QUIT;
/* KISS: Only apply the regexp to the complete file name. */
if (basenames)
return 0;
if (regexp == NULL || re_exec (filename))
return 1;
return 0;
}
/* Expand all symbol tables whose name matches an optional regexp. */
static void
@ -1003,8 +972,20 @@ maintenance_expand_symtabs (char *args, int from_tty)
if (objfile->sf)
{
objfile->sf->qf->expand_symtabs_matching
(objfile, maintenance_expand_file_matcher,
maintenance_expand_name_matcher, NULL, ALL_DOMAIN, regexp);
(objfile,
[&] (const char *filename, bool basenames)
{
/* KISS: Only apply the regexp to the complete file name. */
return (!basenames
&& (regexp == NULL || re_exec (filename)));
},
[] (const char *symname)
{
/* Since we're not searching on symbols, just return true. */
return true;
},
NULL,
ALL_DOMAIN);
}
}

287
gdb/symtab.c
View File

@ -382,23 +382,20 @@ compare_glob_filenames_for_search (const char *filename,
If NAME is not absolute, then REAL_PATH is NULL
If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
The return value, NAME, REAL_PATH, CALLBACK, and DATA
are identical to the `map_symtabs_matching_filename' method of
quick_symbol_functions.
The return value, NAME, REAL_PATH and CALLBACK are identical to the
`map_symtabs_matching_filename' method of quick_symbol_functions.
FIRST and AFTER_LAST indicate the range of compunit symtabs to search.
Each symtab within the specified compunit symtab is also searched.
AFTER_LAST is one past the last compunit symtab to search; NULL means to
search until the end of the list. */
int
bool
iterate_over_some_symtabs (const char *name,
const char *real_path,
int (*callback) (struct symtab *symtab,
void *data),
void *data,
struct compunit_symtab *first,
struct compunit_symtab *after_last)
struct compunit_symtab *after_last,
gdb::function_view<bool (symtab *)> callback)
{
struct compunit_symtab *cust;
struct symtab *s;
@ -410,8 +407,8 @@ iterate_over_some_symtabs (const char *name,
{
if (compare_filenames_for_search (s->filename, name))
{
if (callback (s, data))
return 1;
if (callback (s))
return true;
continue;
}
@ -423,8 +420,8 @@ iterate_over_some_symtabs (const char *name,
if (compare_filenames_for_search (symtab_to_fullname (s), name))
{
if (callback (s, data))
return 1;
if (callback (s))
return true;
continue;
}
@ -438,82 +435,59 @@ iterate_over_some_symtabs (const char *name,
gdb_assert (IS_ABSOLUTE_PATH (name));
if (FILENAME_CMP (real_path, fullname) == 0)
{
if (callback (s, data))
return 1;
if (callback (s))
return true;
continue;
}
}
}
}
return 0;
return false;
}
/* Check for a symtab of a specific name; first in symtabs, then in
psymtabs. *If* there is no '/' in the name, a match after a '/'
in the symtab filename will also work.
Calls CALLBACK with each symtab that is found and with the supplied
DATA. If CALLBACK returns true, the search stops. */
Calls CALLBACK with each symtab that is found. If CALLBACK returns
true, the search stops. */
void
iterate_over_symtabs (const char *name,
int (*callback) (struct symtab *symtab,
void *data),
void *data)
gdb::function_view<bool (symtab *)> callback)
{
struct objfile *objfile;
char *real_path = NULL;
struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
gdb::unique_xmalloc_ptr<char> real_path;
/* Here we are interested in canonicalizing an absolute path, not
absolutizing a relative path. */
if (IS_ABSOLUTE_PATH (name))
{
real_path = gdb_realpath (name);
make_cleanup (xfree, real_path);
gdb_assert (IS_ABSOLUTE_PATH (real_path));
real_path.reset (gdb_realpath (name));
gdb_assert (IS_ABSOLUTE_PATH (real_path.get ()));
}
ALL_OBJFILES (objfile)
{
if (iterate_over_some_symtabs (name, real_path, callback, data,
objfile->compunit_symtabs, NULL))
{
do_cleanups (cleanups);
{
if (iterate_over_some_symtabs (name, real_path.get (),
objfile->compunit_symtabs, NULL,
callback))
return;
}
}
}
/* Same search rules as above apply here, but now we look thru the
psymtabs. */
ALL_OBJFILES (objfile)
{
if (objfile->sf
&& objfile->sf->qf->map_symtabs_matching_filename (objfile,
name,
real_path,
callback,
data))
{
do_cleanups (cleanups);
{
if (objfile->sf
&& objfile->sf->qf->map_symtabs_matching_filename (objfile,
name,
real_path.get (),
callback))
return;
}
}
do_cleanups (cleanups);
}
/* The callback function used by lookup_symtab. */
static int
lookup_symtab_callback (struct symtab *symtab, void *data)
{
struct symtab **result_ptr = (struct symtab **) data;
*result_ptr = symtab;
return 1;
}
}
/* A wrapper for iterate_over_symtabs that returns the first matching
@ -524,7 +498,12 @@ lookup_symtab (const char *name)
{
struct symtab *result = NULL;
iterate_over_symtabs (name, lookup_symtab_callback, &result);
iterate_over_symtabs (name, [&] (symtab *symtab)
{
result = symtab;
return true;
});
return result;
}
@ -2777,18 +2756,17 @@ basic_lookup_transparent_type (const char *name)
}
/* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
For each symbol that matches, CALLBACK is called. The symbol and
DATA are passed to the callback.
If CALLBACK returns zero, the iteration ends. Otherwise, the
For each symbol that matches, CALLBACK is called. The symbol is
passed to the callback.
If CALLBACK returns false, the iteration ends. Otherwise, the
search continues. */
void
iterate_over_symbols (const struct block *block, const char *name,
const domain_enum domain,
symbol_found_callback_ftype *callback,
void *data)
gdb::function_view<symbol_found_callback_ftype> callback)
{
struct block_iterator iter;
struct symbol *sym;
@ -2798,7 +2776,7 @@ iterate_over_symbols (const struct block *block, const char *name,
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
SYMBOL_DOMAIN (sym), domain))
{
if (!callback (sym, data))
if (!callback (sym))
return;
}
}
@ -4282,39 +4260,6 @@ sort_search_symbols_remove_dups (struct symbol_search *found, int nfound,
xfree (symbols);
}
/* An object of this type is passed as the user_data to the
expand_symtabs_matching method. */
struct search_symbols_data
{
int nfiles;
const char **files;
/* It is true if PREG contains valid data, false otherwise. */
unsigned preg_p : 1;
regex_t preg;
};
/* A callback for expand_symtabs_matching. */
static int
search_symbols_file_matches (const char *filename, void *user_data,
int basenames)
{
struct search_symbols_data *data = (struct search_symbols_data *) user_data;
return file_matches (filename, data->files, data->nfiles, basenames);
}
/* A callback for expand_symtabs_matching. */
static int
search_symbols_name_matches (const char *symname, void *user_data)
{
struct search_symbols_data *data = (struct search_symbols_data *) user_data;
return !data->preg_p || regexec (&data->preg, symname, 0, NULL, 0) == 0;
}
/* Search the symbol table for matches to the regular expression REGEXP,
returning the results in *MATCHES.
@ -4359,8 +4304,10 @@ search_symbols (const char *regexp, enum search_domain kind,
enum minimal_symbol_type ourtype4;
struct symbol_search *found;
struct symbol_search *tail;
struct search_symbols_data datum;
int nfound;
/* This is true if PREG contains valid data, false otherwise. */
bool preg_p;
regex_t preg;
/* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
CLEANUP_CHAIN is freed only in the case of an error. */
@ -4375,7 +4322,7 @@ search_symbols (const char *regexp, enum search_domain kind,
ourtype4 = types4[kind];
*matches = NULL;
datum.preg_p = 0;
preg_p = false;
if (regexp != NULL)
{
@ -4414,31 +4361,35 @@ search_symbols (const char *regexp, enum search_domain kind,
}
}
errcode = regcomp (&datum.preg, regexp,
errcode = regcomp (&preg, regexp,
REG_NOSUB | (case_sensitivity == case_sensitive_off
? REG_ICASE : 0));
if (errcode != 0)
{
char *err = get_regcomp_error (errcode, &datum.preg);
char *err = get_regcomp_error (errcode, &preg);
make_cleanup (xfree, err);
error (_("Invalid regexp (%s): %s"), err, regexp);
}
datum.preg_p = 1;
make_regfree_cleanup (&datum.preg);
preg_p = true;
make_regfree_cleanup (&preg);
}
/* Search through the partial symtabs *first* for all symbols
matching the regexp. That way we don't have to reproduce all of
the machinery below. */
datum.nfiles = nfiles;
datum.files = files;
expand_symtabs_matching ((nfiles == 0
? NULL
: search_symbols_file_matches),
search_symbols_name_matches,
NULL, kind, &datum);
expand_symtabs_matching ([&] (const char *filename, bool basenames)
{
return file_matches (filename, files, nfiles,
basenames);
},
[&] (const char *symname)
{
return (!preg_p || regexec (&preg, symname,
0, NULL, 0) == 0);
},
NULL,
kind);
/* Here, we search through the minimal symbol tables for functions
and variables that match, and force their symbols to be read.
@ -4470,8 +4421,8 @@ search_symbols (const char *regexp, enum search_domain kind,
|| MSYMBOL_TYPE (msymbol) == ourtype3
|| MSYMBOL_TYPE (msymbol) == ourtype4)
{
if (!datum.preg_p
|| regexec (&datum.preg, MSYMBOL_NATURAL_NAME (msymbol), 0,
if (!preg_p
|| regexec (&preg, MSYMBOL_NATURAL_NAME (msymbol), 0,
NULL, 0) == 0)
{
/* Note: An important side-effect of these lookup functions
@ -4514,8 +4465,8 @@ search_symbols (const char *regexp, enum search_domain kind,
files, nfiles, 1))
&& file_matches (symtab_to_fullname (real_symtab),
files, nfiles, 0)))
&& ((!datum.preg_p
|| regexec (&datum.preg, SYMBOL_NATURAL_NAME (sym), 0,
&& ((!preg_p
|| regexec (&preg, SYMBOL_NATURAL_NAME (sym), 0,
NULL, 0) == 0)
&& ((kind == VARIABLES_DOMAIN
&& SYMBOL_CLASS (sym) != LOC_TYPEDEF
@ -4572,8 +4523,8 @@ search_symbols (const char *regexp, enum search_domain kind,
|| MSYMBOL_TYPE (msymbol) == ourtype3
|| MSYMBOL_TYPE (msymbol) == ourtype4)
{
if (!datum.preg_p
|| regexec (&datum.preg, MSYMBOL_NATURAL_NAME (msymbol), 0,
if (!preg_p
|| regexec (&preg, MSYMBOL_NATURAL_NAME (msymbol), 0,
NULL, 0) == 0)
{
/* For functions we can do a quick check of whether the
@ -5110,46 +5061,6 @@ completion_list_add_fields (struct symbol *sym, const char *sym_text,
}
}
/* Type of the user_data argument passed to add_macro_name,
symbol_completion_matcher and symtab_expansion_callback. */
struct add_name_data
{
/* Arguments required by completion_list_add_name. */
const char *sym_text;
int sym_text_len;
const char *text;
const char *word;
/* Extra argument required for add_symtab_completions. */
enum type_code code;
};
/* A callback used with macro_for_each and macro_for_each_in_scope.
This adds a macro's name to the current completion list. */
static void
add_macro_name (const char *name, const struct macro_definition *ignore,
struct macro_source_file *ignore2, int ignore3,
void *user_data)
{
struct add_name_data *datum = (struct add_name_data *) user_data;
completion_list_add_name (name,
datum->sym_text, datum->sym_text_len,
datum->text, datum->word);
}
/* A callback for expand_symtabs_matching. */
static int
symbol_completion_matcher (const char *name, void *user_data)
{
struct add_name_data *datum = (struct add_name_data *) user_data;
return compare_symbol_name (name, datum->sym_text, datum->sym_text_len);
}
/* Add matching symbols from SYMTAB to the current completion list. */
static void
@ -5182,21 +5093,6 @@ add_symtab_completions (struct compunit_symtab *cust,
}
}
/* Callback to add completions to the current list when symbol tables
are expanded during completion list generation. */
static void
symtab_expansion_callback (struct compunit_symtab *symtab,
void *user_data)
{
struct add_name_data *datum = (struct add_name_data *) user_data;
add_symtab_completions (symtab,
datum->sym_text, datum->sym_text_len,
datum->text, datum->word,
datum->code);
}
static void
default_make_symbol_completion_list_break_on_1 (const char *text,
const char *word,
@ -5218,7 +5114,6 @@ default_make_symbol_completion_list_break_on_1 (const char *text,
const char *sym_text;
/* Length of sym_text. */
int sym_text_len;
struct add_name_data datum;
struct cleanup *cleanups;
/* Now look for the symbol we are supposed to complete on. */
@ -5292,12 +5187,6 @@ default_make_symbol_completion_list_break_on_1 (const char *text,
completion_tracker = new_completion_tracker ();
cleanups = make_cleanup_free_completion_tracker (&completion_tracker);
datum.sym_text = sym_text;
datum.sym_text_len = sym_text_len;
datum.text = text;
datum.word = word;
datum.code = code;
/* At this point scan through the misc symbol vectors and add each
symbol you find to the list. Eventually we want to ignore
anything that isn't a text symbol (everything else will be
@ -5321,13 +5210,22 @@ default_make_symbol_completion_list_break_on_1 (const char *text,
add_symtab_completions (cust, sym_text, sym_text_len, text, word,
code);
/* Look through the partial symtabs for all symbols which begin
by matching SYM_TEXT. Expand all CUs that you find to the list.
symtab_expansion_callback is called for each expanded symtab,
causing those symtab's completions to be added to the list too. */
expand_symtabs_matching (NULL, symbol_completion_matcher,
symtab_expansion_callback, ALL_DOMAIN,
&datum);
/* Look through the partial symtabs for all symbols which begin by
matching SYM_TEXT. Expand all CUs that you find to the list. */
expand_symtabs_matching (NULL,
[&] (const char *name) /* symbol matcher */
{
return compare_symbol_name (name,
sym_text,
sym_text_len);
},
[&] (compunit_symtab *symtab) /* expansion notify */
{
add_symtab_completions (symtab,
sym_text, sym_text_len,
text, word, code);
},
ALL_DOMAIN);
/* Search upwards from currently selected frame (so that we can
complete on local vars). Also catch fields of types defined in
@ -5385,6 +5283,17 @@ default_make_symbol_completion_list_break_on_1 (const char *text,
{
struct macro_scope *scope;
/* This adds a macro's name to the current completion list. */
auto add_macro_name = [&] (const char *macro_name,
const macro_definition *,
macro_source_file *,
int)
{
completion_list_add_name (macro_name,
sym_text, sym_text_len,
text, word);
};
/* Add any macros visible in the default scope. Note that this
may yield the occasional wrong result, because an expression
might be evaluated in a scope other than the default. For
@ -5396,12 +5305,12 @@ default_make_symbol_completion_list_break_on_1 (const char *text,
if (scope)
{
macro_for_each_in_scope (scope->file, scope->line,
add_macro_name, &datum);
add_macro_name);
xfree (scope);
}
/* User-defined macros are always visible. */
macro_for_each (macro_user_macros, add_macro_name, &datum);
macro_for_each (macro_user_macros, add_macro_name);
}
do_cleanups (cleanups);

33
gdb/symtab.h
View File

@ -24,6 +24,7 @@
#include "gdb_vecs.h"
#include "gdbtypes.h"
#include "common/enum-flags.h"
#include "common/function-view.h"
/* Opaque declarations. */
struct ui_file;
@ -1607,35 +1608,29 @@ int compare_filenames_for_search (const char *filename,
int compare_glob_filenames_for_search (const char *filename,
const char *search_name);
int iterate_over_some_symtabs (const char *name,
const char *real_path,
int (*callback) (struct symtab *symtab,
void *data),
void *data,
struct compunit_symtab *first,
struct compunit_symtab *after_last);
bool iterate_over_some_symtabs (const char *name,
const char *real_path,
struct compunit_symtab *first,
struct compunit_symtab *after_last,
gdb::function_view<bool (symtab *)> callback);
void iterate_over_symtabs (const char *name,
int (*callback) (struct symtab *symtab,
void *data),
void *data);
gdb::function_view<bool (symtab *)> callback);
VEC (CORE_ADDR) *find_pcs_for_symtab_line (struct symtab *symtab, int line,
struct linetable_entry **best_entry);
/* Callback for LA_ITERATE_OVER_SYMBOLS. The callback will be called
once per matching symbol SYM, with DATA being the argument of the
same name that was passed to LA_ITERATE_OVER_SYMBOLS. The callback
should return nonzero to indicate that LA_ITERATE_OVER_SYMBOLS
should continue iterating, or zero to indicate that the iteration
should end. */
/* Prototype for callbacks for LA_ITERATE_OVER_SYMBOLS. The callback
is called once per matching symbol SYM. The callback should return
true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
iterating, or false to indicate that the iteration should end. */
typedef int (symbol_found_callback_ftype) (struct symbol *sym, void *data);
typedef bool (symbol_found_callback_ftype) (symbol *sym);
void iterate_over_symbols (const struct block *block, const char *name,
const domain_enum domain,
symbol_found_callback_ftype *callback,
void *data);
gdb::function_view<symbol_found_callback_ftype> callback);
/* Storage type used by demangle_for_lookup. demangle_for_lookup
either returns a const char * pointer that points to either of the