From patchwork Fri Aug 10 23:25:32 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Keith Seitz X-Patchwork-Id: 28856 Received: (qmail 57040 invoked by alias); 10 Aug 2018 23:31:40 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 57002 invoked by uid 89); 10 Aug 2018 23:31:39 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-25.4 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_STOCKGEN, SPF_HELO_PASS, T_FILL_THIS_FORM_SHORT autolearn=ham version=3.3.2 spammy= X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 10 Aug 2018 23:31:36 +0000 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 551A7C07F989 for ; Fri, 10 Aug 2018 23:25:37 +0000 (UTC) Received: from theo.uglyboxes.com (ovpn04.gateway.prod.ext.phx2.redhat.com [10.5.9.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id 1697152FD4 for ; Fri, 10 Aug 2018 23:25:37 +0000 (UTC) From: Keith Seitz To: gdb-patches@sourceware.org Subject: [PATCH 7/9] Use block_symbol_d in linespec APIs Date: Fri, 10 Aug 2018 16:25:32 -0700 Message-Id: <20180810232534.481-8-keiths@redhat.com> In-Reply-To: <20180810232534.481-1-keiths@redhat.com> References: <20180810232534.481-1-keiths@redhat.com> X-IsSubscribed: yes 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) : Change to vector of block_symbol. Update all users. (struct collect_info) : Likewise. (collect_info::add_symbol): Take block_symbol as argument. Update all callers. (decode_compound_collector) : 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 + * linespec.c (struct linespec) : + Change to vector of block_symbol. Update all users. + (struct collect_info) : Likewise. + (collect_info::add_symbol): Take block_symbol as argument. + Update all callers. + (decode_compound_collector) : 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 + * 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 *function_symbols; + std::vector *function_symbols; std::vector *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 *label_symbols; - std::vector *function_symbols; + std::vector *label_symbols; + std::vector *function_symbols; } labels; }; typedef struct linespec *linespec_p; @@ -194,21 +194,21 @@ struct collect_info /* The result being accumulated. */ struct { - std::vector *symbols; + std::vector *symbols; std::vector *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 decode_objc (struct linespec_state *self, static std::vector *symtabs_from_filename (const char *, struct program_space *pspace); -static std::vector *find_label_symbols - (struct linespec_state *self, std::vector *function_symbols, - std::vector *label_funcs_ret, const char *name, +static std::vector *find_label_symbols + (struct linespec_state *self, std::vector *function_symbols, + std::vector *label_funcs_ret, const char *name, bool completion_mode = false); static void find_linespec_symbols (struct linespec_state *self, std::vector *file_symtabs, const char *name, symbol_name_match_type name_match_type, - std::vector *symbols, + std::vector *symbols, std::vector *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 name; linespec_token token; - std::vector symbols; - std::vector *labels; + std::vector symbols; + std::vector *labels; std::vector 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 (std::move (symbols)); + = new std::vector (std::move (symbols)); PARSER_RESULT (parser)->minimal_symbols = new std::vector (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 (std::move (symbols)); + = new std::vector (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 (std::move (symbols)); + = new std::vector (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 symbols; - std::vector *labels; + std::vector symbols; + std::vector *labels; std::vector 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 (std::move (symbols)); + = new std::vector (std::move (symbols)); result->minimal_symbols = new std::vector (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 (std::move (symbols)); + = new std::vector (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 label_function_symbols; - std::vector *labels + std::vector label_function_symbols; + std::vector *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 (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 function_symbols; + std::vector function_symbols; std::vector 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 (std::move (function_symbols)); + = new std::vector (std::move (function_symbols)); PARSER_RESULT (&parser)->minimal_symbols = new std::vector (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 symbols; + std::vector symbols; info.result.symbols = &symbols; std::vector 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 (std::move (symbols)); + ls->function_symbols + = new std::vector (std::move (symbols)); ls->minimal_symbols = new std::vector (std::move (minimal_symbols)); values = convert_linespec_to_sals (self, ls); @@ -3500,13 +3504,13 @@ public: } /* Return all symbols collected. */ - std::vector release_symbols () + std::vector 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 m_symbols; + std::vector 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 +static std::vector lookup_prefix_sym (struct linespec_state *state, std::vector *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 &&superclasses, static void find_method (struct linespec_state *self, std::vector *file_symtabs, const char *class_name, const char *method_name, - std::vector *sym_classes, std::vector *symbols, + std::vector *sym_classes, + std::vector *symbols, std::vector *minsyms) { size_t last_result_len; @@ -3697,7 +3705,7 @@ find_method (struct linespec_state *self, std::vector *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 *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 *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 *file_symtabs, const char *name, symbol_name_match_type name_match_type, - std::vector *symbols, + std::vector *symbols, std::vector *minsyms) { struct collect_info info; @@ -3913,7 +3922,7 @@ find_linespec_symbols (struct linespec_state *state, std::vector *file_symtabs, const char *lookup_name, symbol_name_match_type name_match_type, - std::vector *symbols, + std::vector *symbols, std::vector *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 classes + std::vector 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 *result, - std::vector *label_funcs_ret) + std::vector *result, + std::vector *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 * + +static std::vector * find_label_symbols (struct linespec_state *self, - std::vector *function_symbols, - std::vector *label_funcs_ret, const char *name, + std::vector *function_symbols, + std::vector *label_funcs_ret, + const char *name, bool completion_mode) { const struct block *block; struct symbol *fn_sym; - std::vector result; + std::vector 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 (std::move (result)); + return new std::vector (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 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,