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);
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 /* Initialize storage for partial symbols.  */
1666
1667 void
1668 init_psymbol_list (struct objfile *objfile, int total_symbols)
1669 {
1670   /* Free any previously allocated psymbol lists.  */
1671   objfile->global_psymbols.clear ();
1672   objfile->static_psymbols.clear ();
1673
1674   /* Current best guess is that approximately a twentieth
1675      of the total symbols (in a debugging file) are global or static
1676      oriented symbols, then multiply that by slop factor of two.  */
1677   objfile->global_psymbols.reserve (total_symbols / 10);
1678   objfile->static_psymbols.reserve (total_symbols / 10);
1679 }
1680
1681 /* See psympriv.h.  */
1682
1683 struct partial_symtab *
1684 allocate_psymtab (const char *filename, struct objfile *objfile)
1685 {
1686   struct partial_symtab *psymtab;
1687
1688   if (objfile->free_psymtabs)
1689     {
1690       psymtab = objfile->free_psymtabs;
1691       objfile->free_psymtabs = psymtab->next;
1692     }
1693   else
1694     psymtab = XOBNEW (&objfile->objfile_obstack, partial_symtab);
1695
1696   memset (psymtab, 0, sizeof (struct partial_symtab));
1697   psymtab->filename
1698     = (const char *) bcache (filename, strlen (filename) + 1,
1699                              objfile->per_bfd->filename_cache);
1700   psymtab->compunit_symtab = NULL;
1701
1702   /* Prepend it to the psymtab list for the objfile it belongs to.
1703      Psymtabs are searched in most recent inserted -> least recent
1704      inserted order.  */
1705
1706   psymtab->next = objfile->psymtabs;
1707   objfile->psymtabs = psymtab;
1708
1709   if (symtab_create_debug)
1710     {
1711       /* Be a bit clever with debugging messages, and don't print objfile
1712          every time, only when it changes.  */
1713       static char *last_objfile_name = NULL;
1714
1715       if (last_objfile_name == NULL
1716           || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
1717         {
1718           xfree (last_objfile_name);
1719           last_objfile_name = xstrdup (objfile_name (objfile));
1720           fprintf_filtered (gdb_stdlog,
1721                             "Creating one or more psymtabs for objfile %s ...\n",
1722                             last_objfile_name);
1723         }
1724       fprintf_filtered (gdb_stdlog,
1725                         "Created psymtab %s for module %s.\n",
1726                         host_address_to_string (psymtab), filename);
1727     }
1728
1729   return psymtab;
1730 }
1731
1732 void
1733 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
1734 {
1735   struct partial_symtab **prev_pst;
1736
1737   /* From dbxread.c:
1738      Empty psymtabs happen as a result of header files which don't
1739      have any symbols in them.  There can be a lot of them.  But this
1740      check is wrong, in that a psymtab with N_SLINE entries but
1741      nothing else is not empty, but we don't realize that.  Fixing
1742      that without slowing things down might be tricky.  */
1743
1744   /* First, snip it out of the psymtab chain.  */
1745
1746   prev_pst = &(objfile->psymtabs);
1747   while ((*prev_pst) != pst)
1748     prev_pst = &((*prev_pst)->next);
1749   (*prev_pst) = pst->next;
1750
1751   /* Next, put it on a free list for recycling.  */
1752
1753   pst->next = objfile->free_psymtabs;
1754   objfile->free_psymtabs = pst;
1755 }
1756
1757 \f
1758
1759 /* We need to pass a couple of items to the addrmap_foreach function,
1760    so use a struct.  */
1761
1762 struct dump_psymtab_addrmap_data
1763 {
1764   struct objfile *objfile;
1765   struct partial_symtab *psymtab;
1766   struct ui_file *outfile;
1767
1768   /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1769      If so, we want to print the next one as well (since the next addrmap
1770      entry defines the end of the range).  */
1771   int previous_matched;
1772 };
1773
1774 /* Helper function for dump_psymtab_addrmap to print an addrmap entry.  */
1775
1776 static int
1777 dump_psymtab_addrmap_1 (void *datap, CORE_ADDR start_addr, void *obj)
1778 {
1779   struct dump_psymtab_addrmap_data *data
1780     = (struct dump_psymtab_addrmap_data *) datap;
1781   struct gdbarch *gdbarch = get_objfile_arch (data->objfile);
1782   struct partial_symtab *addrmap_psymtab = (struct partial_symtab *) obj;
1783   const char *psymtab_address_or_end = NULL;
1784
1785   QUIT;
1786
1787   if (data->psymtab == NULL
1788       || data->psymtab == addrmap_psymtab)
1789     psymtab_address_or_end = host_address_to_string (addrmap_psymtab);
1790   else if (data->previous_matched)
1791     psymtab_address_or_end = "<ends here>";
1792
1793   if (data->psymtab == NULL
1794       || data->psymtab == addrmap_psymtab
1795       || data->previous_matched)
1796     {
1797       fprintf_filtered (data->outfile, "  %s%s %s\n",
1798                         data->psymtab != NULL ? "  " : "",
1799                         paddress (gdbarch, start_addr),
1800                         psymtab_address_or_end);
1801     }
1802
1803   data->previous_matched = (data->psymtab == NULL
1804                             || data->psymtab == addrmap_psymtab);
1805
1806   return 0;
1807 }
1808
1809 /* Helper function for maintenance_print_psymbols to print the addrmap
1810    of PSYMTAB.  If PSYMTAB is NULL print the entire addrmap.  */
1811
1812 static void
1813 dump_psymtab_addrmap (struct objfile *objfile, struct partial_symtab *psymtab,
1814                       struct ui_file *outfile)
1815 {
1816   struct dump_psymtab_addrmap_data addrmap_dump_data;
1817
1818   if ((psymtab == NULL
1819        || psymtab->psymtabs_addrmap_supported)
1820       && objfile->psymtabs_addrmap != NULL)
1821     {
1822       addrmap_dump_data.objfile = objfile;
1823       addrmap_dump_data.psymtab = psymtab;
1824       addrmap_dump_data.outfile = outfile;
1825       addrmap_dump_data.previous_matched = 0;
1826       fprintf_filtered (outfile, "%sddress map:\n",
1827                         psymtab == NULL ? "Entire a" : "  A");
1828       addrmap_foreach (objfile->psymtabs_addrmap, dump_psymtab_addrmap_1,
1829                        &addrmap_dump_data);
1830     }
1831 }
1832
1833 static void
1834 maintenance_print_psymbols (const char *args, int from_tty)
1835 {
1836   struct ui_file *outfile = gdb_stdout;
1837   char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
1838   int i, outfile_idx, found;
1839   CORE_ADDR pc = 0;
1840   struct obj_section *section = NULL;
1841
1842   dont_repeat ();
1843
1844   gdb_argv argv (args);
1845
1846   for (i = 0; argv != NULL && argv[i] != NULL; ++i)
1847     {
1848       if (strcmp (argv[i], "-pc") == 0)
1849         {
1850           if (argv[i + 1] == NULL)
1851             error (_("Missing pc value"));
1852           address_arg = argv[++i];
1853         }
1854       else if (strcmp (argv[i], "-source") == 0)
1855         {
1856           if (argv[i + 1] == NULL)
1857             error (_("Missing source file"));
1858           source_arg = argv[++i];
1859         }
1860       else if (strcmp (argv[i], "-objfile") == 0)
1861         {
1862           if (argv[i + 1] == NULL)
1863             error (_("Missing objfile name"));
1864           objfile_arg = argv[++i];
1865         }
1866       else if (strcmp (argv[i], "--") == 0)
1867         {
1868           /* End of options.  */
1869           ++i;
1870           break;
1871         }
1872       else if (argv[i][0] == '-')
1873         {
1874           /* Future proofing: Don't allow OUTFILE to begin with "-".  */
1875           error (_("Unknown option: %s"), argv[i]);
1876         }
1877       else
1878         break;
1879     }
1880   outfile_idx = i;
1881
1882   if (address_arg != NULL && source_arg != NULL)
1883     error (_("Must specify at most one of -pc and -source"));
1884
1885   stdio_file arg_outfile;
1886
1887   if (argv != NULL && argv[outfile_idx] != NULL)
1888     {
1889       if (argv[outfile_idx + 1] != NULL)
1890         error (_("Junk at end of command"));
1891       gdb::unique_xmalloc_ptr<char> outfile_name
1892         (tilde_expand (argv[outfile_idx]));
1893       if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
1894         perror_with_name (outfile_name.get ());
1895       outfile = &arg_outfile;
1896     }
1897
1898   if (address_arg != NULL)
1899     {
1900       pc = parse_and_eval_address (address_arg);
1901       /* If we fail to find a section, that's ok, try the lookup anyway.  */
1902       section = find_pc_section (pc);
1903     }
1904
1905   found = 0;
1906   for (objfile *objfile : all_objfiles (current_program_space))
1907     {
1908       int printed_objfile_header = 0;
1909       int print_for_objfile = 1;
1910
1911       QUIT;
1912       if (objfile_arg != NULL)
1913         print_for_objfile
1914           = compare_filenames_for_search (objfile_name (objfile),
1915                                           objfile_arg);
1916       if (!print_for_objfile)
1917         continue;
1918
1919       if (address_arg != NULL)
1920         {
1921           struct bound_minimal_symbol msymbol = { NULL, NULL };
1922
1923           /* We don't assume each pc has a unique objfile (this is for
1924              debugging).  */
1925           struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc,
1926                                                             section, msymbol);
1927           if (ps != NULL)
1928             {
1929               if (!printed_objfile_header)
1930                 {
1931                   outfile->printf ("\nPartial symtabs for objfile %s\n",
1932                                   objfile_name (objfile));
1933                   printed_objfile_header = 1;
1934                 }
1935               dump_psymtab (objfile, ps, outfile);
1936               dump_psymtab_addrmap (objfile, ps, outfile);
1937               found = 1;
1938             }
1939         }
1940       else
1941         {
1942           for (partial_symtab *ps : require_partial_symbols (objfile, 1))
1943             {
1944               int print_for_source = 0;
1945
1946               QUIT;
1947               if (source_arg != NULL)
1948                 {
1949                   print_for_source
1950                     = compare_filenames_for_search (ps->filename, source_arg);
1951                   found = 1;
1952                 }
1953               if (source_arg == NULL
1954                   || print_for_source)
1955                 {
1956                   if (!printed_objfile_header)
1957                     {
1958                       outfile->printf ("\nPartial symtabs for objfile %s\n",
1959                                        objfile_name (objfile));
1960                       printed_objfile_header = 1;
1961                     }
1962                   dump_psymtab (objfile, ps, outfile);
1963                   dump_psymtab_addrmap (objfile, ps, outfile);
1964                 }
1965             }
1966         }
1967
1968       /* If we're printing all the objfile's symbols dump the full addrmap.  */
1969
1970       if (address_arg == NULL
1971           && source_arg == NULL
1972           && objfile->psymtabs_addrmap != NULL)
1973         {
1974           outfile->puts ("\n");
1975           dump_psymtab_addrmap (objfile, NULL, outfile);
1976         }
1977     }
1978
1979   if (!found)
1980     {
1981       if (address_arg != NULL)
1982         error (_("No partial symtab for address: %s"), address_arg);
1983       if (source_arg != NULL)
1984         error (_("No partial symtab for source file: %s"), source_arg);
1985     }
1986 }
1987
1988 /* List all the partial symbol tables whose names match REGEXP (optional).  */
1989
1990 static void
1991 maintenance_info_psymtabs (const char *regexp, int from_tty)
1992 {
1993   struct program_space *pspace;
1994
1995   if (regexp)
1996     re_comp (regexp);
1997
1998   ALL_PSPACES (pspace)
1999     for (objfile *objfile : all_objfiles (pspace))
2000       {
2001         struct gdbarch *gdbarch = get_objfile_arch (objfile);
2002
2003         /* We don't want to print anything for this objfile until we
2004            actually find a symtab whose name matches.  */
2005         int printed_objfile_start = 0;
2006
2007         for (partial_symtab *psymtab : require_partial_symbols (objfile, 1))
2008           {
2009             QUIT;
2010
2011             if (! regexp
2012                 || re_exec (psymtab->filename))
2013               {
2014                 if (! printed_objfile_start)
2015                   {
2016                     printf_filtered ("{ objfile %s ", objfile_name (objfile));
2017                     wrap_here ("  ");
2018                     printf_filtered ("((struct objfile *) %s)\n",
2019                                      host_address_to_string (objfile));
2020                     printed_objfile_start = 1;
2021                   }
2022
2023                 printf_filtered ("  { psymtab %s ", psymtab->filename);
2024                 wrap_here ("    ");
2025                 printf_filtered ("((struct partial_symtab *) %s)\n",
2026                                  host_address_to_string (psymtab));
2027
2028                 printf_filtered ("    readin %s\n",
2029                                  psymtab->readin ? "yes" : "no");
2030                 printf_filtered ("    fullname %s\n",
2031                                  psymtab->fullname
2032                                  ? psymtab->fullname : "(null)");
2033                 printf_filtered ("    text addresses ");
2034                 fputs_filtered (paddress (gdbarch,
2035                                           psymtab->text_low (objfile)),
2036                                 gdb_stdout);
2037                 printf_filtered (" -- ");
2038                 fputs_filtered (paddress (gdbarch,
2039                                           psymtab->text_high (objfile)),
2040                                 gdb_stdout);
2041                 printf_filtered ("\n");
2042                 printf_filtered ("    psymtabs_addrmap_supported %s\n",
2043                                  (psymtab->psymtabs_addrmap_supported
2044                                   ? "yes" : "no"));
2045                 printf_filtered ("    globals ");
2046                 if (psymtab->n_global_syms)
2047                   {
2048                     auto p
2049                       = &objfile->global_psymbols[psymtab->globals_offset];
2050
2051                     printf_filtered
2052                       ("(* (struct partial_symbol **) %s @ %d)\n",
2053                        host_address_to_string (p),
2054                        psymtab->n_global_syms);
2055                   }
2056                 else
2057                   printf_filtered ("(none)\n");
2058                 printf_filtered ("    statics ");
2059                 if (psymtab->n_static_syms)
2060                   {
2061                     auto p
2062                       = &objfile->static_psymbols[psymtab->statics_offset];
2063
2064                     printf_filtered
2065                       ("(* (struct partial_symbol **) %s @ %d)\n",
2066                        host_address_to_string (p),
2067                        psymtab->n_static_syms);
2068                   }
2069                 else
2070                   printf_filtered ("(none)\n");
2071                 printf_filtered ("    dependencies ");
2072                 if (psymtab->number_of_dependencies)
2073                   {
2074                     int i;
2075
2076                     printf_filtered ("{\n");
2077                     for (i = 0; i < psymtab->number_of_dependencies; i++)
2078                       {
2079                         struct partial_symtab *dep = psymtab->dependencies[i];
2080
2081                         /* Note the string concatenation there --- no
2082                            comma.  */
2083                         printf_filtered ("      psymtab %s "
2084                                          "((struct partial_symtab *) %s)\n",
2085                                          dep->filename,
2086                                          host_address_to_string (dep));
2087                       }
2088                     printf_filtered ("    }\n");
2089                   }
2090                 else
2091                   printf_filtered ("(none)\n");
2092                 printf_filtered ("  }\n");
2093               }
2094           }
2095
2096         if (printed_objfile_start)
2097           printf_filtered ("}\n");
2098       }
2099 }
2100
2101 /* Check consistency of currently expanded psymtabs vs symtabs.  */
2102
2103 static void
2104 maintenance_check_psymtabs (const char *ignore, int from_tty)
2105 {
2106   struct symbol *sym;
2107   struct compunit_symtab *cust = NULL;
2108   const struct blockvector *bv;
2109   struct block *b;
2110   int length;
2111
2112   for (objfile *objfile : all_objfiles (current_program_space))
2113     for (partial_symtab *ps : require_partial_symbols (objfile, 1))
2114       {
2115         struct gdbarch *gdbarch = get_objfile_arch (objfile);
2116
2117         /* We don't call psymtab_to_symtab here because that may cause symtab
2118            expansion.  When debugging a problem it helps if checkers leave
2119            things unchanged.  */
2120         cust = ps->compunit_symtab;
2121
2122         /* First do some checks that don't require the associated symtab.  */
2123         if (ps->text_high (objfile) < ps->text_low (objfile))
2124           {
2125             printf_filtered ("Psymtab ");
2126             puts_filtered (ps->filename);
2127             printf_filtered (" covers bad range ");
2128             fputs_filtered (paddress (gdbarch, ps->text_low (objfile)),
2129                             gdb_stdout);
2130             printf_filtered (" - ");
2131             fputs_filtered (paddress (gdbarch, ps->text_high (objfile)),
2132                             gdb_stdout);
2133             printf_filtered ("\n");
2134             continue;
2135           }
2136
2137         /* Now do checks requiring the associated symtab.  */
2138         if (cust == NULL)
2139           continue;
2140         bv = COMPUNIT_BLOCKVECTOR (cust);
2141         b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
2142         partial_symbol **psym = &objfile->static_psymbols[ps->statics_offset];
2143         length = ps->n_static_syms;
2144         while (length--)
2145           {
2146             sym = block_lookup_symbol (b, symbol_search_name (*psym),
2147                                        symbol_name_match_type::SEARCH_NAME,
2148                                        (*psym)->domain);
2149             if (!sym)
2150               {
2151                 printf_filtered ("Static symbol `");
2152                 puts_filtered ((*psym)->name);
2153                 printf_filtered ("' only found in ");
2154                 puts_filtered (ps->filename);
2155                 printf_filtered (" psymtab\n");
2156               }
2157             psym++;
2158           }
2159         b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2160         psym = &objfile->global_psymbols[ps->globals_offset];
2161         length = ps->n_global_syms;
2162         while (length--)
2163           {
2164             sym = block_lookup_symbol (b, symbol_search_name (*psym),
2165                                        symbol_name_match_type::SEARCH_NAME,
2166                                        (*psym)->domain);
2167             if (!sym)
2168               {
2169                 printf_filtered ("Global symbol `");
2170                 puts_filtered ((*psym)->name);
2171                 printf_filtered ("' only found in ");
2172                 puts_filtered (ps->filename);
2173                 printf_filtered (" psymtab\n");
2174               }
2175             psym++;
2176           }
2177         if (ps->raw_text_high () != 0
2178             && (ps->text_low (objfile) < BLOCK_START (b)
2179                 || ps->text_high (objfile) > BLOCK_END (b)))
2180           {
2181             printf_filtered ("Psymtab ");
2182             puts_filtered (ps->filename);
2183             printf_filtered (" covers ");
2184             fputs_filtered (paddress (gdbarch, ps->text_low (objfile)),
2185                             gdb_stdout);
2186             printf_filtered (" - ");
2187             fputs_filtered (paddress (gdbarch, ps->text_high (objfile)),
2188                             gdb_stdout);
2189             printf_filtered (" but symtab covers only ");
2190             fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
2191             printf_filtered (" - ");
2192             fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
2193             printf_filtered ("\n");
2194           }
2195       }
2196 }
2197
2198 void
2199 _initialize_psymtab (void)
2200 {
2201   add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
2202 Print dump of current partial symbol definitions.\n\
2203 Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\
2204        mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
2205 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2206 or the terminal if OUTFILE is unspecified.\n\
2207 If ADDRESS is provided, dump only the file for that address.\n\
2208 If SOURCE is provided, dump only that file's symbols.\n\
2209 If OBJFILE is provided, dump only that file's minimal symbols."),
2210            &maintenanceprintlist);
2211
2212   add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
2213 List the partial symbol tables for all object files.\n\
2214 This does not include information about individual partial symbols,\n\
2215 just the symbol table structures themselves."),
2216            &maintenanceinfolist);
2217
2218   add_cmd ("check-psymtabs", class_maintenance, maintenance_check_psymtabs,
2219            _("\
2220 Check consistency of currently expanded psymtabs versus symtabs."),
2221            &maintenancelist);
2222 }