[PATCH 7/9] Use block_symbol_d in linespec APIs

[Keith Seitz <keiths@redhat.com>]

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