gdb: change objfile::map_symtabs_matching_filename to find_symtab_matching_filename

The only user of objfile::map_symtabs_matching_filename uses that method
to find the first matching symtab.  It would therefore be more natural
for that method to be a "find" method, returning the first symtab
matching the predicate.

Change map_symtabs_matching_filename to be
find_symtab_matching_filename, and the internal
iterate_over_one_compunit_symtab to be find_symtab_in_compunit_symtab.

This makes function find_symtab simpler.

Change-Id: Id14a95498fad243495d6eab18810d0c4ab8dbf90
Approved-By: Andrew Burgess <aburgess@redhat.com>

diff --git a/gdb/objfiles.h b/gdb/objfiles.h
index 8ae54b37bb794fa0d9e78899ee076dd5b63e4f20..76d6130f504866c361d8c079d52b0075f373e7dd 100644 (file)
--- a/gdb/objfiles.h
+++ b/gdb/objfiles.h
@@ -571,21 +571,17 @@ public:
   /* See quick_symbol_functions.  */
   void forget_cached_source_info ();
 
-  /* Expand and iterate over each "partial" symbol table in OBJFILE
-     where the source file is named NAME.
+  /* Find the first symtab where the source file matches NAME and REAL_PATH,
+     and for which CALLBACK returns true.
 
      If NAME is not absolute, a match after a '/' in the symbol table's
      file name will also work, REAL_PATH is NULL then.  If NAME is
      absolute then REAL_PATH is non-NULL absolute file name as resolved
-     via gdb_realpath from NAME.
-
-     If a match is found, the "partial" symbol table is expanded.
-     Then, this calls iterate_over_some_symtabs (or equivalent) over
-     all newly-created symbol tables, passing CALLBACK to it.
-     The result of this call is returned.  */
-  iteration_status map_symtabs_matching_filename
-    (const char *name, const char *real_path,
-     gdb::function_view<iteration_status (symtab *)> callback);
+     via gdb_realpath from NAME.  */
+
+  symtab *find_symtab_matching_filename (const char *name,
+                                        const char *real_path,
+                                        find_symtab_callback_ftype callback);
 
   /* Check to see if the symbol is defined in a "partial" symbol table
      of this objfile.  BLOCK_INDEX should be either GLOBAL_BLOCK or

diff --git a/gdb/symfile-debug.c b/gdb/symfile-debug.c
index 9fe5e030f7a0bf0f19d6f08ea1a0a6bdbce4b42a..2432a709ddf7dbd9e0f5bd42f63893f1300554f7 100644 (file)
--- a/gdb/symfile-debug.c
+++ b/gdb/symfile-debug.c
@@ -159,29 +159,30 @@ objfile::forget_cached_source_info ()
     iter->forget_cached_source_info (this);
 }
 
-/* Check for a symtab of a specific name by searching some symtabs.
+/* Find the first symtab of CUST matching BASE_NAME, NAME and REAL_PATH, for
+   which CALLBACK returns true.
 
    If NAME is not absolute, then REAL_PATH is NULL
    If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
 
    The return value, NAME, REAL_PATH and CALLBACK are identical to the
-   `map_symtabs_matching_filename' method of quick_symbol_functions.
+   `objfile::find_symtab_matching_filename' method.
 
    CUST indicates which compunit symtab to search.  Each symtab within
    the specified compunit symtab is also searched.  */
 
-static iteration_status
-iterate_over_one_compunit_symtab
-  (const char *base_name, const char *name, const char *real_path,
-   compunit_symtab *cust,
-   gdb::function_view<iteration_status (symtab *)> callback)
+static symtab *
+find_symtab_in_compunit_symtab (const char *base_name, const char *name,
+                               const char *real_path, compunit_symtab *cust,
+                               find_symtab_callback_ftype callback)
 {
   for (symtab *s : cust->filetabs ())
     {
       if (compare_filenames_for_search (s->filename (), name))
        {
-         if (callback (s) == iteration_status::stop)
-           return iteration_status::stop;
+         if (callback (s))
+           return s;
+
          continue;
        }
 
@@ -193,8 +194,9 @@ iterate_over_one_compunit_symtab
 
       if (compare_filenames_for_search (symtab_to_fullname (s), name))
        {
-         if (callback (s) == iteration_status::stop)
-           return iteration_status::stop;
+         if (callback (s))
+           return s;
+
          continue;
        }
 
@@ -211,30 +213,32 @@ iterate_over_one_compunit_symtab
          fullname = fullname_real_path.get ();
          if (FILENAME_CMP (real_path, fullname) == 0)
            {
-             if (callback (s) == iteration_status::stop)
-               return iteration_status::stop;
+             if (callback (s))
+               return s;
+
              continue;
            }
        }
     }
 
   for (compunit_symtab *iter : cust->includes)
-    if (iterate_over_one_compunit_symtab (base_name, name, real_path, iter,
-                                         callback)
-       == iteration_status::stop)
-      return iteration_status::stop;
+    if (symtab *result = find_symtab_in_compunit_symtab (base_name, name,
+                                                        real_path, iter,
+                                                        callback);
+       result != nullptr)
+      return result;
 
-  return iteration_status::keep_going;
+  return nullptr;
 }
 
-iteration_status
-objfile::map_symtabs_matching_filename
-  (const char *name, const char *real_path,
-   gdb::function_view<iteration_status (symtab *)> callback)
+symtab *
+objfile::find_symtab_matching_filename (const char *name,
+                                       const char *real_path,
+                                       find_symtab_callback_ftype callback)
 {
   if (debug_symfile)
     gdb_printf (gdb_stdlog,
-               "qf->map_symtabs_matching_filename (%s, \"%s\", "
+               "qf->find_symtab_matching_filename (%s, \"%s\", "
                "\"%s\", %s)\n",
                objfile_debug_name (this), name,
                real_path ? real_path : NULL,
@@ -254,40 +258,34 @@ objfile::map_symtabs_matching_filename
     return false;
   };
 
+  symtab *result = nullptr;
   auto compunit_callback = [&] (compunit_symtab *symtab)
   {
     /* Skip included compunits, as they are searched by
-       iterate_over_one_compunit_symtab.  */
+       find_symtab_in_compunit_symtab.  */
     if (symtab->user != nullptr)
       return iteration_status::keep_going;
 
-    /* iterate_over_one_compunit_symtab returns true to stop,
-       convert to iteration_status.  */
-    return iterate_over_one_compunit_symtab (name_basename, name, real_path,
+    result = find_symtab_in_compunit_symtab (name_basename, name, real_path,
                                             symtab, callback);
+    return (result == nullptr
+           ? iteration_status::keep_going
+           : iteration_status::stop);
   };
 
-  iteration_status retval = iteration_status::keep_going;
-
   for (const auto &iter : qf)
-    {
-      if (iter->search (this, match_one_filename, nullptr, nullptr,
-                       compunit_callback,
-                       SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
-                       SEARCH_ALL_DOMAINS)
-         == iteration_status::stop)
-       {
-         retval = iteration_status::stop;
-         break;
-       }
-    }
+    if (iter->search (this, match_one_filename, nullptr, nullptr,
+                     compunit_callback,
+                     SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
+                     SEARCH_ALL_DOMAINS)
+       == iteration_status::stop)
+      break;
 
   if (debug_symfile)
-    gdb_printf (gdb_stdlog,
-               "qf->map_symtabs_matching_filename (...) = %s\n",
-               iteration_status_str (retval));
+    gdb_printf (gdb_stdlog, "qf->find_symtab_matching_filename (...) = %p\n",
+               result);
 
-  return retval;
+  return result;
 }
 
 struct compunit_symtab *

diff --git a/gdb/symtab.c b/gdb/symtab.c
index 5aea10d3ff950748ded0befce3eac42f91b4797a..78aa3c8c1f5a12f3694386e1ae90d23eed6d602d 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -638,8 +638,6 @@ static symtab *
 find_symtab (program_space *pspace, const char *name,
             find_symtab_callback_ftype callback)
 {
-  struct symtab *result = nullptr;
-
   gdb::unique_xmalloc_ptr<char> real_path;
 
   /* Here we are interested in canonicalizing an absolute path, not
@@ -650,21 +648,11 @@ find_symtab (program_space *pspace, const char *name,
       gdb_assert (IS_ABSOLUTE_PATH (real_path.get ()));
     }
 
-  auto map_callback = [&] (symtab *symtab)
-    {
-      if (callback (symtab))
-       {
-         result = symtab;
-         return iteration_status::stop;
-       }
-
-      return iteration_status::keep_going;
-    };
-
   for (objfile &objfile : pspace->objfiles ())
-    if (objfile.map_symtabs_matching_filename (name, real_path.get (),
-                                              map_callback)
-       == iteration_status::stop)
+    if (symtab *result
+         = objfile.find_symtab_matching_filename (name, real_path.get (),
+                                                  callback);
+       result != nullptr)
       return result;
 
   return nullptr;