gdb/symfile-debug.c

   1 /* Debug logging for the symbol file functions for the GNU debugger, GDB.
   2
   3    Copyright (C) 2013-2024 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 #include "cli/cli-style.h"
  38 #include "build-id.h"
  39 #include "debuginfod-support.h"
  40
  41 /* We need to save a pointer to the real symbol functions.
  42    Plus, the debug versions are malloc'd because we have to NULL out the
  43    ones that are NULL in the real copy.  */
  44
  45 struct debug_sym_fns_data
  46 {
  47   const struct sym_fns *real_sf = nullptr;
  48   struct sym_fns debug_sf {};
  49 };
  50
  51 /* We need to record a pointer to the real set of functions for each
  52    objfile.  */
  53 static const registry<objfile>::key<debug_sym_fns_data>
  54   symfile_debug_objfile_data_key;
  55
  56 /* If true all calls to the symfile functions are logged.  */
  57 static bool debug_symfile = false;
  58
  59 /* Return non-zero if symfile debug logging is installed.  */
  60
  61 static int
  62 symfile_debug_installed (struct objfile *objfile)
  63 {
  64   return (objfile->sf != NULL
  65           && symfile_debug_objfile_data_key.get (objfile) != NULL);
  66 }
  67
  68 /* Utility return the name to print for SYMTAB.  */
  69
  70 static const char *
  71 debug_symtab_name (struct symtab *symtab)
  72 {
  73   return symtab_to_filename_for_display (symtab);
  74 }
  75 \f
  76
  77 /* See objfiles.h.  */
  78
  79 bool
  80 objfile::has_partial_symbols ()
  81 {
  82   bool retval = false;
  83
  84   /* If we have not read psymbols, but we have a function capable of reading
  85      them, then that is an indication that they are in fact available.  Without
  86      this function the symbols may have been already read in but they also may
  87      not be present in this objfile.  */
  88   for (const auto &iter : qf)
  89     {
  90       retval = iter->has_symbols (this);
  91       if (retval)
  92         break;
  93     }
  94
  95   if (debug_symfile)
  96     gdb_printf (gdb_stdlog, "qf->has_symbols (%s) = %d\n",
  97                 objfile_debug_name (this), retval);
  98
  99   return retval;
 100 }
 101
 102 /* See objfiles.h.  */
 103 bool
 104 objfile::has_unexpanded_symtabs ()
 105 {
 106   if (debug_symfile)
 107     gdb_printf (gdb_stdlog, "qf->has_unexpanded_symtabs (%s)\n",
 108                 objfile_debug_name (this));
 109
 110   bool result = false;
 111   for (const auto &iter : qf)
 112     {
 113       if (iter->has_unexpanded_symtabs (this))
 114         {
 115           result = true;
 116           break;
 117         }
 118     }
 119
 120   if (debug_symfile)
 121     gdb_printf (gdb_stdlog, "qf->has_unexpanded_symtabs (%s) = %d\n",
 122                 objfile_debug_name (this), (result ? 1 : 0));
 123
 124   return result;
 125 }
 126
 127 struct symtab *
 128 objfile::find_last_source_symtab ()
 129 {
 130   struct symtab *retval = nullptr;
 131
 132   if (debug_symfile)
 133     gdb_printf (gdb_stdlog, "qf->find_last_source_symtab (%s)\n",
 134                 objfile_debug_name (this));
 135
 136   for (const auto &iter : qf)
 137     {
 138       retval = iter->find_last_source_symtab (this);
 139       if (retval != nullptr)
 140         break;
 141     }
 142
 143   if (debug_symfile)
 144     gdb_printf (gdb_stdlog, "qf->find_last_source_symtab (...) = %s\n",
 145                 retval ? debug_symtab_name (retval) : "NULL");
 146
 147   return retval;
 148 }
 149
 150 void
 151 objfile::forget_cached_source_info ()
 152 {
 153   if (debug_symfile)
 154     gdb_printf (gdb_stdlog, "qf->forget_cached_source_info (%s)\n",
 155                 objfile_debug_name (this));
 156
 157   for (compunit_symtab *cu : compunits ())
 158     {
 159       for (symtab *s : cu->filetabs ())
 160         {
 161           if (s->fullname != NULL)
 162             {
 163               xfree (s->fullname);
 164               s->fullname = NULL;
 165             }
 166         }
 167     }
 168
 169   for (const auto &iter : qf)
 170     iter->forget_cached_source_info (this);
 171 }
 172
 173 bool
 174 objfile::map_symtabs_matching_filename
 175   (const char *name, const char *real_path,
 176    gdb::function_view<bool (symtab *)> callback)
 177 {
 178   if (debug_symfile)
 179     gdb_printf (gdb_stdlog,
 180                 "qf->map_symtabs_matching_filename (%s, \"%s\", "
 181                 "\"%s\", %s)\n",
 182                 objfile_debug_name (this), name,
 183                 real_path ? real_path : NULL,
 184                 host_address_to_string (&callback));
 185
 186   bool retval = true;
 187   const char *name_basename = lbasename (name);
 188
 189   auto match_one_filename = [&] (const char *filename, bool basenames)
 190   {
 191     if (compare_filenames_for_search (filename, name))
 192       return true;
 193     if (basenames && FILENAME_CMP (name_basename, filename) == 0)
 194       return true;
 195     if (real_path != nullptr && IS_ABSOLUTE_PATH (filename)
 196         && IS_ABSOLUTE_PATH (real_path))
 197       return filename_cmp (filename, real_path) == 0;
 198     return false;
 199   };
 200
 201   compunit_symtab *last_made = this->compunit_symtabs;
 202
 203   auto on_expansion = [&] (compunit_symtab *symtab)
 204   {
 205     /* The callback to iterate_over_some_symtabs returns false to keep
 206        going and true to continue, so we have to invert the result
 207        here, for expand_symtabs_matching.  */
 208     bool result = !iterate_over_some_symtabs (name, real_path,
 209                                               this->compunit_symtabs,
 210                                               last_made,
 211                                               callback);
 212     last_made = this->compunit_symtabs;
 213     return result;
 214   };
 215
 216   for (const auto &iter : qf)
 217     {
 218       if (!iter->expand_symtabs_matching (this,
 219                                           match_one_filename,
 220                                           nullptr,
 221                                           nullptr,
 222                                           on_expansion,
 223                                           (SEARCH_GLOBAL_BLOCK
 224                                            | SEARCH_STATIC_BLOCK),
 225                                           SEARCH_ALL_DOMAINS))
 226         {
 227           retval = false;
 228           break;
 229         }
 230     }
 231
 232   if (debug_symfile)
 233     gdb_printf (gdb_stdlog,
 234                 "qf->map_symtabs_matching_filename (...) = %d\n",
 235                 retval);
 236
 237   /* We must re-invert the return value here to match the caller's
 238      expectations.  */
 239   return !retval;
 240 }
 241
 242 struct compunit_symtab *
 243 objfile::lookup_symbol (block_enum kind, const char *name,
 244                         domain_search_flags domain)
 245 {
 246   struct compunit_symtab *retval = nullptr;
 247
 248   if (debug_symfile)
 249     gdb_printf (gdb_stdlog,
 250                 "qf->lookup_symbol (%s, %d, \"%s\", %s)\n",
 251                 objfile_debug_name (this), kind, name,
 252                 domain_name (domain).c_str ());
 253
 254   lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
 255
 256   auto search_one_symtab = [&] (compunit_symtab *stab)
 257   {
 258     struct symbol *sym, *with_opaque = NULL;
 259     const struct blockvector *bv = stab->blockvector ();
 260     const struct block *block = bv->block (kind);
 261
 262     sym = block_find_symbol (block, lookup_name, domain, &with_opaque);
 263
 264     /* Some caution must be observed with overloaded functions
 265        and methods, since the index will not contain any overload
 266        information (but NAME might contain it).  */
 267
 268     if (sym != nullptr)
 269       {
 270         retval = stab;
 271         /* Found it.  */
 272         return false;
 273       }
 274     if (with_opaque != nullptr)
 275       retval = stab;
 276
 277     /* Keep looking through other psymtabs.  */
 278     return true;
 279   };
 280
 281   for (const auto &iter : qf)
 282     {
 283       if (!iter->expand_symtabs_matching (this,
 284                                           nullptr,
 285                                           &lookup_name,
 286                                           nullptr,
 287                                           search_one_symtab,
 288                                           kind == GLOBAL_BLOCK
 289                                           ? SEARCH_GLOBAL_BLOCK
 290                                           : SEARCH_STATIC_BLOCK,
 291                                           domain))
 292         break;
 293     }
 294
 295   if (debug_symfile)
 296     gdb_printf (gdb_stdlog, "qf->lookup_symbol (...) = %s\n",
 297                 retval
 298                 ? debug_symtab_name (retval->primary_filetab ())
 299                 : "NULL");
 300
 301   return retval;
 302 }
 303
 304 void
 305 objfile::print_stats (bool print_bcache)
 306 {
 307   if (debug_symfile)
 308     gdb_printf (gdb_stdlog, "qf->print_stats (%s, %d)\n",
 309                 objfile_debug_name (this), print_bcache);
 310
 311   for (const auto &iter : qf)
 312     iter->print_stats (this, print_bcache);
 313 }
 314
 315 void
 316 objfile::dump ()
 317 {
 318   if (debug_symfile)
 319     gdb_printf (gdb_stdlog, "qf->dump (%s)\n",
 320                 objfile_debug_name (this));
 321
 322   for (const auto &iter : qf)
 323     iter->dump (this);
 324 }
 325
 326 void
 327 objfile::expand_symtabs_for_function (const char *func_name)
 328 {
 329   if (debug_symfile)
 330     gdb_printf (gdb_stdlog,
 331                 "qf->expand_symtabs_for_function (%s, \"%s\")\n",
 332                 objfile_debug_name (this), func_name);
 333
 334   lookup_name_info base_lookup (func_name, symbol_name_match_type::FULL);
 335   lookup_name_info lookup_name = base_lookup.make_ignore_params ();
 336
 337   for (const auto &iter : qf)
 338     iter->expand_symtabs_matching (this,
 339                                    nullptr,
 340                                    &lookup_name,
 341                                    nullptr,
 342                                    nullptr,
 343                                    (SEARCH_GLOBAL_BLOCK
 344                                     | SEARCH_STATIC_BLOCK),
 345                                    SEARCH_FUNCTION_DOMAIN);
 346 }
 347
 348 void
 349 objfile::expand_all_symtabs ()
 350 {
 351   if (debug_symfile)
 352     gdb_printf (gdb_stdlog, "qf->expand_all_symtabs (%s)\n",
 353                 objfile_debug_name (this));
 354
 355   for (const auto &iter : qf)
 356     iter->expand_all_symtabs (this);
 357 }
 358
 359 void
 360 objfile::expand_symtabs_with_fullname (const char *fullname)
 361 {
 362   if (debug_symfile)
 363     gdb_printf (gdb_stdlog,
 364                 "qf->expand_symtabs_with_fullname (%s, \"%s\")\n",
 365                 objfile_debug_name (this), fullname);
 366
 367   const char *basename = lbasename (fullname);
 368   auto file_matcher = [&] (const char *filename, bool basenames)
 369   {
 370     return filename_cmp (basenames ? basename : fullname, filename) == 0;
 371   };
 372
 373   for (const auto &iter : qf)
 374     iter->expand_symtabs_matching (this,
 375                                    file_matcher,
 376                                    nullptr,
 377                                    nullptr,
 378                                    nullptr,
 379                                    (SEARCH_GLOBAL_BLOCK
 380                                     | SEARCH_STATIC_BLOCK),
 381                                    SEARCH_ALL_DOMAINS);
 382 }
 383
 384 bool
 385 objfile::expand_symtabs_matching
 386   (gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
 387    const lookup_name_info *lookup_name,
 388    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
 389    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
 390    block_search_flags search_flags,
 391    domain_search_flags domain)
 392 {
 393   /* This invariant is documented in quick-functions.h.  */
 394   gdb_assert (lookup_name != nullptr || symbol_matcher == nullptr);
 395
 396   if (debug_symfile)
 397     gdb_printf (gdb_stdlog,
 398                 "qf->expand_symtabs_matching (%s, %s, %s, %s, %s)\n",
 399                 objfile_debug_name (this),
 400                 host_address_to_string (&file_matcher),
 401                 host_address_to_string (&symbol_matcher),
 402                 host_address_to_string (&expansion_notify),
 403                 domain_name (domain).c_str ());
 404
 405   for (const auto &iter : qf)
 406     if (!iter->expand_symtabs_matching (this, file_matcher, lookup_name,
 407                                         symbol_matcher, expansion_notify,
 408                                         search_flags, domain))
 409       return false;
 410   return true;
 411 }
 412
 413 struct compunit_symtab *
 414 objfile::find_pc_sect_compunit_symtab (struct bound_minimal_symbol msymbol,
 415                                        CORE_ADDR pc,
 416                                        struct obj_section *section,
 417                                        int warn_if_readin)
 418 {
 419   struct compunit_symtab *retval = nullptr;
 420
 421   if (debug_symfile)
 422     gdb_printf (gdb_stdlog,
 423                 "qf->find_pc_sect_compunit_symtab (%s, %s, %s, %s, %d)\n",
 424                 objfile_debug_name (this),
 425                 host_address_to_string (msymbol.minsym),
 426                 hex_string (pc),
 427                 host_address_to_string (section),
 428                 warn_if_readin);
 429
 430   for (const auto &iter : qf)
 431     {
 432       retval = iter->find_pc_sect_compunit_symtab (this, msymbol, pc, section,
 433                                                    warn_if_readin);
 434       if (retval != nullptr)
 435         break;
 436     }
 437
 438   if (debug_symfile)
 439     gdb_printf (gdb_stdlog,
 440                 "qf->find_pc_sect_compunit_symtab (...) = %s\n",
 441                 retval
 442                 ? debug_symtab_name (retval->primary_filetab ())
 443                 : "NULL");
 444
 445   return retval;
 446 }
 447
 448 void
 449 objfile::map_symbol_filenames (gdb::function_view<symbol_filename_ftype> fun,
 450                                bool need_fullname)
 451 {
 452   if (debug_symfile)
 453     gdb_printf (gdb_stdlog,
 454                 "qf->map_symbol_filenames (%s, ..., %d)\n",
 455                 objfile_debug_name (this),
 456                 need_fullname);
 457
 458   for (const auto &iter : qf)
 459     iter->map_symbol_filenames (this, fun, need_fullname);
 460 }
 461
 462 void
 463 objfile::compute_main_name ()
 464 {
 465   if (debug_symfile)
 466     gdb_printf (gdb_stdlog,
 467                 "qf->compute_main_name (%s)\n",
 468                 objfile_debug_name (this));
 469
 470   for (const auto &iter : qf)
 471     iter->compute_main_name (this);
 472 }
 473
 474 struct compunit_symtab *
 475 objfile::find_compunit_symtab_by_address (CORE_ADDR address)
 476 {
 477   if (debug_symfile)
 478     gdb_printf (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     gdb_printf (gdb_stdlog,
 493                 "qf->find_compunit_symtab_by_address (...) = %s\n",
 494                 result
 495                 ? debug_symtab_name (result->primary_filetab ())
 496                 : "NULL");
 497
 498   return result;
 499 }
 500
 501 enum language
 502 objfile::lookup_global_symbol_language (const char *name,
 503                                         domain_search_flags 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 /* Call LOOKUP_FUNC to find the filename of a file containing the separate
 521    debug information matching OBJFILE.  If LOOKUP_FUNC does return a
 522    filename then open this file and return a std::pair containing the
 523    gdb_bfd_ref_ptr of the open file and the filename returned by
 524    LOOKUP_FUNC, otherwise this function returns an empty pair; the first
 525    item will be nullptr, and the second will be an empty string.
 526
 527    Any warnings generated by this function, or by calling LOOKUP_FUNC are
 528    placed into WARNINGS, these warnings are only displayed to the user if
 529    GDB is unable to find the separate debug information via any route.  */
 530 static std::pair<gdb_bfd_ref_ptr, std::string>
 531 simple_find_and_open_separate_symbol_file
 532   (struct objfile *objfile,
 533    std::string (*lookup_func) (struct objfile *, deferred_warnings *),
 534    deferred_warnings *warnings)
 535 {
 536   std::string filename = lookup_func (objfile, warnings);
 537
 538   if (!filename.empty ())
 539     {
 540       gdb_bfd_ref_ptr symfile_bfd
 541         = symfile_bfd_open_no_error (filename.c_str ());
 542       if (symfile_bfd != nullptr)
 543         return { symfile_bfd, filename };
 544     }
 545
 546   return {};
 547 }
 548
 549 /* Lookup separate debug information for OBJFILE via debuginfod.  If
 550    successful the debug information will be have been downloaded into the
 551    debuginfod cache and this function will return a std::pair containing a
 552    gdb_bfd_ref_ptr of the open debug information file and the filename for
 553    the file within the debuginfod cache.  If no debug information could be
 554    found then this function returns an empty pair; the first item will be
 555    nullptr, and the second will be an empty string.  */
 556
 557 static std::pair<gdb_bfd_ref_ptr, std::string>
 558 debuginfod_find_and_open_separate_symbol_file (struct objfile * objfile)
 559 {
 560   const struct bfd_build_id *build_id
 561     = build_id_bfd_get (objfile->obfd.get ());
 562   const char *filename = bfd_get_filename (objfile->obfd.get ());
 563
 564   if (build_id != nullptr)
 565     {
 566       gdb::unique_xmalloc_ptr<char> symfile_path;
 567       scoped_fd fd (debuginfod_debuginfo_query (build_id->data, build_id->size,
 568                                                 filename, &symfile_path));
 569
 570       if (fd.get () >= 0)
 571         {
 572           /* File successfully retrieved from server.  */
 573           gdb_bfd_ref_ptr debug_bfd
 574             (symfile_bfd_open_no_error (symfile_path.get ()));
 575
 576           if (debug_bfd != nullptr
 577               && build_id_verify (debug_bfd.get (),
 578                                   build_id->size, build_id->data))
 579             return { debug_bfd, std::string (symfile_path.get ()) };
 580         }
 581     }
 582
 583   return {};
 584 }
 585
 586 /* See objfiles.h.  */
 587
 588 bool
 589 objfile::find_and_add_separate_symbol_file (symfile_add_flags symfile_flags)
 590 {
 591   bool has_dwarf2 = false;
 592
 593   /* Usually we only make a single pass when looking for separate debug
 594      information.  However, it is possible for an extension language hook
 595      to request that GDB make a second pass, in which case max_attempts
 596      will be updated, and the loop restarted.  */
 597   for (unsigned attempt = 0, max_attempts = 1;
 598        attempt < max_attempts && !has_dwarf2;
 599        ++attempt)
 600     {
 601       gdb_assert (max_attempts <= 2);
 602
 603       deferred_warnings warnings;
 604       gdb_bfd_ref_ptr debug_bfd;
 605       std::string filename;
 606
 607       std::tie (debug_bfd, filename)
 608         = simple_find_and_open_separate_symbol_file
 609             (this, find_separate_debug_file_by_buildid, &warnings);
 610
 611       if (debug_bfd == nullptr)
 612         std::tie (debug_bfd, filename)
 613           = simple_find_and_open_separate_symbol_file
 614               (this, find_separate_debug_file_by_debuglink, &warnings);
 615
 616       /* Only try debuginfod on the first attempt.  Sure, we could imagine
 617          an extension that somehow adds the required debug info to the
 618          debuginfod server but, at least for now, we don't support this
 619          scenario.  Better for the extension to return new debug info
 620          directly to GDB.  Plus, going to the debuginfod server might be
 621          slow, so that's a good argument for only doing this once.  */
 622       if (debug_bfd == nullptr && attempt == 0)
 623         std::tie (debug_bfd, filename)
 624           = debuginfod_find_and_open_separate_symbol_file (this);
 625
 626       if (debug_bfd != nullptr)
 627         {
 628           /* We found a separate debug info symbol file.  If this is our
 629              first attempt then setting HAS_DWARF2 will cause us to break
 630              from the attempt loop.  */
 631           symbol_file_add_separate (debug_bfd, filename.c_str (),
 632                                     symfile_flags, this);
 633           has_dwarf2 = true;
 634         }
 635       else if (attempt == 0)
 636         {
 637           /* Failed to find a separate debug info symbol file.  Call out to
 638              the extension languages.  The user might have registered an
 639              extension that can find the debug info for us, or maybe give
 640              the user a system specific message that guides them to finding
 641              the missing debug info.  */
 642
 643           ext_lang_missing_debuginfo_result ext_result
 644             = ext_lang_handle_missing_debuginfo (this);
 645           if (!ext_result.filename ().empty ())
 646             {
 647               /* Extension found a suitable debug file for us.  */
 648               debug_bfd
 649                 = symfile_bfd_open_no_error (ext_result.filename ().c_str ());
 650
 651               if (debug_bfd != nullptr)
 652                 {
 653                   symbol_file_add_separate (debug_bfd,
 654                                             ext_result.filename ().c_str (),
 655                                             symfile_flags, this);
 656                   has_dwarf2 = true;
 657                 }
 658             }
 659           else if (ext_result.try_again ())
 660             {
 661               max_attempts = 2;
 662               continue;
 663             }
 664         }
 665
 666       /* If we still have not got a separate debug symbol file, then
 667          emit any warnings we've collected so far.  */
 668       if (!has_dwarf2)
 669         warnings.emit ();
 670     }
 671
 672   return has_dwarf2;
 673 }
 674
 675 \f
 676 /* Debugging version of struct sym_probe_fns.  */
 677
 678 static const std::vector<std::unique_ptr<probe>> &
 679 debug_sym_get_probes (struct objfile *objfile)
 680 {
 681   const struct debug_sym_fns_data *debug_data
 682     = symfile_debug_objfile_data_key.get (objfile);
 683
 684   const std::vector<std::unique_ptr<probe>> &retval
 685     = debug_data->real_sf->sym_probe_fns->sym_get_probes (objfile);
 686
 687   gdb_printf (gdb_stdlog,
 688               "probes->sym_get_probes (%s) = %s\n",
 689               objfile_debug_name (objfile),
 690               host_address_to_string (retval.data ()));
 691
 692   return retval;
 693 }
 694
 695 static const struct sym_probe_fns debug_sym_probe_fns =
 696 {
 697   debug_sym_get_probes,
 698 };
 699 \f
 700 /* Debugging version of struct sym_fns.  */
 701
 702 static void
 703 debug_sym_new_init (struct objfile *objfile)
 704 {
 705   const struct debug_sym_fns_data *debug_data
 706     = symfile_debug_objfile_data_key.get (objfile);
 707
 708   gdb_printf (gdb_stdlog, "sf->sym_new_init (%s)\n",
 709               objfile_debug_name (objfile));
 710
 711   debug_data->real_sf->sym_new_init (objfile);
 712 }
 713
 714 static void
 715 debug_sym_init (struct objfile *objfile)
 716 {
 717   const struct debug_sym_fns_data *debug_data
 718     = symfile_debug_objfile_data_key.get (objfile);
 719
 720   gdb_printf (gdb_stdlog, "sf->sym_init (%s)\n",
 721               objfile_debug_name (objfile));
 722
 723   debug_data->real_sf->sym_init (objfile);
 724 }
 725
 726 static void
 727 debug_sym_read (struct objfile *objfile, symfile_add_flags symfile_flags)
 728 {
 729   const struct debug_sym_fns_data *debug_data
 730     = symfile_debug_objfile_data_key.get (objfile);
 731
 732   gdb_printf (gdb_stdlog, "sf->sym_read (%s, 0x%x)\n",
 733               objfile_debug_name (objfile), (unsigned) symfile_flags);
 734
 735   debug_data->real_sf->sym_read (objfile, symfile_flags);
 736 }
 737
 738 static void
 739 debug_sym_finish (struct objfile *objfile)
 740 {
 741   const struct debug_sym_fns_data *debug_data
 742     = symfile_debug_objfile_data_key.get (objfile);
 743
 744   gdb_printf (gdb_stdlog, "sf->sym_finish (%s)\n",
 745               objfile_debug_name (objfile));
 746
 747   debug_data->real_sf->sym_finish (objfile);
 748 }
 749
 750 static void
 751 debug_sym_offsets (struct objfile *objfile,
 752                    const section_addr_info &info)
 753 {
 754   const struct debug_sym_fns_data *debug_data
 755     = symfile_debug_objfile_data_key.get (objfile);
 756
 757   gdb_printf (gdb_stdlog, "sf->sym_offsets (%s, %s)\n",
 758               objfile_debug_name (objfile),
 759               host_address_to_string (&info));
 760
 761   debug_data->real_sf->sym_offsets (objfile, info);
 762 }
 763
 764 static symfile_segment_data_up
 765 debug_sym_segments (bfd *abfd)
 766 {
 767   /* This API function is annoying, it doesn't take a "this" pointer.
 768      Fortunately it is only used in one place where we (re-)lookup the
 769      sym_fns table to use.  Thus we will never be called.  */
 770   gdb_assert_not_reached ("debug_sym_segments called");
 771 }
 772
 773 static void
 774 debug_sym_read_linetable (struct objfile *objfile)
 775 {
 776   const struct debug_sym_fns_data *debug_data
 777     = symfile_debug_objfile_data_key.get (objfile);
 778
 779   gdb_printf (gdb_stdlog, "sf->sym_read_linetable (%s)\n",
 780               objfile_debug_name (objfile));
 781
 782   debug_data->real_sf->sym_read_linetable (objfile);
 783 }
 784
 785 static bfd_byte *
 786 debug_sym_relocate (struct objfile *objfile, asection *sectp, bfd_byte *buf)
 787 {
 788   const struct debug_sym_fns_data *debug_data
 789     = symfile_debug_objfile_data_key.get (objfile);
 790   bfd_byte *retval;
 791
 792   retval = debug_data->real_sf->sym_relocate (objfile, sectp, buf);
 793
 794   gdb_printf (gdb_stdlog,
 795               "sf->sym_relocate (%s, %s, %s) = %s\n",
 796               objfile_debug_name (objfile),
 797               host_address_to_string (sectp),
 798               host_address_to_string (buf),
 799               host_address_to_string (retval));
 800
 801   return retval;
 802 }
 803
 804 /* Template of debugging version of struct sym_fns.
 805    A copy is made, with sym_flavour updated, and a pointer to the real table
 806    installed in real_sf, and then a pointer to the copy is installed in the
 807    objfile.  */
 808
 809 static const struct sym_fns debug_sym_fns =
 810 {
 811   debug_sym_new_init,
 812   debug_sym_init,
 813   debug_sym_read,
 814   debug_sym_finish,
 815   debug_sym_offsets,
 816   debug_sym_segments,
 817   debug_sym_read_linetable,
 818   debug_sym_relocate,
 819   &debug_sym_probe_fns,
 820 };
 821 \f
 822 /* Install the debugging versions of the symfile functions for OBJFILE.
 823    Do not call this if the debug versions are already installed.  */
 824
 825 static void
 826 install_symfile_debug_logging (struct objfile *objfile)
 827 {
 828   const struct sym_fns *real_sf;
 829   struct debug_sym_fns_data *debug_data;
 830
 831   /* The debug versions should not already be installed.  */
 832   gdb_assert (!symfile_debug_installed (objfile));
 833
 834   real_sf = objfile->sf;
 835
 836   /* Alas we have to preserve NULL entries in REAL_SF.  */
 837   debug_data = new struct debug_sym_fns_data;
 838
 839 #define COPY_SF_PTR(from, to, name, func)       \
 840   do {                                          \
 841     if ((from)->name)                           \
 842       (to)->debug_sf.name = func;               \
 843   } while (0)
 844
 845   COPY_SF_PTR (real_sf, debug_data, sym_new_init, debug_sym_new_init);
 846   COPY_SF_PTR (real_sf, debug_data, sym_init, debug_sym_init);
 847   COPY_SF_PTR (real_sf, debug_data, sym_read, debug_sym_read);
 848   COPY_SF_PTR (real_sf, debug_data, sym_finish, debug_sym_finish);
 849   COPY_SF_PTR (real_sf, debug_data, sym_offsets, debug_sym_offsets);
 850   COPY_SF_PTR (real_sf, debug_data, sym_segments, debug_sym_segments);
 851   COPY_SF_PTR (real_sf, debug_data, sym_read_linetable,
 852                debug_sym_read_linetable);
 853   COPY_SF_PTR (real_sf, debug_data, sym_relocate, debug_sym_relocate);
 854   if (real_sf->sym_probe_fns)
 855     debug_data->debug_sf.sym_probe_fns = &debug_sym_probe_fns;
 856
 857 #undef COPY_SF_PTR
 858
 859   debug_data->real_sf = real_sf;
 860   symfile_debug_objfile_data_key.set (objfile, debug_data);
 861   objfile->sf = &debug_data->debug_sf;
 862 }
 863
 864 /* Uninstall the debugging versions of the symfile functions for OBJFILE.
 865    Do not call this if the debug versions are not installed.  */
 866
 867 static void
 868 uninstall_symfile_debug_logging (struct objfile *objfile)
 869 {
 870   struct debug_sym_fns_data *debug_data;
 871
 872   /* The debug versions should be currently installed.  */
 873   gdb_assert (symfile_debug_installed (objfile));
 874
 875   debug_data = symfile_debug_objfile_data_key.get (objfile);
 876
 877   objfile->sf = debug_data->real_sf;
 878   symfile_debug_objfile_data_key.clear (objfile);
 879 }
 880
 881 /* Call this function to set OBJFILE->SF.
 882    Do not set OBJFILE->SF directly.  */
 883
 884 void
 885 objfile_set_sym_fns (struct objfile *objfile, const struct sym_fns *sf)
 886 {
 887   if (symfile_debug_installed (objfile))
 888     {
 889       gdb_assert (debug_symfile);
 890       /* Remove the current one, and reinstall a new one later.  */
 891       uninstall_symfile_debug_logging (objfile);
 892     }
 893
 894   /* Assume debug logging is disabled.  */
 895   objfile->sf = sf;
 896
 897   /* Turn debug logging on if enabled.  */
 898   if (debug_symfile)
 899     install_symfile_debug_logging (objfile);
 900 }
 901
 902 static void
 903 set_debug_symfile (const char *args, int from_tty, struct cmd_list_element *c)
 904 {
 905   for (struct program_space *pspace : program_spaces)
 906     for (objfile *objfile : pspace->objfiles ())
 907       {
 908         if (debug_symfile)
 909           {
 910             if (!symfile_debug_installed (objfile))
 911               install_symfile_debug_logging (objfile);
 912           }
 913         else
 914           {
 915             if (symfile_debug_installed (objfile))
 916               uninstall_symfile_debug_logging (objfile);
 917           }
 918       }
 919 }
 920
 921 static void
 922 show_debug_symfile (struct ui_file *file, int from_tty,
 923                         struct cmd_list_element *c, const char *value)
 924 {
 925   gdb_printf (file, _("Symfile debugging is %s.\n"), value);
 926 }
 927
 928 void _initialize_symfile_debug ();
 929 void
 930 _initialize_symfile_debug ()
 931 {
 932   add_setshow_boolean_cmd ("symfile", no_class, &debug_symfile, _("\
 933 Set debugging of the symfile functions."), _("\
 934 Show debugging of the symfile functions."), _("\
 935 When enabled, all calls to the symfile functions are logged."),
 936                            set_debug_symfile, show_debug_symfile,
 937                            &setdebuglist, &showdebuglist);
 938
 939   /* Note: We don't need a new-objfile observer because debug logging
 940      will be installed when objfile init'n calls objfile_set_sym_fns.  */
 941 }