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