gdb/symfile-debug.c

   1 /* Debug logging for the symbol file functions for the GNU debugger, GDB.
   2
   3    Copyright (C) 2013-2021 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 "observable.h"
  32 #include "source.h"
  33 #include "symtab.h"
  34 #include "symfile.h"
  35 #include "block.h"
  36 #include "filenames.h"
  37
  38 /* We need to save a pointer to the real symbol functions.
  39    Plus, the debug versions are malloc'd because we have to NULL out the
  40    ones that are NULL in the real copy.  */
  41
  42 struct debug_sym_fns_data
  43 {
  44   const struct sym_fns *real_sf = nullptr;
  45   struct sym_fns debug_sf {};
  46 };
  47
  48 /* We need to record a pointer to the real set of functions for each
  49    objfile.  */
  50 static const struct objfile_key<debug_sym_fns_data>
  51   symfile_debug_objfile_data_key;
  52
  53 /* If true all calls to the symfile functions are logged.  */
  54 static bool debug_symfile = false;
  55
  56 /* Return non-zero if symfile debug logging is installed.  */
  57
  58 static int
  59 symfile_debug_installed (struct objfile *objfile)
  60 {
  61   return (objfile->sf != NULL
  62           && symfile_debug_objfile_data_key.get (objfile) != NULL);
  63 }
  64
  65 /* Utility return the name to print for SYMTAB.  */
  66
  67 static const char *
  68 debug_symtab_name (struct symtab *symtab)
  69 {
  70   return symtab_to_filename_for_display (symtab);
  71 }
  72 \f
  73
  74 /* See objfiles.h.  */
  75
  76 bool
  77 objfile::has_partial_symbols ()
  78 {
  79   bool retval = false;
  80
  81   /* If we have not read psymbols, but we have a function capable of reading
  82      them, then that is an indication that they are in fact available.  Without
  83      this function the symbols may have been already read in but they also may
  84      not be present in this objfile.  */
  85   for (const auto &iter : qf)
  86     {
  87       if ((flags & OBJF_PSYMTABS_READ) == 0
  88           && iter->can_lazily_read_symbols ())
  89         retval = true;
  90       else
  91         retval = iter->has_symbols (this);
  92       if (retval)
  93         break;
  94     }
  95
  96   if (debug_symfile)
  97     fprintf_filtered (gdb_stdlog, "qf->has_symbols (%s) = %d\n",
  98                       objfile_debug_name (this), retval);
  99
 100   return retval;
 101 }
 102
 103 struct symtab *
 104 objfile::find_last_source_symtab ()
 105 {
 106   struct symtab *retval = nullptr;
 107
 108   if (debug_symfile)
 109     fprintf_filtered (gdb_stdlog, "qf->find_last_source_symtab (%s)\n",
 110                       objfile_debug_name (this));
 111
 112   for (const auto &iter : qf)
 113     {
 114       retval = iter->find_last_source_symtab (this);
 115       if (retval != nullptr)
 116         break;
 117     }
 118
 119   if (debug_symfile)
 120     fprintf_filtered (gdb_stdlog, "qf->find_last_source_symtab (...) = %s\n",
 121                       retval ? debug_symtab_name (retval) : "NULL");
 122
 123   return retval;
 124 }
 125
 126 void
 127 objfile::forget_cached_source_info ()
 128 {
 129   if (debug_symfile)
 130     fprintf_filtered (gdb_stdlog, "qf->forget_cached_source_info (%s)\n",
 131                       objfile_debug_name (this));
 132
 133   for (const auto &iter : qf)
 134     iter->forget_cached_source_info (this);
 135 }
 136
 137 bool
 138 objfile::map_symtabs_matching_filename
 139   (const char *name, const char *real_path,
 140    gdb::function_view<bool (symtab *)> callback)
 141 {
 142   if (debug_symfile)
 143     fprintf_filtered (gdb_stdlog,
 144                       "qf->map_symtabs_matching_filename (%s, \"%s\", "
 145                       "\"%s\", %s)\n",
 146                       objfile_debug_name (this), name,
 147                       real_path ? real_path : NULL,
 148                       host_address_to_string (&callback));
 149
 150   bool retval = true;
 151   const char *name_basename = lbasename (name);
 152
 153   auto match_one_filename = [&] (const char *filename, bool basenames)
 154   {
 155     if (compare_filenames_for_search (filename, name))
 156       return true;
 157     if (basenames && FILENAME_CMP (name_basename, filename) == 0)
 158       return true;
 159     if (real_path != nullptr && IS_ABSOLUTE_PATH (filename)
 160         && IS_ABSOLUTE_PATH (real_path))
 161       return filename_cmp (filename, real_path) == 0;
 162     return false;
 163   };
 164
 165   compunit_symtab *last_made = this->compunit_symtabs;
 166
 167   auto on_expansion = [&] (compunit_symtab *symtab)
 168   {
 169     /* The callback to iterate_over_some_symtabs returns false to keep
 170        going and true to continue, so we have to invert the result
 171        here, for expand_symtabs_matching.  */
 172     bool result = !iterate_over_some_symtabs (name, real_path,
 173                                               this->compunit_symtabs,
 174                                               last_made,
 175                                               callback);
 176     last_made = this->compunit_symtabs;
 177     return result;
 178   };
 179
 180   for (const auto &iter : qf)
 181     {
 182       if (!iter->expand_symtabs_matching (this,
 183                                           match_one_filename,
 184                                           nullptr,
 185                                           nullptr,
 186                                           on_expansion,
 187                                           (SEARCH_GLOBAL_BLOCK
 188                                            | SEARCH_STATIC_BLOCK),
 189                                           UNDEF_DOMAIN,
 190                                           ALL_DOMAIN))
 191         {
 192           retval = false;
 193           break;
 194         }
 195     }
 196
 197   if (debug_symfile)
 198     fprintf_filtered (gdb_stdlog,
 199                       "qf->map_symtabs_matching_filename (...) = %d\n",
 200                       retval);
 201
 202   /* We must re-invert the return value here to match the caller's
 203      expectations.  */
 204   return !retval;
 205 }
 206
 207 struct compunit_symtab *
 208 objfile::lookup_symbol (block_enum kind, const char *name, domain_enum domain)
 209 {
 210   struct compunit_symtab *retval = nullptr;
 211
 212   if (debug_symfile)
 213     fprintf_filtered (gdb_stdlog,
 214                       "qf->lookup_symbol (%s, %d, \"%s\", %s)\n",
 215                       objfile_debug_name (this), kind, name,
 216                       domain_name (domain));
 217
 218   lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
 219
 220   auto search_one_symtab = [&] (compunit_symtab *stab)
 221   {
 222     struct symbol *sym, *with_opaque = NULL;
 223     const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
 224     const struct block *block = BLOCKVECTOR_BLOCK (bv, kind);
 225
 226     sym = block_find_symbol (block, name, domain,
 227                              block_find_non_opaque_type_preferred,
 228                              &with_opaque);
 229
 230     /* Some caution must be observed with overloaded functions
 231        and methods, since the index will not contain any overload
 232        information (but NAME might contain it).  */
 233
 234     if (sym != NULL
 235         && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
 236       {
 237         retval = stab;
 238         /* Found it.  */
 239         return false;
 240       }
 241     if (with_opaque != NULL
 242         && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
 243       retval = stab;
 244
 245     /* Keep looking through other psymtabs.  */
 246     return true;
 247   };
 248
 249   for (const auto &iter : qf)
 250     {
 251       if (!iter->expand_symtabs_matching (this,
 252                                           nullptr,
 253                                           &lookup_name,
 254                                           nullptr,
 255                                           search_one_symtab,
 256                                           kind == GLOBAL_BLOCK
 257                                           ? SEARCH_GLOBAL_BLOCK
 258                                           : SEARCH_STATIC_BLOCK,
 259                                           domain,
 260                                           ALL_DOMAIN))
 261         break;
 262     }
 263
 264   if (debug_symfile)
 265     fprintf_filtered (gdb_stdlog, "qf->lookup_symbol (...) = %s\n",
 266                       retval
 267                       ? debug_symtab_name (compunit_primary_filetab (retval))
 268                       : "NULL");
 269
 270   return retval;
 271 }
 272
 273 void
 274 objfile::print_stats (bool print_bcache)
 275 {
 276   if (debug_symfile)
 277     fprintf_filtered (gdb_stdlog, "qf->print_stats (%s, %d)\n",
 278                       objfile_debug_name (this), print_bcache);
 279
 280   for (const auto &iter : qf)
 281     iter->print_stats (this, print_bcache);
 282 }
 283
 284 void
 285 objfile::dump ()
 286 {
 287   if (debug_symfile)
 288     fprintf_filtered (gdb_stdlog, "qf->dump (%s)\n",
 289                       objfile_debug_name (this));
 290
 291   for (const auto &iter : qf)
 292     iter->dump (this);
 293 }
 294
 295 void
 296 objfile::expand_symtabs_for_function (const char *func_name)
 297 {
 298   if (debug_symfile)
 299     fprintf_filtered (gdb_stdlog,
 300                       "qf->expand_symtabs_for_function (%s, \"%s\")\n",
 301                       objfile_debug_name (this), func_name);
 302
 303   lookup_name_info base_lookup (func_name, symbol_name_match_type::FULL);
 304   lookup_name_info lookup_name = base_lookup.make_ignore_params ();
 305
 306   for (const auto &iter : qf)
 307     iter->expand_symtabs_matching (this,
 308                                    nullptr,
 309                                    &lookup_name,
 310                                    nullptr,
 311                                    nullptr,
 312                                    (SEARCH_GLOBAL_BLOCK
 313                                     | SEARCH_STATIC_BLOCK),
 314                                    VAR_DOMAIN,
 315                                    ALL_DOMAIN);
 316 }
 317
 318 void
 319 objfile::expand_all_symtabs ()
 320 {
 321   if (debug_symfile)
 322     fprintf_filtered (gdb_stdlog, "qf->expand_all_symtabs (%s)\n",
 323                       objfile_debug_name (this));
 324
 325   for (const auto &iter : qf)
 326     iter->expand_all_symtabs (this);
 327 }
 328
 329 void
 330 objfile::expand_symtabs_with_fullname (const char *fullname)
 331 {
 332   if (debug_symfile)
 333     fprintf_filtered (gdb_stdlog,
 334                       "qf->expand_symtabs_with_fullname (%s, \"%s\")\n",
 335                       objfile_debug_name (this), fullname);
 336
 337   const char *basename = lbasename (fullname);
 338   auto file_matcher = [&] (const char *filename, bool basenames)
 339   {
 340     return filename_cmp (basenames ? basename : fullname, filename) == 0;
 341   };
 342
 343   for (const auto &iter : qf)
 344     iter->expand_symtabs_matching (this,
 345                                    file_matcher,
 346                                    nullptr,
 347                                    nullptr,
 348                                    nullptr,
 349                                    (SEARCH_GLOBAL_BLOCK
 350                                     | SEARCH_STATIC_BLOCK),
 351                                    UNDEF_DOMAIN,
 352                                    ALL_DOMAIN);
 353 }
 354
 355 void
 356 objfile::expand_matching_symbols
 357   (const lookup_name_info &name, domain_enum domain,
 358    int global,
 359    symbol_compare_ftype *ordered_compare)
 360 {
 361   if (debug_symfile)
 362     fprintf_filtered (gdb_stdlog,
 363                       "qf->expand_matching_symbols (%s, %s, %d, %s)\n",
 364                       objfile_debug_name (this),
 365                       domain_name (domain), global,
 366                       host_address_to_string (ordered_compare));
 367
 368   for (const auto &iter : qf)
 369     iter->expand_matching_symbols (this, name, domain, global,
 370                                    ordered_compare);
 371 }
 372
 373 bool
 374 objfile::expand_symtabs_matching
 375   (gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
 376    const lookup_name_info *lookup_name,
 377    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
 378    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
 379    block_search_flags search_flags,
 380    domain_enum domain,
 381    enum search_domain kind)
 382 {
 383   if (debug_symfile)
 384     fprintf_filtered (gdb_stdlog,
 385                       "qf->expand_symtabs_matching (%s, %s, %s, %s, %s)\n",
 386                       objfile_debug_name (this),
 387                       host_address_to_string (&file_matcher),
 388                       host_address_to_string (&symbol_matcher),
 389                       host_address_to_string (&expansion_notify),
 390                       search_domain_name (kind));
 391
 392   for (const auto &iter : qf)
 393     if (!iter->expand_symtabs_matching (this, file_matcher, lookup_name,
 394                                         symbol_matcher, expansion_notify,
 395                                         search_flags, domain, kind))
 396       return false;
 397   return true;
 398 }
 399
 400 struct compunit_symtab *
 401 objfile::find_pc_sect_compunit_symtab (struct bound_minimal_symbol msymbol,
 402                                        CORE_ADDR pc,
 403                                        struct obj_section *section,
 404                                        int warn_if_readin)
 405 {
 406   struct compunit_symtab *retval = nullptr;
 407
 408   if (debug_symfile)
 409     fprintf_filtered (gdb_stdlog,
 410                       "qf->find_pc_sect_compunit_symtab (%s, %s, %s, %s, %d)\n",
 411                       objfile_debug_name (this),
 412                       host_address_to_string (msymbol.minsym),
 413                       hex_string (pc),
 414                       host_address_to_string (section),
 415                       warn_if_readin);
 416
 417   for (const auto &iter : qf)
 418     {
 419       retval = iter->find_pc_sect_compunit_symtab (this, msymbol, pc, section,
 420                                                    warn_if_readin);
 421       if (retval != nullptr)
 422         break;
 423     }
 424
 425   if (debug_symfile)
 426     fprintf_filtered (gdb_stdlog,
 427                       "qf->find_pc_sect_compunit_symtab (...) = %s\n",
 428                       retval
 429                       ? debug_symtab_name (compunit_primary_filetab (retval))
 430                       : "NULL");
 431
 432   return retval;
 433 }
 434
 435 void
 436 objfile::map_symbol_filenames (gdb::function_view<symbol_filename_ftype> fun,
 437                                bool need_fullname)
 438 {
 439   if (debug_symfile)
 440     fprintf_filtered (gdb_stdlog,
 441                       "qf->map_symbol_filenames (%s, ..., %d)\n",
 442                       objfile_debug_name (this),
 443                       need_fullname);
 444
 445   for (const auto &iter : qf)
 446     iter->map_symbol_filenames (this, fun, need_fullname);
 447 }
 448
 449 struct compunit_symtab *
 450 objfile::find_compunit_symtab_by_address (CORE_ADDR address)
 451 {
 452   if (debug_symfile)
 453     fprintf_filtered (gdb_stdlog,
 454                       "qf->find_compunit_symtab_by_address (%s, %s)\n",
 455                       objfile_debug_name (this),
 456                       hex_string (address));
 457
 458   struct compunit_symtab *result = NULL;
 459   for (const auto &iter : qf)
 460     {
 461       result = iter->find_compunit_symtab_by_address (this, address);
 462       if (result != nullptr)
 463         break;
 464     }
 465
 466   if (debug_symfile)
 467     fprintf_filtered (gdb_stdlog,
 468                       "qf->find_compunit_symtab_by_address (...) = %s\n",
 469                       result
 470                       ? debug_symtab_name (compunit_primary_filetab (result))
 471                       : "NULL");
 472
 473   return result;
 474 }
 475
 476 enum language
 477 objfile::lookup_global_symbol_language (const char *name,
 478                                         domain_enum domain,
 479                                         bool *symbol_found_p)
 480 {
 481   enum language result = language_unknown;
 482   *symbol_found_p = false;
 483
 484   for (const auto &iter : qf)
 485     {
 486       result = iter->lookup_global_symbol_language (this, name, domain,
 487                                                     symbol_found_p);
 488       if (*symbol_found_p)
 489         break;
 490     }
 491
 492   return result;
 493 }
 494
 495 void
 496 objfile::require_partial_symbols (bool verbose)
 497 {
 498   if ((flags & OBJF_PSYMTABS_READ) == 0)
 499     {
 500       flags |= OBJF_PSYMTABS_READ;
 501
 502       bool printed = false;
 503       for (const auto &iter : qf)
 504         {
 505           if (iter->can_lazily_read_symbols ())
 506             {
 507               if (verbose && !printed)
 508                 {
 509                   printf_filtered (_("Reading symbols from %s...\n"),
 510                                    objfile_name (this));
 511                   printed = true;
 512                 }
 513               iter->read_partial_symbols (this);
 514             }
 515         }
 516       if (printed && !objfile_has_symbols (this))
 517         printf_filtered (_("(No debugging symbols found in %s)\n"),
 518                          objfile_name (this));
 519     }
 520 }
 521
 522 \f
 523 /* Debugging version of struct sym_probe_fns.  */
 524
 525 static const std::vector<std::unique_ptr<probe>> &
 526 debug_sym_get_probes (struct objfile *objfile)
 527 {
 528   const struct debug_sym_fns_data *debug_data
 529     = symfile_debug_objfile_data_key.get (objfile);
 530
 531   const std::vector<std::unique_ptr<probe>> &retval
 532     = debug_data->real_sf->sym_probe_fns->sym_get_probes (objfile);
 533
 534   fprintf_filtered (gdb_stdlog,
 535                     "probes->sym_get_probes (%s) = %s\n",
 536                     objfile_debug_name (objfile),
 537                     host_address_to_string (retval.data ()));
 538
 539   return retval;
 540 }
 541
 542 static const struct sym_probe_fns debug_sym_probe_fns =
 543 {
 544   debug_sym_get_probes,
 545 };
 546 \f
 547 /* Debugging version of struct sym_fns.  */
 548
 549 static void
 550 debug_sym_new_init (struct objfile *objfile)
 551 {
 552   const struct debug_sym_fns_data *debug_data
 553     = symfile_debug_objfile_data_key.get (objfile);
 554
 555   fprintf_filtered (gdb_stdlog, "sf->sym_new_init (%s)\n",
 556                     objfile_debug_name (objfile));
 557
 558   debug_data->real_sf->sym_new_init (objfile);
 559 }
 560
 561 static void
 562 debug_sym_init (struct objfile *objfile)
 563 {
 564   const struct debug_sym_fns_data *debug_data
 565     = symfile_debug_objfile_data_key.get (objfile);
 566
 567   fprintf_filtered (gdb_stdlog, "sf->sym_init (%s)\n",
 568                     objfile_debug_name (objfile));
 569
 570   debug_data->real_sf->sym_init (objfile);
 571 }
 572
 573 static void
 574 debug_sym_read (struct objfile *objfile, symfile_add_flags symfile_flags)
 575 {
 576   const struct debug_sym_fns_data *debug_data
 577     = symfile_debug_objfile_data_key.get (objfile);
 578
 579   fprintf_filtered (gdb_stdlog, "sf->sym_read (%s, 0x%x)\n",
 580                     objfile_debug_name (objfile), (unsigned) symfile_flags);
 581
 582   debug_data->real_sf->sym_read (objfile, symfile_flags);
 583 }
 584
 585 static void
 586 debug_sym_finish (struct objfile *objfile)
 587 {
 588   const struct debug_sym_fns_data *debug_data
 589     = symfile_debug_objfile_data_key.get (objfile);
 590
 591   fprintf_filtered (gdb_stdlog, "sf->sym_finish (%s)\n",
 592                     objfile_debug_name (objfile));
 593
 594   debug_data->real_sf->sym_finish (objfile);
 595 }
 596
 597 static void
 598 debug_sym_offsets (struct objfile *objfile,
 599                    const section_addr_info &info)
 600 {
 601   const struct debug_sym_fns_data *debug_data
 602     = symfile_debug_objfile_data_key.get (objfile);
 603
 604   fprintf_filtered (gdb_stdlog, "sf->sym_offsets (%s, %s)\n",
 605                     objfile_debug_name (objfile),
 606                     host_address_to_string (&info));
 607
 608   debug_data->real_sf->sym_offsets (objfile, info);
 609 }
 610
 611 static symfile_segment_data_up
 612 debug_sym_segments (bfd *abfd)
 613 {
 614   /* This API function is annoying, it doesn't take a "this" pointer.
 615      Fortunately it is only used in one place where we (re-)lookup the
 616      sym_fns table to use.  Thus we will never be called.  */
 617   gdb_assert_not_reached ("debug_sym_segments called");
 618 }
 619
 620 static void
 621 debug_sym_read_linetable (struct objfile *objfile)
 622 {
 623   const struct debug_sym_fns_data *debug_data
 624     = symfile_debug_objfile_data_key.get (objfile);
 625
 626   fprintf_filtered (gdb_stdlog, "sf->sym_read_linetable (%s)\n",
 627                     objfile_debug_name (objfile));
 628
 629   debug_data->real_sf->sym_read_linetable (objfile);
 630 }
 631
 632 static bfd_byte *
 633 debug_sym_relocate (struct objfile *objfile, asection *sectp, bfd_byte *buf)
 634 {
 635   const struct debug_sym_fns_data *debug_data
 636     = symfile_debug_objfile_data_key.get (objfile);
 637   bfd_byte *retval;
 638
 639   retval = debug_data->real_sf->sym_relocate (objfile, sectp, buf);
 640
 641   fprintf_filtered (gdb_stdlog,
 642                     "sf->sym_relocate (%s, %s, %s) = %s\n",
 643                     objfile_debug_name (objfile),
 644                     host_address_to_string (sectp),
 645                     host_address_to_string (buf),
 646                     host_address_to_string (retval));
 647
 648   return retval;
 649 }
 650
 651 /* Template of debugging version of struct sym_fns.
 652    A copy is made, with sym_flavour updated, and a pointer to the real table
 653    installed in real_sf, and then a pointer to the copy is installed in the
 654    objfile.  */
 655
 656 static const struct sym_fns debug_sym_fns =
 657 {
 658   debug_sym_new_init,
 659   debug_sym_init,
 660   debug_sym_read,
 661   debug_sym_finish,
 662   debug_sym_offsets,
 663   debug_sym_segments,
 664   debug_sym_read_linetable,
 665   debug_sym_relocate,
 666   &debug_sym_probe_fns,
 667 };
 668 \f
 669 /* Install the debugging versions of the symfile functions for OBJFILE.
 670    Do not call this if the debug versions are already installed.  */
 671
 672 static void
 673 install_symfile_debug_logging (struct objfile *objfile)
 674 {
 675   const struct sym_fns *real_sf;
 676   struct debug_sym_fns_data *debug_data;
 677
 678   /* The debug versions should not already be installed.  */
 679   gdb_assert (!symfile_debug_installed (objfile));
 680
 681   real_sf = objfile->sf;
 682
 683   /* Alas we have to preserve NULL entries in REAL_SF.  */
 684   debug_data = new struct debug_sym_fns_data;
 685
 686 #define COPY_SF_PTR(from, to, name, func)       \
 687   do {                                          \
 688     if ((from)->name)                           \
 689       (to)->debug_sf.name = func;               \
 690   } while (0)
 691
 692   COPY_SF_PTR (real_sf, debug_data, sym_new_init, debug_sym_new_init);
 693   COPY_SF_PTR (real_sf, debug_data, sym_init, debug_sym_init);
 694   COPY_SF_PTR (real_sf, debug_data, sym_read, debug_sym_read);
 695   COPY_SF_PTR (real_sf, debug_data, sym_finish, debug_sym_finish);
 696   COPY_SF_PTR (real_sf, debug_data, sym_offsets, debug_sym_offsets);
 697   COPY_SF_PTR (real_sf, debug_data, sym_segments, debug_sym_segments);
 698   COPY_SF_PTR (real_sf, debug_data, sym_read_linetable,
 699                debug_sym_read_linetable);
 700   COPY_SF_PTR (real_sf, debug_data, sym_relocate, debug_sym_relocate);
 701   if (real_sf->sym_probe_fns)
 702     debug_data->debug_sf.sym_probe_fns = &debug_sym_probe_fns;
 703
 704 #undef COPY_SF_PTR
 705
 706   debug_data->real_sf = real_sf;
 707   symfile_debug_objfile_data_key.set (objfile, debug_data);
 708   objfile->sf = &debug_data->debug_sf;
 709 }
 710
 711 /* Uninstall the debugging versions of the symfile functions for OBJFILE.
 712    Do not call this if the debug versions are not installed.  */
 713
 714 static void
 715 uninstall_symfile_debug_logging (struct objfile *objfile)
 716 {
 717   struct debug_sym_fns_data *debug_data;
 718
 719   /* The debug versions should be currently installed.  */
 720   gdb_assert (symfile_debug_installed (objfile));
 721
 722   debug_data = symfile_debug_objfile_data_key.get (objfile);
 723
 724   objfile->sf = debug_data->real_sf;
 725   symfile_debug_objfile_data_key.clear (objfile);
 726 }
 727
 728 /* Call this function to set OBJFILE->SF.
 729    Do not set OBJFILE->SF directly.  */
 730
 731 void
 732 objfile_set_sym_fns (struct objfile *objfile, const struct sym_fns *sf)
 733 {
 734   if (symfile_debug_installed (objfile))
 735     {
 736       gdb_assert (debug_symfile);
 737       /* Remove the current one, and reinstall a new one later.  */
 738       uninstall_symfile_debug_logging (objfile);
 739     }
 740
 741   /* Assume debug logging is disabled.  */
 742   objfile->sf = sf;
 743
 744   /* Turn debug logging on if enabled.  */
 745   if (debug_symfile)
 746     install_symfile_debug_logging (objfile);
 747 }
 748
 749 static void
 750 set_debug_symfile (const char *args, int from_tty, struct cmd_list_element *c)
 751 {
 752   for (struct program_space *pspace : program_spaces)
 753     for (objfile *objfile : pspace->objfiles ())
 754       {
 755         if (debug_symfile)
 756           {
 757             if (!symfile_debug_installed (objfile))
 758               install_symfile_debug_logging (objfile);
 759           }
 760         else
 761           {
 762             if (symfile_debug_installed (objfile))
 763               uninstall_symfile_debug_logging (objfile);
 764           }
 765       }
 766 }
 767
 768 static void
 769 show_debug_symfile (struct ui_file *file, int from_tty,
 770                         struct cmd_list_element *c, const char *value)
 771 {
 772   fprintf_filtered (file, _("Symfile debugging is %s.\n"), value);
 773 }
 774
 775 void _initialize_symfile_debug ();
 776 void
 777 _initialize_symfile_debug ()
 778 {
 779   add_setshow_boolean_cmd ("symfile", no_class, &debug_symfile, _("\
 780 Set debugging of the symfile functions."), _("\
 781 Show debugging of the symfile functions."), _("\
 782 When enabled, all calls to the symfile functions are logged."),
 783                            set_debug_symfile, show_debug_symfile,
 784                            &setdebuglist, &showdebuglist);
 785
 786   /* Note: We don't need a new-objfile observer because debug logging
 787      will be installed when objfile init'n calls objfile_set_sym_fns.  */
 788 }