gdb/psymtab.c

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