gdb/symfile-debug.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Debug logging for the symbol file functions for the GNU debugger, GDB.

  3.    Copyright (C) 2013-2015 Free Software Foundation, Inc.

  5.    Contributed by Cygnus Support, using pieces from other GDB modules.

  7.    This file is part of GDB.

  9.    This program is free software; you can redistribute it and/or modify
  10.    it under the terms of the GNU General Public License as published by
  11.    the Free Software Foundation; either version 3 of the License, or
  12.    (at your option) any later version.

  14.    This program is distributed in the hope that it will be useful,
  15.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.    GNU General Public License for more details.

  19.    You should have received a copy of the GNU General Public License
  20.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  22. /* Note: Be careful with functions that can throw errors.
  23.    We want to see a logging message regardless of whether an error was thrown.
  24.    This typically means printing a message before calling the real function
  25.    and then if the function returns a result printing a message after it
  26.    returns.  */

  28. #include "defs.h"
  29. #include "gdbcmd.h"
  30. #include "objfiles.h"
  31. #include "observer.h"
  32. #include "source.h"
  33. #include "symtab.h"
  34. #include "symfile.h"

  36. /* We need to save a pointer to the real symbol functions.
  37.    Plus, the debug versions are malloc'd because we have to NULL out the
  38.    ones that are NULL in the real copy.  */

  40. ‌struct debug_sym_fns_data
  41. {
  42.   const struct sym_fns *real_sf;
  43.   struct sym_fns debug_sf;
  44. };

  46. /* We need to record a pointer to the real set of functions for each
  47.    objfile.  */
  48. ‌static const struct objfile_data *symfile_debug_objfile_data_key;

  50. /* If non-zero all calls to the symfile functions are logged.  */
  51. ‌static int debug_symfile = 0;

  53. /* Return non-zero if symfile debug logging is installed.  */

  55. static int
  56. ‌symfile_debug_installed (struct objfile *objfile)
  57. {
  58.   return (objfile->sf != NULL
  59.           && objfile_data (objfile, symfile_debug_objfile_data_key) != NULL);
  60. }

  62. /* Utility return the name to print for SYMTAB.  */

  64. static const char *
  65. ‌debug_symtab_name (struct symtab *symtab)
  66. {
  67.   return symtab_to_filename_for_display (symtab);
  68. }

  70. /* Debugging version of struct quick_symbol_functions.  */

  72. static int
  73. ‌debug_qf_has_symbols (struct objfile *objfile)
  74. {
  75.   const struct debug_sym_fns_data *debug_data =
  76.     objfile_data (objfile, symfile_debug_objfile_data_key);
  77.   int retval;

  79.   retval = debug_data->real_sf->qf->has_symbols (objfile);

  81.   fprintf_filtered (gdb_stdlog, "qf->has_symbols (%s) = %d\n",
  82.                     objfile_debug_name (objfile), retval);

  84.   return retval;
  85. }

  87. static struct symtab *
  88. ‌debug_qf_find_last_source_symtab (struct objfile *objfile)
  89. {
  90.   const struct debug_sym_fns_data *debug_data =
  91.     objfile_data (objfile, symfile_debug_objfile_data_key);
  92.   struct symtab *retval;

  94.   fprintf_filtered (gdb_stdlog, "qf->find_last_source_symtab (%s)\n",
  95.                     objfile_debug_name (objfile));

  97.   retval = debug_data->real_sf->qf->find_last_source_symtab (objfile);

  99.   fprintf_filtered (gdb_stdlog, "qf->find_last_source_symtab (...) = %s\n",
  100.                     retval ? debug_symtab_name (retval) : "NULL");

  102.   return retval;
  103. }

  105. static void
  106. ‌debug_qf_forget_cached_source_info (struct objfile *objfile)
  107. {
  108.   const struct debug_sym_fns_data *debug_data =
  109.     objfile_data (objfile, symfile_debug_objfile_data_key);

  111.   fprintf_filtered (gdb_stdlog, "qf->forget_cached_source_info (%s)\n",
  112.                     objfile_debug_name (objfile));

  114.   debug_data->real_sf->qf->forget_cached_source_info (objfile);
  115. }

  117. static int
  118. ‌debug_qf_map_symtabs_matching_filename (struct objfile *objfile,
  119.                                         const char *name,
  120.                                         const char *real_path,
  121.                                         int (*callback) (struct symtab *,
  122.                                                          void *),
  123.                                         void *data)
  124. {
  125.   const struct debug_sym_fns_data *debug_data =
  126.     objfile_data (objfile, symfile_debug_objfile_data_key);
  127.   int retval;

  129.   fprintf_filtered (gdb_stdlog,
  130.                     "qf->map_symtabs_matching_filename (%s, \"%s\", \"%s\", %s, %s)\n",
  131.                     objfile_debug_name (objfile), name,
  132.                     real_path ? real_path : NULL,
  133.                     host_address_to_string (callback),
  134.                     host_address_to_string (data));

  136.   retval = debug_data->real_sf->qf->map_symtabs_matching_filename
  137.     (objfile, name, real_path, callback, data);

  139.   fprintf_filtered (gdb_stdlog,
  140.                     "qf->map_symtabs_matching_filename (...) = %d\n",
  141.                     retval);

  143.   return retval;
  144. }

  146. static struct compunit_symtab *
  147. ‌debug_qf_lookup_symbol (struct objfile *objfile, int kind, const char *name,
  148.                         domain_enum domain)
  149. {
  150.   const struct debug_sym_fns_data *debug_data =
  151.     objfile_data (objfile, symfile_debug_objfile_data_key);
  152.   struct compunit_symtab *retval;

  154.   fprintf_filtered (gdb_stdlog,
  155.                     "qf->lookup_symbol (%s, %d, \"%s\", %s)\n",
  156.                     objfile_debug_name (objfile), kind, name,
  157.                     domain_name (domain));

  159.   retval = debug_data->real_sf->qf->lookup_symbol (objfile, kind, name,
  160.                                                    domain);

  162.   fprintf_filtered (gdb_stdlog, "qf->lookup_symbol (...) = %s\n",
  163.                     retval
  164.                     ? debug_symtab_name (compunit_primary_filetab (retval))
  165.                     : "NULL");

  167.   return retval;
  168. }

  170. static void
  171. ‌debug_qf_print_stats (struct objfile *objfile)
  172. {
  173.   const struct debug_sym_fns_data *debug_data =
  174.     objfile_data (objfile, symfile_debug_objfile_data_key);

  176.   fprintf_filtered (gdb_stdlog, "qf->print_stats (%s)\n",
  177.                     objfile_debug_name (objfile));

  179.   debug_data->real_sf->qf->print_stats (objfile);
  180. }

  182. static void
  183. ‌debug_qf_dump (struct objfile *objfile)
  184. {
  185.   const struct debug_sym_fns_data *debug_data =
  186.     objfile_data (objfile, symfile_debug_objfile_data_key);

  188.   fprintf_filtered (gdb_stdlog, "qf->dump (%s)\n",
  189.                     objfile_debug_name (objfile));

  191.   debug_data->real_sf->qf->dump (objfile);
  192. }

  194. static void
  195. ‌debug_qf_relocate (struct objfile *objfile,
  196.                    const struct section_offsets *new_offsets,
  197.                    const struct section_offsets *delta)
  198. {
  199.   const struct debug_sym_fns_data *debug_data =
  200.     objfile_data (objfile, symfile_debug_objfile_data_key);

  202.   fprintf_filtered (gdb_stdlog, "qf->relocate (%s, %s, %s)\n",
  203.                     objfile_debug_name (objfile),
  204.                     host_address_to_string (new_offsets),
  205.                     host_address_to_string (delta));

  207.   debug_data->real_sf->qf->relocate (objfile, new_offsets, delta);
  208. }

  210. static void
  211. ‌debug_qf_expand_symtabs_for_function (struct objfile *objfile,
  212.                                       const char *func_name)
  213. {
  214.   const struct debug_sym_fns_data *debug_data =
  215.     objfile_data (objfile, symfile_debug_objfile_data_key);

  217.   fprintf_filtered (gdb_stdlog,
  218.                     "qf->expand_symtabs_for_function (%s, \"%s\")\n",
  219.                     objfile_debug_name (objfile), func_name);

  221.   debug_data->real_sf->qf->expand_symtabs_for_function (objfile, func_name);
  222. }

  224. static void
  225. ‌debug_qf_expand_all_symtabs (struct objfile *objfile)
  226. {
  227.   const struct debug_sym_fns_data *debug_data =
  228.     objfile_data (objfile, symfile_debug_objfile_data_key);

  230.   fprintf_filtered (gdb_stdlog, "qf->expand_all_symtabs (%s)\n",
  231.                     objfile_debug_name (objfile));

  233.   debug_data->real_sf->qf->expand_all_symtabs (objfile);
  234. }

  236. static void
  237. ‌debug_qf_expand_symtabs_with_fullname (struct objfile *objfile,
  238.                                        const char *fullname)
  239. {
  240.   const struct debug_sym_fns_data *debug_data =
  241.     objfile_data (objfile, symfile_debug_objfile_data_key);

  243.   fprintf_filtered (gdb_stdlog,
  244.                     "qf->expand_symtabs_with_fullname (%s, \"%s\")\n",
  245.                     objfile_debug_name (objfile), fullname);

  247.   debug_data->real_sf->qf->expand_symtabs_with_fullname (objfile, fullname);
  248. }

  250. static void
  251. ‌debug_qf_map_matching_symbols (struct objfile *objfile,
  252.                                const char *name, domain_enum namespace,
  253.                                int global,
  254.                                int (*callback) (struct block *,
  255.                                                 struct symbol *, void *),
  256.                                void *data,
  257.                                symbol_compare_ftype *match,
  258.                                symbol_compare_ftype *ordered_compare)
  259. {
  260.   const struct debug_sym_fns_data *debug_data =
  261.     objfile_data (objfile, symfile_debug_objfile_data_key);

  263.   fprintf_filtered (gdb_stdlog,
  264.                     "qf->map_matching_symbols (%s, \"%s\", %s, %d, %s, %s, %s, %s)\n",
  265.                     objfile_debug_name (objfile), name,
  266.                     domain_name (namespace), global,
  267.                     host_address_to_string (callback),
  268.                     host_address_to_string (data),
  269.                     host_address_to_string (match),
  270.                     host_address_to_string (ordered_compare));

  272.   debug_data->real_sf->qf->map_matching_symbols (objfile, name,
  273.                                                  namespace, global,
  274.                                                  callback, data,
  275.                                                  match,
  276.                                                  ordered_compare);
  277. }

  279. static void
  280. ‌debug_qf_expand_symtabs_matching
  281.   (struct objfile *objfile,
  282.    expand_symtabs_file_matcher_ftype *file_matcher,
  283.    expand_symtabs_symbol_matcher_ftype *symbol_matcher,
  284.    enum search_domain kind, void *data)
  285. {
  286.   const struct debug_sym_fns_data *debug_data =
  287.     objfile_data (objfile, symfile_debug_objfile_data_key);

  289.   fprintf_filtered (gdb_stdlog,
  290.                     "qf->expand_symtabs_matching (%s, %s, %s, %s, %s)\n",
  291.                     objfile_debug_name (objfile),
  292.                     host_address_to_string (file_matcher),
  293.                     host_address_to_string (symbol_matcher),
  294.                     search_domain_name (kind),
  295.                     host_address_to_string (data));

  297.   debug_data->real_sf->qf->expand_symtabs_matching (objfile,
  298.                                                     file_matcher,
  299.                                                     symbol_matcher,
  300.                                                     kind, data);
  301. }

  303. static struct compunit_symtab *
  304. ‌debug_qf_find_pc_sect_compunit_symtab (struct objfile *objfile,
  305.                                        struct bound_minimal_symbol msymbol,
  306.                                        CORE_ADDR pc,
  307.                                        struct obj_section *section,
  308.                                        int warn_if_readin)
  309. {
  310.   const struct debug_sym_fns_data *debug_data =
  311.     objfile_data (objfile, symfile_debug_objfile_data_key);
  312.   struct compunit_symtab *retval;

  314.   fprintf_filtered (gdb_stdlog,
  315.                     "qf->find_pc_sect_compunit_symtab (%s, %s, %s, %s, %d)\n",
  316.                     objfile_debug_name (objfile),
  317.                     host_address_to_string (msymbol.minsym),
  318.                     hex_string (pc),
  319.                     host_address_to_string (section),
  320.                     warn_if_readin);

  322.   retval
  323.     = debug_data->real_sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
  324.                                                              pc, section,
  325.                                                              warn_if_readin);

  327.   fprintf_filtered (gdb_stdlog,
  328.                     "qf->find_pc_sect_compunit_symtab (...) = %s\n",
  329.                     retval
  330.                     ? debug_symtab_name (compunit_primary_filetab (retval))
  331.                     : "NULL");

  333.   return retval;
  334. }

  336. static void
  337. ‌debug_qf_map_symbol_filenames (struct objfile *objfile,
  338.                                symbol_filename_ftype *fun, void *data,
  339.                                int need_fullname)
  340. {
  341.   const struct debug_sym_fns_data *debug_data =
  342.     objfile_data (objfile, symfile_debug_objfile_data_key);
  343.   fprintf_filtered (gdb_stdlog,
  344.                     "qf->map_symbol_filenames (%s, %s, %s, %d)\n",
  345.                     objfile_debug_name (objfile),
  346.                     host_address_to_string (fun),
  347.                     host_address_to_string (data),
  348.                     need_fullname);

  350.   debug_data->real_sf->qf->map_symbol_filenames (objfile, fun, data,
  351.                                                  need_fullname);
  352. }

  354. ‌static const struct quick_symbol_functions debug_sym_quick_functions =
  355. {
  356.   debug_qf_has_symbols,
  357.   debug_qf_find_last_source_symtab,
  358.   debug_qf_forget_cached_source_info,
  359.   debug_qf_map_symtabs_matching_filename,
  360.   debug_qf_lookup_symbol,
  361.   debug_qf_print_stats,
  362.   debug_qf_dump,
  363.   debug_qf_relocate,
  364.   debug_qf_expand_symtabs_for_function,
  365.   debug_qf_expand_all_symtabs,
  366.   debug_qf_expand_symtabs_with_fullname,
  367.   debug_qf_map_matching_symbols,
  368.   debug_qf_expand_symtabs_matching,
  369.   debug_qf_find_pc_sect_compunit_symtab,
  370.   debug_qf_map_symbol_filenames
  371. };

  373. /* Debugging version of struct sym_probe_fns.  */

  375. ‌static VEC (probe_p) *
  376. debug_sym_get_probes (struct objfile *objfile)
  377. {
  378.   const struct debug_sym_fns_data *debug_data =
  379.     objfile_data (objfile, symfile_debug_objfile_data_key);
  380.   VEC (probe_p) *retval;

  382.   retval = debug_data->real_sf->sym_probe_fns->sym_get_probes (objfile);

  384.   fprintf_filtered (gdb_stdlog,
  385.                     "probes->sym_get_probes (%s) = %s\n",
  386.                     objfile_debug_name (objfile),
  387.                     host_address_to_string (retval));

  389.   return retval;
  390. }

  392. ‌static const struct sym_probe_fns debug_sym_probe_fns =
  393. {
  394.   debug_sym_get_probes,
  395. };

  397. /* Debugging version of struct sym_fns.  */

  399. static void
  400. ‌debug_sym_new_init (struct objfile *objfile)
  401. {
  402.   const struct debug_sym_fns_data *debug_data =
  403.     objfile_data (objfile, symfile_debug_objfile_data_key);

  405.   fprintf_filtered (gdb_stdlog, "sf->sym_new_init (%s)\n",
  406.                     objfile_debug_name (objfile));

  408.   debug_data->real_sf->sym_new_init (objfile);
  409. }

  411. static void
  412. ‌debug_sym_init (struct objfile *objfile)
  413. {
  414.   const struct debug_sym_fns_data *debug_data =
  415.     objfile_data (objfile, symfile_debug_objfile_data_key);

  417.   fprintf_filtered (gdb_stdlog, "sf->sym_init (%s)\n",
  418.                     objfile_debug_name (objfile));

  420.   debug_data->real_sf->sym_init (objfile);
  421. }

  423. static void
  424. ‌debug_sym_read (struct objfile *objfile, int symfile_flags)
  425. {
  426.   const struct debug_sym_fns_data *debug_data =
  427.     objfile_data (objfile, symfile_debug_objfile_data_key);

  429.   fprintf_filtered (gdb_stdlog, "sf->sym_read (%s, 0x%x)\n",
  430.                     objfile_debug_name (objfile), symfile_flags);

  432.   debug_data->real_sf->sym_read (objfile, symfile_flags);
  433. }

  435. static void
  436. ‌debug_sym_read_psymbols (struct objfile *objfile)
  437. {
  438.   const struct debug_sym_fns_data *debug_data =
  439.     objfile_data (objfile, symfile_debug_objfile_data_key);

  441.   fprintf_filtered (gdb_stdlog, "sf->sym_read_psymbols (%s)\n",
  442.                     objfile_debug_name (objfile));

  444.   debug_data->real_sf->sym_read_psymbols (objfile);
  445. }

  447. static void
  448. ‌debug_sym_finish (struct objfile *objfile)
  449. {
  450.   const struct debug_sym_fns_data *debug_data =
  451.     objfile_data (objfile, symfile_debug_objfile_data_key);

  453.   fprintf_filtered (gdb_stdlog, "sf->sym_finish (%s)\n",
  454.                     objfile_debug_name (objfile));

  456.   debug_data->real_sf->sym_finish (objfile);
  457. }

  459. static void
  460. ‌debug_sym_offsets (struct objfile *objfile,
  461.                    const struct section_addr_info *info)
  462. {
  463.   const struct debug_sym_fns_data *debug_data =
  464.     objfile_data (objfile, symfile_debug_objfile_data_key);

  466.   fprintf_filtered (gdb_stdlog, "sf->sym_offsets (%s, %s)\n",
  467.                     objfile_debug_name (objfile),
  468.                     host_address_to_string (info));

  470.   debug_data->real_sf->sym_offsets (objfile, info);
  471. }

  473. static struct symfile_segment_data *
  474. ‌debug_sym_segments (bfd *abfd)
  475. {
  476.   /* This API function is annoying, it doesn't take a "this" pointer.
  477.      Fortunately it is only used in one place where we (re-)lookup the
  478.      sym_fns table to use.  Thus we will never be called.  */
  479.   gdb_assert_not_reached ("debug_sym_segments called");
  480. }

  482. static void
  483. ‌debug_sym_read_linetable (struct objfile *objfile)
  484. {
  485.   const struct debug_sym_fns_data *debug_data =
  486.     objfile_data (objfile, symfile_debug_objfile_data_key);

  488.   fprintf_filtered (gdb_stdlog, "sf->sym_read_linetable (%s)\n",
  489.                     objfile_debug_name (objfile));

  491.   debug_data->real_sf->sym_read_linetable (objfile);
  492. }

  494. static bfd_byte *
  495. ‌debug_sym_relocate (struct objfile *objfile, asection *sectp, bfd_byte *buf)
  496. {
  497.   const struct debug_sym_fns_data *debug_data =
  498.     objfile_data (objfile, symfile_debug_objfile_data_key);
  499.   bfd_byte *retval;

  501.   retval = debug_data->real_sf->sym_relocate (objfile, sectp, buf);

  503.   fprintf_filtered (gdb_stdlog,
  504.                     "sf->sym_relocate (%s, %s, %s) = %s\n",
  505.                     objfile_debug_name (objfile),
  506.                     host_address_to_string (sectp),
  507.                     host_address_to_string (buf),
  508.                     host_address_to_string (retval));

  510.   return retval;
  511. }

  513. /* Template of debugging version of struct sym_fns.
  514.    A copy is made, with sym_flavour updated, and a pointer to the real table
  515.    installed in real_sf, and then a pointer to the copy is installed in the
  516.    objfile.  */

  518. ‌static const struct sym_fns debug_sym_fns =
  519. {
  520.   debug_sym_new_init,
  521.   debug_sym_init,
  522.   debug_sym_read,
  523.   debug_sym_read_psymbols,
  524.   debug_sym_finish,
  525.   debug_sym_offsets,
  526.   debug_sym_segments,
  527.   debug_sym_read_linetable,
  528.   debug_sym_relocate,
  529.   &debug_sym_probe_fns,
  530.   &debug_sym_quick_functions
  531. };

  533. /* Free the copy of sym_fns recorded in the registry.  */

  535. static void
  536. ‌symfile_debug_free_objfile (struct objfile *objfile, void *datum)
  537. {
  538.   xfree (datum);
  539. }

  541. /* Install the debugging versions of the symfile functions for OBJFILE.
  542.    Do not call this if the debug versions are already installed.  */

  544. static void
  545. ‌install_symfile_debug_logging (struct objfile *objfile)
  546. {
  547.   const struct sym_fns *real_sf;
  548.   struct debug_sym_fns_data *debug_data;

  550.   /* The debug versions should not already be installed.  */
  551.   gdb_assert (!symfile_debug_installed (objfile));

  553.   real_sf = objfile->sf;

  555.   /* Alas we have to preserve NULL entries in REAL_SF.  */
  556.   debug_data = XCNEW (struct debug_sym_fns_data);

  558. ‌#define COPY_SF_PTR(from, to, name, func)        \
  559.   do {                                                \
  560.     if ((from)->name)                                \
  561.       (to)->debug_sf.name = func;                \
  562.   } while (0)

  564.   COPY_SF_PTR (real_sf, debug_data, sym_new_init, debug_sym_new_init);
  565.   COPY_SF_PTR (real_sf, debug_data, sym_init, debug_sym_init);
  566.   COPY_SF_PTR (real_sf, debug_data, sym_read, debug_sym_read);
  567.   COPY_SF_PTR (real_sf, debug_data, sym_read_psymbols,
  568.                debug_sym_read_psymbols);
  569.   COPY_SF_PTR (real_sf, debug_data, sym_finish, debug_sym_finish);
  570.   COPY_SF_PTR (real_sf, debug_data, sym_offsets, debug_sym_offsets);
  571.   COPY_SF_PTR (real_sf, debug_data, sym_segments, debug_sym_segments);
  572.   COPY_SF_PTR (real_sf, debug_data, sym_read_linetable,
  573.                debug_sym_read_linetable);
  574.   COPY_SF_PTR (real_sf, debug_data, sym_relocate, debug_sym_relocate);
  575.   if (real_sf->sym_probe_fns)
  576.     debug_data->debug_sf.sym_probe_fns = &debug_sym_probe_fns;
  577.   debug_data->debug_sf.qf = &debug_sym_quick_functions;

  579. ‌#undef COPY_SF_PTR

  581.   debug_data->real_sf = real_sf;
  582.   set_objfile_data (objfile, symfile_debug_objfile_data_key, debug_data);
  583.   objfile->sf = &debug_data->debug_sf;
  584. }

  586. /* Uninstall the debugging versions of the symfile functions for OBJFILE.
  587.    Do not call this if the debug versions are not installed.  */

  589. static void
  590. ‌uninstall_symfile_debug_logging (struct objfile *objfile)
  591. {
  592.   struct debug_sym_fns_data *debug_data;

  594.   /* The debug versions should be currently installed.  */
  595.   gdb_assert (symfile_debug_installed (objfile));

  597.   debug_data = objfile_data (objfile, symfile_debug_objfile_data_key);

  599.   objfile->sf = debug_data->real_sf;
  600.   xfree (debug_data);
  601.   set_objfile_data (objfile, symfile_debug_objfile_data_key, NULL);
  602. }

  604. /* Call this function to set OBJFILE->SF.
  605.    Do not set OBJFILE->SF directly.  */

  607. void
  608. ‌objfile_set_sym_fns (struct objfile *objfile, const struct sym_fns *sf)
  609. {
  610.   if (symfile_debug_installed (objfile))
  611.     {
  612.       gdb_assert (debug_symfile);
  613.       /* Remove the current one, and reinstall a new one later.  */
  614.       uninstall_symfile_debug_logging (objfile);
  615.     }

  617.   /* Assume debug logging is disabled.  */
  618.   objfile->sf = sf;

  620.   /* Turn debug logging on if enabled.  */
  621.   if (debug_symfile)
  622.     install_symfile_debug_logging (objfile);
  623. }

  625. static void
  626. ‌set_debug_symfile (char *args, int from_tty, struct cmd_list_element *c)
  627. {
  628.   struct program_space *pspace;
  629.   struct objfile *objfile;

  631.   ALL_PSPACES (pspace)
  632.     ALL_PSPACE_OBJFILES (pspace, objfile)
  633.     {
  634.       if (debug_symfile)
  635.         {
  636.           if (!symfile_debug_installed (objfile))
  637.             install_symfile_debug_logging (objfile);
  638.         }
  639.       else
  640.         {
  641.           if (symfile_debug_installed (objfile))
  642.             uninstall_symfile_debug_logging (objfile);
  643.         }
  644.     }
  645. }

  647. static void
  648. ‌show_debug_symfile (struct ui_file *file, int from_tty,
  649.                         struct cmd_list_element *c, const char *value)
  650. {
  651.   fprintf_filtered (file, _("Symfile debugging is %s.\n"), value);
  652. }

  654. ‌initialize_file_ftype _initialize_symfile_debug;

  656. void
  657. ‌_initialize_symfile_debug (void)
  658. {
  659.   symfile_debug_objfile_data_key
  660.     = register_objfile_data_with_cleanup (NULL, symfile_debug_free_objfile);

  662.   add_setshow_boolean_cmd ("symfile", no_class, &debug_symfile, _("\
  663. Set debugging of the symfile functions."), _("\
  664. Show debugging of the symfile functions."), _("\
  665. When enabled, all calls to the symfile functions are logged."),
  666.                            set_debug_symfile, show_debug_symfile,
  667.                            &setdebuglist, &showdebuglist);

  669.   /* Note: We don't need a new-objfile observer because debug logging
  670.      will be installed when objfile init'n calls objfile_set_sym_fns.  */
  671. }