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       int fd = find_and_open_source (ps->filename, ps->dirname, &fullname);
1133       ps->fullname = fullname.release ();
1134
1135       if (fd >= 0)
1136         close (fd);
1137       else
1138         {
1139           /* rewrite_source_path would be applied by find_and_open_source, we
1140              should report the pathname where GDB tried to find the file.  */
1141
1142           if (ps->dirname == NULL || IS_ABSOLUTE_PATH (ps->filename))
1143             fullname.reset (xstrdup (ps->filename));
1144           else
1145             fullname.reset (concat (ps->dirname, SLASH_STRING,
1146                                     ps->filename, (char *) NULL));
1147
1148           ps->fullname = rewrite_source_path (fullname.get ()).release ();
1149           if (ps->fullname == NULL)
1150             ps->fullname = fullname.release ();
1151         }
1152     }
1153
1154   return ps->fullname;
1155 }
1156
1157 /* For all symbols, s, in BLOCK that are in DOMAIN and match NAME
1158    according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1159    BLOCK is assumed to come from OBJFILE.  Returns 1 iff CALLBACK
1160    ever returns non-zero, and otherwise returns 0.  */
1161
1162 static int
1163 map_block (const char *name, domain_enum domain, struct objfile *objfile,
1164            struct block *block,
1165            int (*callback) (struct block *, struct symbol *, void *),
1166            void *data, symbol_name_match_type match)
1167 {
1168   struct block_iterator iter;
1169   struct symbol *sym;
1170
1171   lookup_name_info lookup_name (name, match);
1172
1173   for (sym = block_iter_match_first (block, lookup_name, &iter);
1174        sym != NULL;
1175        sym = block_iter_match_next (lookup_name, &iter))
1176     {
1177       if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1178                                  SYMBOL_DOMAIN (sym), domain))
1179         {
1180           if (callback (block, sym, data))
1181             return 1;
1182         }
1183     }
1184
1185   return 0;
1186 }
1187
1188 /* Psymtab version of map_matching_symbols.  See its definition in
1189    the definition of quick_symbol_functions in symfile.h.  */
1190
1191 static void
1192 psym_map_matching_symbols (struct objfile *objfile,
1193                            const char *name, domain_enum domain,
1194                            int global,
1195                            int (*callback) (struct block *,
1196                                             struct symbol *, void *),
1197                            void *data,
1198                            symbol_name_match_type match,
1199                            symbol_compare_ftype *ordered_compare)
1200 {
1201   const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
1202   struct partial_symtab *ps;
1203
1204   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1205     {
1206       QUIT;
1207       if (ps->readin
1208           || match_partial_symbol (objfile, ps, global, name, domain, match,
1209                                    ordered_compare))
1210         {
1211           struct compunit_symtab *cust = psymtab_to_symtab (objfile, ps);
1212           struct block *block;
1213
1214           if (cust == NULL)
1215             continue;
1216           block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), block_kind);
1217           if (map_block (name, domain, objfile, block,
1218                          callback, data, match))
1219             return;
1220           if (callback (block, NULL, data))
1221             return;
1222         }
1223     }
1224 }
1225
1226 /* A helper for psym_expand_symtabs_matching that handles searching
1227    included psymtabs.  This returns true if a symbol is found, and
1228    false otherwise.  It also updates the 'searched_flag' on the
1229    various psymtabs that it searches.  */
1230
1231 static bool
1232 recursively_search_psymtabs
1233   (struct partial_symtab *ps,
1234    struct objfile *objfile,
1235    enum search_domain domain,
1236    const lookup_name_info &lookup_name,
1237    gdb::function_view<expand_symtabs_symbol_matcher_ftype> sym_matcher)
1238 {
1239   int keep_going = 1;
1240   enum psymtab_search_status result = PST_SEARCHED_AND_NOT_FOUND;
1241   int i;
1242
1243   if (ps->searched_flag != PST_NOT_SEARCHED)
1244     return ps->searched_flag == PST_SEARCHED_AND_FOUND;
1245
1246   /* Recurse into shared psymtabs first, because they may have already
1247      been searched, and this could save some time.  */
1248   for (i = 0; i < ps->number_of_dependencies; ++i)
1249     {
1250       int r;
1251
1252       /* Skip non-shared dependencies, these are handled elsewhere.  */
1253       if (ps->dependencies[i]->user == NULL)
1254         continue;
1255
1256       r = recursively_search_psymtabs (ps->dependencies[i],
1257                                        objfile, domain, lookup_name,
1258                                        sym_matcher);
1259       if (r != 0)
1260         {
1261           ps->searched_flag = PST_SEARCHED_AND_FOUND;
1262           return true;
1263         }
1264     }
1265
1266   partial_symbol **gbound
1267     = objfile->global_psymbols.data () + ps->globals_offset + ps->n_global_syms;
1268   partial_symbol **sbound
1269     = objfile->static_psymbols.data () + ps->statics_offset + ps->n_static_syms;
1270   partial_symbol **bound = gbound;
1271
1272   /* Go through all of the symbols stored in a partial
1273      symtab in one loop.  */
1274   partial_symbol **psym = objfile->global_psymbols.data () + ps->globals_offset;
1275   while (keep_going)
1276     {
1277       if (psym >= bound)
1278         {
1279           if (bound == gbound && ps->n_static_syms != 0)
1280             {
1281               psym = objfile->static_psymbols.data () + ps->statics_offset;
1282               bound = sbound;
1283             }
1284           else
1285             keep_going = 0;
1286           continue;
1287         }
1288       else
1289         {
1290           QUIT;
1291
1292           if ((domain == ALL_DOMAIN
1293                || (domain == VARIABLES_DOMAIN
1294                    && (*psym)->aclass != LOC_TYPEDEF
1295                    && (*psym)->aclass != LOC_BLOCK)
1296                || (domain == FUNCTIONS_DOMAIN
1297                    && (*psym)->aclass == LOC_BLOCK)
1298                || (domain == TYPES_DOMAIN
1299                    && (*psym)->aclass == LOC_TYPEDEF))
1300               && psymbol_name_matches (*psym, lookup_name)
1301               && (sym_matcher == NULL || sym_matcher (symbol_search_name (*psym))))
1302             {
1303               /* Found a match, so notify our caller.  */
1304               result = PST_SEARCHED_AND_FOUND;
1305               keep_going = 0;
1306             }
1307         }
1308       psym++;
1309     }
1310
1311   ps->searched_flag = result;
1312   return result == PST_SEARCHED_AND_FOUND;
1313 }
1314
1315 /* Psymtab version of expand_symtabs_matching.  See its definition in
1316    the definition of quick_symbol_functions in symfile.h.  */
1317
1318 static void
1319 psym_expand_symtabs_matching
1320   (struct objfile *objfile,
1321    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
1322    const lookup_name_info &lookup_name_in,
1323    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
1324    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
1325    enum search_domain domain)
1326 {
1327   struct partial_symtab *ps;
1328
1329   lookup_name_info lookup_name = lookup_name_in.make_ignore_params ();
1330
1331   /* Clear the search flags.  */
1332   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1333     {
1334       ps->searched_flag = PST_NOT_SEARCHED;
1335     }
1336
1337   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1338     {
1339       QUIT;
1340
1341       if (ps->readin)
1342         continue;
1343
1344       /* We skip shared psymtabs because file-matching doesn't apply
1345          to them; but we search them later in the loop.  */
1346       if (ps->user != NULL)
1347         continue;
1348
1349       if (file_matcher)
1350         {
1351           bool match;
1352
1353           if (ps->anonymous)
1354             continue;
1355
1356           match = file_matcher (ps->filename, false);
1357           if (!match)
1358             {
1359               /* Before we invoke realpath, which can get expensive when many
1360                  files are involved, do a quick comparison of the basenames.  */
1361               if (basenames_may_differ
1362                   || file_matcher (lbasename (ps->filename), true))
1363                 match = file_matcher (psymtab_to_fullname (ps), false);
1364             }
1365           if (!match)
1366             continue;
1367         }
1368
1369       if (recursively_search_psymtabs (ps, objfile, domain,
1370                                        lookup_name, symbol_matcher))
1371         {
1372           struct compunit_symtab *symtab =
1373             psymtab_to_symtab (objfile, ps);
1374
1375           if (expansion_notify != NULL)
1376             expansion_notify (symtab);
1377         }
1378     }
1379 }
1380
1381 /* Psymtab version of has_symbols.  See its definition in
1382    the definition of quick_symbol_functions in symfile.h.  */
1383
1384 static int
1385 psym_has_symbols (struct objfile *objfile)
1386 {
1387   return objfile->psymtabs != NULL;
1388 }
1389
1390 /* Helper function for psym_find_compunit_symtab_by_address that fills
1391    in psymbol_map for a given range of psymbols.  */
1392
1393 static void
1394 psym_fill_psymbol_map (struct objfile *objfile,
1395                        struct partial_symtab *psymtab,
1396                        std::set<CORE_ADDR> *seen_addrs,
1397                        const std::vector<partial_symbol *> &symbols,
1398                        int start,
1399                        int length)
1400 {
1401   for (int i = 0; i < length; ++i)
1402     {
1403       struct partial_symbol *psym = symbols[start + i];
1404
1405       if (psym->aclass == LOC_STATIC)
1406         {
1407           CORE_ADDR addr = psym->address (objfile);
1408           if (seen_addrs->find (addr) == seen_addrs->end ())
1409             {
1410               seen_addrs->insert (addr);
1411               objfile->psymbol_map.emplace_back (addr, psymtab);
1412             }
1413         }
1414     }
1415 }
1416
1417 /* See find_compunit_symtab_by_address in quick_symbol_functions, in
1418    symfile.h.  */
1419
1420 static compunit_symtab *
1421 psym_find_compunit_symtab_by_address (struct objfile *objfile,
1422                                       CORE_ADDR address)
1423 {
1424   if (objfile->psymbol_map.empty ())
1425     {
1426       struct partial_symtab *pst;
1427
1428       std::set<CORE_ADDR> seen_addrs;
1429
1430       ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
1431       {
1432         psym_fill_psymbol_map (objfile, pst,
1433                                &seen_addrs,
1434                                objfile->global_psymbols,
1435                                pst->globals_offset,
1436                                pst->n_global_syms);
1437         psym_fill_psymbol_map (objfile, pst,
1438                                &seen_addrs,
1439                                objfile->static_psymbols,
1440                                pst->statics_offset,
1441                                pst->n_static_syms);
1442       }
1443
1444       objfile->psymbol_map.shrink_to_fit ();
1445
1446       std::sort (objfile->psymbol_map.begin (), objfile->psymbol_map.end (),
1447                  [] (const std::pair<CORE_ADDR, partial_symtab *> &a,
1448                      const std::pair<CORE_ADDR, partial_symtab *> &b)
1449                  {
1450                    return a.first < b.first;
1451                  });
1452     }
1453
1454   auto iter = std::lower_bound
1455     (objfile->psymbol_map.begin (), objfile->psymbol_map.end (), address,
1456      [] (const std::pair<CORE_ADDR, partial_symtab *> &a,
1457          CORE_ADDR b)
1458      {
1459        return a.first < b;
1460      });
1461
1462   if (iter == objfile->psymbol_map.end () || iter->first != address)
1463     return NULL;
1464
1465   return psymtab_to_symtab (objfile, iter->second);
1466 }
1467
1468 const struct quick_symbol_functions psym_functions =
1469 {
1470   psym_has_symbols,
1471   psym_find_last_source_symtab,
1472   psym_forget_cached_source_info,
1473   psym_map_symtabs_matching_filename,
1474   psym_lookup_symbol,
1475   psym_print_stats,
1476   psym_dump,
1477   psym_expand_symtabs_for_function,
1478   psym_expand_all_symtabs,
1479   psym_expand_symtabs_with_fullname,
1480   psym_map_matching_symbols,
1481   psym_expand_symtabs_matching,
1482   psym_find_pc_sect_compunit_symtab,
1483   psym_find_compunit_symtab_by_address,
1484   psym_map_symbol_filenames
1485 };
1486
1487 \f
1488
1489 static void
1490 sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
1491 {
1492   /* Sort the global list; don't sort the static list.  */
1493   auto begin = objfile->global_psymbols.begin ();
1494   std::advance (begin, pst->globals_offset);
1495
1496   /* The psymbols for this partial_symtab are currently at the end of the
1497      vector.  */
1498   auto end = objfile->global_psymbols.end ();
1499
1500   std::sort (begin, end, [] (partial_symbol *s1, partial_symbol *s2)
1501     {
1502       return strcmp_iw_ordered (symbol_search_name (s1),
1503                                 symbol_search_name (s2)) < 0;
1504     });
1505 }
1506
1507 /* Allocate and partially fill a partial symtab.  It will be
1508    completely filled at the end of the symbol list.
1509
1510    FILENAME is the name of the symbol-file we are reading from.  */
1511
1512 struct partial_symtab *
1513 start_psymtab_common (struct objfile *objfile,
1514                       const char *filename,
1515                       CORE_ADDR textlow,
1516                       std::vector<partial_symbol *> &global_psymbols,
1517                       std::vector<partial_symbol *> &static_psymbols)
1518 {
1519   struct partial_symtab *psymtab;
1520
1521   psymtab = allocate_psymtab (filename, objfile);
1522   psymtab->set_text_low (textlow);
1523   psymtab->set_text_high (psymtab->raw_text_low ()); /* default */
1524   psymtab->globals_offset = global_psymbols.size ();
1525   psymtab->statics_offset = static_psymbols.size ();
1526   return psymtab;
1527 }
1528
1529 /* Perform "finishing up" operations of a partial symtab.  */
1530
1531 void
1532 end_psymtab_common (struct objfile *objfile, struct partial_symtab *pst)
1533 {
1534   pst->n_global_syms = objfile->global_psymbols.size () - pst->globals_offset;
1535   pst->n_static_syms = objfile->static_psymbols.size () - pst->statics_offset;
1536
1537   sort_pst_symbols (objfile, pst);
1538 }
1539
1540 /* Calculate a hash code for the given partial symbol.  The hash is
1541    calculated using the symbol's value, language, domain, class
1542    and name.  These are the values which are set by
1543    add_psymbol_to_bcache.  */
1544
1545 static unsigned long
1546 psymbol_hash (const void *addr, int length)
1547 {
1548   unsigned long h = 0;
1549   struct partial_symbol *psymbol = (struct partial_symbol *) addr;
1550   unsigned int lang = psymbol->language;
1551   unsigned int domain = psymbol->domain;
1552   unsigned int theclass = psymbol->aclass;
1553
1554   h = hash_continue (&psymbol->value, sizeof (psymbol->value), h);
1555   h = hash_continue (&lang, sizeof (unsigned int), h);
1556   h = hash_continue (&domain, sizeof (unsigned int), h);
1557   h = hash_continue (&theclass, sizeof (unsigned int), h);
1558   /* Note that psymbol names are interned via symbol_set_names, so
1559      there's no need to hash the contents of the name here.  */
1560   h = hash_continue (&psymbol->name,
1561                      sizeof (psymbol->name), h);
1562
1563   return h;
1564 }
1565
1566 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1567    For the comparison this function uses a symbols value,
1568    language, domain, class and name.  */
1569
1570 static int
1571 psymbol_compare (const void *addr1, const void *addr2, int length)
1572 {
1573   struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1574   struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
1575
1576   return (memcmp (&sym1->value, &sym2->value,
1577                   sizeof (sym1->value)) == 0
1578           && sym1->language == sym2->language
1579           && sym1->domain == sym2->domain
1580           && sym1->aclass == sym2->aclass
1581           /* Note that psymbol names are interned via
1582              symbol_set_names, so there's no need to compare the
1583              contents of the name here.  */
1584           && sym1->name == sym2->name);
1585 }
1586
1587 /* Initialize a partial symbol bcache.  */
1588
1589 struct psymbol_bcache *
1590 psymbol_bcache_init (void)
1591 {
1592   struct psymbol_bcache *bcache = XCNEW (struct psymbol_bcache);
1593
1594   bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
1595   return bcache;
1596 }
1597
1598 /* Free a partial symbol bcache.  */
1599
1600 void
1601 psymbol_bcache_free (struct psymbol_bcache *bcache)
1602 {
1603   if (bcache == NULL)
1604     return;
1605
1606   bcache_xfree (bcache->bcache);
1607   xfree (bcache);
1608 }
1609
1610 /* Return the internal bcache of the psymbol_bcache BCACHE.  */
1611
1612 struct bcache *
1613 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
1614 {
1615   return bcache->bcache;
1616 }
1617
1618 /* Find a copy of the SYM in BCACHE.  If BCACHE has never seen this
1619    symbol before, add a copy to BCACHE.  In either case, return a pointer
1620    to BCACHE's copy of the symbol.  If optional ADDED is not NULL, return
1621    1 in case of new entry or 0 if returning an old entry.  */
1622
1623 static struct partial_symbol *
1624 psymbol_bcache_full (struct partial_symbol *sym,
1625                      struct psymbol_bcache *bcache,
1626                      int *added)
1627 {
1628   return ((struct partial_symbol *)
1629           bcache_full (sym, sizeof (struct partial_symbol), bcache->bcache,
1630                        added));
1631 }
1632
1633 /* Helper function, initialises partial symbol structure and stashes
1634    it into objfile's bcache.  Note that our caching mechanism will
1635    use all fields of struct partial_symbol to determine hash value of the
1636    structure.  In other words, having two symbols with the same name but
1637    different domain (or address) is possible and correct.  */
1638
1639 static struct partial_symbol *
1640 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
1641                        domain_enum domain,
1642                        enum address_class theclass,
1643                        short section,
1644                        CORE_ADDR coreaddr,
1645                        enum language language, struct objfile *objfile,
1646                        int *added)
1647 {
1648   struct partial_symbol psymbol;
1649
1650   psymbol.set_unrelocated_address (coreaddr);
1651   psymbol.section = section;
1652   psymbol.domain = domain;
1653   psymbol.aclass = theclass;
1654
1655   memset (&psymbol.language_specific, 0, sizeof (psymbol.language_specific));
1656   psymbol.ada_mangled = 0;
1657   symbol_set_language (&psymbol, language, &objfile->objfile_obstack);
1658   symbol_set_names (&psymbol, name, namelength, copy_name, objfile);
1659
1660   /* Stash the partial symbol away in the cache.  */
1661   return psymbol_bcache_full (&psymbol, objfile->psymbol_cache, added);
1662 }
1663
1664 /* Helper function, adds partial symbol to the given partial symbol list.  */
1665
1666 static void
1667 append_psymbol_to_list (std::vector<partial_symbol *> *list,
1668                         struct partial_symbol *psym,
1669                         struct objfile *objfile)
1670 {
1671   list->push_back (psym);
1672   OBJSTAT (objfile, n_psyms++);
1673 }
1674
1675 /* Add a symbol with a long value to a psymtab.
1676    Since one arg is a struct, we pass in a ptr and deref it (sigh).
1677    The only value we need to store for psyms is an address.
1678    For all other psyms pass zero for COREADDR.
1679    Return the partial symbol that has been added.  */
1680
1681 void
1682 add_psymbol_to_list (const char *name, int namelength, int copy_name,
1683                      domain_enum domain,
1684                      enum address_class theclass,
1685                      short section,
1686                      std::vector<partial_symbol *> *list,
1687                      CORE_ADDR coreaddr,
1688                      enum language language, struct objfile *objfile)
1689 {
1690   struct partial_symbol *psym;
1691
1692   int added;
1693
1694   /* Stash the partial symbol away in the cache.  */
1695   psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, theclass,
1696                                 section, coreaddr, language, objfile, &added);
1697
1698   /* Do not duplicate global partial symbols.  */
1699   if (list == &objfile->global_psymbols
1700       && !added)
1701     return;
1702
1703   /* Save pointer to partial symbol in psymtab, growing symtab if needed.  */
1704   append_psymbol_to_list (list, psym, objfile);
1705 }
1706
1707 /* Initialize storage for partial symbols.  */
1708
1709 void
1710 init_psymbol_list (struct objfile *objfile, int total_symbols)
1711 {
1712   /* Free any previously allocated psymbol lists.  */
1713   objfile->global_psymbols.clear ();
1714   objfile->static_psymbols.clear ();
1715
1716   /* Current best guess is that approximately a twentieth
1717      of the total symbols (in a debugging file) are global or static
1718      oriented symbols, then multiply that by slop factor of two.  */
1719   objfile->global_psymbols.reserve (total_symbols / 10);
1720   objfile->static_psymbols.reserve (total_symbols / 10);
1721 }
1722
1723 struct partial_symtab *
1724 allocate_psymtab (const char *filename, struct objfile *objfile)
1725 {
1726   struct partial_symtab *psymtab;
1727
1728   if (objfile->free_psymtabs)
1729     {
1730       psymtab = objfile->free_psymtabs;
1731       objfile->free_psymtabs = psymtab->next;
1732     }
1733   else
1734     psymtab = XOBNEW (&objfile->objfile_obstack, partial_symtab);
1735
1736   memset (psymtab, 0, sizeof (struct partial_symtab));
1737   psymtab->filename
1738     = (const char *) bcache (filename, strlen (filename) + 1,
1739                              objfile->per_bfd->filename_cache);
1740   psymtab->compunit_symtab = NULL;
1741
1742   /* Prepend it to the psymtab list for the objfile it belongs to.
1743      Psymtabs are searched in most recent inserted -> least recent
1744      inserted order.  */
1745
1746   psymtab->next = objfile->psymtabs;
1747   objfile->psymtabs = psymtab;
1748
1749   if (symtab_create_debug)
1750     {
1751       /* Be a bit clever with debugging messages, and don't print objfile
1752          every time, only when it changes.  */
1753       static char *last_objfile_name = NULL;
1754
1755       if (last_objfile_name == NULL
1756           || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
1757         {
1758           xfree (last_objfile_name);
1759           last_objfile_name = xstrdup (objfile_name (objfile));
1760           fprintf_filtered (gdb_stdlog,
1761                             "Creating one or more psymtabs for objfile %s ...\n",
1762                             last_objfile_name);
1763         }
1764       fprintf_filtered (gdb_stdlog,
1765                         "Created psymtab %s for module %s.\n",
1766                         host_address_to_string (psymtab), filename);
1767     }
1768
1769   return psymtab;
1770 }
1771
1772 void
1773 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
1774 {
1775   struct partial_symtab **prev_pst;
1776
1777   /* From dbxread.c:
1778      Empty psymtabs happen as a result of header files which don't
1779      have any symbols in them.  There can be a lot of them.  But this
1780      check is wrong, in that a psymtab with N_SLINE entries but
1781      nothing else is not empty, but we don't realize that.  Fixing
1782      that without slowing things down might be tricky.  */
1783
1784   /* First, snip it out of the psymtab chain.  */
1785
1786   prev_pst = &(objfile->psymtabs);
1787   while ((*prev_pst) != pst)
1788     prev_pst = &((*prev_pst)->next);
1789   (*prev_pst) = pst->next;
1790
1791   /* Next, put it on a free list for recycling.  */
1792
1793   pst->next = objfile->free_psymtabs;
1794   objfile->free_psymtabs = pst;
1795 }
1796
1797 \f
1798
1799 /* We need to pass a couple of items to the addrmap_foreach function,
1800    so use a struct.  */
1801
1802 struct dump_psymtab_addrmap_data
1803 {
1804   struct objfile *objfile;
1805   struct partial_symtab *psymtab;
1806   struct ui_file *outfile;
1807
1808   /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1809      If so, we want to print the next one as well (since the next addrmap
1810      entry defines the end of the range).  */
1811   int previous_matched;
1812 };
1813
1814 /* Helper function for dump_psymtab_addrmap to print an addrmap entry.  */
1815
1816 static int
1817 dump_psymtab_addrmap_1 (void *datap, CORE_ADDR start_addr, void *obj)
1818 {
1819   struct dump_psymtab_addrmap_data *data
1820     = (struct dump_psymtab_addrmap_data *) datap;
1821   struct gdbarch *gdbarch = get_objfile_arch (data->objfile);
1822   struct partial_symtab *addrmap_psymtab = (struct partial_symtab *) obj;
1823   const char *psymtab_address_or_end = NULL;
1824
1825   QUIT;
1826
1827   if (data->psymtab == NULL
1828       || data->psymtab == addrmap_psymtab)
1829     psymtab_address_or_end = host_address_to_string (addrmap_psymtab);
1830   else if (data->previous_matched)
1831     psymtab_address_or_end = "<ends here>";
1832
1833   if (data->psymtab == NULL
1834       || data->psymtab == addrmap_psymtab
1835       || data->previous_matched)
1836     {
1837       fprintf_filtered (data->outfile, "  %s%s %s\n",
1838                         data->psymtab != NULL ? "  " : "",
1839                         paddress (gdbarch, start_addr),
1840                         psymtab_address_or_end);
1841     }
1842
1843   data->previous_matched = (data->psymtab == NULL
1844                             || data->psymtab == addrmap_psymtab);
1845
1846   return 0;
1847 }
1848
1849 /* Helper function for maintenance_print_psymbols to print the addrmap
1850    of PSYMTAB.  If PSYMTAB is NULL print the entire addrmap.  */
1851
1852 static void
1853 dump_psymtab_addrmap (struct objfile *objfile, struct partial_symtab *psymtab,
1854                       struct ui_file *outfile)
1855 {
1856   struct dump_psymtab_addrmap_data addrmap_dump_data;
1857
1858   if ((psymtab == NULL
1859        || psymtab->psymtabs_addrmap_supported)
1860       && objfile->psymtabs_addrmap != NULL)
1861     {
1862       addrmap_dump_data.objfile = objfile;
1863       addrmap_dump_data.psymtab = psymtab;
1864       addrmap_dump_data.outfile = outfile;
1865       addrmap_dump_data.previous_matched = 0;
1866       fprintf_filtered (outfile, "%sddress map:\n",
1867                         psymtab == NULL ? "Entire a" : "  A");
1868       addrmap_foreach (objfile->psymtabs_addrmap, dump_psymtab_addrmap_1,
1869                        &addrmap_dump_data);
1870     }
1871 }
1872
1873 static void
1874 maintenance_print_psymbols (const char *args, int from_tty)
1875 {
1876   struct ui_file *outfile = gdb_stdout;
1877   char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
1878   struct objfile *objfile;
1879   struct partial_symtab *ps;
1880   int i, outfile_idx, found;
1881   CORE_ADDR pc = 0;
1882   struct obj_section *section = NULL;
1883
1884   dont_repeat ();
1885
1886   gdb_argv argv (args);
1887
1888   for (i = 0; argv != NULL && argv[i] != NULL; ++i)
1889     {
1890       if (strcmp (argv[i], "-pc") == 0)
1891         {
1892           if (argv[i + 1] == NULL)
1893             error (_("Missing pc value"));
1894           address_arg = argv[++i];
1895         }
1896       else if (strcmp (argv[i], "-source") == 0)
1897         {
1898           if (argv[i + 1] == NULL)
1899             error (_("Missing source file"));
1900           source_arg = argv[++i];
1901         }
1902       else if (strcmp (argv[i], "-objfile") == 0)
1903         {
1904           if (argv[i + 1] == NULL)
1905             error (_("Missing objfile name"));
1906           objfile_arg = argv[++i];
1907         }
1908       else if (strcmp (argv[i], "--") == 0)
1909         {
1910           /* End of options.  */
1911           ++i;
1912           break;
1913         }
1914       else if (argv[i][0] == '-')
1915         {
1916           /* Future proofing: Don't allow OUTFILE to begin with "-".  */
1917           error (_("Unknown option: %s"), argv[i]);
1918         }
1919       else
1920         break;
1921     }
1922   outfile_idx = i;
1923
1924   if (address_arg != NULL && source_arg != NULL)
1925     error (_("Must specify at most one of -pc and -source"));
1926
1927   stdio_file arg_outfile;
1928
1929   if (argv != NULL && argv[outfile_idx] != NULL)
1930     {
1931       if (argv[outfile_idx + 1] != NULL)
1932         error (_("Junk at end of command"));
1933       gdb::unique_xmalloc_ptr<char> outfile_name
1934         (tilde_expand (argv[outfile_idx]));
1935       if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
1936         perror_with_name (outfile_name.get ());
1937       outfile = &arg_outfile;
1938     }
1939
1940   if (address_arg != NULL)
1941     {
1942       pc = parse_and_eval_address (address_arg);
1943       /* If we fail to find a section, that's ok, try the lookup anyway.  */
1944       section = find_pc_section (pc);
1945     }
1946
1947   found = 0;
1948   ALL_OBJFILES (objfile)
1949     {
1950       int printed_objfile_header = 0;
1951       int print_for_objfile = 1;
1952
1953       QUIT;
1954       if (objfile_arg != NULL)
1955         print_for_objfile
1956           = compare_filenames_for_search (objfile_name (objfile),
1957                                           objfile_arg);
1958       if (!print_for_objfile)
1959         continue;
1960
1961       if (address_arg != NULL)
1962         {
1963           struct bound_minimal_symbol msymbol = { NULL, NULL };
1964
1965           /* We don't assume each pc has a unique objfile (this is for
1966              debugging).  */
1967           ps = find_pc_sect_psymtab (objfile, pc, section, msymbol);
1968           if (ps != NULL)
1969             {
1970               if (!printed_objfile_header)
1971                 {
1972                   outfile->printf ("\nPartial symtabs for objfile %s\n",
1973                                   objfile_name (objfile));
1974                   printed_objfile_header = 1;
1975                 }
1976               dump_psymtab (objfile, ps, outfile);
1977               dump_psymtab_addrmap (objfile, ps, outfile);
1978               found = 1;
1979             }
1980         }
1981       else
1982         {
1983           ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1984             {
1985               int print_for_source = 0;
1986
1987               QUIT;
1988               if (source_arg != NULL)
1989                 {
1990                   print_for_source
1991                     = compare_filenames_for_search (ps->filename, source_arg);
1992                   found = 1;
1993                 }
1994               if (source_arg == NULL
1995                   || print_for_source)
1996                 {
1997                   if (!printed_objfile_header)
1998                     {
1999                       outfile->printf ("\nPartial symtabs for objfile %s\n",
2000                                        objfile_name (objfile));
2001                       printed_objfile_header = 1;
2002                     }
2003                   dump_psymtab (objfile, ps, outfile);
2004                   dump_psymtab_addrmap (objfile, ps, outfile);
2005                 }
2006             }
2007         }
2008
2009       /* If we're printing all the objfile's symbols dump the full addrmap.  */
2010
2011       if (address_arg == NULL
2012           && source_arg == NULL
2013           && objfile->psymtabs_addrmap != NULL)
2014         {
2015           outfile->puts ("\n");
2016           dump_psymtab_addrmap (objfile, NULL, outfile);
2017         }
2018     }
2019
2020   if (!found)
2021     {
2022       if (address_arg != NULL)
2023         error (_("No partial symtab for address: %s"), address_arg);
2024       if (source_arg != NULL)
2025         error (_("No partial symtab for source file: %s"), source_arg);
2026     }
2027 }
2028
2029 /* List all the partial symbol tables whose names match REGEXP (optional).  */
2030
2031 static void
2032 maintenance_info_psymtabs (const char *regexp, int from_tty)
2033 {
2034   struct program_space *pspace;
2035   struct objfile *objfile;
2036
2037   if (regexp)
2038     re_comp (regexp);
2039
2040   ALL_PSPACES (pspace)
2041     ALL_PSPACE_OBJFILES (pspace, objfile)
2042     {
2043       struct gdbarch *gdbarch = get_objfile_arch (objfile);
2044       struct partial_symtab *psymtab;
2045
2046       /* We don't want to print anything for this objfile until we
2047          actually find a symtab whose name matches.  */
2048       int printed_objfile_start = 0;
2049
2050       ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
2051         {
2052           QUIT;
2053
2054           if (! regexp
2055               || re_exec (psymtab->filename))
2056             {
2057               if (! printed_objfile_start)
2058                 {
2059                   printf_filtered ("{ objfile %s ", objfile_name (objfile));
2060                   wrap_here ("  ");
2061                   printf_filtered ("((struct objfile *) %s)\n",
2062                                    host_address_to_string (objfile));
2063                   printed_objfile_start = 1;
2064                 }
2065
2066               printf_filtered ("  { psymtab %s ", psymtab->filename);
2067               wrap_here ("    ");
2068               printf_filtered ("((struct partial_symtab *) %s)\n",
2069                                host_address_to_string (psymtab));
2070
2071               printf_filtered ("    readin %s\n",
2072                                psymtab->readin ? "yes" : "no");
2073               printf_filtered ("    fullname %s\n",
2074                                psymtab->fullname
2075                                ? psymtab->fullname : "(null)");
2076               printf_filtered ("    text addresses ");
2077               fputs_filtered (paddress (gdbarch, psymtab->text_low (objfile)),
2078                               gdb_stdout);
2079               printf_filtered (" -- ");
2080               fputs_filtered (paddress (gdbarch, psymtab->text_high (objfile)),
2081                               gdb_stdout);
2082               printf_filtered ("\n");
2083               printf_filtered ("    psymtabs_addrmap_supported %s\n",
2084                                (psymtab->psymtabs_addrmap_supported
2085                                 ? "yes" : "no"));
2086               printf_filtered ("    globals ");
2087               if (psymtab->n_global_syms)
2088                 {
2089                   auto p = &objfile->global_psymbols[psymtab->globals_offset];
2090
2091                   printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2092                                    host_address_to_string (p),
2093                                    psymtab->n_global_syms);
2094                 }
2095               else
2096                 printf_filtered ("(none)\n");
2097               printf_filtered ("    statics ");
2098               if (psymtab->n_static_syms)
2099                 {
2100                   auto p = &objfile->static_psymbols[psymtab->statics_offset];
2101
2102                   printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2103                                    host_address_to_string (p),
2104                                    psymtab->n_static_syms);
2105                 }
2106               else
2107                 printf_filtered ("(none)\n");
2108               printf_filtered ("    dependencies ");
2109               if (psymtab->number_of_dependencies)
2110                 {
2111                   int i;
2112
2113                   printf_filtered ("{\n");
2114                   for (i = 0; i < psymtab->number_of_dependencies; i++)
2115                     {
2116                       struct partial_symtab *dep = psymtab->dependencies[i];
2117
2118                       /* Note the string concatenation there --- no comma.  */
2119                       printf_filtered ("      psymtab %s "
2120                                        "((struct partial_symtab *) %s)\n",
2121                                        dep->filename,
2122                                        host_address_to_string (dep));
2123                     }
2124                   printf_filtered ("    }\n");
2125                 }
2126               else
2127                 printf_filtered ("(none)\n");
2128               printf_filtered ("  }\n");
2129             }
2130         }
2131
2132       if (printed_objfile_start)
2133         printf_filtered ("}\n");
2134     }
2135 }
2136
2137 /* Check consistency of currently expanded psymtabs vs symtabs.  */
2138
2139 static void
2140 maintenance_check_psymtabs (const char *ignore, int from_tty)
2141 {
2142   struct symbol *sym;
2143   struct compunit_symtab *cust = NULL;
2144   struct partial_symtab *ps;
2145   const struct blockvector *bv;
2146   struct objfile *objfile;
2147   struct block *b;
2148   int length;
2149
2150   ALL_PSYMTABS (objfile, ps)
2151   {
2152     struct gdbarch *gdbarch = get_objfile_arch (objfile);
2153
2154     /* We don't call psymtab_to_symtab here because that may cause symtab
2155        expansion.  When debugging a problem it helps if checkers leave
2156        things unchanged.  */
2157     cust = ps->compunit_symtab;
2158
2159     /* First do some checks that don't require the associated symtab.  */
2160     if (ps->text_high (objfile) < ps->text_low (objfile))
2161       {
2162         printf_filtered ("Psymtab ");
2163         puts_filtered (ps->filename);
2164         printf_filtered (" covers bad range ");
2165         fputs_filtered (paddress (gdbarch, ps->text_low (objfile)),
2166                         gdb_stdout);
2167         printf_filtered (" - ");
2168         fputs_filtered (paddress (gdbarch, ps->text_high (objfile)),
2169                         gdb_stdout);
2170         printf_filtered ("\n");
2171         continue;
2172       }
2173
2174     /* Now do checks requiring the associated symtab.  */
2175     if (cust == NULL)
2176       continue;
2177     bv = COMPUNIT_BLOCKVECTOR (cust);
2178     b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
2179     partial_symbol **psym = &objfile->static_psymbols[ps->statics_offset];
2180     length = ps->n_static_syms;
2181     while (length--)
2182       {
2183         sym = block_lookup_symbol (b, symbol_search_name (*psym),
2184                                    symbol_name_match_type::SEARCH_NAME,
2185                                    (*psym)->domain);
2186         if (!sym)
2187           {
2188             printf_filtered ("Static symbol `");
2189             puts_filtered ((*psym)->name);
2190             printf_filtered ("' only found in ");
2191             puts_filtered (ps->filename);
2192             printf_filtered (" psymtab\n");
2193           }
2194         psym++;
2195       }
2196     b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2197     psym = &objfile->global_psymbols[ps->globals_offset];
2198     length = ps->n_global_syms;
2199     while (length--)
2200       {
2201         sym = block_lookup_symbol (b, symbol_search_name (*psym),
2202                                    symbol_name_match_type::SEARCH_NAME,
2203                                    (*psym)->domain);
2204         if (!sym)
2205           {
2206             printf_filtered ("Global symbol `");
2207             puts_filtered ((*psym)->name);
2208             printf_filtered ("' only found in ");
2209             puts_filtered (ps->filename);
2210             printf_filtered (" psymtab\n");
2211           }
2212         psym++;
2213       }
2214     if (ps->raw_text_high () != 0
2215         && (ps->text_low (objfile) < BLOCK_START (b)
2216             || ps->text_high (objfile) > BLOCK_END (b)))
2217       {
2218         printf_filtered ("Psymtab ");
2219         puts_filtered (ps->filename);
2220         printf_filtered (" covers ");
2221         fputs_filtered (paddress (gdbarch, ps->text_low (objfile)),
2222                         gdb_stdout);
2223         printf_filtered (" - ");
2224         fputs_filtered (paddress (gdbarch, ps->text_high (objfile)),
2225                         gdb_stdout);
2226         printf_filtered (" but symtab covers only ");
2227         fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
2228         printf_filtered (" - ");
2229         fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
2230         printf_filtered ("\n");
2231       }
2232   }
2233 }
2234
2235 void
2236 _initialize_psymtab (void)
2237 {
2238   add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
2239 Print dump of current partial symbol definitions.\n\
2240 Usage: mt print psymbols [-objfile objfile] [-pc address] [--] [outfile]\n\
2241        mt print psymbols [-objfile objfile] [-source source] [--] [outfile]\n\
2242 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2243 or the terminal if OUTFILE is unspecified.\n\
2244 If ADDRESS is provided, dump only the file for that address.\n\
2245 If SOURCE is provided, dump only that file's symbols.\n\
2246 If OBJFILE is provided, dump only that file's minimal symbols."),
2247            &maintenanceprintlist);
2248
2249   add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
2250 List the partial symbol tables for all object files.\n\
2251 This does not include information about individual partial symbols,\n\
2252 just the symbol table structures themselves."),
2253            &maintenanceinfolist);
2254
2255   add_cmd ("check-psymtabs", class_maintenance, maintenance_check_psymtabs,
2256            _("\
2257 Check consistency of currently expanded psymtabs versus symtabs."),
2258            &maintenancelist);
2259 }