gdb/psymtab.c

   1 /* Partial symbol tables.
   2
   3    Copyright (C) 2009-2019 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "objfiles.h"
  23 #include "psympriv.h"
  24 #include "block.h"
  25 #include "filenames.h"
  26 #include "source.h"
  27 #include "addrmap.h"
  28 #include "gdbtypes.h"
  29 #include "bcache.h"
  30 #include "ui-out.h"
  31 #include "command.h"
  32 #include "readline/readline.h"
  33 #include "gdb_regex.h"
  34 #include "dictionary.h"
  35 #include "language.h"
  36 #include "cp-support.h"
  37 #include "gdbcmd.h"
  38 #include <algorithm>
  39 #include <set>
  40
  41 struct psymbol_bcache
  42 {
  43   struct bcache *bcache;
  44 };
  45
  46 static struct partial_symbol *match_partial_symbol (struct objfile *,
  47                                                     struct partial_symtab *,
  48                                                     int,
  49                                                     const char *, domain_enum,
  50                                                     symbol_name_match_type,
  51                                                     symbol_compare_ftype *);
  52
  53 static struct partial_symbol *lookup_partial_symbol (struct objfile *,
  54                                                      struct partial_symtab *,
  55                                                      const char *, int,
  56                                                      domain_enum);
  57
  58 static const char *psymtab_to_fullname (struct partial_symtab *ps);
  59
  60 static struct partial_symbol *find_pc_sect_psymbol (struct objfile *,
  61                                                     struct partial_symtab *,
  62                                                     CORE_ADDR,
  63                                                     struct obj_section *);
  64
  65 static struct compunit_symtab *psymtab_to_symtab (struct objfile *objfile,
  66                                                   struct partial_symtab *pst);
  67
  68 /* See psymtab.h.  */
  69
  70 objfile_psymtabs
  71 require_partial_symbols (struct objfile *objfile, int verbose)
  72 {
  73   if ((objfile->flags & OBJF_PSYMTABS_READ) == 0)
  74     {
  75       objfile->flags |= OBJF_PSYMTABS_READ;
  76
  77       if (objfile->sf->sym_read_psymbols)
  78         {
  79           if (verbose)
  80             printf_filtered (_("Reading symbols from %s...\n"),
  81                              objfile_name (objfile));
  82           (*objfile->sf->sym_read_psymbols) (objfile);
  83
  84           /* Partial symbols list are not expected to changed after this
  85              point.  */
  86           objfile->global_psymbols.shrink_to_fit ();
  87           objfile->static_psymbols.shrink_to_fit ();
  88
  89           if (verbose && !objfile_has_symbols (objfile))
  90             printf_filtered (_("(No debugging symbols found in %s)\n"),
  91                              objfile_name (objfile));
  92         }
  93     }
  94
  95   return objfile_psymtabs (objfile);
  96 }
  97
  98 /* Helper function for psym_map_symtabs_matching_filename that
  99    expands the symtabs and calls the iterator.  */
 100
 101 static bool
 102 partial_map_expand_apply (struct objfile *objfile,
 103                           const char *name,
 104                           const char *real_path,
 105                           struct partial_symtab *pst,
 106                           gdb::function_view<bool (symtab *)> callback)
 107 {
 108   struct compunit_symtab *last_made = objfile->compunit_symtabs;
 109
 110   /* Shared psymtabs should never be seen here.  Instead they should
 111      be handled properly by the caller.  */
 112   gdb_assert (pst->user == NULL);
 113
 114   /* Don't visit already-expanded psymtabs.  */
 115   if (pst->readin)
 116     return 0;
 117
 118   /* This may expand more than one symtab, and we want to iterate over
 119      all of them.  */
 120   psymtab_to_symtab (objfile, pst);
 121
 122   return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
 123                                     last_made, callback);
 124 }
 125
 126 /*  Psymtab version of map_symtabs_matching_filename.  See its definition in
 127     the definition of quick_symbol_functions in symfile.h.  */
 128
 129 static bool
 130 psym_map_symtabs_matching_filename
 131   (struct objfile *objfile,
 132    const char *name,
 133    const char *real_path,
 134    gdb::function_view<bool (symtab *)> callback)
 135 {
 136   const char *name_basename = lbasename (name);
 137
 138   for (partial_symtab *pst : require_partial_symbols (objfile, 1))
 139     {
 140       /* We can skip shared psymtabs here, because any file name will be
 141          attached to the unshared psymtab.  */
 142       if (pst->user != NULL)
 143         continue;
 144
 145       /* Anonymous psymtabs don't have a file name.  */
 146       if (pst->anonymous)
 147         continue;
 148
 149       if (compare_filenames_for_search (pst->filename, name))
 150         {
 151           if (partial_map_expand_apply (objfile, name, real_path,
 152                                         pst, callback))
 153             return true;
 154           continue;
 155         }
 156
 157       /* Before we invoke realpath, which can get expensive when many
 158          files are involved, do a quick comparison of the basenames.  */
 159       if (! basenames_may_differ
 160           && FILENAME_CMP (name_basename, lbasename (pst->filename)) != 0)
 161         continue;
 162
 163       if (compare_filenames_for_search (psymtab_to_fullname (pst), name))
 164         {
 165           if (partial_map_expand_apply (objfile, name, real_path,
 166                                         pst, callback))
 167             return true;
 168           continue;
 169         }
 170
 171       /* If the user gave us an absolute path, try to find the file in
 172          this symtab and use its absolute path.  */
 173       if (real_path != NULL)
 174         {
 175           gdb_assert (IS_ABSOLUTE_PATH (real_path));
 176           gdb_assert (IS_ABSOLUTE_PATH (name));
 177           if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0)
 178             {
 179               if (partial_map_expand_apply (objfile, name, real_path,
 180                                             pst, callback))
 181                 return true;
 182               continue;
 183             }
 184         }
 185     }
 186
 187   return false;
 188 }
 189
 190 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
 191    We may find a different psymtab than PST.  See FIND_PC_SECT_PSYMTAB.  */
 192
 193 static struct partial_symtab *
 194 find_pc_sect_psymtab_closer (struct objfile *objfile,
 195                              CORE_ADDR pc, struct obj_section *section,
 196                              struct partial_symtab *pst,
 197                              struct bound_minimal_symbol msymbol)
 198 {
 199   struct partial_symtab *tpst;
 200   struct partial_symtab *best_pst = pst;
 201   CORE_ADDR best_addr = pst->text_low (objfile);
 202
 203   gdb_assert (!pst->psymtabs_addrmap_supported);
 204
 205   /* An objfile that has its functions reordered might have
 206      many partial symbol tables containing the PC, but
 207      we want the partial symbol table that contains the
 208      function containing the PC.  */
 209   if (!(objfile->flags & OBJF_REORDERED)
 210       && section == NULL)  /* Can't validate section this way.  */
 211     return pst;
 212
 213   if (msymbol.minsym == NULL)
 214     return pst;
 215
 216   /* The code range of partial symtabs sometimes overlap, so, in
 217      the loop below, we need to check all partial symtabs and
 218      find the one that fits better for the given PC address.  We
 219      select the partial symtab that contains a symbol whose
 220      address is closest to the PC address.  By closest we mean
 221      that find_pc_sect_symbol returns the symbol with address
 222      that is closest and still less than the given PC.  */
 223   for (tpst = pst; tpst != NULL; tpst = tpst->next)
 224     {
 225       if (pc >= tpst->text_low (objfile) && pc < tpst->text_high (objfile))
 226         {
 227           struct partial_symbol *p;
 228           CORE_ADDR this_addr;
 229
 230           /* NOTE: This assumes that every psymbol has a
 231              corresponding msymbol, which is not necessarily
 232              true; the debug info might be much richer than the
 233              object's symbol table.  */
 234           p = find_pc_sect_psymbol (objfile, tpst, pc, section);
 235           if (p != NULL
 236               && (p->address (objfile) == BMSYMBOL_VALUE_ADDRESS (msymbol)))
 237             return tpst;
 238
 239           /* Also accept the textlow value of a psymtab as a
 240              "symbol", to provide some support for partial
 241              symbol tables with line information but no debug
 242              symbols (e.g. those produced by an assembler).  */
 243           if (p != NULL)
 244             this_addr = p->address (objfile);
 245           else
 246             this_addr = tpst->text_low (objfile);
 247
 248           /* Check whether it is closer than our current
 249              BEST_ADDR.  Since this symbol address is
 250              necessarily lower or equal to PC, the symbol closer
 251              to PC is the symbol which address is the highest.
 252              This way we return the psymtab which contains such
 253              best match symbol.  This can help in cases where the
 254              symbol information/debuginfo is not complete, like
 255              for instance on IRIX6 with gcc, where no debug info
 256              is emitted for statics.  (See also the nodebug.exp
 257              testcase.)  */
 258           if (this_addr > best_addr)
 259             {
 260               best_addr = this_addr;
 261               best_pst = tpst;
 262             }
 263         }
 264     }
 265   return best_pst;
 266 }
 267
 268 /* Find which partial symtab contains PC and SECTION.  Return NULL if
 269    none.  We return the psymtab that contains a symbol whose address
 270    exactly matches PC, or, if we cannot find an exact match, the
 271    psymtab that contains a symbol whose address is closest to PC.  */
 272
 273 static struct partial_symtab *
 274 find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
 275                       struct obj_section *section,
 276                       struct bound_minimal_symbol msymbol)
 277 {
 278   CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
 279                                  SECT_OFF_TEXT (objfile));
 280
 281   /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
 282      than the later used TEXTLOW/TEXTHIGH one.  */
 283
 284   if (objfile->psymtabs_addrmap != NULL)
 285     {
 286       struct partial_symtab *pst
 287         = ((struct partial_symtab *)
 288            addrmap_find (objfile->psymtabs_addrmap, pc - baseaddr));
 289       if (pst != NULL)
 290         {
 291           /* FIXME: addrmaps currently do not handle overlayed sections,
 292              so fall back to the non-addrmap case if we're debugging
 293              overlays and the addrmap returned the wrong section.  */
 294           if (overlay_debugging && msymbol.minsym != NULL && section != NULL)
 295             {
 296               struct partial_symbol *p;
 297
 298               /* NOTE: This assumes that every psymbol has a
 299                  corresponding msymbol, which is not necessarily
 300                  true; the debug info might be much richer than the
 301                  object's symbol table.  */
 302               p = find_pc_sect_psymbol (objfile, pst, pc, section);
 303               if (p == NULL
 304                   || (p->address (objfile)
 305                       != BMSYMBOL_VALUE_ADDRESS (msymbol)))
 306                 goto next;
 307             }
 308
 309           /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
 310              PSYMTABS_ADDRMAP we used has already the best 1-byte
 311              granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
 312              a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
 313              overlap.  */
 314
 315           return pst;
 316         }
 317     }
 318
 319  next:
 320
 321   /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
 322      which still have no corresponding full SYMTABs read.  But it is not
 323      present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
 324      so far.  */
 325
 326   /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
 327      its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
 328      debug info type in single OBJFILE.  */
 329
 330   for (partial_symtab *pst : require_partial_symbols (objfile, 1))
 331     if (!pst->psymtabs_addrmap_supported
 332         && pc >= pst->text_low (objfile) && pc < pst->text_high (objfile))
 333       {
 334         struct partial_symtab *best_pst;
 335
 336         best_pst = find_pc_sect_psymtab_closer (objfile, pc, section, pst,
 337                                                 msymbol);
 338         if (best_pst != NULL)
 339           return best_pst;
 340       }
 341
 342   return NULL;
 343 }
 344
 345 /* Psymtab version of find_pc_sect_compunit_symtab.  See its definition in
 346    the definition of quick_symbol_functions in symfile.h.  */
 347
 348 static struct compunit_symtab *
 349 psym_find_pc_sect_compunit_symtab (struct objfile *objfile,
 350                                    struct bound_minimal_symbol msymbol,
 351                                    CORE_ADDR pc,
 352                                    struct obj_section *section,
 353                                    int warn_if_readin)
 354 {
 355   struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section,
 356                                                     msymbol);
 357   if (ps != NULL)
 358     {
 359       if (warn_if_readin && ps->readin)
 360         /* Might want to error() here (in case symtab is corrupt and
 361            will cause a core dump), but maybe we can successfully
 362            continue, so let's not.  */
 363         warning (_("\
 364 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
 365                  paddress (get_objfile_arch (objfile), pc));
 366       psymtab_to_symtab (objfile, ps);
 367       return ps->compunit_symtab;
 368     }
 369   return NULL;
 370 }
 371
 372 /* Find which partial symbol within a psymtab matches PC and SECTION.
 373    Return NULL if none.  */
 374
 375 static struct partial_symbol *
 376 find_pc_sect_psymbol (struct objfile *objfile,
 377                       struct partial_symtab *psymtab, CORE_ADDR pc,
 378                       struct obj_section *section)
 379 {
 380   struct partial_symbol *best = NULL;
 381   CORE_ADDR best_pc;
 382   const CORE_ADDR textlow = psymtab->text_low (objfile);
 383
 384   gdb_assert (psymtab != NULL);
 385
 386   /* Cope with programs that start at address 0.  */
 387   best_pc = (textlow != 0) ? textlow - 1 : 0;
 388
 389   /* Search the global symbols as well as the static symbols, so that
 390      find_pc_partial_function doesn't use a minimal symbol and thus
 391      cache a bad endaddr.  */
 392   for (int i = 0; i < psymtab->n_global_syms; i++)
 393     {
 394       partial_symbol *p = objfile->global_psymbols[psymtab->globals_offset + i];
 395
 396       if (p->domain == VAR_DOMAIN
 397           && p->aclass == LOC_BLOCK
 398           && pc >= p->address (objfile)
 399           && (p->address (objfile) > best_pc
 400               || (psymtab->text_low (objfile) == 0
 401                   && best_pc == 0 && p->address (objfile) == 0)))
 402         {
 403           if (section != NULL)  /* Match on a specific section.  */
 404             {
 405               if (!matching_obj_sections (p->obj_section (objfile),
 406                                           section))
 407                 continue;
 408             }
 409           best_pc = p->address (objfile);
 410           best = p;
 411         }
 412     }
 413
 414   for (int i = 0; i < psymtab->n_static_syms; i++)
 415     {
 416       partial_symbol *p = objfile->static_psymbols[psymtab->statics_offset + i];
 417
 418       if (p->domain == VAR_DOMAIN
 419           && p->aclass == LOC_BLOCK
 420           && pc >= p->address (objfile)
 421           && (p->address (objfile) > best_pc
 422               || (psymtab->text_low (objfile) == 0
 423                   && best_pc == 0 && p->address (objfile) == 0)))
 424         {
 425           if (section != NULL)  /* Match on a specific section.  */
 426             {
 427               if (!matching_obj_sections (p->obj_section (objfile),
 428                                           section))
 429                 continue;
 430             }
 431           best_pc = p->address (objfile);
 432           best = p;
 433         }
 434     }
 435
 436   return best;
 437 }
 438
 439 /* Psymtab version of lookup_symbol.  See its definition in
 440    the definition of quick_symbol_functions in symfile.h.  */
 441
 442 static struct compunit_symtab *
 443 psym_lookup_symbol (struct objfile *objfile,
 444                     int block_index, const char *name,
 445                     const domain_enum domain)
 446 {
 447   const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
 448   struct compunit_symtab *stab_best = NULL;
 449
 450   lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
 451
 452   for (partial_symtab *ps : require_partial_symbols (objfile, 1))
 453     {
 454       if (!ps->readin && lookup_partial_symbol (objfile, ps, name,
 455                                                 psymtab_index, domain))
 456         {
 457           struct symbol *sym, *with_opaque = NULL;
 458           struct compunit_symtab *stab = psymtab_to_symtab (objfile, ps);
 459           /* Note: While psymtab_to_symtab can return NULL if the
 460              partial symtab is empty, we can assume it won't here
 461              because lookup_partial_symbol succeeded.  */
 462           const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
 463           struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
 464
 465           sym = block_find_symbol (block, name, domain,
 466                                    block_find_non_opaque_type_preferred,
 467                                    &with_opaque);
 468
 469           /* Some caution must be observed with overloaded functions
 470              and methods, since the index will not contain any overload
 471              information (but NAME might contain it).  */
 472
 473           if (sym != NULL
 474               && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
 475             return stab;
 476           if (with_opaque != NULL
 477               && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
 478             stab_best = stab;
 479
 480           /* Keep looking through other psymtabs.  */
 481         }
 482     }
 483
 484   return stab_best;
 485 }
 486
 487 /* Returns true if PSYM matches LOOKUP_NAME.  */
 488
 489 static bool
 490 psymbol_name_matches (partial_symbol *psym,
 491                       const lookup_name_info &lookup_name)
 492 {
 493   const language_defn *lang = language_def (psym->language);
 494   symbol_name_matcher_ftype *name_match
 495     = get_symbol_name_matcher (lang, lookup_name);
 496   return name_match (symbol_search_name (psym), lookup_name, NULL);
 497 }
 498
 499 /* Look in PST for a symbol in DOMAIN whose name matches NAME.  Search
 500    the global block of PST if GLOBAL, and otherwise the static block.
 501    MATCH is the comparison operation that returns true iff MATCH (s,
 502    NAME), where s is a SYMBOL_SEARCH_NAME.  If ORDERED_COMPARE is
 503    non-null, the symbols in the block are assumed to be ordered
 504    according to it (allowing binary search).  It must be compatible
 505    with MATCH.  Returns the symbol, if found, and otherwise NULL.  */
 506
 507 static struct partial_symbol *
 508 match_partial_symbol (struct objfile *objfile,
 509                       struct partial_symtab *pst, int global,
 510                       const char *name, domain_enum domain,
 511                       symbol_name_match_type match_type,
 512                       symbol_compare_ftype *ordered_compare)
 513 {
 514   struct partial_symbol **start, **psym;
 515   struct partial_symbol **top, **real_top, **bottom, **center;
 516   int length = (global ? pst->n_global_syms : pst->n_static_syms);
 517   int do_linear_search = 1;
 518
 519   if (length == 0)
 520     return NULL;
 521
 522   lookup_name_info lookup_name (name, match_type);
 523
 524   start = (global ?
 525            &objfile->global_psymbols[pst->globals_offset] :
 526            &objfile->static_psymbols[pst->statics_offset]);
 527
 528   if (global && ordered_compare)  /* Can use a binary search.  */
 529     {
 530       do_linear_search = 0;
 531
 532       /* Binary search.  This search is guaranteed to end with center
 533          pointing at the earliest partial symbol whose name might be
 534          correct.  At that point *all* partial symbols with an
 535          appropriate name will be checked against the correct
 536          domain.  */
 537
 538       bottom = start;
 539       top = start + length - 1;
 540       real_top = top;
 541       while (top > bottom)
 542         {
 543           center = bottom + (top - bottom) / 2;
 544           gdb_assert (center < top);
 545
 546           enum language lang = (*center)->language;
 547           const char *lang_ln
 548             = lookup_name.language_lookup_name (lang).c_str ();
 549
 550           if (ordered_compare (symbol_search_name (*center), lang_ln) >= 0)
 551             top = center;
 552           else
 553             bottom = center + 1;
 554         }
 555       gdb_assert (top == bottom);
 556
 557       while (top <= real_top
 558              && psymbol_name_matches (*top, lookup_name))
 559         {
 560           if (symbol_matches_domain ((*top)->language,
 561                                      (*top)->domain, domain))
 562             return *top;
 563           top++;
 564         }
 565     }
 566
 567   /* Can't use a binary search or else we found during the binary search that
 568      we should also do a linear search.  */
 569
 570   if (do_linear_search)
 571     {
 572       for (psym = start; psym < start + length; psym++)
 573         {
 574           if (symbol_matches_domain ((*psym)->language,
 575                                      (*psym)->domain, domain)
 576               && psymbol_name_matches (*psym, lookup_name))
 577             return *psym;
 578         }
 579     }
 580
 581   return NULL;
 582 }
 583
 584 /* Returns the name used to search psymtabs.  Unlike symtabs, psymtabs do
 585    not contain any method/function instance information (since this would
 586    force reading type information while reading psymtabs).  Therefore,
 587    if NAME contains overload information, it must be stripped before searching
 588    psymtabs.  */
 589
 590 static gdb::unique_xmalloc_ptr<char>
 591 psymtab_search_name (const char *name)
 592 {
 593   switch (current_language->la_language)
 594     {
 595     case language_cplus:
 596       {
 597         if (strchr (name, '('))
 598           {
 599             gdb::unique_xmalloc_ptr<char> ret = cp_remove_params (name);
 600
 601             if (ret)
 602               return ret;
 603           }
 604       }
 605       break;
 606
 607     default:
 608       break;
 609     }
 610
 611   return gdb::unique_xmalloc_ptr<char> (xstrdup (name));
 612 }
 613
 614 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
 615    Check the global symbols if GLOBAL, the static symbols if not.  */
 616
 617 static struct partial_symbol *
 618 lookup_partial_symbol (struct objfile *objfile,
 619                        struct partial_symtab *pst, const char *name,
 620                        int global, domain_enum domain)
 621 {
 622   struct partial_symbol **start, **psym;
 623   struct partial_symbol **top, **real_top, **bottom, **center;
 624   int length = (global ? pst->n_global_syms : pst->n_static_syms);
 625   int do_linear_search = 1;
 626
 627   if (length == 0)
 628     return NULL;
 629
 630   gdb::unique_xmalloc_ptr<char> search_name = psymtab_search_name (name);
 631
 632   lookup_name_info lookup_name (search_name.get (), symbol_name_match_type::FULL);
 633
 634   start = (global ?
 635            &objfile->global_psymbols[pst->globals_offset] :
 636            &objfile->static_psymbols[pst->statics_offset]);
 637
 638   if (global)                   /* This means we can use a binary search.  */
 639     {
 640       do_linear_search = 0;
 641
 642       /* Binary search.  This search is guaranteed to end with center
 643          pointing at the earliest partial symbol whose name might be
 644          correct.  At that point *all* partial symbols with an
 645          appropriate name will be checked against the correct
 646          domain.  */
 647
 648       bottom = start;
 649       top = start + length - 1;
 650       real_top = top;
 651       while (top > bottom)
 652         {
 653           center = bottom + (top - bottom) / 2;
 654           if (!(center < top))
 655             internal_error (__FILE__, __LINE__,
 656                             _("failed internal consistency check"));
 657           if (strcmp_iw_ordered (symbol_search_name (*center),
 658                                  search_name.get ()) >= 0)
 659             {
 660               top = center;
 661             }
 662           else
 663             {
 664               bottom = center + 1;
 665             }
 666         }
 667       if (!(top == bottom))
 668         internal_error (__FILE__, __LINE__,
 669                         _("failed internal consistency check"));
 670
 671       /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
 672          search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME.  */
 673       while (top >= start && symbol_matches_search_name (*top, lookup_name))
 674         top--;
 675
 676       /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME.  */
 677       top++;
 678
 679       while (top <= real_top && symbol_matches_search_name (*top, lookup_name))
 680         {
 681           if (symbol_matches_domain ((*top)->language,
 682                                      (*top)->domain, domain))
 683             return *top;
 684           top++;
 685         }
 686     }
 687
 688   /* Can't use a binary search or else we found during the binary search that
 689      we should also do a linear search.  */
 690
 691   if (do_linear_search)
 692     {
 693       for (psym = start; psym < start + length; psym++)
 694         {
 695           if (symbol_matches_domain ((*psym)->language,
 696                                      (*psym)->domain, domain)
 697               && symbol_matches_search_name (*psym, lookup_name))
 698             return *psym;
 699         }
 700     }
 701
 702   return NULL;
 703 }
 704
 705 /* Get the symbol table that corresponds to a partial_symtab.
 706    This is fast after the first time you do it.
 707    The result will be NULL if the primary symtab has no symbols,
 708    which can happen.  Otherwise the result is the primary symtab
 709    that contains PST.  */
 710
 711 static struct compunit_symtab *
 712 psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
 713 {
 714   /* If it is a shared psymtab, find an unshared psymtab that includes
 715      it.  Any such psymtab will do.  */
 716   while (pst->user != NULL)
 717     pst = pst->user;
 718
 719   /* If it's been looked up before, return it.  */
 720   if (pst->compunit_symtab)
 721     return pst->compunit_symtab;
 722
 723   /* If it has not yet been read in, read it.  */
 724   if (!pst->readin)
 725     {
 726       scoped_restore decrementer = increment_reading_symtab ();
 727
 728       (*pst->read_symtab) (pst, objfile);
 729     }
 730
 731   return pst->compunit_symtab;
 732 }
 733
 734 /* Psymtab version of find_last_source_symtab.  See its definition in
 735    the definition of quick_symbol_functions in symfile.h.  */
 736
 737 static struct symtab *
 738 psym_find_last_source_symtab (struct objfile *ofp)
 739 {
 740   struct partial_symtab *cs_pst = NULL;
 741
 742   for (partial_symtab *ps : require_partial_symbols (ofp, 1))
 743     {
 744       const char *name = ps->filename;
 745       int len = strlen (name);
 746
 747       if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
 748                         || strcmp (name, "<<C++-namespaces>>") == 0)))
 749         cs_pst = ps;
 750     }
 751
 752   if (cs_pst)
 753     {
 754       if (cs_pst->readin)
 755         {
 756           internal_error (__FILE__, __LINE__,
 757                           _("select_source_symtab: "
 758                           "readin pst found and no symtabs."));
 759         }
 760       else
 761         {
 762           struct compunit_symtab *cust = psymtab_to_symtab (ofp, cs_pst);
 763
 764           if (cust == NULL)
 765             return NULL;
 766           return compunit_primary_filetab (cust);
 767         }
 768     }
 769   return NULL;
 770 }
 771
 772 /* Psymtab version of forget_cached_source_info.  See its definition in
 773    the definition of quick_symbol_functions in symfile.h.  */
 774
 775 static void
 776 psym_forget_cached_source_info (struct objfile *objfile)
 777 {
 778   for (partial_symtab *pst : require_partial_symbols (objfile, 1))
 779     {
 780       if (pst->fullname != NULL)
 781         {
 782           xfree (pst->fullname);
 783           pst->fullname = NULL;
 784         }
 785     }
 786 }
 787
 788 static void
 789 print_partial_symbols (struct gdbarch *gdbarch, struct objfile *objfile,
 790                        struct partial_symbol **p, int count, const char *what,
 791                        struct ui_file *outfile)
 792 {
 793   fprintf_filtered (outfile, "  %s partial symbols:\n", what);
 794   while (count-- > 0)
 795     {
 796       QUIT;
 797       fprintf_filtered (outfile, "    `%s'", (*p)->name);
 798       if (symbol_demangled_name (*p) != NULL)
 799         {
 800           fprintf_filtered (outfile, "  `%s'", symbol_demangled_name (*p));
 801         }
 802       fputs_filtered (", ", outfile);
 803       switch ((*p)->domain)
 804         {
 805         case UNDEF_DOMAIN:
 806           fputs_filtered ("undefined domain, ", outfile);
 807           break;
 808         case VAR_DOMAIN:
 809           /* This is the usual thing -- don't print it.  */
 810           break;
 811         case STRUCT_DOMAIN:
 812           fputs_filtered ("struct domain, ", outfile);
 813           break;
 814         case LABEL_DOMAIN:
 815           fputs_filtered ("label domain, ", outfile);
 816           break;
 817         default:
 818           fputs_filtered ("<invalid domain>, ", outfile);
 819           break;
 820         }
 821       switch ((*p)->aclass)
 822         {
 823         case LOC_UNDEF:
 824           fputs_filtered ("undefined", outfile);
 825           break;
 826         case LOC_CONST:
 827           fputs_filtered ("constant int", outfile);
 828           break;
 829         case LOC_STATIC:
 830           fputs_filtered ("static", outfile);
 831           break;
 832         case LOC_REGISTER:
 833           fputs_filtered ("register", outfile);
 834           break;
 835         case LOC_ARG:
 836           fputs_filtered ("pass by value", outfile);
 837           break;
 838         case LOC_REF_ARG:
 839           fputs_filtered ("pass by reference", outfile);
 840           break;
 841         case LOC_REGPARM_ADDR:
 842           fputs_filtered ("register address parameter", outfile);
 843           break;
 844         case LOC_LOCAL:
 845           fputs_filtered ("stack parameter", outfile);
 846           break;
 847         case LOC_TYPEDEF:
 848           fputs_filtered ("type", outfile);
 849           break;
 850         case LOC_LABEL:
 851           fputs_filtered ("label", outfile);
 852           break;
 853         case LOC_BLOCK:
 854           fputs_filtered ("function", outfile);
 855           break;
 856         case LOC_CONST_BYTES:
 857           fputs_filtered ("constant bytes", outfile);
 858           break;
 859         case LOC_UNRESOLVED:
 860           fputs_filtered ("unresolved", outfile);
 861           break;
 862         case LOC_OPTIMIZED_OUT:
 863           fputs_filtered ("optimized out", outfile);
 864           break;
 865         case LOC_COMPUTED:
 866           fputs_filtered ("computed at runtime", outfile);
 867           break;
 868         default:
 869           fputs_filtered ("<invalid location>", outfile);
 870           break;
 871         }
 872       fputs_filtered (", ", outfile);
 873       fputs_filtered (paddress (gdbarch, (*p)->unrelocated_address ()), outfile);
 874       fprintf_filtered (outfile, "\n");
 875       p++;
 876     }
 877 }
 878
 879 static void
 880 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
 881               struct ui_file *outfile)
 882 {
 883   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 884   int i;
 885
 886   if (psymtab->anonymous)
 887     {
 888       fprintf_filtered (outfile, "\nAnonymous partial symtab (%s) ",
 889                         psymtab->filename);
 890     }
 891   else
 892     {
 893       fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
 894                         psymtab->filename);
 895     }
 896   fprintf_filtered (outfile, "(object ");
 897   gdb_print_host_address (psymtab, outfile);
 898   fprintf_filtered (outfile, ")\n\n");
 899   fprintf_filtered (outfile, "  Read from object file %s (",
 900                     objfile_name (objfile));
 901   gdb_print_host_address (objfile, outfile);
 902   fprintf_filtered (outfile, ")\n");
 903
 904   if (psymtab->readin)
 905     {
 906       fprintf_filtered (outfile,
 907                         "  Full symtab was read (at ");
 908       gdb_print_host_address (psymtab->compunit_symtab, outfile);
 909       fprintf_filtered (outfile, " by function at ");
 910       gdb_print_host_address (psymtab->read_symtab, outfile);
 911       fprintf_filtered (outfile, ")\n");
 912     }
 913
 914   fprintf_filtered (outfile, "  Symbols cover text addresses ");
 915   fputs_filtered (paddress (gdbarch, psymtab->text_low (objfile)), outfile);
 916   fprintf_filtered (outfile, "-");
 917   fputs_filtered (paddress (gdbarch, psymtab->text_high (objfile)), outfile);
 918   fprintf_filtered (outfile, "\n");
 919   fprintf_filtered (outfile, "  Address map supported - %s.\n",
 920                     psymtab->psymtabs_addrmap_supported ? "yes" : "no");
 921   fprintf_filtered (outfile, "  Depends on %d other partial symtabs.\n",
 922                     psymtab->number_of_dependencies);
 923   for (i = 0; i < psymtab->number_of_dependencies; i++)
 924     {
 925       fprintf_filtered (outfile, "    %d ", i);
 926       gdb_print_host_address (psymtab->dependencies[i], outfile);
 927       fprintf_filtered (outfile, " %s\n",
 928                         psymtab->dependencies[i]->filename);
 929     }
 930   if (psymtab->user != NULL)
 931     {
 932       fprintf_filtered (outfile, "  Shared partial symtab with user ");
 933       gdb_print_host_address (psymtab->user, outfile);
 934       fprintf_filtered (outfile, "\n");
 935     }
 936   if (psymtab->n_global_syms > 0)
 937     {
 938       print_partial_symbols (gdbarch, objfile,
 939                              &objfile->global_psymbols[psymtab->globals_offset],
 940                              psymtab->n_global_syms, "Global", outfile);
 941     }
 942   if (psymtab->n_static_syms > 0)
 943     {
 944       print_partial_symbols (gdbarch, objfile,
 945                              &objfile->static_psymbols[psymtab->statics_offset],
 946                              psymtab->n_static_syms, "Static", outfile);
 947     }
 948   fprintf_filtered (outfile, "\n");
 949 }
 950
 951 /* Psymtab version of print_stats.  See its definition in
 952    the definition of quick_symbol_functions in symfile.h.  */
 953
 954 static void
 955 psym_print_stats (struct objfile *objfile)
 956 {
 957   int i;
 958
 959   i = 0;
 960   for (partial_symtab *ps : require_partial_symbols (objfile, 1))
 961     {
 962       if (ps->readin == 0)
 963         i++;
 964     }
 965   printf_filtered (_("  Number of psym tables (not yet expanded): %d\n"), i);
 966 }
 967
 968 /* Psymtab version of dump.  See its definition in
 969    the definition of quick_symbol_functions in symfile.h.  */
 970
 971 static void
 972 psym_dump (struct objfile *objfile)
 973 {
 974   struct partial_symtab *psymtab;
 975
 976   if (objfile->psymtabs)
 977     {
 978       printf_filtered ("Psymtabs:\n");
 979       for (psymtab = objfile->psymtabs;
 980            psymtab != NULL;
 981            psymtab = psymtab->next)
 982         {
 983           printf_filtered ("%s at ",
 984                            psymtab->filename);
 985           gdb_print_host_address (psymtab, gdb_stdout);
 986           printf_filtered (", ");
 987           wrap_here ("  ");
 988         }
 989       printf_filtered ("\n\n");
 990     }
 991 }
 992
 993 /* Psymtab version of expand_symtabs_for_function.  See its definition in
 994    the definition of quick_symbol_functions in symfile.h.  */
 995
 996 static void
 997 psym_expand_symtabs_for_function (struct objfile *objfile,
 998                                   const char *func_name)
 999 {
1000   for (partial_symtab *ps : require_partial_symbols (objfile, 1))
1001     {
1002       if (ps->readin)
1003         continue;
1004
1005       if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)
1006            != NULL)
1007           || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)
1008               != NULL))
1009         psymtab_to_symtab (objfile, ps);
1010     }
1011 }
1012
1013 /* Psymtab version of expand_all_symtabs.  See its definition in
1014    the definition of quick_symbol_functions in symfile.h.  */
1015
1016 static void
1017 psym_expand_all_symtabs (struct objfile *objfile)
1018 {
1019   for (partial_symtab *psymtab : require_partial_symbols (objfile, 1))
1020     psymtab_to_symtab (objfile, psymtab);
1021 }
1022
1023 /* Psymtab version of expand_symtabs_with_fullname.  See its definition in
1024    the definition of quick_symbol_functions in symfile.h.  */
1025
1026 static void
1027 psym_expand_symtabs_with_fullname (struct objfile *objfile,
1028                                    const char *fullname)
1029 {
1030   for (partial_symtab *p : require_partial_symbols (objfile, 1))
1031     {
1032       /* Anonymous psymtabs don't have a name of a source file.  */
1033       if (p->anonymous)
1034         continue;
1035
1036       /* psymtab_to_fullname tries to open the file which is slow.
1037          Don't call it if we know the basenames don't match.  */
1038       if ((basenames_may_differ
1039            || filename_cmp (lbasename (fullname), lbasename (p->filename)) == 0)
1040           && filename_cmp (fullname, psymtab_to_fullname (p)) == 0)
1041         psymtab_to_symtab (objfile, p);
1042     }
1043 }
1044
1045 /* Psymtab version of map_symbol_filenames.  See its definition in
1046    the definition of quick_symbol_functions in symfile.h.  */
1047
1048 static void
1049 psym_map_symbol_filenames (struct objfile *objfile,
1050                            symbol_filename_ftype *fun, void *data,
1051                            int need_fullname)
1052 {
1053   for (partial_symtab *ps : require_partial_symbols (objfile, 1))
1054     {
1055       const char *fullname;
1056
1057       if (ps->readin)
1058         continue;
1059
1060       /* We can skip shared psymtabs here, because any file name will be
1061          attached to the unshared psymtab.  */
1062       if (ps->user != NULL)
1063         continue;
1064
1065       /* Anonymous psymtabs don't have a file name.  */
1066       if (ps->anonymous)
1067         continue;
1068
1069       QUIT;
1070       if (need_fullname)
1071         fullname = psymtab_to_fullname (ps);
1072       else
1073         fullname = NULL;
1074       (*fun) (ps->filename, fullname, data);
1075     }
1076 }
1077
1078 /* Finds the fullname that a partial_symtab represents.
1079
1080    If this functions finds the fullname, it will save it in ps->fullname
1081    and it will also return the value.
1082
1083    If this function fails to find the file that this partial_symtab represents,
1084    NULL will be returned and ps->fullname will be set to NULL.  */
1085
1086 static const char *
1087 psymtab_to_fullname (struct partial_symtab *ps)
1088 {
1089   gdb_assert (!ps->anonymous);
1090
1091   /* Use cached copy if we have it.
1092      We rely on forget_cached_source_info being called appropriately
1093      to handle cases like the file being moved.  */
1094   if (ps->fullname == NULL)
1095     {
1096       gdb::unique_xmalloc_ptr<char> fullname;
1097       scoped_fd fd = find_and_open_source (ps->filename, ps->dirname,
1098                                            &fullname);
1099       ps->fullname = fullname.release ();
1100
1101       if (fd.get () < 0)
1102         {
1103           /* rewrite_source_path would be applied by find_and_open_source, we
1104              should report the pathname where GDB tried to find the file.  */
1105
1106           if (ps->dirname == NULL || IS_ABSOLUTE_PATH (ps->filename))
1107             fullname.reset (xstrdup (ps->filename));
1108           else
1109             fullname.reset (concat (ps->dirname, SLASH_STRING,
1110                                     ps->filename, (char *) NULL));
1111
1112           ps->fullname = rewrite_source_path (fullname.get ()).release ();
1113           if (ps->fullname == NULL)
1114             ps->fullname = fullname.release ();
1115         }
1116     }
1117
1118   return ps->fullname;
1119 }
1120
1121 /* For all symbols, s, in BLOCK that are in DOMAIN and match NAME
1122    according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1123    BLOCK is assumed to come from OBJFILE.  Returns 1 iff CALLBACK
1124    ever returns non-zero, and otherwise returns 0.  */
1125
1126 static int
1127 map_block (const char *name, domain_enum domain, struct objfile *objfile,
1128            struct block *block,
1129            int (*callback) (struct block *, struct symbol *, void *),
1130            void *data, symbol_name_match_type match)
1131 {
1132   struct block_iterator iter;
1133   struct symbol *sym;
1134
1135   lookup_name_info lookup_name (name, match);
1136
1137   for (sym = block_iter_match_first (block, lookup_name, &iter);
1138        sym != NULL;
1139        sym = block_iter_match_next (lookup_name, &iter))
1140     {
1141       if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1142                                  SYMBOL_DOMAIN (sym), domain))
1143         {
1144           if (callback (block, sym, data))
1145             return 1;
1146         }
1147     }
1148
1149   return 0;
1150 }
1151
1152 /* Psymtab version of map_matching_symbols.  See its definition in
1153    the definition of quick_symbol_functions in symfile.h.  */
1154
1155 static void
1156 psym_map_matching_symbols (struct objfile *objfile,
1157                            const char *name, domain_enum domain,
1158                            int global,
1159                            int (*callback) (struct block *,
1160                                             struct symbol *, void *),
1161                            void *data,
1162                            symbol_name_match_type match,
1163                            symbol_compare_ftype *ordered_compare)
1164 {
1165   const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
1166
1167   for (partial_symtab *ps : require_partial_symbols (objfile, 1))
1168     {
1169       QUIT;
1170       if (ps->readin
1171           || match_partial_symbol (objfile, ps, global, name, domain, match,
1172                                    ordered_compare))
1173         {
1174           struct compunit_symtab *cust = psymtab_to_symtab (objfile, ps);
1175           struct block *block;
1176
1177           if (cust == NULL)
1178             continue;
1179           block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), block_kind);
1180           if (map_block (name, domain, objfile, block,
1181                          callback, data, match))
1182             return;
1183           if (callback (block, NULL, data))
1184             return;
1185         }
1186     }
1187 }
1188
1189 /* A helper for psym_expand_symtabs_matching that handles searching
1190    included psymtabs.  This returns true if a symbol is found, and
1191    false otherwise.  It also updates the 'searched_flag' on the
1192    various psymtabs that it searches.  */
1193
1194 static bool
1195 recursively_search_psymtabs
1196   (struct partial_symtab *ps,
1197    struct objfile *objfile,
1198    enum search_domain domain,
1199    const lookup_name_info &lookup_name,
1200    gdb::function_view<expand_symtabs_symbol_matcher_ftype> sym_matcher)
1201 {
1202   int keep_going = 1;
1203   enum psymtab_search_status result = PST_SEARCHED_AND_NOT_FOUND;
1204   int i;
1205
1206   if (ps->searched_flag != PST_NOT_SEARCHED)
1207     return ps->searched_flag == PST_SEARCHED_AND_FOUND;
1208
1209   /* Recurse into shared psymtabs first, because they may have already
1210      been searched, and this could save some time.  */
1211   for (i = 0; i < ps->number_of_dependencies; ++i)
1212     {
1213       int r;
1214
1215       /* Skip non-shared dependencies, these are handled elsewhere.  */
1216       if (ps->dependencies[i]->user == NULL)
1217         continue;
1218
1219       r = recursively_search_psymtabs (ps->dependencies[i],
1220                                        objfile, domain, lookup_name,
1221                                        sym_matcher);
1222       if (r != 0)
1223         {
1224           ps->searched_flag = PST_SEARCHED_AND_FOUND;
1225           return true;
1226         }
1227     }
1228
1229   partial_symbol **gbound
1230     = objfile->global_psymbols.data () + ps->globals_offset + ps->n_global_syms;
1231   partial_symbol **sbound
1232     = objfile->static_psymbols.data () + ps->statics_offset + ps->n_static_syms;
1233   partial_symbol **bound = gbound;
1234
1235   /* Go through all of the symbols stored in a partial
1236      symtab in one loop.  */
1237   partial_symbol **psym = objfile->global_psymbols.data () + ps->globals_offset;
1238   while (keep_going)
1239     {
1240       if (psym >= bound)
1241         {
1242           if (bound == gbound && ps->n_static_syms != 0)
1243             {
1244               psym = objfile->static_psymbols.data () + ps->statics_offset;
1245               bound = sbound;
1246             }
1247           else
1248             keep_going = 0;
1249           continue;
1250         }
1251       else
1252         {
1253           QUIT;
1254
1255           if ((domain == ALL_DOMAIN
1256                || (domain == VARIABLES_DOMAIN
1257                    && (*psym)->aclass != LOC_TYPEDEF
1258                    && (*psym)->aclass != LOC_BLOCK)
1259                || (domain == FUNCTIONS_DOMAIN
1260                    && (*psym)->aclass == LOC_BLOCK)
1261                || (domain == TYPES_DOMAIN
1262                    && (*psym)->aclass == LOC_TYPEDEF))
1263               && psymbol_name_matches (*psym, lookup_name)
1264               && (sym_matcher == NULL || sym_matcher (symbol_search_name (*psym))))
1265             {
1266               /* Found a match, so notify our caller.  */
1267               result = PST_SEARCHED_AND_FOUND;
1268               keep_going = 0;
1269             }
1270         }
1271       psym++;
1272     }
1273
1274   ps->searched_flag = result;
1275   return result == PST_SEARCHED_AND_FOUND;
1276 }
1277
1278 /* Psymtab version of expand_symtabs_matching.  See its definition in
1279    the definition of quick_symbol_functions in symfile.h.  */
1280
1281 static void
1282 psym_expand_symtabs_matching
1283   (struct objfile *objfile,
1284    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
1285    const lookup_name_info &lookup_name_in,
1286    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
1287    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
1288    enum search_domain domain)
1289 {
1290   lookup_name_info lookup_name = lookup_name_in.make_ignore_params ();
1291
1292   /* Clear the search flags.  */
1293   for (partial_symtab *ps : require_partial_symbols (objfile, 1))
1294     ps->searched_flag = PST_NOT_SEARCHED;
1295
1296   for (partial_symtab *ps : objfile_psymtabs (objfile))
1297     {
1298       QUIT;
1299
1300       if (ps->readin)
1301         continue;
1302
1303       /* We skip shared psymtabs because file-matching doesn't apply
1304          to them; but we search them later in the loop.  */
1305       if (ps->user != NULL)
1306         continue;
1307
1308       if (file_matcher)
1309         {
1310           bool match;
1311
1312           if (ps->anonymous)
1313             continue;
1314
1315           match = file_matcher (ps->filename, false);
1316           if (!match)
1317             {
1318               /* Before we invoke realpath, which can get expensive when many
1319                  files are involved, do a quick comparison of the basenames.  */
1320               if (basenames_may_differ
1321                   || file_matcher (lbasename (ps->filename), true))
1322                 match = file_matcher (psymtab_to_fullname (ps), false);
1323             }
1324           if (!match)
1325             continue;
1326         }
1327
1328       if (recursively_search_psymtabs (ps, objfile, domain,
1329                                        lookup_name, symbol_matcher))
1330         {
1331           struct compunit_symtab *symtab =
1332             psymtab_to_symtab (objfile, ps);
1333
1334           if (expansion_notify != NULL)
1335             expansion_notify (symtab);
1336         }
1337     }
1338 }
1339
1340 /* Psymtab version of has_symbols.  See its definition in
1341    the definition of quick_symbol_functions in symfile.h.  */
1342
1343 static int
1344 psym_has_symbols (struct objfile *objfile)
1345 {
1346   return objfile->psymtabs != NULL;
1347 }
1348
1349 /* Helper function for psym_find_compunit_symtab_by_address that fills
1350    in psymbol_map for a given range of psymbols.  */
1351
1352 static void
1353 psym_fill_psymbol_map (struct objfile *objfile,
1354                        struct partial_symtab *psymtab,
1355                        std::set<CORE_ADDR> *seen_addrs,
1356                        const std::vector<partial_symbol *> &symbols,
1357                        int start,
1358                        int length)
1359 {
1360   for (int i = 0; i < length; ++i)
1361     {
1362       struct partial_symbol *psym = symbols[start + i];
1363
1364       if (psym->aclass == LOC_STATIC)
1365         {
1366           CORE_ADDR addr = psym->address (objfile);
1367           if (seen_addrs->find (addr) == seen_addrs->end ())
1368             {
1369               seen_addrs->insert (addr);
1370               objfile->psymbol_map.emplace_back (addr, psymtab);
1371             }
1372         }
1373     }
1374 }
1375
1376 /* See find_compunit_symtab_by_address in quick_symbol_functions, in
1377    symfile.h.  */
1378
1379 static compunit_symtab *
1380 psym_find_compunit_symtab_by_address (struct objfile *objfile,
1381                                       CORE_ADDR address)
1382 {
1383   if (objfile->psymbol_map.empty ())
1384     {
1385       std::set<CORE_ADDR> seen_addrs;
1386
1387       for (partial_symtab *pst : require_partial_symbols (objfile, 1))
1388         {
1389           psym_fill_psymbol_map (objfile, pst,
1390                                  &seen_addrs,
1391                                  objfile->global_psymbols,
1392                                  pst->globals_offset,
1393                                  pst->n_global_syms);
1394           psym_fill_psymbol_map (objfile, pst,
1395                                  &seen_addrs,
1396                                  objfile->static_psymbols,
1397                                  pst->statics_offset,
1398                                  pst->n_static_syms);
1399         }
1400
1401       objfile->psymbol_map.shrink_to_fit ();
1402
1403       std::sort (objfile->psymbol_map.begin (), objfile->psymbol_map.end (),
1404                  [] (const std::pair<CORE_ADDR, partial_symtab *> &a,
1405                      const std::pair<CORE_ADDR, partial_symtab *> &b)
1406                  {
1407                    return a.first < b.first;
1408                  });
1409     }
1410
1411   auto iter = std::lower_bound
1412     (objfile->psymbol_map.begin (), objfile->psymbol_map.end (), address,
1413      [] (const std::pair<CORE_ADDR, partial_symtab *> &a,
1414          CORE_ADDR b)
1415      {
1416        return a.first < b;
1417      });
1418
1419   if (iter == objfile->psymbol_map.end () || iter->first != address)
1420     return NULL;
1421
1422   return psymtab_to_symtab (objfile, iter->second);
1423 }
1424
1425 const struct quick_symbol_functions psym_functions =
1426 {
1427   psym_has_symbols,
1428   psym_find_last_source_symtab,
1429   psym_forget_cached_source_info,
1430   psym_map_symtabs_matching_filename,
1431   psym_lookup_symbol,
1432   psym_print_stats,
1433   psym_dump,
1434   psym_expand_symtabs_for_function,
1435   psym_expand_all_symtabs,
1436   psym_expand_symtabs_with_fullname,
1437   psym_map_matching_symbols,
1438   psym_expand_symtabs_matching,
1439   psym_find_pc_sect_compunit_symtab,
1440   psym_find_compunit_symtab_by_address,
1441   psym_map_symbol_filenames
1442 };
1443
1444 \f
1445
1446 static void
1447 sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
1448 {
1449   /* Sort the global list; don't sort the static list.  */
1450   auto begin = objfile->global_psymbols.begin ();
1451   std::advance (begin, pst->globals_offset);
1452
1453   /* The psymbols for this partial_symtab are currently at the end of the
1454      vector.  */
1455   auto end = objfile->global_psymbols.end ();
1456
1457   std::sort (begin, end, [] (partial_symbol *s1, partial_symbol *s2)
1458     {
1459       return strcmp_iw_ordered (symbol_search_name (s1),
1460                                 symbol_search_name (s2)) < 0;
1461     });
1462 }
1463
1464 /* Allocate and partially fill a partial symtab.  It will be
1465    completely filled at the end of the symbol list.
1466
1467    FILENAME is the name of the symbol-file we are reading from.  */
1468
1469 struct partial_symtab *
1470 start_psymtab_common (struct objfile *objfile,
1471                       const char *filename,
1472                       CORE_ADDR textlow)
1473 {
1474   struct partial_symtab *psymtab;
1475
1476   psymtab = allocate_psymtab (filename, objfile);
1477   psymtab->set_text_low (textlow);
1478   psymtab->set_text_high (psymtab->raw_text_low ()); /* default */
1479   psymtab->globals_offset = objfile->global_psymbols.size ();
1480   psymtab->statics_offset = objfile->static_psymbols.size ();
1481   return psymtab;
1482 }
1483
1484 /* Perform "finishing up" operations of a partial symtab.  */
1485
1486 void
1487 end_psymtab_common (struct objfile *objfile, struct partial_symtab *pst)
1488 {
1489   pst->n_global_syms = objfile->global_psymbols.size () - pst->globals_offset;
1490   pst->n_static_syms = objfile->static_psymbols.size () - pst->statics_offset;
1491
1492   sort_pst_symbols (objfile, pst);
1493 }
1494
1495 /* Calculate a hash code for the given partial symbol.  The hash is
1496    calculated using the symbol's value, language, domain, class
1497    and name.  These are the values which are set by
1498    add_psymbol_to_bcache.  */
1499
1500 static unsigned long
1501 psymbol_hash (const void *addr, int length)
1502 {
1503   unsigned long h = 0;
1504   struct partial_symbol *psymbol = (struct partial_symbol *) addr;
1505   unsigned int lang = psymbol->language;
1506   unsigned int domain = psymbol->domain;
1507   unsigned int theclass = psymbol->aclass;
1508
1509   h = hash_continue (&psymbol->value, sizeof (psymbol->value), h);
1510   h = hash_continue (&lang, sizeof (unsigned int), h);
1511   h = hash_continue (&domain, sizeof (unsigned int), h);
1512   h = hash_continue (&theclass, sizeof (unsigned int), h);
1513   /* Note that psymbol names are interned via symbol_set_names, so
1514      there's no need to hash the contents of the name here.  */
1515   h = hash_continue (&psymbol->name,
1516                      sizeof (psymbol->name), h);
1517
1518   return h;
1519 }
1520
1521 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1522    For the comparison this function uses a symbols value,
1523    language, domain, class and name.  */
1524
1525 static int
1526 psymbol_compare (const void *addr1, const void *addr2, int length)
1527 {
1528   struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1529   struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
1530
1531   return (memcmp (&sym1->value, &sym2->value,
1532                   sizeof (sym1->value)) == 0
1533           && sym1->language == sym2->language
1534           && sym1->domain == sym2->domain
1535           && sym1->aclass == sym2->aclass
1536           /* Note that psymbol names are interned via
1537              symbol_set_names, so there's no need to compare the
1538              contents of the name here.  */
1539           && sym1->name == sym2->name);
1540 }
1541
1542 /* Initialize a partial symbol bcache.  */
1543
1544 struct psymbol_bcache *
1545 psymbol_bcache_init (void)
1546 {
1547   struct psymbol_bcache *bcache = XCNEW (struct psymbol_bcache);
1548
1549   bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
1550   return bcache;
1551 }
1552
1553 /* Free a partial symbol bcache.  */
1554
1555 void
1556 psymbol_bcache_free (struct psymbol_bcache *bcache)
1557 {
1558   if (bcache == NULL)
1559     return;
1560
1561   bcache_xfree (bcache->bcache);
1562   xfree (bcache);
1563 }
1564
1565 /* Return the internal bcache of the psymbol_bcache BCACHE.  */
1566
1567 struct bcache *
1568 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
1569 {
1570   return bcache->bcache;
1571 }
1572
1573 /* Find a copy of the SYM in BCACHE.  If BCACHE has never seen this
1574    symbol before, add a copy to BCACHE.  In either case, return a pointer
1575    to BCACHE's copy of the symbol.  If optional ADDED is not NULL, return
1576    1 in case of new entry or 0 if returning an old entry.  */
1577
1578 static struct partial_symbol *
1579 psymbol_bcache_full (struct partial_symbol *sym,
1580                      struct psymbol_bcache *bcache,
1581                      int *added)
1582 {
1583   return ((struct partial_symbol *)
1584           bcache_full (sym, sizeof (struct partial_symbol), bcache->bcache,
1585                        added));
1586 }
1587
1588 /* Helper function, initialises partial symbol structure and stashes
1589    it into objfile's bcache.  Note that our caching mechanism will
1590    use all fields of struct partial_symbol to determine hash value of the
1591    structure.  In other words, having two symbols with the same name but
1592    different domain (or address) is possible and correct.  */
1593
1594 static struct partial_symbol *
1595 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
1596                        domain_enum domain,
1597                        enum address_class theclass,
1598                        short section,
1599                        CORE_ADDR coreaddr,
1600                        enum language language, struct objfile *objfile,
1601                        int *added)
1602 {
1603   struct partial_symbol psymbol;
1604
1605   psymbol.set_unrelocated_address (coreaddr);
1606   psymbol.section = section;
1607   psymbol.domain = domain;
1608   psymbol.aclass = theclass;
1609
1610   memset (&psymbol.language_specific, 0, sizeof (psymbol.language_specific));
1611   psymbol.ada_mangled = 0;
1612   symbol_set_language (&psymbol, language, &objfile->objfile_obstack);
1613   symbol_set_names (&psymbol, name, namelength, copy_name, objfile->per_bfd);
1614
1615   /* Stash the partial symbol away in the cache.  */
1616   return psymbol_bcache_full (&psymbol, objfile->psymbol_cache, added);
1617 }
1618
1619 /* Helper function, adds partial symbol to the given partial symbol list.  */
1620
1621 static void
1622 append_psymbol_to_list (std::vector<partial_symbol *> *list,
1623                         struct partial_symbol *psym,
1624                         struct objfile *objfile)
1625 {
1626   list->push_back (psym);
1627   OBJSTAT (objfile, n_psyms++);
1628 }
1629
1630 /* Add a symbol with a long value to a psymtab.
1631    Since one arg is a struct, we pass in a ptr and deref it (sigh).
1632    The only value we need to store for psyms is an address.
1633    For all other psyms pass zero for COREADDR.
1634    Return the partial symbol that has been added.  */
1635
1636 void
1637 add_psymbol_to_list (const char *name, int namelength, int copy_name,
1638                      domain_enum domain,
1639                      enum address_class theclass,
1640                      short section,
1641                      psymbol_placement where,
1642                      CORE_ADDR coreaddr,
1643                      enum language language, struct objfile *objfile)
1644 {
1645   struct partial_symbol *psym;
1646
1647   int added;
1648
1649   /* Stash the partial symbol away in the cache.  */
1650   psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, theclass,
1651                                 section, coreaddr, language, objfile, &added);
1652
1653   /* Do not duplicate global partial symbols.  */
1654   if (where == psymbol_placement::GLOBAL && !added)
1655     return;
1656
1657   /* Save pointer to partial symbol in psymtab, growing symtab if needed.  */
1658   std::vector<partial_symbol *> *list
1659     = (where == psymbol_placement::STATIC
1660        ? &objfile->static_psymbols
1661        : &objfile->global_psymbols);
1662   append_psymbol_to_list (list, psym, objfile);
1663 }
1664
1665 /* See psympriv.h.  */
1666
1667 void
1668 init_psymbol_list (struct objfile *objfile, int total_symbols)
1669 {
1670   if (objfile->global_psymbols.capacity () == 0
1671       && objfile->static_psymbols.capacity () == 0)
1672     {
1673       /* Current best guess is that approximately a twentieth of the
1674          total symbols (in a debugging file) are global or static
1675          oriented symbols, then multiply that by slop factor of
1676          two.  */
1677       objfile->global_psymbols.reserve (total_symbols / 10);
1678       objfile->static_psymbols.reserve (total_symbols / 10);
1679     }
1680 }
1681
1682 /* See psympriv.h.  */
1683
1684 struct partial_symtab *
1685 allocate_psymtab (const char *filename, struct objfile *objfile)
1686 {
1687   struct partial_symtab *psymtab;
1688
1689   if (objfile->free_psymtabs)
1690     {
1691       psymtab = objfile->free_psymtabs;
1692       objfile->free_psymtabs = psymtab->next;
1693     }
1694   else
1695     psymtab = XOBNEW (&objfile->objfile_obstack, partial_symtab);
1696
1697   memset (psymtab, 0, sizeof (struct partial_symtab));
1698   psymtab->filename
1699     = (const char *) bcache (filename, strlen (filename) + 1,
1700                              objfile->per_bfd->filename_cache);
1701   psymtab->compunit_symtab = NULL;
1702
1703   /* Prepend it to the psymtab list for the objfile it belongs to.
1704      Psymtabs are searched in most recent inserted -> least recent
1705      inserted order.  */
1706
1707   psymtab->next = objfile->psymtabs;
1708   objfile->psymtabs = psymtab;
1709
1710   if (symtab_create_debug)
1711     {
1712       /* Be a bit clever with debugging messages, and don't print objfile
1713          every time, only when it changes.  */
1714       static char *last_objfile_name = NULL;
1715
1716       if (last_objfile_name == NULL
1717           || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
1718         {
1719           xfree (last_objfile_name);
1720           last_objfile_name = xstrdup (objfile_name (objfile));
1721           fprintf_filtered (gdb_stdlog,
1722                             "Creating one or more psymtabs for objfile %s ...\n",
1723                             last_objfile_name);
1724         }
1725       fprintf_filtered (gdb_stdlog,
1726                         "Created psymtab %s for module %s.\n",
1727                         host_address_to_string (psymtab), filename);
1728     }
1729
1730   return psymtab;
1731 }
1732
1733 void
1734 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
1735 {
1736   struct partial_symtab **prev_pst;
1737
1738   /* From dbxread.c:
1739      Empty psymtabs happen as a result of header files which don't
1740      have any symbols in them.  There can be a lot of them.  But this
1741      check is wrong, in that a psymtab with N_SLINE entries but
1742      nothing else is not empty, but we don't realize that.  Fixing
1743      that without slowing things down might be tricky.  */
1744
1745   /* First, snip it out of the psymtab chain.  */
1746
1747   prev_pst = &(objfile->psymtabs);
1748   while ((*prev_pst) != pst)
1749     prev_pst = &((*prev_pst)->next);
1750   (*prev_pst) = pst->next;
1751
1752   /* Next, put it on a free list for recycling.  */
1753
1754   pst->next = objfile->free_psymtabs;
1755   objfile->free_psymtabs = pst;
1756 }
1757
1758 \f
1759
1760 /* We need to pass a couple of items to the addrmap_foreach function,
1761    so use a struct.  */
1762
1763 struct dump_psymtab_addrmap_data
1764 {
1765   struct objfile *objfile;
1766   struct partial_symtab *psymtab;
1767   struct ui_file *outfile;
1768
1769   /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1770      If so, we want to print the next one as well (since the next addrmap
1771      entry defines the end of the range).  */
1772   int previous_matched;
1773 };
1774
1775 /* Helper function for dump_psymtab_addrmap to print an addrmap entry.  */
1776
1777 static int
1778 dump_psymtab_addrmap_1 (void *datap, CORE_ADDR start_addr, void *obj)
1779 {
1780   struct dump_psymtab_addrmap_data *data
1781     = (struct dump_psymtab_addrmap_data *) datap;
1782   struct gdbarch *gdbarch = get_objfile_arch (data->objfile);
1783   struct partial_symtab *addrmap_psymtab = (struct partial_symtab *) obj;
1784   const char *psymtab_address_or_end = NULL;
1785
1786   QUIT;
1787
1788   if (data->psymtab == NULL
1789       || data->psymtab == addrmap_psymtab)
1790     psymtab_address_or_end = host_address_to_string (addrmap_psymtab);
1791   else if (data->previous_matched)
1792     psymtab_address_or_end = "<ends here>";
1793
1794   if (data->psymtab == NULL
1795       || data->psymtab == addrmap_psymtab
1796       || data->previous_matched)
1797     {
1798       fprintf_filtered (data->outfile, "  %s%s %s\n",
1799                         data->psymtab != NULL ? "  " : "",
1800                         paddress (gdbarch, start_addr),
1801                         psymtab_address_or_end);
1802     }
1803
1804   data->previous_matched = (data->psymtab == NULL
1805                             || data->psymtab == addrmap_psymtab);
1806
1807   return 0;
1808 }
1809
1810 /* Helper function for maintenance_print_psymbols to print the addrmap
1811    of PSYMTAB.  If PSYMTAB is NULL print the entire addrmap.  */
1812
1813 static void
1814 dump_psymtab_addrmap (struct objfile *objfile, struct partial_symtab *psymtab,
1815                       struct ui_file *outfile)
1816 {
1817   struct dump_psymtab_addrmap_data addrmap_dump_data;
1818
1819   if ((psymtab == NULL
1820        || psymtab->psymtabs_addrmap_supported)
1821       && objfile->psymtabs_addrmap != NULL)
1822     {
1823       addrmap_dump_data.objfile = objfile;
1824       addrmap_dump_data.psymtab = psymtab;
1825       addrmap_dump_data.outfile = outfile;
1826       addrmap_dump_data.previous_matched = 0;
1827       fprintf_filtered (outfile, "%sddress map:\n",
1828                         psymtab == NULL ? "Entire a" : "  A");
1829       addrmap_foreach (objfile->psymtabs_addrmap, dump_psymtab_addrmap_1,
1830                        &addrmap_dump_data);
1831     }
1832 }
1833
1834 static void
1835 maintenance_print_psymbols (const char *args, int from_tty)
1836 {
1837   struct ui_file *outfile = gdb_stdout;
1838   char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
1839   int i, outfile_idx, found;
1840   CORE_ADDR pc = 0;
1841   struct obj_section *section = NULL;
1842
1843   dont_repeat ();
1844
1845   gdb_argv argv (args);
1846
1847   for (i = 0; argv != NULL && argv[i] != NULL; ++i)
1848     {
1849       if (strcmp (argv[i], "-pc") == 0)
1850         {
1851           if (argv[i + 1] == NULL)
1852             error (_("Missing pc value"));
1853           address_arg = argv[++i];
1854         }
1855       else if (strcmp (argv[i], "-source") == 0)
1856         {
1857           if (argv[i + 1] == NULL)
1858             error (_("Missing source file"));
1859           source_arg = argv[++i];
1860         }
1861       else if (strcmp (argv[i], "-objfile") == 0)
1862         {
1863           if (argv[i + 1] == NULL)
1864             error (_("Missing objfile name"));
1865           objfile_arg = argv[++i];
1866         }
1867       else if (strcmp (argv[i], "--") == 0)
1868         {
1869           /* End of options.  */
1870           ++i;
1871           break;
1872         }
1873       else if (argv[i][0] == '-')
1874         {
1875           /* Future proofing: Don't allow OUTFILE to begin with "-".  */
1876           error (_("Unknown option: %s"), argv[i]);
1877         }
1878       else
1879         break;
1880     }
1881   outfile_idx = i;
1882
1883   if (address_arg != NULL && source_arg != NULL)
1884     error (_("Must specify at most one of -pc and -source"));
1885
1886   stdio_file arg_outfile;
1887
1888   if (argv != NULL && argv[outfile_idx] != NULL)
1889     {
1890       if (argv[outfile_idx + 1] != NULL)
1891         error (_("Junk at end of command"));
1892       gdb::unique_xmalloc_ptr<char> outfile_name
1893         (tilde_expand (argv[outfile_idx]));
1894       if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
1895         perror_with_name (outfile_name.get ());
1896       outfile = &arg_outfile;
1897     }
1898
1899   if (address_arg != NULL)
1900     {
1901       pc = parse_and_eval_address (address_arg);
1902       /* If we fail to find a section, that's ok, try the lookup anyway.  */
1903       section = find_pc_section (pc);
1904     }
1905
1906   found = 0;
1907   for (objfile *objfile : all_objfiles (current_program_space))
1908     {
1909       int printed_objfile_header = 0;
1910       int print_for_objfile = 1;
1911
1912       QUIT;
1913       if (objfile_arg != NULL)
1914         print_for_objfile
1915           = compare_filenames_for_search (objfile_name (objfile),
1916                                           objfile_arg);
1917       if (!print_for_objfile)
1918         continue;
1919
1920       if (address_arg != NULL)
1921         {
1922           struct bound_minimal_symbol msymbol = { NULL, NULL };
1923
1924           /* We don't assume each pc has a unique objfile (this is for
1925              debugging).  */
1926           struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc,
1927                                                             section, msymbol);
1928           if (ps != NULL)
1929             {
1930               if (!printed_objfile_header)
1931                 {
1932                   outfile->printf ("\nPartial symtabs for objfile %s\n",
1933                                   objfile_name (objfile));
1934                   printed_objfile_header = 1;
1935                 }
1936               dump_psymtab (objfile, ps, outfile);
1937               dump_psymtab_addrmap (objfile, ps, outfile);
1938               found = 1;
1939             }
1940         }
1941       else
1942         {
1943           for (partial_symtab *ps : require_partial_symbols (objfile, 1))
1944             {
1945               int print_for_source = 0;
1946
1947               QUIT;
1948               if (source_arg != NULL)
1949                 {
1950                   print_for_source
1951                     = compare_filenames_for_search (ps->filename, source_arg);
1952                   found = 1;
1953                 }
1954               if (source_arg == NULL
1955                   || print_for_source)
1956                 {
1957                   if (!printed_objfile_header)
1958                     {
1959                       outfile->printf ("\nPartial symtabs for objfile %s\n",
1960                                        objfile_name (objfile));
1961                       printed_objfile_header = 1;
1962                     }
1963                   dump_psymtab (objfile, ps, outfile);
1964                   dump_psymtab_addrmap (objfile, ps, outfile);
1965                 }
1966             }
1967         }
1968
1969       /* If we're printing all the objfile's symbols dump the full addrmap.  */
1970
1971       if (address_arg == NULL
1972           && source_arg == NULL
1973           && objfile->psymtabs_addrmap != NULL)
1974         {
1975           outfile->puts ("\n");
1976           dump_psymtab_addrmap (objfile, NULL, outfile);
1977         }
1978     }
1979
1980   if (!found)
1981     {
1982       if (address_arg != NULL)
1983         error (_("No partial symtab for address: %s"), address_arg);
1984       if (source_arg != NULL)
1985         error (_("No partial symtab for source file: %s"), source_arg);
1986     }
1987 }
1988
1989 /* List all the partial symbol tables whose names match REGEXP (optional).  */
1990
1991 static void
1992 maintenance_info_psymtabs (const char *regexp, int from_tty)
1993 {
1994   struct program_space *pspace;
1995
1996   if (regexp)
1997     re_comp (regexp);
1998
1999   ALL_PSPACES (pspace)
2000     for (objfile *objfile : all_objfiles (pspace))
2001       {
2002         struct gdbarch *gdbarch = get_objfile_arch (objfile);
2003
2004         /* We don't want to print anything for this objfile until we
2005            actually find a symtab whose name matches.  */
2006         int printed_objfile_start = 0;
2007
2008         for (partial_symtab *psymtab : require_partial_symbols (objfile, 1))
2009           {
2010             QUIT;
2011
2012             if (! regexp
2013                 || re_exec (psymtab->filename))
2014               {
2015                 if (! printed_objfile_start)
2016                   {
2017                     printf_filtered ("{ objfile %s ", objfile_name (objfile));
2018                     wrap_here ("  ");
2019                     printf_filtered ("((struct objfile *) %s)\n",
2020                                      host_address_to_string (objfile));
2021                     printed_objfile_start = 1;
2022                   }
2023
2024                 printf_filtered ("  { psymtab %s ", psymtab->filename);
2025                 wrap_here ("    ");
2026                 printf_filtered ("((struct partial_symtab *) %s)\n",
2027                                  host_address_to_string (psymtab));
2028
2029                 printf_filtered ("    readin %s\n",
2030                                  psymtab->readin ? "yes" : "no");
2031                 printf_filtered ("    fullname %s\n",
2032                                  psymtab->fullname
2033                                  ? psymtab->fullname : "(null)");
2034                 printf_filtered ("    text addresses ");
2035                 fputs_filtered (paddress (gdbarch,
2036                                           psymtab->text_low (objfile)),
2037                                 gdb_stdout);
2038                 printf_filtered (" -- ");
2039                 fputs_filtered (paddress (gdbarch,
2040                                           psymtab->text_high (objfile)),
2041                                 gdb_stdout);
2042                 printf_filtered ("\n");
2043                 printf_filtered ("    psymtabs_addrmap_supported %s\n",
2044                                  (psymtab->psymtabs_addrmap_supported
2045                                   ? "yes" : "no"));
2046                 printf_filtered ("    globals ");
2047                 if (psymtab->n_global_syms)
2048                   {
2049                     auto p
2050                       = &objfile->global_psymbols[psymtab->globals_offset];
2051
2052                     printf_filtered
2053                       ("(* (struct partial_symbol **) %s @ %d)\n",
2054                        host_address_to_string (p),
2055                        psymtab->n_global_syms);
2056                   }
2057                 else
2058                   printf_filtered ("(none)\n");
2059                 printf_filtered ("    statics ");
2060                 if (psymtab->n_static_syms)
2061                   {
2062                     auto p
2063                       = &objfile->static_psymbols[psymtab->statics_offset];
2064
2065                     printf_filtered
2066                       ("(* (struct partial_symbol **) %s @ %d)\n",
2067                        host_address_to_string (p),
2068                        psymtab->n_static_syms);
2069                   }
2070                 else
2071                   printf_filtered ("(none)\n");
2072                 printf_filtered ("    dependencies ");
2073                 if (psymtab->number_of_dependencies)
2074                   {
2075                     int i;
2076
2077                     printf_filtered ("{\n");
2078                     for (i = 0; i < psymtab->number_of_dependencies; i++)
2079                       {
2080                         struct partial_symtab *dep = psymtab->dependencies[i];
2081
2082                         /* Note the string concatenation there --- no
2083                            comma.  */
2084                         printf_filtered ("      psymtab %s "
2085                                          "((struct partial_symtab *) %s)\n",
2086                                          dep->filename,
2087                                          host_address_to_string (dep));
2088                       }
2089                     printf_filtered ("    }\n");
2090                   }
2091                 else
2092                   printf_filtered ("(none)\n");
2093                 printf_filtered ("  }\n");
2094               }
2095           }
2096
2097         if (printed_objfile_start)
2098           printf_filtered ("}\n");
2099       }
2100 }
2101
2102 /* Check consistency of currently expanded psymtabs vs symtabs.  */
2103
2104 static void
2105 maintenance_check_psymtabs (const char *ignore, int from_tty)
2106 {
2107   struct symbol *sym;
2108   struct compunit_symtab *cust = NULL;
2109   const struct blockvector *bv;
2110   struct block *b;
2111   int length;
2112
2113   for (objfile *objfile : all_objfiles (current_program_space))
2114     for (partial_symtab *ps : require_partial_symbols (objfile, 1))
2115       {
2116         struct gdbarch *gdbarch = get_objfile_arch (objfile);
2117
2118         /* We don't call psymtab_to_symtab here because that may cause symtab
2119            expansion.  When debugging a problem it helps if checkers leave
2120            things unchanged.  */
2121         cust = ps->compunit_symtab;
2122
2123         /* First do some checks that don't require the associated symtab.  */
2124         if (ps->text_high (objfile) < ps->text_low (objfile))
2125           {
2126             printf_filtered ("Psymtab ");
2127             puts_filtered (ps->filename);
2128             printf_filtered (" covers bad range ");
2129             fputs_filtered (paddress (gdbarch, ps->text_low (objfile)),
2130                             gdb_stdout);
2131             printf_filtered (" - ");
2132             fputs_filtered (paddress (gdbarch, ps->text_high (objfile)),
2133                             gdb_stdout);
2134             printf_filtered ("\n");
2135             continue;
2136           }
2137
2138         /* Now do checks requiring the associated symtab.  */
2139         if (cust == NULL)
2140           continue;
2141         bv = COMPUNIT_BLOCKVECTOR (cust);
2142         b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
2143         partial_symbol **psym = &objfile->static_psymbols[ps->statics_offset];
2144         length = ps->n_static_syms;
2145         while (length--)
2146           {
2147             sym = block_lookup_symbol (b, symbol_search_name (*psym),
2148                                        symbol_name_match_type::SEARCH_NAME,
2149                                        (*psym)->domain);
2150             if (!sym)
2151               {
2152                 printf_filtered ("Static symbol `");
2153                 puts_filtered ((*psym)->name);
2154                 printf_filtered ("' only found in ");
2155                 puts_filtered (ps->filename);
2156                 printf_filtered (" psymtab\n");
2157               }
2158             psym++;
2159           }
2160         b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2161         psym = &objfile->global_psymbols[ps->globals_offset];
2162         length = ps->n_global_syms;
2163         while (length--)
2164           {
2165             sym = block_lookup_symbol (b, symbol_search_name (*psym),
2166                                        symbol_name_match_type::SEARCH_NAME,
2167                                        (*psym)->domain);
2168             if (!sym)
2169               {
2170                 printf_filtered ("Global symbol `");
2171                 puts_filtered ((*psym)->name);
2172                 printf_filtered ("' only found in ");
2173                 puts_filtered (ps->filename);
2174                 printf_filtered (" psymtab\n");
2175               }
2176             psym++;
2177           }
2178         if (ps->raw_text_high () != 0
2179             && (ps->text_low (objfile) < BLOCK_START (b)
2180                 || ps->text_high (objfile) > BLOCK_END (b)))
2181           {
2182             printf_filtered ("Psymtab ");
2183             puts_filtered (ps->filename);
2184             printf_filtered (" covers ");
2185             fputs_filtered (paddress (gdbarch, ps->text_low (objfile)),
2186                             gdb_stdout);
2187             printf_filtered (" - ");
2188             fputs_filtered (paddress (gdbarch, ps->text_high (objfile)),
2189                             gdb_stdout);
2190             printf_filtered (" but symtab covers only ");
2191             fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
2192             printf_filtered (" - ");
2193             fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
2194             printf_filtered ("\n");
2195           }
2196       }
2197 }
2198
2199 void
2200 _initialize_psymtab (void)
2201 {
2202   add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
2203 Print dump of current partial symbol definitions.\n\
2204 Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\
2205        mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
2206 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2207 or the terminal if OUTFILE is unspecified.\n\
2208 If ADDRESS is provided, dump only the file for that address.\n\
2209 If SOURCE is provided, dump only that file's symbols.\n\
2210 If OBJFILE is provided, dump only that file's minimal symbols."),
2211            &maintenanceprintlist);
2212
2213   add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
2214 List the partial symbol tables for all object files.\n\
2215 This does not include information about individual partial symbols,\n\
2216 just the symbol table structures themselves."),
2217            &maintenanceinfolist);
2218
2219   add_cmd ("check-psymtabs", class_maintenance, maintenance_check_psymtabs,
2220            _("\
2221 Check consistency of currently expanded psymtabs versus symtabs."),
2222            &maintenancelist);
2223 }