Update Copyright year range in all files maintained by GDB.
[external/binutils.git] / gdb / symfile-debug.c
1 /* Debug logging for the symbol file functions for the GNU debugger, GDB.
2
3    Copyright (C) 2013-2014 Free Software Foundation, Inc.
4
5    Contributed by Cygnus Support, using pieces from other GDB modules.
6
7    This file is part of GDB.
8
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.
13
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.
18
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/>.  */
21
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.  */
27
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"
35
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.  */
39
40 struct debug_sym_fns_data
41 {
42   const struct sym_fns *real_sf;
43   struct sym_fns debug_sf;
44 };
45
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;
49
50 /* If non-zero all calls to the symfile functions are logged.  */
51 static int debug_symfile = 0;
52
53 /* Return non-zero if symfile debug logging is installed.  */
54
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 }
61
62 /* Utility to return the name to print for OBJFILE.  */
63
64 static const char *
65 debug_objfile_name (const struct objfile *objfile)
66 {
67   return lbasename (objfile->original_name);
68 }
69
70 /* Utility return the name to print for SYMTAB.  */
71
72 static const char *
73 debug_symtab_name (struct symtab *symtab)
74 {
75   return symtab_to_filename_for_display (symtab);
76 }
77 \f
78 /* Debugging version of struct quick_symbol_functions.  */
79
80 static int
81 debug_qf_has_symbols (struct objfile *objfile)
82 {
83   const struct debug_sym_fns_data *debug_data =
84     objfile_data (objfile, symfile_debug_objfile_data_key);
85   int retval;
86
87   retval = debug_data->real_sf->qf->has_symbols (objfile);
88
89   fprintf_filtered (gdb_stdlog, "qf->has_symbols (%s) = %d\n",
90                     debug_objfile_name (objfile), retval);
91
92   return retval;
93 }
94
95 static struct symtab *
96 debug_qf_find_last_source_symtab (struct objfile *objfile)
97 {
98   const struct debug_sym_fns_data *debug_data =
99     objfile_data (objfile, symfile_debug_objfile_data_key);
100   struct symtab *retval;
101
102   fprintf_filtered (gdb_stdlog, "qf->find_last_source_symtab (%s)\n",
103                     debug_objfile_name (objfile));
104
105   retval = debug_data->real_sf->qf->find_last_source_symtab (objfile);
106
107   fprintf_filtered (gdb_stdlog, "qf->find_last_source_symtab (...) = %s\n",
108                     retval ? debug_symtab_name (retval) : "NULL");
109
110   return retval;
111 }
112
113 static void
114 debug_qf_forget_cached_source_info (struct objfile *objfile)
115 {
116   const struct debug_sym_fns_data *debug_data =
117     objfile_data (objfile, symfile_debug_objfile_data_key);
118
119   fprintf_filtered (gdb_stdlog, "qf->forget_cached_source_info (%s)\n",
120                     debug_objfile_name (objfile));
121
122   debug_data->real_sf->qf->forget_cached_source_info (objfile);
123 }
124
125 static int
126 debug_qf_map_symtabs_matching_filename (struct objfile *objfile,
127                                         const char *name,
128                                         const char *real_path,
129                                         int (*callback) (struct symtab *,
130                                                          void *),
131                                         void *data)
132 {
133   const struct debug_sym_fns_data *debug_data =
134     objfile_data (objfile, symfile_debug_objfile_data_key);
135   int retval;
136
137   fprintf_filtered (gdb_stdlog,
138                     "qf->map_symtabs_matching_filename (%s, \"%s\", \"%s\", %s, %s)\n",
139                     debug_objfile_name (objfile), name,
140                     real_path ? real_path : NULL,
141                     host_address_to_string (callback),
142                     host_address_to_string (data));
143
144   retval = debug_data->real_sf->qf->map_symtabs_matching_filename
145     (objfile, name, real_path, callback, data);
146
147   fprintf_filtered (gdb_stdlog,
148                     "qf->map_symtabs_matching_filename (...) = %d\n",
149                     retval);
150
151   return retval;
152 }
153
154 static struct symtab *
155 debug_qf_lookup_symbol (struct objfile *objfile, int kind, const char *name,
156                         domain_enum domain)
157 {
158   const struct debug_sym_fns_data *debug_data =
159     objfile_data (objfile, symfile_debug_objfile_data_key);
160   struct symtab *retval;
161
162   fprintf_filtered (gdb_stdlog,
163                     "qf->lookup_symbol (%s, %d, \"%s\", %s)\n",
164                     debug_objfile_name (objfile), kind, name,
165                     domain_name (domain));
166
167   retval = debug_data->real_sf->qf->lookup_symbol (objfile, kind, name,
168                                                    domain);
169
170   fprintf_filtered (gdb_stdlog, "qf->lookup_symbol (...) = %s\n",
171                     retval ? debug_symtab_name (retval) : "NULL");
172
173   return retval;
174 }
175
176 static void
177 debug_qf_print_stats (struct objfile *objfile)
178 {
179   const struct debug_sym_fns_data *debug_data =
180     objfile_data (objfile, symfile_debug_objfile_data_key);
181
182   fprintf_filtered (gdb_stdlog, "qf->print_stats (%s)\n",
183                     debug_objfile_name (objfile));
184
185   debug_data->real_sf->qf->print_stats (objfile);
186 }
187
188 static void
189 debug_qf_dump (struct objfile *objfile)
190 {
191   const struct debug_sym_fns_data *debug_data =
192     objfile_data (objfile, symfile_debug_objfile_data_key);
193
194   fprintf_filtered (gdb_stdlog, "qf->dump (%s)\n",
195                     debug_objfile_name (objfile));
196
197   debug_data->real_sf->qf->dump (objfile);
198 }
199
200 static void
201 debug_qf_relocate (struct objfile *objfile,
202                    const struct section_offsets *new_offsets,
203                    const struct section_offsets *delta)
204 {
205   const struct debug_sym_fns_data *debug_data =
206     objfile_data (objfile, symfile_debug_objfile_data_key);
207
208   fprintf_filtered (gdb_stdlog, "qf->relocate (%s, %s, %s)\n",
209                     debug_objfile_name (objfile),
210                     host_address_to_string (new_offsets),
211                     host_address_to_string (delta));
212
213   debug_data->real_sf->qf->relocate (objfile, new_offsets, delta);
214 }
215
216 static void
217 debug_qf_expand_symtabs_for_function (struct objfile *objfile,
218                                       const char *func_name)
219 {
220   const struct debug_sym_fns_data *debug_data =
221     objfile_data (objfile, symfile_debug_objfile_data_key);
222
223   fprintf_filtered (gdb_stdlog,
224                     "qf->expand_symtabs_for_function (%s, \"%s\")\n",
225                     debug_objfile_name (objfile), func_name);
226
227   debug_data->real_sf->qf->expand_symtabs_for_function (objfile, func_name);
228 }
229
230 static void
231 debug_qf_expand_all_symtabs (struct objfile *objfile)
232 {
233   const struct debug_sym_fns_data *debug_data =
234     objfile_data (objfile, symfile_debug_objfile_data_key);
235
236   fprintf_filtered (gdb_stdlog, "qf->expand_all_symtabs (%s)\n",
237                     debug_objfile_name (objfile));
238
239   debug_data->real_sf->qf->expand_all_symtabs (objfile);
240 }
241
242 static void
243 debug_qf_expand_symtabs_with_fullname (struct objfile *objfile,
244                                        const char *fullname)
245 {
246   const struct debug_sym_fns_data *debug_data =
247     objfile_data (objfile, symfile_debug_objfile_data_key);
248
249   fprintf_filtered (gdb_stdlog,
250                     "qf->expand_symtabs_with_fullname (%s, \"%s\")\n",
251                     debug_objfile_name (objfile), fullname);
252
253   debug_data->real_sf->qf->expand_symtabs_with_fullname (objfile, fullname);
254 }
255
256 static void
257 debug_qf_map_matching_symbols (struct objfile *objfile,
258                                const char *name, domain_enum namespace,
259                                int global,
260                                int (*callback) (struct block *,
261                                                 struct symbol *, void *),
262                                void *data,
263                                symbol_compare_ftype *match,
264                                symbol_compare_ftype *ordered_compare)
265 {
266   const struct debug_sym_fns_data *debug_data =
267     objfile_data (objfile, symfile_debug_objfile_data_key);
268
269   fprintf_filtered (gdb_stdlog,
270                     "qf->map_matching_symbols (%s, \"%s\", %s, %d, %s, %s, %s, %s)\n",
271                     debug_objfile_name (objfile), name,
272                     domain_name (namespace), global,
273                     host_address_to_string (callback),
274                     host_address_to_string (data),
275                     host_address_to_string (match),
276                     host_address_to_string (ordered_compare));
277
278   debug_data->real_sf->qf->map_matching_symbols (objfile, name,
279                                                  namespace, global,
280                                                  callback, data,
281                                                  match,
282                                                  ordered_compare);
283 }
284
285 static void
286 debug_qf_expand_symtabs_matching (struct objfile *objfile,
287                                   int (*file_matcher) (const char *, void *,
288                                                        int basenames),
289                                   int (*name_matcher) (const char *, void *),
290                                   enum search_domain kind,
291                                   void *data)
292 {
293   const struct debug_sym_fns_data *debug_data =
294     objfile_data (objfile, symfile_debug_objfile_data_key);
295
296   fprintf_filtered (gdb_stdlog,
297                     "qf->expand_symtabs_matching (%s, %s, %s, %s, %s)\n",
298                     debug_objfile_name (objfile),
299                     host_address_to_string (file_matcher),
300                     host_address_to_string (name_matcher),
301                     search_domain_name (kind),
302                     host_address_to_string (data));
303
304   debug_data->real_sf->qf->expand_symtabs_matching (objfile,
305                                                     file_matcher,
306                                                     name_matcher,
307                                                     kind, data);
308 }
309
310 static struct symtab *
311 debug_qf_find_pc_sect_symtab (struct objfile *objfile,
312                               struct minimal_symbol *msymbol,
313                               CORE_ADDR pc,
314                               struct obj_section *section,
315                               int warn_if_readin)
316 {
317   const struct debug_sym_fns_data *debug_data =
318     objfile_data (objfile, symfile_debug_objfile_data_key);
319   struct symtab *retval;
320
321   fprintf_filtered (gdb_stdlog,
322                     "qf->find_pc_sect_symtab (%s, %s, %s, %s, %d)\n",
323                     debug_objfile_name (objfile),
324                     host_address_to_string (msymbol),
325                     hex_string (pc),
326                     host_address_to_string (section),
327                     warn_if_readin);
328
329   retval = debug_data->real_sf->qf->find_pc_sect_symtab (objfile, msymbol,
330                                                          pc, section,
331                                                          warn_if_readin);
332
333   fprintf_filtered (gdb_stdlog, "qf->find_pc_sect_symtab (...) = %s\n",
334                     retval ? debug_symtab_name (retval) : "NULL");
335
336   return retval;
337 }
338
339 static void
340 debug_qf_map_symbol_filenames (struct objfile *objfile,
341                                symbol_filename_ftype *fun, void *data,
342                                int need_fullname)
343 {
344   const struct debug_sym_fns_data *debug_data =
345     objfile_data (objfile, symfile_debug_objfile_data_key);
346   fprintf_filtered (gdb_stdlog,
347                     "qf->map_symbol_filenames (%s, %s, %s, %d)\n",
348                     debug_objfile_name (objfile),
349                     host_address_to_string (fun),
350                     host_address_to_string (data),
351                     need_fullname);
352
353   debug_data->real_sf->qf->map_symbol_filenames (objfile, fun, data,
354                                                  need_fullname);
355 }
356
357 static const struct quick_symbol_functions debug_sym_quick_functions =
358 {
359   debug_qf_has_symbols,
360   debug_qf_find_last_source_symtab,
361   debug_qf_forget_cached_source_info,
362   debug_qf_map_symtabs_matching_filename,
363   debug_qf_lookup_symbol,
364   debug_qf_print_stats,
365   debug_qf_dump,
366   debug_qf_relocate,
367   debug_qf_expand_symtabs_for_function,
368   debug_qf_expand_all_symtabs,
369   debug_qf_expand_symtabs_with_fullname,
370   debug_qf_map_matching_symbols,
371   debug_qf_expand_symtabs_matching,
372   debug_qf_find_pc_sect_symtab,
373   debug_qf_map_symbol_filenames
374 };
375 \f
376 /* Debugging version of struct sym_probe_fns.  */
377
378 static VEC (probe_p) *
379 debug_sym_get_probes (struct objfile *objfile)
380 {
381   const struct debug_sym_fns_data *debug_data =
382     objfile_data (objfile, symfile_debug_objfile_data_key);
383   VEC (probe_p) *retval;
384
385   retval = debug_data->real_sf->sym_probe_fns->sym_get_probes (objfile);
386
387   fprintf_filtered (gdb_stdlog,
388                     "probes->sym_get_probes (%s) = %s\n",
389                     debug_objfile_name (objfile),
390                     host_address_to_string (retval));
391
392   return retval;
393 }
394
395 static void
396 debug_sym_relocate_probe (struct objfile *objfile,
397                           const struct section_offsets *new_offsets,
398                           const struct section_offsets *delta)
399 {
400   const struct debug_sym_fns_data *debug_data =
401     objfile_data (objfile, symfile_debug_objfile_data_key);
402
403   fprintf_filtered (gdb_stdlog,
404                     "probes->sym_relocate_probe (%s, %s, %s)\n",
405                     debug_objfile_name (objfile),
406                     host_address_to_string (new_offsets),
407                     host_address_to_string (delta));
408
409   debug_data->real_sf->sym_probe_fns->sym_relocate_probe
410     (objfile, new_offsets, delta);
411 }
412
413 static const struct sym_probe_fns debug_sym_probe_fns =
414 {
415   debug_sym_get_probes,
416   debug_sym_relocate_probe
417 };
418 \f
419 /* Debugging version of struct sym_fns.  */
420
421 static void
422 debug_sym_new_init (struct objfile *objfile)
423 {
424   const struct debug_sym_fns_data *debug_data =
425     objfile_data (objfile, symfile_debug_objfile_data_key);
426
427   fprintf_filtered (gdb_stdlog, "sf->sym_new_init (%s)\n",
428                     debug_objfile_name (objfile));
429
430   debug_data->real_sf->sym_new_init (objfile);
431 }
432
433 static void
434 debug_sym_init (struct objfile *objfile)
435 {
436   const struct debug_sym_fns_data *debug_data =
437     objfile_data (objfile, symfile_debug_objfile_data_key);
438
439   fprintf_filtered (gdb_stdlog, "sf->sym_init (%s)\n",
440                     debug_objfile_name (objfile));
441
442   debug_data->real_sf->sym_init (objfile);
443 }
444
445 static void
446 debug_sym_read (struct objfile *objfile, int symfile_flags)
447 {
448   const struct debug_sym_fns_data *debug_data =
449     objfile_data (objfile, symfile_debug_objfile_data_key);
450
451   fprintf_filtered (gdb_stdlog, "sf->sym_read (%s, 0x%x)\n",
452                     debug_objfile_name (objfile), symfile_flags);
453
454   debug_data->real_sf->sym_read (objfile, symfile_flags);
455 }
456
457 static void
458 debug_sym_read_psymbols (struct objfile *objfile)
459 {
460   const struct debug_sym_fns_data *debug_data =
461     objfile_data (objfile, symfile_debug_objfile_data_key);
462
463   fprintf_filtered (gdb_stdlog, "sf->sym_read_psymbols (%s)\n",
464                     debug_objfile_name (objfile));
465
466   debug_data->real_sf->sym_read_psymbols (objfile);
467 }
468
469 static void
470 debug_sym_finish (struct objfile *objfile)
471 {
472   const struct debug_sym_fns_data *debug_data =
473     objfile_data (objfile, symfile_debug_objfile_data_key);
474
475   fprintf_filtered (gdb_stdlog, "sf->sym_finish (%s)\n",
476                     debug_objfile_name (objfile));
477
478   debug_data->real_sf->sym_finish (objfile);
479 }
480
481 static void
482 debug_sym_offsets (struct objfile *objfile,
483                    const struct section_addr_info *info)
484 {
485   const struct debug_sym_fns_data *debug_data =
486     objfile_data (objfile, symfile_debug_objfile_data_key);
487
488   fprintf_filtered (gdb_stdlog, "sf->sym_offsets (%s, %s)\n",
489                     debug_objfile_name (objfile),
490                     host_address_to_string (info));
491
492   debug_data->real_sf->sym_offsets (objfile, info);
493 }
494
495 static struct symfile_segment_data *
496 debug_sym_segments (bfd *abfd)
497 {
498   /* This API function is annoying, it doesn't take a "this" pointer.
499      Fortunately it is only used in one place where we (re-)lookup the
500      sym_fns table to use.  Thus we will never be called.  */
501   gdb_assert_not_reached ("debug_sym_segments called");
502 }
503
504 static void
505 debug_sym_read_linetable (struct objfile *objfile)
506 {
507   const struct debug_sym_fns_data *debug_data =
508     objfile_data (objfile, symfile_debug_objfile_data_key);
509
510   fprintf_filtered (gdb_stdlog, "sf->sym_read_linetable (%s)\n",
511                     debug_objfile_name (objfile));
512
513   debug_data->real_sf->sym_read_linetable (objfile);
514 }
515
516 static bfd_byte *
517 debug_sym_relocate (struct objfile *objfile, asection *sectp, bfd_byte *buf)
518 {
519   const struct debug_sym_fns_data *debug_data =
520     objfile_data (objfile, symfile_debug_objfile_data_key);
521   bfd_byte *retval;
522
523   retval = debug_data->real_sf->sym_relocate (objfile, sectp, buf);
524
525   fprintf_filtered (gdb_stdlog,
526                     "sf->sym_relocate (%s, %s, %s) = %s\n",
527                     debug_objfile_name (objfile),
528                     host_address_to_string (sectp),
529                     host_address_to_string (buf),
530                     host_address_to_string (retval));
531
532   return retval;
533 }
534
535 /* Template of debugging version of struct sym_fns.
536    A copy is made, with sym_flavour updated, and a pointer to the real table
537    installed in real_sf, and then a pointer to the copy is installed in the
538    objfile.  */
539
540 static const struct sym_fns debug_sym_fns =
541 {
542   debug_sym_new_init,
543   debug_sym_init,
544   debug_sym_read,
545   debug_sym_read_psymbols,
546   debug_sym_finish,
547   debug_sym_offsets,
548   debug_sym_segments,
549   debug_sym_read_linetable,
550   debug_sym_relocate,
551   &debug_sym_probe_fns,
552   &debug_sym_quick_functions
553 };
554 \f
555 /* Free the copy of sym_fns recorded in the registry.  */
556
557 static void
558 symfile_debug_free_objfile (struct objfile *objfile, void *datum)
559 {
560   xfree (datum);
561 }
562
563 /* Install the debugging versions of the symfile functions for OBJFILE.
564    Do not call this if the debug versions are already installed.  */
565
566 static void
567 install_symfile_debug_logging (struct objfile *objfile)
568 {
569   const struct sym_fns *real_sf;
570   struct debug_sym_fns_data *debug_data;
571
572   /* The debug versions should not already be installed.  */
573   gdb_assert (!symfile_debug_installed (objfile));
574
575   real_sf = objfile->sf;
576
577   /* Alas we have to preserve NULL entries in REAL_SF.  */
578   debug_data = XZALLOC (struct debug_sym_fns_data);
579
580 #define COPY_SF_PTR(from, to, name, func)       \
581   do {                                          \
582     if ((from)->name)                           \
583       (to)->debug_sf.name = func;               \
584   } while (0)
585
586   COPY_SF_PTR (real_sf, debug_data, sym_new_init, debug_sym_new_init);
587   COPY_SF_PTR (real_sf, debug_data, sym_init, debug_sym_init);
588   COPY_SF_PTR (real_sf, debug_data, sym_read, debug_sym_read);
589   COPY_SF_PTR (real_sf, debug_data, sym_read_psymbols,
590                debug_sym_read_psymbols);
591   COPY_SF_PTR (real_sf, debug_data, sym_finish, debug_sym_finish);
592   COPY_SF_PTR (real_sf, debug_data, sym_offsets, debug_sym_offsets);
593   COPY_SF_PTR (real_sf, debug_data, sym_segments, debug_sym_segments);
594   COPY_SF_PTR (real_sf, debug_data, sym_read_linetable,
595                debug_sym_read_linetable);
596   COPY_SF_PTR (real_sf, debug_data, sym_relocate, debug_sym_relocate);
597   if (real_sf->sym_probe_fns)
598     debug_data->debug_sf.sym_probe_fns = &debug_sym_probe_fns;
599   debug_data->debug_sf.qf = &debug_sym_quick_functions;
600
601 #undef COPY_SF_PTR
602
603   debug_data->real_sf = real_sf;
604   set_objfile_data (objfile, symfile_debug_objfile_data_key, debug_data);
605   objfile->sf = &debug_data->debug_sf;
606 }
607
608 /* Uninstall the debugging versions of the symfile functions for OBJFILE.
609    Do not call this if the debug versions are not installed.  */
610
611 static void
612 uninstall_symfile_debug_logging (struct objfile *objfile)
613 {
614   struct debug_sym_fns_data *debug_data;
615
616   /* The debug versions should be currently installed.  */
617   gdb_assert (symfile_debug_installed (objfile));
618
619   debug_data = objfile_data (objfile, symfile_debug_objfile_data_key);
620
621   objfile->sf = debug_data->real_sf;
622   xfree (debug_data);
623   set_objfile_data (objfile, symfile_debug_objfile_data_key, NULL);
624 }
625
626 /* Call this function to set OBJFILE->SF.
627    Do not set OBJFILE->SF directly.  */
628
629 void
630 objfile_set_sym_fns (struct objfile *objfile, const struct sym_fns *sf)
631 {
632   if (symfile_debug_installed (objfile))
633     {
634       gdb_assert (debug_symfile);
635       /* Remove the current one, and reinstall a new one later.  */
636       uninstall_symfile_debug_logging (objfile);
637     }
638
639   /* Assume debug logging is disabled.  */
640   objfile->sf = sf;
641
642   /* Turn debug logging on if enabled.  */
643   if (debug_symfile)
644     install_symfile_debug_logging (objfile);
645 }
646
647 static void
648 set_debug_symfile (char *args, int from_tty, struct cmd_list_element *c)
649 {
650   struct program_space *pspace;
651   struct objfile *objfile;
652
653   ALL_PSPACES (pspace)
654     ALL_PSPACE_OBJFILES (pspace, objfile)
655     {
656       if (debug_symfile)
657         {
658           if (!symfile_debug_installed (objfile))
659             install_symfile_debug_logging (objfile);
660         }
661       else
662         {
663           if (symfile_debug_installed (objfile))
664             uninstall_symfile_debug_logging (objfile);
665         }
666     }
667 }
668
669 static void
670 show_debug_symfile (struct ui_file *file, int from_tty,
671                         struct cmd_list_element *c, const char *value)
672 {
673   fprintf_filtered (file, _("Symfile debugging is %s.\n"), value);
674 }
675
676 initialize_file_ftype _initialize_symfile_debug;
677
678 void
679 _initialize_symfile_debug (void)
680 {
681   symfile_debug_objfile_data_key
682     = register_objfile_data_with_cleanup (NULL, symfile_debug_free_objfile);
683
684   add_setshow_boolean_cmd ("symfile", no_class, &debug_symfile, _("\
685 Set debugging of the symfile functions."), _("\
686 Show debugging of the symfile functions."), _("\
687 When enabled, all calls to the symfile functions are logged."),
688                            set_debug_symfile, show_debug_symfile,
689                            &setdebuglist, &showdebuglist);
690
691   /* Note: We don't need a new-objfile observer because debug logging
692      will be installed when objfile init'n calls objfile_set_sym_fns.  */
693 }