gdb/psymtab.c

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