Introduce method wrappers for quick_symbol_functions

This introduces wrappers for each function in quick_symbol_functions.
The wrappers are methods on objfile, and are defined in
symfile-debug.c, so that they can use the symfile_debug variable.
Places that call the quick functions are all updated to call these new
wrapper methods.

gdb/ChangeLog
2021-03-20  Tom Tromey  <tom@tromey.com>

	* symtab.c (iterate_over_symtabs, expand_symtab_containing_pc)
	(lookup_symbol_via_quick_fns, find_quick_global_symbol_language)
	(basic_lookup_transparent_type_quick)
	(find_pc_sect_compunit_symtab, find_symbol_at_address)
	(find_line_symtab, global_symbol_searcher::expand_symtabs):
	Update.
	* symmisc.c (print_objfile_statistics, dump_objfile)
	(maintenance_expand_symtabs): Update.
	* symfile.c (symbol_file_add_with_addrs)
	(expand_symtabs_matching, map_symbol_filenames): Update.
	* symfile-debug.c (objfile::has_partial_symbols)
	(objfile::find_last_source_symtab)
	(objfile::forget_cached_source_info)
	(objfile::map_symtabs_matching_filename, objfile::lookup_symbol)
	(objfile::print_stats, objfile::dump)
	(objfile::expand_symtabs_for_function)
	(objfile::expand_all_symtabs)
	(objfile::expand_symtabs_with_fullname)
	(objfile::map_matching_symbols)
	(objfile::expand_symtabs_matching)
	(objfile::find_pc_sect_compunit_symtab)
	(objfile::map_symbol_filenames)
	(objfile::find_compunit_symtab_by_address)
	(objfile::lookup_global_symbol_language): New methods.
	(debug_sym_quick_functions): Remove.
	(debug_sym_fns, install_symfile_debug_logging): Update.
	* source.c (forget_cached_source_info_for_objfile)
	(select_source_symtab): Update.
	* objfiles.h (struct objfile): Add methods corresponding to
	quick_symbol_functions.
	* objfiles.c (objfile::has_partial_symbols): Move to
	symfile-debug.c.
	* linespec.c (iterate_over_all_matching_symtabs): Update.
	* cp-support.c (add_symbol_overload_list_qualified): Update.
	* ada-lang.c (add_nonlocal_symbols): Update.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 8d2b32d10de573d19d23d277e16cb516b2143773..dc96da12c7852751654c22f30614351e693287df 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,41 @@
+2021-03-20  Tom Tromey  <tom@tromey.com>
+
+       * symtab.c (iterate_over_symtabs, expand_symtab_containing_pc)
+       (lookup_symbol_via_quick_fns, find_quick_global_symbol_language)
+       (basic_lookup_transparent_type_quick)
+       (find_pc_sect_compunit_symtab, find_symbol_at_address)
+       (find_line_symtab, global_symbol_searcher::expand_symtabs):
+       Update.
+       * symmisc.c (print_objfile_statistics, dump_objfile)
+       (maintenance_expand_symtabs): Update.
+       * symfile.c (symbol_file_add_with_addrs)
+       (expand_symtabs_matching, map_symbol_filenames): Update.
+       * symfile-debug.c (objfile::has_partial_symbols)
+       (objfile::find_last_source_symtab)
+       (objfile::forget_cached_source_info)
+       (objfile::map_symtabs_matching_filename, objfile::lookup_symbol)
+       (objfile::print_stats, objfile::dump)
+       (objfile::expand_symtabs_for_function)
+       (objfile::expand_all_symtabs)
+       (objfile::expand_symtabs_with_fullname)
+       (objfile::map_matching_symbols)
+       (objfile::expand_symtabs_matching)
+       (objfile::find_pc_sect_compunit_symtab)
+       (objfile::map_symbol_filenames)
+       (objfile::find_compunit_symtab_by_address)
+       (objfile::lookup_global_symbol_language): New methods.
+       (debug_sym_quick_functions): Remove.
+       (debug_sym_fns, install_symfile_debug_logging): Update.
+       * source.c (forget_cached_source_info_for_objfile)
+       (select_source_symtab): Update.
+       * objfiles.h (struct objfile): Add methods corresponding to
+       quick_symbol_functions.
+       * objfiles.c (objfile::has_partial_symbols): Move to
+       symfile-debug.c.
+       * linespec.c (iterate_over_all_matching_symtabs): Update.
+       * cp-support.c (add_symbol_overload_list_qualified): Update.
+       * ada-lang.c (add_nonlocal_symbols): Update.
+
 2021-03-20  Tom Tromey  <tom@tromey.com>
 
        * objfiles.h (struct objfile) <has_partial_symbols>: Return bool.

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 1fc303a5c09ac15ee1ddc5cf911f29591f59ece5..d0374780b9891e9d3018409796d15c9647986d12 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -5203,11 +5203,8 @@ add_nonlocal_symbols (std::vector<struct block_symbol> &result,
     {
       data.objfile = objfile;
 
-      if (objfile->sf != nullptr)
-       objfile->sf->qf->map_matching_symbols (objfile, lookup_name,
-                                              domain, global, callback,
-                                              (is_wild_match
-                                               ? NULL : compare_names));
+      objfile->map_matching_symbols (lookup_name, domain, global, callback,
+                                    is_wild_match ? NULL : compare_names);
 
       for (compunit_symtab *cu : objfile->compunits ())
        {
@@ -5229,10 +5226,8 @@ add_nonlocal_symbols (std::vector<struct block_symbol> &result,
       for (objfile *objfile : current_program_space->objfiles ())
        {
          data.objfile = objfile;
-         if (objfile->sf != nullptr)
-           objfile->sf->qf->map_matching_symbols (objfile, name1,
-                                                  domain, global, callback,
-                                                  compare_names);
+         objfile->map_matching_symbols (name1, domain, global, callback,
+                                        compare_names);
        }
     }          
 }

diff --git a/gdb/cp-support.c b/gdb/cp-support.c
index fb4e4289777aac9ddcc97faf6155bf8701b9ed52..eba477d549d1c124338fb2d67551c79322388d91 100644 (file)
--- a/gdb/cp-support.c
+++ b/gdb/cp-support.c
@@ -1452,10 +1452,7 @@ add_symbol_overload_list_qualified (const char *func_name,
      matching FUNC_NAME.  Make sure we read that symbol table in.  */
 
   for (objfile *objf : current_program_space->objfiles ())
-    {
-      if (objf->sf)
-       objf->sf->qf->expand_symtabs_for_function (objf, func_name);
-    }
+    objf->expand_symtabs_for_function (func_name);
 
   /* Search upwards from currently selected frame (so that we can
      complete on local vars.  */

diff --git a/gdb/linespec.c b/gdb/linespec.c
index 9bfa159514ef19b32d2be9c67f5e2afabb674a1d..c7dbd3eeae2a34a8dced072ea8b879fe0a38df62 100644 (file)
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -1168,12 +1168,8 @@ iterate_over_all_matching_symtabs
 
       for (objfile *objfile : current_program_space->objfiles ())
        {
-         if (objfile->sf)
-           objfile->sf->qf->expand_symtabs_matching (objfile,
-                                                     NULL,
-                                                     &lookup_name,
-                                                     NULL, NULL,
-                                                     search_domain);
+         objfile->expand_symtabs_matching (NULL, &lookup_name, NULL, NULL,
+                                           search_domain);
 
          for (compunit_symtab *cu : objfile->compunits ())
            {

diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index 746f7d1f2968d2363941017ae6f716dd29fb8bbe..f18f6158fc3a57e05bfb750df202e1fc11718491 100644 (file)
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -810,25 +810,6 @@ objfile_rebase (struct objfile *objfile, CORE_ADDR slide)
     breakpoint_re_set ();
 }
 \f
-/* See objfiles.h.  */
-
-bool
-objfile::has_partial_symbols ()
-{
-  if (!sf)
-    return false;
-
-  /* If we have not read psymbols, but we have a function capable of reading
-     them, then that is an indication that they are in fact available.  Without
-     this function the symbols may have been already read in but they also may
-     not be present in this objfile.  */
-  if ((flags & OBJF_PSYMTABS_READ) == 0
-      && sf->sym_read_psymbols != NULL)
-    return true;
-
-  return sf->qf->has_symbols (this);
-}
-
 /* Return non-zero if OBJFILE has full symbols.  */
 
 int

diff --git a/gdb/objfiles.h b/gdb/objfiles.h
index f961bdc011685f64accf03518d951ffa0d275791..c55f0f174fc9220791c4e924c2e547e256617014 100644 (file)
--- a/gdb/objfiles.h
+++ b/gdb/objfiles.h
@@ -415,8 +415,8 @@ private:
 
    GDB typically reads symbols twice -- first an initial scan which just
    reads "partial symbols"; these are partial information for the
-   static/global symbols in a symbol file.  When later looking up symbols,
-   objfile->sf->qf->lookup_symbol is used to check if we only have a partial
+   static/global symbols in a symbol file.  When later looking up
+   symbols, lookup_symbol is used to check if we only have a partial
    symbol and if so, read and expand the full compunit.  */
 
 struct objfile
@@ -552,6 +552,71 @@ public:
 
   bool has_partial_symbols ();
 
+  /* See quick_symbol_functions.  */
+  struct symtab *find_last_source_symtab ();
+
+  /* See quick_symbol_functions.  */
+  void forget_cached_source_info ();
+
+  /* See quick_symbol_functions.  */
+  bool map_symtabs_matching_filename
+    (const char *name, const char *real_path,
+     gdb::function_view<bool (symtab *)> callback);
+
+  /* See quick_symbol_functions.  */
+  struct compunit_symtab *lookup_symbol (block_enum kind, const char *name,
+                                        domain_enum domain);
+
+  /* See quick_symbol_functions.  */
+  void print_stats ();
+
+  /* See quick_symbol_functions.  */
+  void dump ();
+
+  /* See quick_symbol_functions.  */
+  void expand_symtabs_for_function (const char *func_name);
+
+  /* See quick_symbol_functions.  */
+  void expand_all_symtabs ();
+
+  /* See quick_symbol_functions.  */
+  void expand_symtabs_with_fullname (const char *fullname);
+
+  /* See quick_symbol_functions.  */
+  void map_matching_symbols
+    (const lookup_name_info &name, domain_enum domain,
+     int global,
+     gdb::function_view<symbol_found_callback_ftype> callback,
+     symbol_compare_ftype *ordered_compare);
+
+  /* See quick_symbol_functions.  */
+  void expand_symtabs_matching
+    (gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
+     const lookup_name_info *lookup_name,
+     gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
+     gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
+     enum search_domain kind);
+
+  /* See quick_symbol_functions.  */
+  struct compunit_symtab *find_pc_sect_compunit_symtab
+    (struct bound_minimal_symbol msymbol,
+     CORE_ADDR pc,
+     struct obj_section *section,
+     int warn_if_readin);
+
+  /* See quick_symbol_functions.  */
+  void map_symbol_filenames (symbol_filename_ftype *fun, void *data,
+                            int need_fullname);
+
+  /* See quick_symbol_functions.  */
+  struct compunit_symtab *find_compunit_symtab_by_address (CORE_ADDR address);
+
+  /* See quick_symbol_functions.  */
+  enum language lookup_global_symbol_language (const char *name,
+                                              domain_enum domain,
+                                              bool *symbol_found_p);
+
+
   /* The object file's original name as specified by the user,
      made absolute, and tilde-expanded.  However, it is not canonicalized
      (i.e., it has not been passed through gdb_realpath).

diff --git a/gdb/source.c b/gdb/source.c
index 3a8f829759bea1c1d98ca5fbec4ceb0068834a3e..6fc27ae72f78a35da8b6f220e3ea02424a315d35 100644 (file)
--- a/gdb/source.c
+++ b/gdb/source.c
@@ -342,8 +342,7 @@ select_source_symtab (struct symtab *s)
 
   for (objfile *objfile : current_program_space->objfiles ())
     {
-      if (objfile->sf)
-       s = objfile->sf->qf->find_last_source_symtab (objfile);
+      s = objfile->find_last_source_symtab ();
       if (s)
        new_symtab = s;
     }
@@ -417,8 +416,7 @@ forget_cached_source_info_for_objfile (struct objfile *objfile)
        }
     }
 
-  if (objfile->sf)
-    objfile->sf->qf->forget_cached_source_info (objfile);
+  objfile->forget_cached_source_info ();
 }
 
 /* See source.h.  */

diff --git a/gdb/symfile-debug.c b/gdb/symfile-debug.c
index 7c022ae341d7e98e406d93b958564b62d8eed9b5..419f24d2240af788c03557119d079923feb95608 100644 (file)
--- a/gdb/symfile-debug.c
+++ b/gdb/symfile-debug.c
@@ -68,312 +68,296 @@ debug_symtab_name (struct symtab *symtab)
   return symtab_to_filename_for_display (symtab);
 }
 \f
-/* Debugging version of struct quick_symbol_functions.  */
 
-static bool
-debug_qf_has_symbols (struct objfile *objfile)
+/* See objfiles.h.  */
+
+bool
+objfile::has_partial_symbols ()
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-  bool retval;
+  bool retval = false;
 
-  retval = debug_data->real_sf->qf->has_symbols (objfile);
+  /* If we have not read psymbols, but we have a function capable of reading
+     them, then that is an indication that they are in fact available.  Without
+     this function the symbols may have been already read in but they also may
+     not be present in this objfile.  */
+  if ((flags & OBJF_PSYMTABS_READ) == 0
+      && sf != nullptr
+      && sf->sym_read_psymbols != NULL)
+    retval = true;
+  else if (sf != nullptr)
+    retval = sf->qf->has_symbols (this);
 
-  fprintf_filtered (gdb_stdlog, "qf->has_symbols (%s) = %d\n",
-                   objfile_debug_name (objfile), retval);
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog, "qf->has_symbols (%s) = %d\n",
+                     objfile_debug_name (this), retval);
 
   return retval;
 }
 
-static struct symtab *
-debug_qf_find_last_source_symtab (struct objfile *objfile)
+struct symtab *
+objfile::find_last_source_symtab ()
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-  struct symtab *retval;
+  struct symtab *retval = nullptr;
 
-  fprintf_filtered (gdb_stdlog, "qf->find_last_source_symtab (%s)\n",
-                   objfile_debug_name (objfile));
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog, "qf->find_last_source_symtab (%s)\n",
+                     objfile_debug_name (this));
 
-  retval = debug_data->real_sf->qf->find_last_source_symtab (objfile);
+  if (sf != nullptr)
+    retval = sf->qf->find_last_source_symtab (this);
 
-  fprintf_filtered (gdb_stdlog, "qf->find_last_source_symtab (...) = %s\n",
-                   retval ? debug_symtab_name (retval) : "NULL");
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog, "qf->find_last_source_symtab (...) = %s\n",
+                     retval ? debug_symtab_name (retval) : "NULL");
 
   return retval;
 }
 
-static void
-debug_qf_forget_cached_source_info (struct objfile *objfile)
+void
+objfile::forget_cached_source_info ()
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-
-  fprintf_filtered (gdb_stdlog, "qf->forget_cached_source_info (%s)\n",
-                   objfile_debug_name (objfile));
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog, "qf->forget_cached_source_info (%s)\n",
+                     objfile_debug_name (this));
 
-  debug_data->real_sf->qf->forget_cached_source_info (objfile);
+  if (sf != nullptr)
+    sf->qf->forget_cached_source_info (this);
 }
 
-static bool
-debug_qf_map_symtabs_matching_filename
-  (struct objfile *objfile, const char *name, const char *real_path,
+bool
+objfile::map_symtabs_matching_filename
+  (const char *name, const char *real_path,
    gdb::function_view<bool (symtab *)> callback)
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-
-  fprintf_filtered (gdb_stdlog,
-                   "qf->map_symtabs_matching_filename (%s, \"%s\", \"%s\", %s)\n",
-                   objfile_debug_name (objfile), name,
-                   real_path ? real_path : NULL,
-                   host_address_to_string (&callback));
-
-  bool retval = (debug_data->real_sf->qf->map_symtabs_matching_filename
-                (objfile, name, real_path, callback));
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog,
+                     "qf->map_symtabs_matching_filename (%s, \"%s\", "
+                     "\"%s\", %s)\n",
+                     objfile_debug_name (this), name,
+                     real_path ? real_path : NULL,
+                     host_address_to_string (&callback));
+
+  bool retval = false;
+  if (sf != nullptr)
+    retval = (sf->qf->map_symtabs_matching_filename
+             (this, name, real_path, callback));
 
-  fprintf_filtered (gdb_stdlog,
-                   "qf->map_symtabs_matching_filename (...) = %d\n",
-                   retval);
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog,
+                     "qf->map_symtabs_matching_filename (...) = %d\n",
+                     retval);
 
   return retval;
 }
 
-static struct compunit_symtab *
-debug_qf_lookup_symbol (struct objfile *objfile, block_enum kind,
-                       const char *name, domain_enum domain)
+struct compunit_symtab *
+objfile::lookup_symbol (block_enum kind, const char *name, domain_enum domain)
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-  struct compunit_symtab *retval;
+  struct compunit_symtab *retval = nullptr;
 
-  fprintf_filtered (gdb_stdlog,
-                   "qf->lookup_symbol (%s, %d, \"%s\", %s)\n",
-                   objfile_debug_name (objfile), kind, name,
-                   domain_name (domain));
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog,
+                     "qf->lookup_symbol (%s, %d, \"%s\", %s)\n",
+                     objfile_debug_name (this), kind, name,
+                     domain_name (domain));
 
-  retval = debug_data->real_sf->qf->lookup_symbol (objfile, kind, name,
-                                                  domain);
+  if (sf != nullptr)
+    retval = sf->qf->lookup_symbol (this, kind, name, domain);
 
-  fprintf_filtered (gdb_stdlog, "qf->lookup_symbol (...) = %s\n",
-                   retval
-                   ? debug_symtab_name (compunit_primary_filetab (retval))
-                   : "NULL");
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog, "qf->lookup_symbol (...) = %s\n",
+                     retval
+                     ? debug_symtab_name (compunit_primary_filetab (retval))
+                     : "NULL");
 
   return retval;
 }
 
-static void
-debug_qf_print_stats (struct objfile *objfile)
+void
+objfile::print_stats ()
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-
-  fprintf_filtered (gdb_stdlog, "qf->print_stats (%s)\n",
-                   objfile_debug_name (objfile));
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog, "qf->print_stats (%s)\n",
+                     objfile_debug_name (this));
 
-  debug_data->real_sf->qf->print_stats (objfile);
+  if (sf != nullptr)
+    sf->qf->print_stats (this);
 }
 
-static void
-debug_qf_dump (struct objfile *objfile)
+void
+objfile::dump ()
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-
-  fprintf_filtered (gdb_stdlog, "qf->dump (%s)\n",
-                   objfile_debug_name (objfile));
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog, "qf->dump (%s)\n",
+                     objfile_debug_name (this));
 
-  debug_data->real_sf->qf->dump (objfile);
+  if (sf != nullptr)
+    sf->qf->dump (this);
 }
 
-static void
-debug_qf_expand_symtabs_for_function (struct objfile *objfile,
-                                     const char *func_name)
+void
+objfile::expand_symtabs_for_function (const char *func_name)
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-
-  fprintf_filtered (gdb_stdlog,
-                   "qf->expand_symtabs_for_function (%s, \"%s\")\n",
-                   objfile_debug_name (objfile), func_name);
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog,
+                     "qf->expand_symtabs_for_function (%s, \"%s\")\n",
+                     objfile_debug_name (this), func_name);
 
-  debug_data->real_sf->qf->expand_symtabs_for_function (objfile, func_name);
+  if (sf != nullptr)
+    sf->qf->expand_symtabs_for_function (this, func_name);
 }
 
-static void
-debug_qf_expand_all_symtabs (struct objfile *objfile)
+void
+objfile::expand_all_symtabs ()
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-
-  fprintf_filtered (gdb_stdlog, "qf->expand_all_symtabs (%s)\n",
-                   objfile_debug_name (objfile));
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog, "qf->expand_all_symtabs (%s)\n",
+                     objfile_debug_name (this));
 
-  debug_data->real_sf->qf->expand_all_symtabs (objfile);
+  if (sf != nullptr)
+    sf->qf->expand_all_symtabs (this);
 }
 
-static void
-debug_qf_expand_symtabs_with_fullname (struct objfile *objfile,
-                                      const char *fullname)
+void
+objfile::expand_symtabs_with_fullname (const char *fullname)
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-
-  fprintf_filtered (gdb_stdlog,
-                   "qf->expand_symtabs_with_fullname (%s, \"%s\")\n",
-                   objfile_debug_name (objfile), fullname);
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog,
+                     "qf->expand_symtabs_with_fullname (%s, \"%s\")\n",
+                     objfile_debug_name (this), fullname);
 
-  debug_data->real_sf->qf->expand_symtabs_with_fullname (objfile, fullname);
+  if (sf != nullptr)
+    sf->qf->expand_symtabs_with_fullname (this, fullname);
 }
 
-static void
-debug_qf_map_matching_symbols
-  (struct objfile *objfile,
-   const lookup_name_info &name, domain_enum domain,
+void
+objfile::map_matching_symbols
+  (const lookup_name_info &name, domain_enum domain,
    int global,
    gdb::function_view<symbol_found_callback_ftype> callback,
    symbol_compare_ftype *ordered_compare)
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-
-  fprintf_filtered (gdb_stdlog,
-                   "qf->map_matching_symbols (%s, %s, %d, %s)\n",
-                   objfile_debug_name (objfile),
-                   domain_name (domain), global,
-                   host_address_to_string (ordered_compare));
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog,
+                     "qf->map_matching_symbols (%s, %s, %d, %s)\n",
+                     objfile_debug_name (this),
+                     domain_name (domain), global,
+                     host_address_to_string (ordered_compare));
 
-  debug_data->real_sf->qf->map_matching_symbols (objfile, name,
-                                                domain, global,
-                                                callback,
-                                                ordered_compare);
+  if (sf != nullptr)
+    sf->qf->map_matching_symbols (this, name, domain, global,
+                                 callback, ordered_compare);
 }
 
-static void
-debug_qf_expand_symtabs_matching
-  (struct objfile *objfile,
-   gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
+void
+objfile::expand_symtabs_matching
+  (gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
    const lookup_name_info *lookup_name,
    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
    enum search_domain kind)
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog,
+                     "qf->expand_symtabs_matching (%s, %s, %s, %s, %s)\n",
+                     objfile_debug_name (this),
+                     host_address_to_string (&file_matcher),
+                     host_address_to_string (&symbol_matcher),
+                     host_address_to_string (&expansion_notify),
+                     search_domain_name (kind));
 
-  fprintf_filtered (gdb_stdlog,
-                   "qf->expand_symtabs_matching (%s, %s, %s, %s, %s)\n",
-                   objfile_debug_name (objfile),
-                   host_address_to_string (&file_matcher),
-                   host_address_to_string (&symbol_matcher),
-                   host_address_to_string (&expansion_notify),
-                   search_domain_name (kind));
-
-  debug_data->real_sf->qf->expand_symtabs_matching (objfile,
-                                                   file_matcher,
-                                                   lookup_name,
-                                                   symbol_matcher,
-                                                   expansion_notify,
-                                                   kind);
-}
-
-static struct compunit_symtab *
-debug_qf_find_pc_sect_compunit_symtab (struct objfile *objfile,
-                                      struct bound_minimal_symbol msymbol,
+  if (sf != nullptr)
+    sf->qf->expand_symtabs_matching (this, file_matcher, lookup_name,
+                                    symbol_matcher, expansion_notify, kind);
+}
+
+struct compunit_symtab *
+objfile::find_pc_sect_compunit_symtab (struct bound_minimal_symbol msymbol,
                                       CORE_ADDR pc,
                                       struct obj_section *section,
                                       int warn_if_readin)
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-  struct compunit_symtab *retval;
+  struct compunit_symtab *retval = nullptr;
 
-  fprintf_filtered (gdb_stdlog,
-                   "qf->find_pc_sect_compunit_symtab (%s, %s, %s, %s, %d)\n",
-                   objfile_debug_name (objfile),
-                   host_address_to_string (msymbol.minsym),
-                   hex_string (pc),
-                   host_address_to_string (section),
-                   warn_if_readin);
-
-  retval
-    = debug_data->real_sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
-                                                            pc, section,
-                                                            warn_if_readin);
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog,
+                     "qf->find_pc_sect_compunit_symtab (%s, %s, %s, %s, %d)\n",
+                     objfile_debug_name (this),
+                     host_address_to_string (msymbol.minsym),
+                     hex_string (pc),
+                     host_address_to_string (section),
+                     warn_if_readin);
+
+  if (sf != nullptr)
+    retval
+      = sf->qf->find_pc_sect_compunit_symtab (this, msymbol, pc, section,
+                                             warn_if_readin);
 
-  fprintf_filtered (gdb_stdlog,
-                   "qf->find_pc_sect_compunit_symtab (...) = %s\n",
-                   retval
-                   ? debug_symtab_name (compunit_primary_filetab (retval))
-                   : "NULL");
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog,
+                     "qf->find_pc_sect_compunit_symtab (...) = %s\n",
+                     retval
+                     ? debug_symtab_name (compunit_primary_filetab (retval))
+                     : "NULL");
 
   return retval;
 }
 
-static void
-debug_qf_map_symbol_filenames (struct objfile *objfile,
-                              symbol_filename_ftype *fun, void *data,
+void
+objfile::map_symbol_filenames (symbol_filename_ftype *fun, void *data,
                               int need_fullname)
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-  fprintf_filtered (gdb_stdlog,
-                   "qf->map_symbol_filenames (%s, %s, %s, %d)\n",
-                   objfile_debug_name (objfile),
-                   host_address_to_string (fun),
-                   host_address_to_string (data),
-                   need_fullname);
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog,
+                     "qf->map_symbol_filenames (%s, %s, %s, %d)\n",
+                     objfile_debug_name (this),
+                     host_address_to_string (fun),
+                     host_address_to_string (data),
+                     need_fullname);
 
-  debug_data->real_sf->qf->map_symbol_filenames (objfile, fun, data,
-                                                need_fullname);
+  if (sf != nullptr)
+    sf->qf->map_symbol_filenames (this, fun, data, need_fullname);
 }
 
-static struct compunit_symtab *
-debug_qf_find_compunit_symtab_by_address (struct objfile *objfile,
-                                         CORE_ADDR address)
+struct compunit_symtab *
+objfile::find_compunit_symtab_by_address (CORE_ADDR address)
 {
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-  fprintf_filtered (gdb_stdlog,
-                   "qf->find_compunit_symtab_by_address (%s, %s)\n",
-                   objfile_debug_name (objfile),
-                   hex_string (address));
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog,
+                     "qf->find_compunit_symtab_by_address (%s, %s)\n",
+                     objfile_debug_name (this),
+                     hex_string (address));
 
   struct compunit_symtab *result = NULL;
-  if (debug_data->real_sf->qf->map_symbol_filenames != NULL)
-    result
-      = debug_data->real_sf->qf->find_compunit_symtab_by_address (objfile,
-                                                                 address);
+  if (sf != nullptr && sf->qf->find_compunit_symtab_by_address != NULL)
+    result = sf->qf->find_compunit_symtab_by_address (this, address);
 
-  fprintf_filtered (gdb_stdlog,
-                   "qf->find_compunit_symtab_by_address (...) = %s\n",
-                   result
-                   ? debug_symtab_name (compunit_primary_filetab (result))
-                   : "NULL");
+  if (debug_symfile)
+    fprintf_filtered (gdb_stdlog,
+                     "qf->find_compunit_symtab_by_address (...) = %s\n",
+                     result
+                     ? debug_symtab_name (compunit_primary_filetab (result))
+                     : "NULL");
+
+  return result;
+}
+
+enum language
+objfile::lookup_global_symbol_language (const char *name,
+                                       domain_enum domain,
+                                       bool *symbol_found_p)
+{
+  enum language result = language_unknown;
+
+  if (sf != nullptr && sf->qf->lookup_global_symbol_language != nullptr)
+    result = sf->qf->lookup_global_symbol_language (this, name, domain,
+                                                   symbol_found_p);
+  else
+    *symbol_found_p = false;
 
   return result;
 }
 
-static const struct quick_symbol_functions debug_sym_quick_functions =
-{
-  debug_qf_has_symbols,
-  debug_qf_find_last_source_symtab,
-  debug_qf_forget_cached_source_info,
-  debug_qf_map_symtabs_matching_filename,
-  debug_qf_lookup_symbol,
-  NULL,
-  debug_qf_print_stats,
-  debug_qf_dump,
-  debug_qf_expand_symtabs_for_function,
-  debug_qf_expand_all_symtabs,
-  debug_qf_expand_symtabs_with_fullname,
-  debug_qf_map_matching_symbols,
-  debug_qf_expand_symtabs_matching,
-  debug_qf_find_pc_sect_compunit_symtab,
-  debug_qf_find_compunit_symtab_by_address,
-  debug_qf_map_symbol_filenames
-};
 \f
 /* Debugging version of struct sym_probe_fns.  */
 
@@ -532,7 +516,7 @@ static const struct sym_fns debug_sym_fns =
   debug_sym_read_linetable,
   debug_sym_relocate,
   &debug_sym_probe_fns,
-  &debug_sym_quick_functions
+  nullptr
 };
 \f
 /* Install the debugging versions of the symfile functions for OBJFILE.
@@ -571,7 +555,7 @@ install_symfile_debug_logging (struct objfile *objfile)
   COPY_SF_PTR (real_sf, debug_data, sym_relocate, debug_sym_relocate);
   if (real_sf->sym_probe_fns)
     debug_data->debug_sf.sym_probe_fns = &debug_sym_probe_fns;
-  debug_data->debug_sf.qf = &debug_sym_quick_functions;
+  debug_data->debug_sf.qf = real_sf->qf;
 
 #undef COPY_SF_PTR
 

diff --git a/gdb/symfile.c b/gdb/symfile.c
index 34d6363a91a71a369eb9019adea7b29934026d43..ac9adc816a483fcba4546267b001f1d526da2568 100644 (file)
--- a/gdb/symfile.c
+++ b/gdb/symfile.c
@@ -1100,8 +1100,7 @@ symbol_file_add_with_addrs (bfd *abfd, const char *name,
        printf_filtered (_("Expanding full symbols from %ps...\n"),
                         styled_string (file_name_style.style (), name));
 
-      if (objfile->sf)
-       objfile->sf->qf->expand_all_symtabs (objfile);
+      objfile->expand_all_symtabs ();
     }
 
   /* Note that we only print a message if we have no symbols and have
@@ -3731,13 +3730,10 @@ expand_symtabs_matching
    enum search_domain kind)
 {
   for (objfile *objfile : current_program_space->objfiles ())
-    {
-      if (objfile->sf)
-       objfile->sf->qf->expand_symtabs_matching (objfile, file_matcher,
-                                                 &lookup_name,
-                                                 symbol_matcher,
-                                                 expansion_notify, kind);
-    }
+    objfile->expand_symtabs_matching (file_matcher,
+                                     &lookup_name,
+                                     symbol_matcher,
+                                     expansion_notify, kind);
 }
 
 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
@@ -3749,11 +3745,7 @@ map_symbol_filenames (symbol_filename_ftype *fun, void *data,
                      int need_fullname)
 {
   for (objfile *objfile : current_program_space->objfiles ())
-    {
-      if (objfile->sf)
-       objfile->sf->qf->map_symbol_filenames (objfile, fun, data,
-                                              need_fullname);
-    }
+    objfile->map_symbol_filenames (fun, data, need_fullname);
 }
 
 #if GDB_SELF_TEST

diff --git a/gdb/symmisc.c b/gdb/symmisc.c
index 3703e50c6debdc53c6db2779d7362b0719d63bdc..0aab30d08abc48770fc7d1e2624220894e38eca6 100644 (file)
--- a/gdb/symmisc.c
+++ b/gdb/symmisc.c
@@ -105,8 +105,7 @@ print_objfile_statistics (void)
        if (OBJSTAT (objfile, n_types) > 0)
          printf_filtered (_("  Number of \"types\" defined: %d\n"),
                           OBJSTAT (objfile, n_types));
-       if (objfile->sf)
-         objfile->sf->qf->print_stats (objfile);
+       objfile->print_stats ();
        i = linetables = 0;
        for (compunit_symtab *cu : objfile->compunits ())
          {
@@ -153,8 +152,7 @@ dump_objfile (struct objfile *objfile)
   printf_filtered (", %d minsyms\n\n",
                   objfile->per_bfd->minimal_symbol_count);
 
-  if (objfile->sf)
-    objfile->sf->qf->dump (objfile);
+  objfile->dump ();
 
   if (objfile->compunit_symtabs != NULL)
     {
@@ -963,23 +961,17 @@ maintenance_expand_symtabs (const char *args, int from_tty)
 
   for (struct program_space *pspace : program_spaces)
     for (objfile *objfile : pspace->objfiles ())
-      {
-       if (objfile->sf)
-         {
-           objfile->sf->qf->expand_symtabs_matching
-             (objfile,
-              [&] (const char *filename, bool basenames)
-              {
-                /* KISS: Only apply the regexp to the complete file name.  */
-                return (!basenames
-                        && (regexp == NULL || re_exec (filename)));
-              },
-              NULL,
-              NULL,
-              NULL,
-              ALL_DOMAIN);
-         }
-      }
+      objfile->expand_symtabs_matching
+       ([&] (const char *filename, bool basenames)
+        {
+          /* KISS: Only apply the regexp to the complete file name.  */
+          return (!basenames
+                  && (regexp == NULL || re_exec (filename)));
+        },
+        NULL,
+        NULL,
+        NULL,
+        ALL_DOMAIN);
 }
 \f
 

diff --git a/gdb/symtab.c b/gdb/symtab.c
index 3650b49832eb9457fb293fd6cdc6b9cadaaee667..084e8ecc2e86442c3b72cb8e8e158b615562f0a5 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -555,11 +555,8 @@ iterate_over_symtabs (const char *name,
 
   for (objfile *objfile : current_program_space->objfiles ())
     {
-      if (objfile->sf
-         && objfile->sf->qf->map_symtabs_matching_filename (objfile,
-                                                            name,
-                                                            real_path.get (),
-                                                            callback))
+      if (objfile->map_symtabs_matching_filename (name, real_path.get (),
+                                                 callback))
        return;
     }
 }
@@ -1114,11 +1111,8 @@ expand_symtab_containing_pc (CORE_ADDR pc, struct obj_section *section)
 
   for (objfile *objfile : current_program_space->objfiles ())
     {
-      struct compunit_symtab *cust = NULL;
-
-      if (objfile->sf)
-       cust = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
-                                                             pc, section, 0);
+      struct compunit_symtab *cust
+       = objfile->find_pc_sect_compunit_symtab (msymbol, pc, section, 0);
       if (cust)
        return;
     }
@@ -2369,9 +2363,6 @@ lookup_symbol_via_quick_fns (struct objfile *objfile,
   const struct block *block;
   struct block_symbol result;
 
-  if (!objfile->sf)
-    return {};
-
   if (symbol_lookup_debug > 1)
     {
       fprintf_unfiltered (gdb_stdlog,
@@ -2382,7 +2373,7 @@ lookup_symbol_via_quick_fns (struct objfile *objfile,
                          name, domain_name (domain));
     }
 
-  cust = objfile->sf->qf->lookup_symbol (objfile, block_index, name, domain);
+  cust = objfile->lookup_symbol (block_index, name, domain);
   if (cust == NULL)
     {
       if (symbol_lookup_debug > 1)
@@ -2549,23 +2540,13 @@ lookup_symbol_in_objfile (struct objfile *objfile, enum block_enum block_index,
 static enum language
 find_quick_global_symbol_language (const char *name, const domain_enum domain)
 {
-  for (objfile *objfile : current_program_space->objfiles ())
-    {
-      if (objfile->sf && objfile->sf->qf
-         && objfile->sf->qf->lookup_global_symbol_language)
-       continue;
-      return language_unknown;
-    }
-
   for (objfile *objfile : current_program_space->objfiles ())
     {
       bool symbol_found_p;
       enum language lang
-       = objfile->sf->qf->lookup_global_symbol_language (objfile, name, domain,
-                                                         &symbol_found_p);
-      if (!symbol_found_p)
-       continue;
-      return lang;
+       = objfile->lookup_global_symbol_language (name, domain, &symbol_found_p);
+      if (symbol_found_p)
+       return lang;
     }
 
   return language_unknown;
@@ -2749,10 +2730,7 @@ basic_lookup_transparent_type_quick (struct objfile *objfile,
   const struct block *block;
   struct symbol *sym;
 
-  if (!objfile->sf)
-    return NULL;
-  cust = objfile->sf->qf->lookup_symbol (objfile, block_index, name,
-                                        STRUCT_DOMAIN);
+  cust = objfile->lookup_symbol (block_index, name, STRUCT_DOMAIN);
   if (cust == NULL)
     return NULL;
 
@@ -2955,16 +2933,15 @@ find_pc_sect_compunit_symtab (CORE_ADDR pc, struct obj_section *section)
          /* In order to better support objfiles that contain both
             stabs and coff debugging info, we continue on if a psymtab
             can't be found.  */
-         if ((obj_file->flags & OBJF_REORDERED) && obj_file->sf)
+         if ((obj_file->flags & OBJF_REORDERED) != 0)
            {
              struct compunit_symtab *result;
 
              result
-               = obj_file->sf->qf->find_pc_sect_compunit_symtab (obj_file,
-                                                                 msymbol,
-                                                                 pc,
-                                                                 section,
-                                                                 0);
+               = obj_file->find_pc_sect_compunit_symtab (msymbol,
+                                                         pc,
+                                                         section,
+                                                         0);
              if (result != NULL)
                return result;
            }
@@ -3005,14 +2982,8 @@ find_pc_sect_compunit_symtab (CORE_ADDR pc, struct obj_section *section)
 
   for (objfile *objf : current_program_space->objfiles ())
     {
-      struct compunit_symtab *result;
-
-      if (!objf->sf)
-       continue;
-      result = objf->sf->qf->find_pc_sect_compunit_symtab (objf,
-                                                          msymbol,
-                                                          pc, section,
-                                                          1);
+      struct compunit_symtab *result
+       = objf->find_pc_sect_compunit_symtab (msymbol, pc, section, 1);
       if (result != NULL)
        return result;
     }
@@ -3059,11 +3030,9 @@ find_symbol_at_address (CORE_ADDR address)
 
   for (objfile *objfile : current_program_space->objfiles ())
     {
-      /* If this objfile doesn't have "quick" functions, then it may
-        have been read with -readnow, in which case we need to search
-        the symtabs directly.  */
-      if (objfile->sf == NULL
-         || objfile->sf->qf->find_compunit_symtab_by_address == NULL)
+      /* If this objfile was read with -readnow, then we need to
+        search the symtabs directly.  */
+      if ((objfile->flags & OBJF_READNOW) != 0)
        {
          for (compunit_symtab *symtab : objfile->compunits ())
            {
@@ -3075,8 +3044,7 @@ find_symbol_at_address (CORE_ADDR address)
       else
        {
          struct compunit_symtab *symtab
-           = objfile->sf->qf->find_compunit_symtab_by_address (objfile,
-                                                               address);
+           = objfile->find_compunit_symtab_by_address (address);
          if (symtab != NULL)
            {
              struct symbol *sym = search_symtab (symtab, address);
@@ -3451,11 +3419,7 @@ find_line_symtab (struct symtab *sym_tab, int line,
        best = 0;
 
       for (objfile *objfile : current_program_space->objfiles ())
-       {
-         if (objfile->sf)
-           objfile->sf->qf->expand_symtabs_with_fullname
-             (objfile, symtab_to_fullname (sym_tab));
-       }
+       objfile->expand_symtabs_with_fullname (symtab_to_fullname (sym_tab));
 
       for (objfile *objfile : current_program_space->objfiles ())
        {
@@ -4576,21 +4540,19 @@ global_symbol_searcher::expand_symtabs
   enum search_domain kind = m_kind;
   bool found_msymbol = false;
 
-  if (objfile->sf)
-    objfile->sf->qf->expand_symtabs_matching
-      (objfile,
-       [&] (const char *filename, bool basenames)
-       {
-        return file_matches (filename, filenames, basenames);
-       },
-       &lookup_name_info::match_any (),
-       [&] (const char *symname)
-       {
-        return (!preg.has_value ()
-                || preg->exec (symname, 0, NULL, 0) == 0);
-       },
-       NULL,
-       kind);
+  objfile->expand_symtabs_matching
+    ([&] (const char *filename, bool basenames)
+     {
+       return file_matches (filename, filenames, basenames);
+     },
+     &lookup_name_info::match_any (),
+     [&] (const char *symname)
+     {
+       return (!preg.has_value ()
+              || preg->exec (symname, 0, NULL, 0) == 0);
+     },
+     NULL,
+     kind);
 
   /* Here, we search through the minimal symbol tables for functions and
      variables that match, and force their symbols to be read.  This is in