[PATCH 7/9] Use block_symbol_d in linespec APIs

Keith Seitz
2018-08-10T23:31:40Z

This patch changes the linespec.c APIs to use block_symbol instead of just
a symbol. lookup_symbol et al already return block_symbol's.

gdb/ChangeLog:

* linespec.c (struct linespec) <function_symbols, label_symbols>:
Change to vector of block_symbol. Update all users.
(struct collect_info) <symbols>: Likewise.
(collect_info::add_symbol): Take block_symbol as argument.
Update all callers.
(decode_compound_collector) <m_symbols>: Change type to vector
of block_symbol. Update all users.
(decode_compound_collector::operator ()): Change parameter type
to block_symbol.
(find_method, find_function_symbols, find_linespec_symbols)
(find_label_symbols_in_block, find_label_symbols): Change symbol
vectors to block_symbol vectors.
* symtab.h (symbol_found_callback_ftype): Change parameter type to
block_symbol.
---
gdb/ChangeLog | 17 ++++++
gdb/ada-lang.c | 2 +-
gdb/linespec.c | 180 +++++++++++++++++++++++++++++++--------------------------
gdb/symtab.c | 4 +-
gdb/symtab.h | 2 +-
5 files changed, 119 insertions(+), 86 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 8bd7ac01df..6fc1ce5262 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,22 @@
YYYY-MM-DD Keith Seitz <keiths@redhat.com>

+ * linespec.c (struct linespec) <function_symbols, label_symbols>:
+ Change to vector of block_symbol. Update all users.
+ (struct collect_info) <symbols>: Likewise.
+ (collect_info::add_symbol): Take block_symbol as argument.
+ Update all callers.
+ (decode_compound_collector) <m_symbols>: Change type to vector
+ of block_symbol. Update all users.
+ (decode_compound_collector::operator ()): Change parameter type
+ to block_symbol.
+ (find_method, find_function_symbols, find_linespec_symbols)
+ (find_label_symbols_in_block, find_label_symbols): Change symbol
+ vectors to block_symbol vectors.
+ * symtab.h (symbol_found_callback_ftype): Change parameter type to
+ block_symbol.
+
+YYYY-MM-DD Keith Seitz <keiths@redhat.com>
+
* linespec.c (symbolp): Remove typedef and VEC definitions.
(bound_minimal_symbol_d): Likewise.

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 07a0536684..d4169254f5 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -5841,7 +5841,7 @@ ada_iterate_over_symbols

for (i = 0; i < ndefs; ++i)
{
- if (!callback (results[i].symbol))
+ if (!callback (&results[i]))
break;
}
}
diff --git a/gdb/linespec.c b/gdb/linespec.c
index dea02381b9..ef4556d8ea 100644
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -108,7 +108,7 @@ struct linespec

/* A list of matching function symbols and minimal symbols. Both lists
may be NULL (or empty) if no matching symbols were found. */
- std::vector<symbol *> *function_symbols;
+ std::vector<block_symbol> *function_symbols;
std::vector<bound_minimal_symbol> *minimal_symbols;

/* A structure of matching label symbols and the corresponding
@@ -116,8 +116,8 @@ struct linespec
or both must be non-NULL. */
struct
{
- std::vector<symbol *> *label_symbols;
- std::vector<symbol *> *function_symbols;
+ std::vector<block_symbol> *label_symbols;
+ std::vector<block_symbol> *function_symbols;
} labels;
};
typedef struct linespec *linespec_p;
@@ -194,21 +194,21 @@ struct collect_info
/* The result being accumulated. */
struct
{
- std::vector<symbol *> *symbols;
+ std::vector<block_symbol> *symbols;
std::vector<bound_minimal_symbol> *minimal_symbols;
} result;

/* Possibly add a symbol to the results. */
- bool add_symbol (symbol *sym);
+ bool add_symbol (block_symbol *bsym);
};

bool
-collect_info::add_symbol (symbol *sym)
+collect_info::add_symbol (block_symbol *bsym)
{
/* 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)
- this->result.symbols->push_back (sym);
+ if (SYMBOL_CLASS (bsym->symbol) == LOC_BLOCK || this->state->list_mode)
+ this->result.symbols->push_back (*bsym);

/* Continue iterating. */
return true;
@@ -345,16 +345,16 @@ static std::vector<symtab_and_line> decode_objc (struct linespec_state *self,
static std::vector<symtab *> *symtabs_from_filename
(const char *, struct program_space *pspace);

-static std::vector<symbol *> *find_label_symbols
- (struct linespec_state *self, std::vector<symbol *> *function_symbols,
- std::vector<symbol *> *label_funcs_ret, const char *name,
+static std::vector<block_symbol> *find_label_symbols
+ (struct linespec_state *self, std::vector<block_symbol> *function_symbols,
+ std::vector<block_symbol> *label_funcs_ret, const char *name,
bool completion_mode = false);

static void find_linespec_symbols (struct linespec_state *self,
std::vector<symtab *> *file_symtabs,
const char *name,
symbol_name_match_type name_match_type,
- std::vector<symbol *> *symbols,
+ std::vector<block_symbol> *symbols,
std::vector<bound_minimal_symbol> *minsyms);

static struct line_offset
@@ -1149,12 +1149,12 @@ iterate_over_all_matching_symtabs
{
block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), i);
state->language->la_iterate_over_symbols
- (block, lookup_name, name_domain, [&] (symbol *sym)
+ (block, lookup_name, name_domain, [&] (block_symbol *bsym)
{
/* Restrict calls to CALLBACK to symbols
representing inline symbols only. */
- if (SYMBOL_INLINED (sym))
- return callback (sym);
+ if (SYMBOL_INLINED (bsym->symbol))
+ return callback (bsym);
return true;
});
}
@@ -1759,8 +1759,8 @@ linespec_parse_basic (linespec_parser *parser)
{
gdb::unique_xmalloc_ptr<char> name;
linespec_token token;
- std::vector<symbol *> symbols;
- std::vector<symbol *> *labels;
+ std::vector<block_symbol> symbols;
+ std::vector<block_symbol> *labels;
std::vector<bound_minimal_symbol> minimal_symbols;

/* Get the next token. */
@@ -1867,7 +1867,7 @@ linespec_parse_basic (linespec_parser *parser)
if (!symbols.empty () || !minimal_symbols.empty ())
{
PARSER_RESULT (parser)->function_symbols
- = new std::vector<symbol *> (std::move (symbols));
+ = new std::vector<block_symbol> (std::move (symbols));
PARSER_RESULT (parser)->minimal_symbols
= new std::vector<bound_minimal_symbol>
(std::move (minimal_symbols));
@@ -1883,7 +1883,7 @@ linespec_parse_basic (linespec_parser *parser)
{
PARSER_RESULT (parser)->labels.label_symbols = labels;
PARSER_RESULT (parser)->labels.function_symbols
- = new std::vector<symbol *> (std::move (symbols));
+ = new std::vector<block_symbol> (std::move (symbols));
PARSER_EXPLICIT (parser)->label_name = name.release ();
}
else if (token.type == LSTOKEN_STRING
@@ -1989,7 +1989,7 @@ linespec_parse_basic (linespec_parser *parser)
{
PARSER_RESULT (parser)->labels.label_symbols = labels;
PARSER_RESULT (parser)->labels.function_symbols
- = new std::vector<symbol *> (std::move (symbols));
+ = new std::vector<block_symbol> (std::move (symbols));
PARSER_EXPLICIT (parser)->label_name = name.release ();
}
else
@@ -2059,8 +2059,9 @@ canonicalize_linespec (struct linespec_state *state, const linespec_p ls)
/* No function was specified, so add the symbol name. */
gdb_assert (!ls->labels.function_symbols->empty ()
&& (ls->labels.function_symbols->size () == 1));
- struct symbol *s = ls->labels.function_symbols->front ();
- explicit_loc->function_name = xstrdup (SYMBOL_NATURAL_NAME (s));
+ block_symbol s = ls->labels.function_symbols->front ();
+ explicit_loc->function_name
+ = xstrdup (SYMBOL_NATURAL_NAME (s.symbol));
}
}

@@ -2236,15 +2237,17 @@ convert_linespec_to_sals (struct linespec_state *state, linespec_p ls)
if (ls->labels.label_symbols != NULL)
{
/* We have just a bunch of functions/methods or labels. */
+ struct symtab_and_line sal;
+
for (const auto &sym : *ls->labels.label_symbols)
{
- struct symtab_and_line sal;
- struct program_space *pspace = SYMTAB_PSPACE (symbol_symtab (sym));
+ struct program_space *pspace
+ = SYMTAB_PSPACE (symbol_symtab (sym.symbol));

- if (symbol_to_sal (&sal, state->funfirstline, sym)
+ if (symbol_to_sal (&sal, state->funfirstline, sym.symbol)
&& maybe_add_address (state->addr_set, pspace, sal.pc))
add_sal_to_sals (state, &sals, &sal,
- SYMBOL_NATURAL_NAME (sym), 0);
+ SYMBOL_NATURAL_NAME (sym.symbol), 0);
}
}
else if (ls->function_symbols != NULL || ls->minimal_symbols != NULL)
@@ -2255,11 +2258,11 @@ convert_linespec_to_sals (struct linespec_state *state, linespec_p ls)
/* Sort symbols so that symbols with the same program space are next
to each other. */
qsort (ls->function_symbols->data (), ls->function_symbols->size (),
- sizeof (symbol *), compare_symbols);
-
+ sizeof (block_symbol), compare_symbols);
for (const auto &sym : *ls->function_symbols)
{
- program_space *pspace = SYMTAB_PSPACE (symbol_symtab (sym));
+ program_space *pspace
+ = SYMTAB_PSPACE (symbol_symtab (sym.symbol));
set_current_program_space (pspace);

/* Don't skip to the first line of the function if we
@@ -2270,10 +2273,10 @@ convert_linespec_to_sals (struct linespec_state *state, linespec_p ls)

if (state->funfirstline
&& ls->minimal_symbols != NULL
- && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ && SYMBOL_CLASS (sym.symbol) == LOC_BLOCK)
{
const CORE_ADDR addr
- = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+ = BLOCK_START (SYMBOL_BLOCK_VALUE (sym.symbol));

for (const auto &elem : *ls->minimal_symbols)
{
@@ -2304,10 +2307,10 @@ convert_linespec_to_sals (struct linespec_state *state, linespec_p ls)
if (!found_ifunc)
{
symtab_and_line sal;
- if (symbol_to_sal (&sal, state->funfirstline, sym)
+ if (symbol_to_sal (&sal, state->funfirstline, sym.symbol)
&& maybe_add_address (state->addr_set, pspace, sal.pc))
add_sal_to_sals (state, &sals, &sal,
- SYMBOL_NATURAL_NAME (sym), 0);
+ SYMBOL_NATURAL_NAME (sym.symbol), 0);
}
}
}
@@ -2369,8 +2372,8 @@ convert_explicit_location_to_linespec (struct linespec_state *self,
const char *label_name,
struct line_offset line_offset)
{
- std::vector<symbol *> symbols;
- std::vector<symbol *> *labels;
+ std::vector<block_symbol> symbols;
+ std::vector<block_symbol> *labels;
std::vector<bound_minimal_symbol> minimal_symbols;

result->explicit_loc.func_name_match_type = fname_match_type;
@@ -2407,7 +2410,7 @@ convert_explicit_location_to_linespec (struct linespec_state *self,

result->explicit_loc.function_name = xstrdup (function_name);
result->function_symbols
- = new std::vector<symbol *> (std::move (symbols));
+ = new std::vector<block_symbol> (std::move (symbols));
result->minimal_symbols
= new std::vector<bound_minimal_symbol> (std::move (minimal_symbols));
}
@@ -2424,7 +2427,7 @@ convert_explicit_location_to_linespec (struct linespec_state *self,
result->explicit_loc.label_name = xstrdup (label_name);
result->labels.label_symbols = labels;
result->labels.function_symbols
- = new std::vector<symbol *> (std::move (symbols));
+ = new std::vector<block_symbol> (std::move (symbols));
}

if (line_offset.sign != LINE_OFFSET_UNKNOWN)
@@ -2894,8 +2897,8 @@ complete_label (completion_tracker &tracker,
linespec_parser *parser,
const char *label_name)
{
- std::vector<symbol *> label_function_symbols;
- std::vector<symbol *> *labels
+ std::vector<block_symbol> label_function_symbols;
+ std::vector<block_symbol> *labels
= find_label_symbols (PARSER_STATE (parser),
PARSER_RESULT (parser)->function_symbols,
&label_function_symbols,
@@ -2905,7 +2908,7 @@ complete_label (completion_tracker &tracker,
{
for (const auto &label : *labels)
{
- char *match = xstrdup (SYMBOL_SEARCH_NAME (label));
+ char *match = xstrdup (SYMBOL_SEARCH_NAME (label.symbol));
tracker.add_completion (gdb::unique_xmalloc_ptr<char> (match));
}
delete labels;
@@ -3018,7 +3021,7 @@ linespec_complete (completion_tracker &tracker, const char *text,

const char *func_name = PARSER_EXPLICIT (&parser)->function_name;

- std::vector<symbol *> function_symbols;
+ std::vector<block_symbol> function_symbols;
std::vector<bound_minimal_symbol> minimal_symbols;
find_linespec_symbols (PARSER_STATE (&parser),
PARSER_RESULT (&parser)->file_symtabs,
@@ -3026,7 +3029,7 @@ linespec_complete (completion_tracker &tracker, const char *text,
&function_symbols, &minimal_symbols);

PARSER_RESULT (&parser)->function_symbols
- = new std::vector<symbol *> (std::move (function_symbols));
+ = new std::vector<block_symbol> (std::move (function_symbols));
PARSER_RESULT (&parser)->minimal_symbols
= new std::vector<bound_minimal_symbol> (std::move (minimal_symbols));

@@ -3426,7 +3429,7 @@ decode_objc (struct linespec_state *self, linespec_p ls, const char *arg)

info.file_symtabs = &symtabs;

- std::vector<symbol *> symbols;
+ std::vector<block_symbol> symbols;
info.result.symbols = &symbols;
std::vector<bound_minimal_symbol> minimal_symbols;
info.result.minimal_symbols = &minimal_symbols;
@@ -3448,7 +3451,8 @@ decode_objc (struct linespec_state *self, linespec_p ls, const char *arg)
saved_arg[new_argptr - arg] = '\0';

ls->explicit_loc.function_name = xstrdup (saved_arg);
- ls->function_symbols = new std::vector<symbol *> (std::move (symbols));
+ ls->function_symbols
+ = new std::vector<block_symbol> (std::move (symbols));
ls->minimal_symbols
= new std::vector<bound_minimal_symbol> (std::move (minimal_symbols));
values = convert_linespec_to_sals (self, ls);
@@ -3500,13 +3504,13 @@ public:
}

/* Return all symbols collected. */
- std::vector<symbol *> release_symbols ()
+ std::vector<block_symbol> release_symbols ()
{
return m_symbols;
}

/* Callable as a symbol_found_callback_ftype callback. */
- bool operator () (symbol *sym);
+ bool operator () (block_symbol *bsym);

private:
/* A hash table of all symbols we found. We use this to avoid
@@ -3514,14 +3518,15 @@ private:
htab_t m_unique_syms;

/* The result vector. */
- std::vector<symbol *> m_symbols;
+ std::vector<block_symbol> m_symbols;
};

bool
-decode_compound_collector::operator () (symbol *sym)
+decode_compound_collector::operator () (block_symbol *bsym)
{
void **slot;
struct type *t;
+ struct symbol *sym = bsym->symbol;

if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
return true; /* Continue iterating. */
@@ -3537,7 +3542,7 @@ decode_compound_collector::operator () (symbol *sym)
if (!*slot)
{
*slot = sym;
- m_symbols.push_back (sym);
+ m_symbols.push_back (*bsym);
}

return true; /* Continue iterating. */
@@ -3547,7 +3552,7 @@ decode_compound_collector::operator () (symbol *sym)

/* Return any symbols corresponding to CLASS_NAME in FILE_SYMTABS. */

-static std::vector<symbol *>
+static std::vector<block_symbol>
lookup_prefix_sym (struct linespec_state *state,
std::vector<symtab *> *file_symtabs,
const char *class_name)
@@ -3588,20 +3593,22 @@ lookup_prefix_sym (struct linespec_state *state,
static int
compare_symbols (const void *a, const void *b)
{
- struct symbol * const *sa = (struct symbol * const*) a;
- struct symbol * const *sb = (struct symbol * const*) b;
+ const struct block_symbol *ba = (const struct block_symbol *) a;
+ const struct block_symbol *bb = (const struct block_symbol *) b;
+ const struct symbol *sa = ba->symbol;
+ const struct symbol *sb = bb->symbol;
uintptr_t uia, uib;

- uia = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (*sa));
- uib = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (*sb));
+ uia = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (sa));
+ uib = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (sb));

if (uia < uib)
return -1;
if (uia > uib)
return 1;

- uia = (uintptr_t) *sa;
- uib = (uintptr_t) *sb;
+ uia = (uintptr_t) sa;
+ uib = (uintptr_t) sb;

if (uia < uib)
return -1;
@@ -3686,7 +3693,8 @@ find_superclass_methods (std::vector<struct type *> &&superclasses,
static void
find_method (struct linespec_state *self, std::vector<symtab *> *file_symtabs,
const char *class_name, const char *method_name,
- std::vector<symbol *> *sym_classes, std::vector<symbol *> *symbols,
+ std::vector<block_symbol> *sym_classes,
+ std::vector<block_symbol> *symbols,
std::vector<bound_minimal_symbol> *minsyms)
{
size_t last_result_len;
@@ -3697,7 +3705,7 @@ find_method (struct linespec_state *self, std::vector<symtab *> *file_symtabs,
/* Sort symbols so that symbols with the same program space are next
to each other. */
qsort (sym_classes->data (), sym_classes->size (),
- sizeof (symbol *), compare_symbols);
+ sizeof (block_symbol), compare_symbols);

info.state = self;
info.file_symtabs = file_symtabs;
@@ -3715,10 +3723,11 @@ find_method (struct linespec_state *self, std::vector<symtab *> *file_symtabs,
what to do. */
last_result_len = 0;
unsigned int ix = 0;
- for (const auto &sym : *sym_classes)
+ for (const auto &elt : *sym_classes)
{
struct type *t;
struct program_space *pspace;
+ struct symbol *sym = elt.symbol;

/* Program spaces that are executing startup should have
been filtered out earlier. */
@@ -3733,7 +3742,7 @@ find_method (struct linespec_state *self, std::vector<symtab *> *file_symtabs,
sure not to miss the last batch. */
if (ix == sym_classes->size () - 1
|| (pspace
- != SYMTAB_PSPACE (symbol_symtab (sym_classes->at (ix + 1)))))
+ != SYMTAB_PSPACE (symbol_symtab (sym_classes->at (ix + 1).symbol))))
{
/* If we did not find a direct implementation anywhere in
this program space, consider superclasses. */
@@ -3884,7 +3893,7 @@ static void
find_function_symbols (struct linespec_state *state,
std::vector<symtab *> *file_symtabs, const char *name,
symbol_name_match_type name_match_type,
- std::vector<symbol *> *symbols,
+ std::vector<block_symbol> *symbols,
std::vector<bound_minimal_symbol> *minsyms)
{
struct collect_info info;
@@ -3913,7 +3922,7 @@ find_linespec_symbols (struct linespec_state *state,
std::vector<symtab *> *file_symtabs,
const char *lookup_name,
symbol_name_match_type name_match_type,
- std::vector <symbol *> *symbols,
+ std::vector <block_symbol> *symbols,
std::vector<bound_minimal_symbol> *minsyms)
{
std::string canon = cp_canonicalize_string_no_typedefs (lookup_name);
@@ -3967,7 +3976,7 @@ find_linespec_symbols (struct linespec_state *state,
method = last;

/* Find a list of classes named KLASS. */
- std::vector<symbol *> classes
+ std::vector<block_symbol> classes
= lookup_prefix_sym (state, file_symtabs, klass.c_str ());
if (!classes.empty ())
{
@@ -4002,8 +4011,8 @@ static void
find_label_symbols_in_block (const struct block *block,
const char *name, struct symbol *fn_sym,
bool completion_mode,
- std::vector<symbol *> *result,
- std::vector<symbol *> *label_funcs_ret)
+ std::vector<block_symbol> *result,
+ std::vector<block_symbol> *label_funcs_ret)
{
if (completion_mode)
{
@@ -4020,19 +4029,20 @@ find_label_symbols_in_block (const struct block *block,
SYMBOL_DOMAIN (sym), LABEL_DOMAIN)
&& cmp (SYMBOL_SEARCH_NAME (sym), name, name_len) == 0)
{
- result->push_back (sym);
- label_funcs_ret->push_back (fn_sym);
+ result->push_back ({sym, block});
+ label_funcs_ret->push_back ({fn_sym, block});
}
}
}
else
{
- struct symbol *sym = lookup_symbol (name, block, LABEL_DOMAIN, 0).symbol;
+ struct block_symbol label_sym
+ = lookup_symbol (name, block, LABEL_DOMAIN, 0);

- if (sym != NULL)
+ if (label_sym.symbol != NULL)
{
- result->push_back (sym);
- label_funcs_ret->push_back (fn_sym);
+ result->push_back (label_sym);
+ label_funcs_ret->push_back ({fn_sym, block});
}
}
}
@@ -4045,15 +4055,17 @@ find_label_symbols_in_block (const struct block *block,
interpreted as a label name prefix. Otherwise, only labels named
exactly NAME match. */

-static std::vector<symbol *> *
+
+static std::vector<block_symbol> *
find_label_symbols (struct linespec_state *self,
- std::vector<symbol *> *function_symbols,
- std::vector<symbol *> *label_funcs_ret, const char *name,
+ std::vector<block_symbol> *function_symbols,
+ std::vector<block_symbol> *label_funcs_ret,
+ const char *name,
bool completion_mode)
{
const struct block *block;
struct symbol *fn_sym;
- std::vector<symbol *> result;
+ std::vector<block_symbol> result;

if (function_symbols == NULL)
{
@@ -4075,16 +4087,17 @@ find_label_symbols (struct linespec_state *self,
{
for (const auto &elt : *function_symbols)
{
- set_current_program_space (SYMTAB_PSPACE (symbol_symtab (elt)));
- block = SYMBOL_BLOCK_VALUE (elt);
+ fn_sym = elt.symbol;
+ set_current_program_space (SYMTAB_PSPACE (symbol_symtab (fn_sym)));
+ block = SYMBOL_BLOCK_VALUE (fn_sym);

- find_label_symbols_in_block (block, name, elt, completion_mode,
+ find_label_symbols_in_block (block, name, fn_sym, completion_mode,
&result, label_funcs_ret);
}
}

if (!result.empty ())
- return new std::vector<symbol *> (std::move (result));
+ return new std::vector<block_symbol> (std::move (result));
return nullptr;
}

@@ -4429,8 +4442,9 @@ add_matching_symbols_to_info (const char *name,
{
iterate_over_all_matching_symtabs (info->state, lookup_name,
VAR_DOMAIN, search_domain,
- pspace, true, [&] (symbol *sym)
- { return info->add_symbol (sym); });
+ pspace, true,
+ [&] (block_symbol *bsym)
+ { return info->add_symbol (bsym); });
search_minsyms_for_name (info, lookup_name, pspace, NULL);
}
else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt))
@@ -4442,8 +4456,8 @@ add_matching_symbols_to_info (const char *name,
gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
set_current_program_space (SYMTAB_PSPACE (elt));
iterate_over_file_blocks (elt, lookup_name, VAR_DOMAIN,
- [&] (symbol *sym)
- { return info->add_symbol (sym); });
+ [&] (block_symbol *bsym)
+ { return info->add_symbol (bsym); });

/* If no new symbols were found in this iteration and this symtab
is in assembler, we might actually be looking for a label for
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 73c79833ce..5a8cfa20b8 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -2860,7 +2860,9 @@ iterate_over_symbols (const struct block *block,
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
SYMBOL_DOMAIN (sym), domain))
{
- if (!callback (sym))
+ struct block_symbol block_sym = {sym, block};
+
+ if (!callback (&block_sym))
return;
}
}
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 0b155d0659..da498cdb95 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -2073,7 +2073,7 @@ std::vector<CORE_ADDR> find_pcs_for_symtab_line
true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
iterating, or false to indicate that the iteration should end. */

-typedef bool (symbol_found_callback_ftype) (symbol *sym);
+typedef bool (symbol_found_callback_ftype) (struct block_symbol *bsym);

void iterate_over_symbols (const struct block *block,
const lookup_name_info &name,
--
2.13.6