Use block_symbol in linespec APIs

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.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index b345ec5..830f429 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,22 @@
 2018-08-29  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.
+
+2018-08-29  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 d9d3087..ef87164 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -5836,7 +5836,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 06ec78b..ea0d829 100644 (file)
--- 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 symtab_vector_up 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
@@ -393,7 +393,7 @@ static void minsym_found (struct linespec_state *self, struct objfile *objfile,
                          struct minimal_symbol *msymbol,
                          std::vector<symtab_and_line> *result);
 
-static bool compare_symbols (const struct symbol *a, const struct symbol *b);
+static bool compare_symbols (const block_symbol &a, const block_symbol &b);
 
 static bool compare_msymbols (const bound_minimal_symbol &a,
                              const bound_minimal_symbol &b);
@@ -1150,12 +1150,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;
                     });
                }
@@ -1760,8 +1760,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.  */
@@ -1868,7 +1868,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));
@@ -1884,7 +1884,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
@@ -1990,7 +1990,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
@@ -2060,8 +2060,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));
        }
     }
 
@@ -2237,15 +2238,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)
@@ -2261,7 +2264,8 @@ convert_linespec_to_sals (struct linespec_state *state, linespec_p ls)
 
          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
@@ -2272,10 +2276,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_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym));
+                   = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym.symbol));
 
                  for (const auto &elem : *ls->minimal_symbols)
                    {
@@ -2306,10 +2310,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);
                }
            }
        }
@@ -2372,8 +2376,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;
@@ -2411,7 +2415,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));
     }
@@ -2428,7 +2432,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)
@@ -2899,8 +2903,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,
@@ -2910,7 +2914,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;
@@ -3023,7 +3027,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,
@@ -3031,7 +3035,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));
 
@@ -3431,7 +3435,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;
@@ -3453,7 +3457,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);
@@ -3505,13 +3510,13 @@ public:
   }
 
   /* Return all symbols collected.  */
-  std::vector<symbol *> release_symbols ()
+  std::vector<block_symbol> release_symbols ()
   {
     return std::move (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
@@ -3519,14 +3524,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.  */
@@ -3542,7 +3548,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.  */
@@ -3552,7 +3558,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)
@@ -3591,20 +3597,20 @@ lookup_prefix_sym (struct linespec_state *state,
    symbols with the same program space end up next to each other.  */
 
 static bool
-compare_symbols (const struct symbol *a, const struct symbol *b)
+compare_symbols (const block_symbol &a, const block_symbol &b)
 {
   uintptr_t uia, uib;
 
-  uia = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (a));
-  uib = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (b));
+  uia = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (a.symbol));
+  uib = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (b.symbol));
 
   if (uia < uib)
     return true;
   if (uia > uib)
     return false;
 
-  uia = (uintptr_t) a;
-  uib = (uintptr_t) b;
+  uia = (uintptr_t) a.symbol;
+  uib = (uintptr_t) b.symbol;
 
   if (uia < uib)
     return true;
@@ -3681,7 +3687,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;
@@ -3710,10 +3717,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.  */
@@ -3728,7 +3736,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.  */
@@ -3876,7 +3884,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;
@@ -3905,7 +3913,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);
@@ -3959,7 +3967,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 ())
        {
@@ -3994,8 +4002,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)
     {
@@ -4012,19 +4020,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});
        }
     }
 }
@@ -4037,15 +4046,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)
     {
@@ -4067,16 +4078,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;
 }
 
@@ -4421,8 +4433,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))
@@ -4434,8 +4447,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 0a1caa5..04dd5e2 100644 (file)
--- 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 eb14f34..1dc9a09 100644 (file)
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -2124,7 +2124,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,