gdb/psymtab.c

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