[binutils-gdb] gdb: make iterate_over_symbols return void, rename to for_each_symbol

Simon Marchi via Gdb-cvs <[email protected]>
Newsgroups gmane.comp.gdb.cvs
Message-ID <[email protected]> 
https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=594acddca78d2ce96029c90cd2ef8d52c3ba1002

commit 594acddca78d2ce96029c90cd2ef8d52c3ba1002
Author: Simon Marchi <[email protected]>
Date:   Thu Apr 16 16:16:21 2026 -0400

    gdb: make iterate_over_symbols return void, rename to for_each_symbol
    
    Nothing really uses the return value of iterate_over_symbols and
    language::iterate_over_symbols.  Also, all provided callback always
    return true, iterating on all matching symbols.  Simplify them to not
    return a value and not have the "stop iterating" feature.
    
    Rename to for_each_symbol, just to be consistent with previous patches.
    
    Also rename symbol_found_callback_ftype to
    for_each_symbol_callback_ftype for consistency.
    
    Change-Id: I55ff3162098bb069dc1de1afca10dd9abfc05c34
    Approved-By: Andrew Burgess <[email protected]>

Diff:
---
 gdb/ada-lang.c      | 29 +++++++++--------------------
 gdb/language.h      | 13 ++++---------
 gdb/linespec.c      | 38 ++++++++++++++++----------------------
 gdb/linux-nat.c     |  4 ++--
 gdb/nat/linux-nat.h |  2 +-
 gdb/symtab.c        | 23 +++++++++--------------
 gdb/symtab.h        | 22 +++++++---------------
 7 files changed, 48 insertions(+), 83 deletions(-)

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index d388a301fa1..71a338ce17e 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -5427,7 +5427,7 @@ struct match_data
   }
   DISABLE_COPY_AND_ASSIGN (match_data);
 
-  bool operator() (struct block_symbol *bsym);
+  void operator() (struct block_symbol *bsym);
 
   void finish (const block *block);
 
@@ -5452,14 +5452,14 @@ match_data::finish (const block *block)
 /* A callback for add_nonlocal_symbols that adds symbol, found in
    BSYM, to a list of symbols.  */
 
-bool
+void
 match_data::operator() (struct block_symbol *bsym)
 {
   const struct block *block = bsym->block;
   struct symbol *sym = bsym->symbol;
 
   if (sym->loc_class () == LOC_UNRESOLVED)
-    return true;
+    return;
   else if (sym->is_argument ())
     arg_sym = sym;
   else
@@ -5467,8 +5467,6 @@ match_data::operator() (struct block_symbol *bsym)
       found_sym = true;
       add_defn_to_vec (*resultp, sym, block);
     }
-
-  return true;
 }
 
 /* Helper for add_nonlocal_symbols.  Find symbols in DOMAIN which are
@@ -5563,10 +5561,7 @@ map_matching_symbols (struct objfile *objfile,
     {
       const struct block *block
 	= symtab->blockvector ()->block (block_kind);
-      /* match_data::operator() always returns true; we ignore the
-	 result but assert just to be future-proof.  */
-      bool result = iterate_over_symbols (block, lookup_name, domain, data);
-      gdb_assert (result);
+      for_each_symbol (block, lookup_name, domain, data);
       data.finish (block);
       return iteration_status::keep_going;
     };
@@ -5664,9 +5659,8 @@ ada_add_all_symbols (std::vector<struct block_symbol> &result,
 	ada_add_local_symbols (result, lookup_name, block, domain);
       else
 	{
-	  /* In the !full_search case we're are being called by
-	     iterate_over_symbols, and we don't want to search
-	     superblocks.  */
+	  /* In the !full_search case we're being called by for_each_symbol, and
+	     we don't want to search superblocks.  */
 	  ada_add_block_symbols (result, block, lookup_name, domain, NULL);
 	}
       if (!result.empty () || !full_search)
@@ -13702,20 +13696,15 @@ public:
 
   /* See language.h.  */
 
-  bool iterate_over_symbols
+  void for_each_symbol
 	(const struct block *block, const lookup_name_info &name,
 	 domain_search_flags domain,
-	 symbol_found_callback_ftype callback) const override
+	 for_each_symbol_callback_ftype callback) const override
   {
     std::vector<struct block_symbol> results
       = ada_lookup_symbol_list_worker (name, block, domain, 0);
     for (block_symbol &sym : results)
-      {
-	if (!callback (&sym))
-	  return false;
-      }
-
-    return true;
+      callback (&sym);
   }
 
   /* See language.h.  */
diff --git a/gdb/language.h b/gdb/language.h
index 0cc075f8a29..b43dae66107 100644
--- a/gdb/language.h
+++ b/gdb/language.h
@@ -353,18 +353,13 @@ struct language_defn
      The caller is responsible for iterating up through superblocks
      if desired.
 
-     For each one, call CALLBACK with the symbol.  If CALLBACK
-     returns false, the iteration ends at that point.
-
-     This field may not be NULL.  If the language does not need any
-     special processing here, 'iterate_over_symbols' should be
-     used as the definition.  */
-  virtual bool iterate_over_symbols
+     For each one, call CALLBACK with the symbol.  */
+  virtual void for_each_symbol
 	(const struct block *block, const lookup_name_info &name,
 	 domain_search_flags domain,
-	 symbol_found_callback_ftype callback) const
+	 for_each_symbol_callback_ftype callback) const
   {
-    return ::iterate_over_symbols (block, name, domain, callback);
+    ::for_each_symbol (block, name, domain, callback);
   }
 
   /* Return a pointer to the function that should be used to match a
diff --git a/gdb/linespec.c b/gdb/linespec.c
index bfdd075ac82..45e12e09272 100644
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -237,17 +237,14 @@ struct collect_info
   std::vector<bound_minimal_symbol> *minimal_symbols;
 
   /* Possibly add a symbol to the results.  */
-  bool add_symbol (block_symbol *bsym);
+  void add_symbol (block_symbol *bsym);
 };
 
-bool
+void
 collect_info::add_symbol (block_symbol *bsym)
 {
   if (record_all || bsym->symbol->loc_class () == LOC_BLOCK)
     this->symbols->push_back (*bsym);
-
-  /* Continue iterating.  */
-  return true;
 }
 
 /* Token types  */
@@ -363,7 +360,7 @@ struct linespec_parser
 static void iterate_over_file_blocks
   (struct symtab *symtab, const lookup_name_info &name,
    domain_search_flags domain,
-   symbol_found_callback_ftype callback);
+   for_each_symbol_callback_ftype callback);
 
 static void initialize_defaults (struct symtab **default_symtab,
 				 int *default_line);
@@ -1128,7 +1125,7 @@ iterate_over_all_matching_symtabs
    const lookup_name_info &lookup_name,
    const domain_search_flags domain,
    struct program_space *search_pspace, bool include_inline,
-   symbol_found_callback_ftype callback)
+   for_each_symbol_callback_ftype callback)
 {
   for (struct program_space *pspace : program_spaces)
     {
@@ -1156,15 +1153,14 @@ iterate_over_all_matching_symtabs
 		  for (i = FIRST_LOCAL_BLOCK; i < bv->num_blocks (); i++)
 		    {
 		      block = bv->block (i);
-		      state->language->iterate_over_symbols
+		      state->language->for_each_symbol
 			(block, lookup_name, domain,
 			 [&] (block_symbol *bsym)
 			 {
 			   /* Restrict calls to CALLBACK to symbols
 			      representing inline symbols only.  */
 			   if (bsym->symbol->is_inlined ())
-			     return callback (bsym);
-			   return true;
+			     callback (bsym);
 			 });
 		    }
 		}
@@ -1196,14 +1192,14 @@ static void
 iterate_over_file_blocks
   (struct symtab *symtab, const lookup_name_info &name,
    domain_search_flags domain,
-   symbol_found_callback_ftype callback)
+   for_each_symbol_callback_ftype callback)
 {
   const struct block *block;
 
   for (block = symtab->compunit ()->blockvector ()->static_block ();
        block != NULL;
        block = block->superblock ())
-    current_language->iterate_over_symbols (block, name, domain, callback);
+    current_language->for_each_symbol (block, name, domain, callback);
 }
 
 /* A helper for find_method.  This finds all methods in type T of
@@ -3325,8 +3321,8 @@ decode_objc (struct linespec_state *self, linespec *ls, const char *arg)
 
 namespace {
 
-/* A function object that serves as symbol_found_callback_ftype
-   callback for iterate_over_symbols.  This is used by
+/* A function object that serves as for_each_symbol_callback_ftype
+   callback for for_each_symbol.  This is used by
    lookup_prefix_sym to collect type symbols.  */
 class decode_compound_collector
 {
@@ -3341,8 +3337,8 @@ public:
     return std::move (m_symbols);
   }
 
-  /* Callable as a symbol_found_callback_ftype callback.  */
-  bool operator () (block_symbol *bsym);
+  /* Callable as a for_each_symbol_callback_ftype callback.  */
+  void operator () (block_symbol *bsym);
 
 private:
   /* A hash table of all symbols we found.  We use this to avoid
@@ -3353,26 +3349,24 @@ private:
   std::vector<block_symbol>  m_symbols;
 };
 
-bool
+void
 decode_compound_collector::operator () (block_symbol *bsym)
 {
   struct type *t;
   struct symbol *sym = bsym->symbol;
 
   if (sym->loc_class () != LOC_TYPEDEF)
-    return true; /* Continue iterating.  */
+    return;
 
   t = sym->type ();
   t = check_typedef (t);
   if (t->code () != TYPE_CODE_STRUCT
       && t->code () != TYPE_CODE_UNION
       && t->code () != TYPE_CODE_NAMESPACE)
-    return true; /* Continue iterating.  */
+    return;
 
   if (m_unique_syms.insert (sym).second)
     m_symbols.push_back (*bsym);
-
-  return true; /* Continue iterating.  */
 }
 
 } // namespace
@@ -4245,7 +4239,7 @@ add_matching_symbols_to_info (const char *name,
 
   auto add_symbol = [&] (block_symbol *bsym)
     {
-      return info->add_symbol (bsym);
+      info->add_symbol (bsym);
     };
 
   for (const auto &elt : info->file_symtabs)
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index 15fca3f6d35..6018d6c9914 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -939,7 +939,7 @@ for_each_lwp (int pid, for_each_lwp_ftype callback)
 
 /* Iterate over all LWPs, calling CALLBACK for every LWP.
 
-   Only consider the LWPs matching FILTER.  */
+   Only consider the LWPs that match FILTER.  */
 
 static void
 for_each_lwp (ptid_t filter, for_each_lwp_ftype callback)
@@ -2951,7 +2951,7 @@ select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
   (*orig_lp)->status = 0;
 }
 
-/* Return non-zero if LP has been resumed.  */
+/* Return true if LP has been resumed.  */
 
 static bool
 resumed_callback (struct lwp_info *lp)
diff --git a/gdb/nat/linux-nat.h b/gdb/nat/linux-nat.h
index 4414749b93d..1eec5b5b614 100644
--- a/gdb/nat/linux-nat.h
+++ b/gdb/nat/linux-nat.h
@@ -52,7 +52,7 @@ using for_each_lwp_ftype = gdb::function_view<void (lwp_info *lwp)>;
 
 /* Iterate over all LWPs, calling CALLBACK for every LWP.
 
-   Only consider the LWPs with that pid.  */
+   Only consider the LWPs that match PID.  */
 
 extern void for_each_lwp (int pid, for_each_lwp_ftype callback);
 
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 6fba0cd838a..357b8e63b19 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -2697,23 +2697,18 @@ lookup_transparent_type (const char *name, domain_search_flags flags)
 
 /* See symtab.h.  */
 
-bool
-iterate_over_symbols (const struct block *block,
-		      const lookup_name_info &name,
-		      const domain_search_flags domain,
-		      symbol_found_callback_ftype callback)
+void
+for_each_symbol (const struct block *block, const lookup_name_info &name,
+		 const domain_search_flags domain,
+		 for_each_symbol_callback_ftype callback)
 {
   for (struct symbol *sym : block_iterator_range (block, &name))
-    {
-      if (sym->matches (domain))
-	{
-	  struct block_symbol block_sym = {sym, block};
+    if (sym->matches (domain))
+      {
+	block_symbol block_sym = { sym, block };
 
-	  if (!callback (&block_sym))
-	    return false;
-	}
-    }
-  return true;
+	callback (&block_sym);
+      }
 }
 
 /* Find the compunit symtab associated with PC and SECTION.
diff --git a/gdb/symtab.h b/gdb/symtab.h
index b8e8caf8d5f..7b1a8238613 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -2808,26 +2808,18 @@ using find_symtab_callback_ftype = std::function<bool (symtab *)>;
 std::vector<const linetable_entry *> find_linetable_entries_for_symtab_line
     (struct symtab *symtab, int line, const linetable_entry **best_entry);
 
-/* Prototype for callbacks for LA_ITERATE_OVER_SYMBOLS.  The callback
-   is called once per matching symbol SYM.  The callback should return
-   true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
-   iterating, or false to indicate that the iteration should end.  */
+/* Callback type for function for_each_symbol.  */
 
-using symbol_found_callback_ftype = gdb::function_view<bool (block_symbol *)>;
+using for_each_symbol_callback_ftype
+  = gdb::function_view<void (block_symbol *)>;
 
 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
 
-   For each symbol that matches, CALLBACK is called.  The symbol is
-   passed to the callback.
+   For each symbol that matches, call CALLBACK with the symbol.  */
 
-   If CALLBACK returns false, the iteration ends and this function
-   returns false.  Otherwise, the search continues, and the function
-   eventually returns true.  */
-
-bool iterate_over_symbols (const struct block *block,
-			   const lookup_name_info &name,
-			   const domain_search_flags domain,
-			   symbol_found_callback_ftype callback);
+void for_each_symbol (const struct block *block, const lookup_name_info &name,
+		      const domain_search_flags domain,
+		      for_each_symbol_callback_ftype callback);
 
 /* Storage type used by demangle_for_lookup.  demangle_for_lookup
    either returns a const char * pointer that points to either of the
lmpx.com only provides a reader for public news (NNTP) servers. It is not affiliated with the servers or forums shown here and is not responsible for the content of articles, which is written by their respective authors.