Let expand_symtabs_matching short-circuit
[deliverable/binutils-gdb.git] / gdb / symfile-debug.c
index 37959bf0d408dc96c89843f9f134bc56fb01c9be..eff2e3aa3371ba6fb7697af747a637a0198eed8a 100644 (file)
@@ -1,6 +1,6 @@
 /* Debug logging for the symbol file functions for the GNU debugger, GDB.
 
-   Copyright (C) 2013-2019 Free Software Foundation, Inc.
+   Copyright (C) 2013-2021 Free Software Foundation, Inc.
 
    Contributed by Cygnus Support, using pieces from other GDB modules.
 
@@ -68,311 +68,350 @@ debug_symtab_name (struct symtab *symtab)
   return symtab_to_filename_for_display (symtab);
 }
 \f
-/* Debugging version of struct quick_symbol_functions.  */
 
-static int
-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);
-  int 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.  */
+  for (const auto &iter : qf)
+    {
+      if ((flags & OBJF_PSYMTABS_READ) == 0
+         && iter->can_lazily_read_symbols ())
+       retval = true;
+      else
+       retval = iter->has_symbols (this);
+      if (retval)
+       break;
+    }
 
-  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);
+  for (const auto &iter : qf)
+    {
+      retval = iter->find_last_source_symtab (this);
+      if (retval != nullptr)
+       break;
+    }
 
-  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);
+  for (const auto &iter : qf)
+    iter->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;
+  for (const auto &iter : qf)
+    {
+      retval = (iter->map_symtabs_matching_filename
+               (this, name, real_path, callback));
+      if (retval)
+       break;
+    }
 
-  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);
+  for (const auto &iter : qf)
+    {
+      retval = iter->lookup_symbol (this, kind, name, domain);
+      if (retval != nullptr)
+       break;
+    }
 
-  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 (bool print_bcache)
 {
-  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, %d)\n",
+                     objfile_debug_name (this), print_bcache);
 
-  debug_data->real_sf->qf->print_stats (objfile);
+  for (const auto &iter : qf)
+    iter->print_stats (this, print_bcache);
 }
 
-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);
+  for (const auto &iter : qf)
+    iter->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);
+  for (const auto &iter : qf)
+    iter->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);
+  for (const auto &iter : qf)
+    iter->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);
+  for (const auto &iter : qf)
+    iter->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);
+  for (const auto &iter : qf)
+    iter->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,
-   const lookup_name_info &lookup_name,
+bool
+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);
-
-  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 (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));
+
+  for (const auto &iter : qf)
+    if (!iter->expand_symtabs_matching (this, file_matcher, lookup_name,
+                                       symbol_matcher, expansion_notify,
+                                       kind))
+      return false;
+  return true;
+}
+
+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;
-
-  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);
+  struct compunit_symtab *retval = nullptr;
 
-  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);
+
+  for (const auto &iter : qf)
+    {
+      retval = iter->find_pc_sect_compunit_symtab (this, msymbol, pc, section,
+                                                  warn_if_readin);
+      if (retval != nullptr)
+       break;
+    }
 
-  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,
-                              int need_fullname)
+void
+objfile::map_symbol_filenames (gdb::function_view<symbol_filename_ftype> fun,
+                              bool 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, ..., %d)\n",
+                     objfile_debug_name (this),
+                     need_fullname);
 
-  debug_data->real_sf->qf->map_symbol_filenames (objfile, fun, data,
-                                                need_fullname);
+  for (const auto &iter : qf)
+    iter->map_symbol_filenames (this, fun, 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);
+  for (const auto &iter : qf)
+    {
+      result = iter->find_compunit_symtab_by_address (this, address);
+      if (result != nullptr)
+       break;
+    }
 
-  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;
 }
 
-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,
-  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
-};
+enum language
+objfile::lookup_global_symbol_language (const char *name,
+                                       domain_enum domain,
+                                       bool *symbol_found_p)
+{
+  enum language result = language_unknown;
+  *symbol_found_p = false;
+
+  for (const auto &iter : qf)
+    {
+      result = iter->lookup_global_symbol_language (this, name, domain,
+                                                   symbol_found_p);
+      if (*symbol_found_p)
+       break;
+    }
+
+  return result;
+}
+
+void
+objfile::require_partial_symbols (bool verbose)
+{
+  if ((flags & OBJF_PSYMTABS_READ) == 0)
+    {
+      flags |= OBJF_PSYMTABS_READ;
+
+      bool printed = false;
+      for (const auto &iter : qf)
+       {
+         if (iter->can_lazily_read_symbols ())
+           {
+             if (verbose && !printed)
+               {
+                 printf_filtered (_("Reading symbols from %s...\n"),
+                                  objfile_name (this));
+                 printed = true;
+               }
+             iter->read_partial_symbols (this);
+           }
+       }
+      if (printed && !objfile_has_symbols (this))
+       printf_filtered (_("(No debugging symbols found in %s)\n"),
+                        objfile_name (this));
+    }
+}
+
 \f
 /* Debugging version of struct sym_probe_fns.  */
 
@@ -436,18 +475,6 @@ debug_sym_read (struct objfile *objfile, symfile_add_flags symfile_flags)
   debug_data->real_sf->sym_read (objfile, symfile_flags);
 }
 
-static void
-debug_sym_read_psymbols (struct objfile *objfile)
-{
-  const struct debug_sym_fns_data *debug_data
-    = symfile_debug_objfile_data_key.get (objfile);
-
-  fprintf_filtered (gdb_stdlog, "sf->sym_read_psymbols (%s)\n",
-                   objfile_debug_name (objfile));
-
-  debug_data->real_sf->sym_read_psymbols (objfile);
-}
-
 static void
 debug_sym_finish (struct objfile *objfile)
 {
@@ -474,7 +501,7 @@ debug_sym_offsets (struct objfile *objfile,
   debug_data->real_sf->sym_offsets (objfile, info);
 }
 
-static struct symfile_segment_data *
+static symfile_segment_data_up
 debug_sym_segments (bfd *abfd)
 {
   /* This API function is annoying, it doesn't take a "this" pointer.
@@ -524,14 +551,12 @@ static const struct sym_fns debug_sym_fns =
   debug_sym_new_init,
   debug_sym_init,
   debug_sym_read,
-  debug_sym_read_psymbols,
   debug_sym_finish,
   debug_sym_offsets,
   debug_sym_segments,
   debug_sym_read_linetable,
   debug_sym_relocate,
   &debug_sym_probe_fns,
-  &debug_sym_quick_functions
 };
 \f
 /* Install the debugging versions of the symfile functions for OBJFILE.
@@ -560,8 +585,6 @@ install_symfile_debug_logging (struct objfile *objfile)
   COPY_SF_PTR (real_sf, debug_data, sym_new_init, debug_sym_new_init);
   COPY_SF_PTR (real_sf, debug_data, sym_init, debug_sym_init);
   COPY_SF_PTR (real_sf, debug_data, sym_read, debug_sym_read);
-  COPY_SF_PTR (real_sf, debug_data, sym_read_psymbols,
-              debug_sym_read_psymbols);
   COPY_SF_PTR (real_sf, debug_data, sym_finish, debug_sym_finish);
   COPY_SF_PTR (real_sf, debug_data, sym_offsets, debug_sym_offsets);
   COPY_SF_PTR (real_sf, debug_data, sym_segments, debug_sym_segments);
@@ -570,7 +593,6 @@ 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;
 
 #undef COPY_SF_PTR
 
@@ -620,9 +642,7 @@ objfile_set_sym_fns (struct objfile *objfile, const struct sym_fns *sf)
 static void
 set_debug_symfile (const char *args, int from_tty, struct cmd_list_element *c)
 {
-  struct program_space *pspace;
-
-  ALL_PSPACES (pspace)
+  for (struct program_space *pspace : program_spaces)
     for (objfile *objfile : pspace->objfiles ())
       {
        if (debug_symfile)
@@ -645,8 +665,9 @@ show_debug_symfile (struct ui_file *file, int from_tty,
   fprintf_filtered (file, _("Symfile debugging is %s.\n"), value);
 }
 
+void _initialize_symfile_debug ();
 void
-_initialize_symfile_debug (void)
+_initialize_symfile_debug ()
 {
   add_setshow_boolean_cmd ("symfile", no_class, &debug_symfile, _("\
 Set debugging of the symfile functions."), _("\
This page took 0.047987 seconds and 4 git commands to generate.