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_in,
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   lookup_name_info lookup_name = lookup_name_in.make_ignore_params ();
1401
1402   /* Clear the search flags.  */
1403   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1404     {
1405       ps->searched_flag = PST_NOT_SEARCHED;
1406     }
1407
1408   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1409     {
1410       QUIT;
1411
1412       if (ps->readin)
1413         continue;
1414
1415       /* We skip shared psymtabs because file-matching doesn't apply
1416          to them; but we search them later in the loop.  */
1417       if (ps->user != NULL)
1418         continue;
1419
1420       if (file_matcher)
1421         {
1422           bool match;
1423
1424           if (ps->anonymous)
1425             continue;
1426
1427           match = file_matcher (ps->filename, false);
1428           if (!match)
1429             {
1430               /* Before we invoke realpath, which can get expensive when many
1431                  files are involved, do a quick comparison of the basenames.  */
1432               if (basenames_may_differ
1433                   || file_matcher (lbasename (ps->filename), true))
1434                 match = file_matcher (psymtab_to_fullname (ps), false);
1435             }
1436           if (!match)
1437             continue;
1438         }
1439
1440       if (recursively_search_psymtabs (ps, objfile, domain,
1441                                        lookup_name, symbol_matcher))
1442         {
1443           struct compunit_symtab *symtab =
1444             psymtab_to_symtab (objfile, ps);
1445
1446           if (expansion_notify != NULL)
1447             expansion_notify (symtab);
1448         }
1449     }
1450 }
1451
1452 /* Psymtab version of has_symbols.  See its definition in
1453    the definition of quick_symbol_functions in symfile.h.  */
1454
1455 static int
1456 psym_has_symbols (struct objfile *objfile)
1457 {
1458   return objfile->psymtabs != NULL;
1459 }
1460
1461 const struct quick_symbol_functions psym_functions =
1462 {
1463   psym_has_symbols,
1464   psym_find_last_source_symtab,
1465   psym_forget_cached_source_info,
1466   psym_map_symtabs_matching_filename,
1467   psym_lookup_symbol,
1468   psym_print_stats,
1469   psym_dump,
1470   psym_relocate,
1471   psym_expand_symtabs_for_function,
1472   psym_expand_all_symtabs,
1473   psym_expand_symtabs_with_fullname,
1474   psym_map_matching_symbols,
1475   psym_expand_symtabs_matching,
1476   psym_find_pc_sect_compunit_symtab,
1477   psym_map_symbol_filenames
1478 };
1479
1480 \f
1481
1482 static void
1483 sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
1484 {
1485   /* Sort the global list; don't sort the static list.  */
1486   auto begin = objfile->global_psymbols.begin ();
1487   std::advance (begin, pst->globals_offset);
1488
1489   /* The psymbols for this partial_symtab are currently at the end of the
1490      vector.  */
1491   auto end = objfile->global_psymbols.end ();
1492
1493   std::sort (begin, end, [] (partial_symbol *s1, partial_symbol *s2)
1494     {
1495       return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (s1),
1496                                 SYMBOL_SEARCH_NAME (s2)) < 0;
1497     });
1498 }
1499
1500 /* Allocate and partially fill a partial symtab.  It will be
1501    completely filled at the end of the symbol list.
1502
1503    FILENAME is the name of the symbol-file we are reading from.  */
1504
1505 struct partial_symtab *
1506 start_psymtab_common (struct objfile *objfile,
1507                       const char *filename,
1508                       CORE_ADDR textlow,
1509                       std::vector<partial_symbol *> &global_psymbols,
1510                       std::vector<partial_symbol *> &static_psymbols)
1511 {
1512   struct partial_symtab *psymtab;
1513
1514   psymtab = allocate_psymtab (filename, objfile);
1515   psymtab->textlow = textlow;
1516   psymtab->texthigh = psymtab->textlow;         /* default */
1517   psymtab->globals_offset = global_psymbols.size ();
1518   psymtab->statics_offset = static_psymbols.size ();
1519   return psymtab;
1520 }
1521
1522 /* Perform "finishing up" operations of a partial symtab.  */
1523
1524 void
1525 end_psymtab_common (struct objfile *objfile, struct partial_symtab *pst)
1526 {
1527   pst->n_global_syms = objfile->global_psymbols.size () - pst->globals_offset;
1528   pst->n_static_syms = objfile->static_psymbols.size () - pst->statics_offset;
1529
1530   sort_pst_symbols (objfile, pst);
1531 }
1532
1533 /* Calculate a hash code for the given partial symbol.  The hash is
1534    calculated using the symbol's value, language, domain, class
1535    and name.  These are the values which are set by
1536    add_psymbol_to_bcache.  */
1537
1538 static unsigned long
1539 psymbol_hash (const void *addr, int length)
1540 {
1541   unsigned long h = 0;
1542   struct partial_symbol *psymbol = (struct partial_symbol *) addr;
1543   unsigned int lang = psymbol->ginfo.language;
1544   unsigned int domain = PSYMBOL_DOMAIN (psymbol);
1545   unsigned int theclass = PSYMBOL_CLASS (psymbol);
1546
1547   h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
1548   h = hash_continue (&lang, sizeof (unsigned int), h);
1549   h = hash_continue (&domain, sizeof (unsigned int), h);
1550   h = hash_continue (&theclass, sizeof (unsigned int), h);
1551   h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h);
1552
1553   return h;
1554 }
1555
1556 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1557    For the comparison this function uses a symbols value,
1558    language, domain, class and name.  */
1559
1560 static int
1561 psymbol_compare (const void *addr1, const void *addr2, int length)
1562 {
1563   struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1564   struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
1565
1566   return (memcmp (&sym1->ginfo.value, &sym2->ginfo.value,
1567                   sizeof (sym1->ginfo.value)) == 0
1568           && sym1->ginfo.language == sym2->ginfo.language
1569           && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2)
1570           && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2)
1571           && sym1->ginfo.name == sym2->ginfo.name);
1572 }
1573
1574 /* Initialize a partial symbol bcache.  */
1575
1576 struct psymbol_bcache *
1577 psymbol_bcache_init (void)
1578 {
1579   struct psymbol_bcache *bcache = XCNEW (struct psymbol_bcache);
1580
1581   bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
1582   return bcache;
1583 }
1584
1585 /* Free a partial symbol bcache.  */
1586
1587 void
1588 psymbol_bcache_free (struct psymbol_bcache *bcache)
1589 {
1590   if (bcache == NULL)
1591     return;
1592
1593   bcache_xfree (bcache->bcache);
1594   xfree (bcache);
1595 }
1596
1597 /* Return the internal bcache of the psymbol_bcache BCACHE.  */
1598
1599 struct bcache *
1600 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
1601 {
1602   return bcache->bcache;
1603 }
1604
1605 /* Find a copy of the SYM in BCACHE.  If BCACHE has never seen this
1606    symbol before, add a copy to BCACHE.  In either case, return a pointer
1607    to BCACHE's copy of the symbol.  If optional ADDED is not NULL, return
1608    1 in case of new entry or 0 if returning an old entry.  */
1609
1610 static struct partial_symbol *
1611 psymbol_bcache_full (struct partial_symbol *sym,
1612                      struct psymbol_bcache *bcache,
1613                      int *added)
1614 {
1615   return ((struct partial_symbol *)
1616           bcache_full (sym, sizeof (struct partial_symbol), bcache->bcache,
1617                        added));
1618 }
1619
1620 /* Helper function, initialises partial symbol structure and stashes
1621    it into objfile's bcache.  Note that our caching mechanism will
1622    use all fields of struct partial_symbol to determine hash value of the
1623    structure.  In other words, having two symbols with the same name but
1624    different domain (or address) is possible and correct.  */
1625
1626 static struct partial_symbol *
1627 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
1628                        domain_enum domain,
1629                        enum address_class theclass,
1630                        CORE_ADDR coreaddr,
1631                        enum language language, struct objfile *objfile,
1632                        int *added)
1633 {
1634   struct partial_symbol psymbol;
1635
1636   /* We must ensure that the entire struct has been zeroed before
1637      assigning to it, because an assignment may not touch some of the
1638      holes.  */
1639   memset (&psymbol, 0, sizeof (psymbol));
1640
1641   SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
1642   SYMBOL_SECTION (&psymbol) = -1;
1643   SYMBOL_SET_LANGUAGE (&psymbol, language, &objfile->objfile_obstack);
1644   PSYMBOL_DOMAIN (&psymbol) = domain;
1645   PSYMBOL_CLASS (&psymbol) = theclass;
1646
1647   SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
1648
1649   /* Stash the partial symbol away in the cache.  */
1650   return psymbol_bcache_full (&psymbol, objfile->psymbol_cache, added);
1651 }
1652
1653 /* Helper function, adds partial symbol to the given partial symbol list.  */
1654
1655 static void
1656 append_psymbol_to_list (std::vector<partial_symbol *> *list,
1657                         struct partial_symbol *psym,
1658                         struct objfile *objfile)
1659 {
1660   list->push_back (psym);
1661   OBJSTAT (objfile, n_psyms++);
1662 }
1663
1664 /* Add a symbol with a long value to a psymtab.
1665    Since one arg is a struct, we pass in a ptr and deref it (sigh).
1666    The only value we need to store for psyms is an address.
1667    For all other psyms pass zero for COREADDR.
1668    Return the partial symbol that has been added.  */
1669
1670 void
1671 add_psymbol_to_list (const char *name, int namelength, int copy_name,
1672                      domain_enum domain,
1673                      enum address_class theclass,
1674                      std::vector<partial_symbol *> *list,
1675                      CORE_ADDR coreaddr,
1676                      enum language language, struct objfile *objfile)
1677 {
1678   struct partial_symbol *psym;
1679
1680   int added;
1681
1682   /* Stash the partial symbol away in the cache.  */
1683   psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, theclass,
1684                                 coreaddr, language, objfile, &added);
1685
1686   /* Do not duplicate global partial symbols.  */
1687   if (list == &objfile->global_psymbols
1688       && !added)
1689     return;
1690
1691   /* Save pointer to partial symbol in psymtab, growing symtab if needed.  */
1692   append_psymbol_to_list (list, psym, objfile);
1693 }
1694
1695 /* Initialize storage for partial symbols.  */
1696
1697 void
1698 init_psymbol_list (struct objfile *objfile, int total_symbols)
1699 {
1700   /* Free any previously allocated psymbol lists.  */
1701   objfile->global_psymbols.clear ();
1702   objfile->static_psymbols.clear ();
1703
1704   /* Current best guess is that approximately a twentieth
1705      of the total symbols (in a debugging file) are global or static
1706      oriented symbols, then multiply that by slop factor of two.  */
1707   objfile->global_psymbols.reserve (total_symbols / 10);
1708   objfile->static_psymbols.reserve (total_symbols / 10);
1709 }
1710
1711 struct partial_symtab *
1712 allocate_psymtab (const char *filename, struct objfile *objfile)
1713 {
1714   struct partial_symtab *psymtab;
1715
1716   if (objfile->free_psymtabs)
1717     {
1718       psymtab = objfile->free_psymtabs;
1719       objfile->free_psymtabs = psymtab->next;
1720     }
1721   else
1722     psymtab = (struct partial_symtab *)
1723       obstack_alloc (&objfile->objfile_obstack,
1724                      sizeof (struct partial_symtab));
1725
1726   memset (psymtab, 0, sizeof (struct partial_symtab));
1727   psymtab->filename
1728     = (const char *) bcache (filename, strlen (filename) + 1,
1729                              objfile->per_bfd->filename_cache);
1730   psymtab->compunit_symtab = NULL;
1731
1732   /* Prepend it to the psymtab list for the objfile it belongs to.
1733      Psymtabs are searched in most recent inserted -> least recent
1734      inserted order.  */
1735
1736   psymtab->next = objfile->psymtabs;
1737   objfile->psymtabs = psymtab;
1738
1739   if (symtab_create_debug)
1740     {
1741       /* Be a bit clever with debugging messages, and don't print objfile
1742          every time, only when it changes.  */
1743       static char *last_objfile_name = NULL;
1744
1745       if (last_objfile_name == NULL
1746           || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
1747         {
1748           xfree (last_objfile_name);
1749           last_objfile_name = xstrdup (objfile_name (objfile));
1750           fprintf_unfiltered (gdb_stdlog,
1751                               "Creating one or more psymtabs for objfile %s ...\n",
1752                               last_objfile_name);
1753         }
1754       fprintf_unfiltered (gdb_stdlog,
1755                           "Created psymtab %s for module %s.\n",
1756                           host_address_to_string (psymtab), filename);
1757     }
1758
1759   return psymtab;
1760 }
1761
1762 void
1763 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
1764 {
1765   struct partial_symtab **prev_pst;
1766
1767   /* From dbxread.c:
1768      Empty psymtabs happen as a result of header files which don't
1769      have any symbols in them.  There can be a lot of them.  But this
1770      check is wrong, in that a psymtab with N_SLINE entries but
1771      nothing else is not empty, but we don't realize that.  Fixing
1772      that without slowing things down might be tricky.  */
1773
1774   /* First, snip it out of the psymtab chain.  */
1775
1776   prev_pst = &(objfile->psymtabs);
1777   while ((*prev_pst) != pst)
1778     prev_pst = &((*prev_pst)->next);
1779   (*prev_pst) = pst->next;
1780
1781   /* Next, put it on a free list for recycling.  */
1782
1783   pst->next = objfile->free_psymtabs;
1784   objfile->free_psymtabs = pst;
1785 }
1786
1787 \f
1788
1789 /* We need to pass a couple of items to the addrmap_foreach function,
1790    so use a struct.  */
1791
1792 struct dump_psymtab_addrmap_data
1793 {
1794   struct objfile *objfile;
1795   struct partial_symtab *psymtab;
1796   struct ui_file *outfile;
1797
1798   /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1799      If so, we want to print the next one as well (since the next addrmap
1800      entry defines the end of the range).  */
1801   int previous_matched;
1802 };
1803
1804 /* Helper function for dump_psymtab_addrmap to print an addrmap entry.  */
1805
1806 static int
1807 dump_psymtab_addrmap_1 (void *datap, CORE_ADDR start_addr, void *obj)
1808 {
1809   struct dump_psymtab_addrmap_data *data
1810     = (struct dump_psymtab_addrmap_data *) datap;
1811   struct gdbarch *gdbarch = get_objfile_arch (data->objfile);
1812   struct partial_symtab *addrmap_psymtab = (struct partial_symtab *) obj;
1813   const char *psymtab_address_or_end = NULL;
1814
1815   QUIT;
1816
1817   if (data->psymtab == NULL
1818       || data->psymtab == addrmap_psymtab)
1819     psymtab_address_or_end = host_address_to_string (addrmap_psymtab);
1820   else if (data->previous_matched)
1821     psymtab_address_or_end = "<ends here>";
1822
1823   if (data->psymtab == NULL
1824       || data->psymtab == addrmap_psymtab
1825       || data->previous_matched)
1826     {
1827       fprintf_filtered (data->outfile, "  %s%s %s\n",
1828                         data->psymtab != NULL ? "  " : "",
1829                         paddress (gdbarch, start_addr),
1830                         psymtab_address_or_end);
1831     }
1832
1833   data->previous_matched = (data->psymtab == NULL
1834                             || data->psymtab == addrmap_psymtab);
1835
1836   return 0;
1837 }
1838
1839 /* Helper function for maintenance_print_psymbols to print the addrmap
1840    of PSYMTAB.  If PSYMTAB is NULL print the entire addrmap.  */
1841
1842 static void
1843 dump_psymtab_addrmap (struct objfile *objfile, struct partial_symtab *psymtab,
1844                       struct ui_file *outfile)
1845 {
1846   struct dump_psymtab_addrmap_data addrmap_dump_data;
1847
1848   if ((psymtab == NULL
1849        || psymtab->psymtabs_addrmap_supported)
1850       && objfile->psymtabs_addrmap != NULL)
1851     {
1852       addrmap_dump_data.objfile = objfile;
1853       addrmap_dump_data.psymtab = psymtab;
1854       addrmap_dump_data.outfile = outfile;
1855       addrmap_dump_data.previous_matched = 0;
1856       fprintf_filtered (outfile, "%sddress map:\n",
1857                         psymtab == NULL ? "Entire a" : "  A");
1858       addrmap_foreach (objfile->psymtabs_addrmap, dump_psymtab_addrmap_1,
1859                        &addrmap_dump_data);
1860     }
1861 }
1862
1863 static void
1864 maintenance_print_psymbols (const char *args, int from_tty)
1865 {
1866   struct ui_file *outfile = gdb_stdout;
1867   char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
1868   struct objfile *objfile;
1869   struct partial_symtab *ps;
1870   int i, outfile_idx, found;
1871   CORE_ADDR pc = 0;
1872   struct obj_section *section = NULL;
1873
1874   dont_repeat ();
1875
1876   gdb_argv argv (args);
1877
1878   for (i = 0; argv != NULL && argv[i] != NULL; ++i)
1879     {
1880       if (strcmp (argv[i], "-pc") == 0)
1881         {
1882           if (argv[i + 1] == NULL)
1883             error (_("Missing pc value"));
1884           address_arg = argv[++i];
1885         }
1886       else if (strcmp (argv[i], "-source") == 0)
1887         {
1888           if (argv[i + 1] == NULL)
1889             error (_("Missing source file"));
1890           source_arg = argv[++i];
1891         }
1892       else if (strcmp (argv[i], "-objfile") == 0)
1893         {
1894           if (argv[i + 1] == NULL)
1895             error (_("Missing objfile name"));
1896           objfile_arg = argv[++i];
1897         }
1898       else if (strcmp (argv[i], "--") == 0)
1899         {
1900           /* End of options.  */
1901           ++i;
1902           break;
1903         }
1904       else if (argv[i][0] == '-')
1905         {
1906           /* Future proofing: Don't allow OUTFILE to begin with "-".  */
1907           error (_("Unknown option: %s"), argv[i]);
1908         }
1909       else
1910         break;
1911     }
1912   outfile_idx = i;
1913
1914   if (address_arg != NULL && source_arg != NULL)
1915     error (_("Must specify at most one of -pc and -source"));
1916
1917   stdio_file arg_outfile;
1918
1919   if (argv != NULL && argv[outfile_idx] != NULL)
1920     {
1921       if (argv[outfile_idx + 1] != NULL)
1922         error (_("Junk at end of command"));
1923       gdb::unique_xmalloc_ptr<char> outfile_name
1924         (tilde_expand (argv[outfile_idx]));
1925       if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
1926         perror_with_name (outfile_name.get ());
1927       outfile = &arg_outfile;
1928     }
1929
1930   if (address_arg != NULL)
1931     {
1932       pc = parse_and_eval_address (address_arg);
1933       /* If we fail to find a section, that's ok, try the lookup anyway.  */
1934       section = find_pc_section (pc);
1935     }
1936
1937   found = 0;
1938   ALL_OBJFILES (objfile)
1939     {
1940       int printed_objfile_header = 0;
1941       int print_for_objfile = 1;
1942
1943       QUIT;
1944       if (objfile_arg != NULL)
1945         print_for_objfile
1946           = compare_filenames_for_search (objfile_name (objfile),
1947                                           objfile_arg);
1948       if (!print_for_objfile)
1949         continue;
1950
1951       if (address_arg != NULL)
1952         {
1953           struct bound_minimal_symbol msymbol = { NULL, NULL };
1954
1955           /* We don't assume each pc has a unique objfile (this is for
1956              debugging).  */
1957           ps = find_pc_sect_psymtab (objfile, pc, section, msymbol);
1958           if (ps != NULL)
1959             {
1960               if (!printed_objfile_header)
1961                 {
1962                   outfile->printf ("\nPartial symtabs for objfile %s\n",
1963                                   objfile_name (objfile));
1964                   printed_objfile_header = 1;
1965                 }
1966               dump_psymtab (objfile, ps, outfile);
1967               dump_psymtab_addrmap (objfile, ps, outfile);
1968               found = 1;
1969             }
1970         }
1971       else
1972         {
1973           ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1974             {
1975               int print_for_source = 0;
1976
1977               QUIT;
1978               if (source_arg != NULL)
1979                 {
1980                   print_for_source
1981                     = compare_filenames_for_search (ps->filename, source_arg);
1982                   found = 1;
1983                 }
1984               if (source_arg == NULL
1985                   || print_for_source)
1986                 {
1987                   if (!printed_objfile_header)
1988                     {
1989                       outfile->printf ("\nPartial symtabs for objfile %s\n",
1990                                        objfile_name (objfile));
1991                       printed_objfile_header = 1;
1992                     }
1993                   dump_psymtab (objfile, ps, outfile);
1994                   dump_psymtab_addrmap (objfile, ps, outfile);
1995                 }
1996             }
1997         }
1998
1999       /* If we're printing all the objfile's symbols dump the full addrmap.  */
2000
2001       if (address_arg == NULL
2002           && source_arg == NULL
2003           && objfile->psymtabs_addrmap != NULL)
2004         {
2005           outfile->puts ("\n");
2006           dump_psymtab_addrmap (objfile, NULL, outfile);
2007         }
2008     }
2009
2010   if (!found)
2011     {
2012       if (address_arg != NULL)
2013         error (_("No partial symtab for address: %s"), address_arg);
2014       if (source_arg != NULL)
2015         error (_("No partial symtab for source file: %s"), source_arg);
2016     }
2017 }
2018
2019 /* List all the partial symbol tables whose names match REGEXP (optional).  */
2020
2021 static void
2022 maintenance_info_psymtabs (const char *regexp, int from_tty)
2023 {
2024   struct program_space *pspace;
2025   struct objfile *objfile;
2026
2027   if (regexp)
2028     re_comp (regexp);
2029
2030   ALL_PSPACES (pspace)
2031     ALL_PSPACE_OBJFILES (pspace, objfile)
2032     {
2033       struct gdbarch *gdbarch = get_objfile_arch (objfile);
2034       struct partial_symtab *psymtab;
2035
2036       /* We don't want to print anything for this objfile until we
2037          actually find a symtab whose name matches.  */
2038       int printed_objfile_start = 0;
2039
2040       ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
2041         {
2042           QUIT;
2043
2044           if (! regexp
2045               || re_exec (psymtab->filename))
2046             {
2047               if (! printed_objfile_start)
2048                 {
2049                   printf_filtered ("{ objfile %s ", objfile_name (objfile));
2050                   wrap_here ("  ");
2051                   printf_filtered ("((struct objfile *) %s)\n",
2052                                    host_address_to_string (objfile));
2053                   printed_objfile_start = 1;
2054                 }
2055
2056               printf_filtered ("  { psymtab %s ", psymtab->filename);
2057               wrap_here ("    ");
2058               printf_filtered ("((struct partial_symtab *) %s)\n",
2059                                host_address_to_string (psymtab));
2060
2061               printf_filtered ("    readin %s\n",
2062                                psymtab->readin ? "yes" : "no");
2063               printf_filtered ("    fullname %s\n",
2064                                psymtab->fullname
2065                                ? psymtab->fullname : "(null)");
2066               printf_filtered ("    text addresses ");
2067               fputs_filtered (paddress (gdbarch, psymtab->textlow),
2068                               gdb_stdout);
2069               printf_filtered (" -- ");
2070               fputs_filtered (paddress (gdbarch, psymtab->texthigh),
2071                               gdb_stdout);
2072               printf_filtered ("\n");
2073               printf_filtered ("    psymtabs_addrmap_supported %s\n",
2074                                (psymtab->psymtabs_addrmap_supported
2075                                 ? "yes" : "no"));
2076               printf_filtered ("    globals ");
2077               if (psymtab->n_global_syms)
2078                 {
2079                   auto p = &objfile->global_psymbols[psymtab->globals_offset];
2080
2081                   printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2082                                    host_address_to_string (p),
2083                                    psymtab->n_global_syms);
2084                 }
2085               else
2086                 printf_filtered ("(none)\n");
2087               printf_filtered ("    statics ");
2088               if (psymtab->n_static_syms)
2089                 {
2090                   auto p = &objfile->static_psymbols[psymtab->statics_offset];
2091
2092                   printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2093                                    host_address_to_string (p),
2094                                    psymtab->n_static_syms);
2095                 }
2096               else
2097                 printf_filtered ("(none)\n");
2098               printf_filtered ("    dependencies ");
2099               if (psymtab->number_of_dependencies)
2100                 {
2101                   int i;
2102
2103                   printf_filtered ("{\n");
2104                   for (i = 0; i < psymtab->number_of_dependencies; i++)
2105                     {
2106                       struct partial_symtab *dep = psymtab->dependencies[i];
2107
2108                       /* Note the string concatenation there --- no comma.  */
2109                       printf_filtered ("      psymtab %s "
2110                                        "((struct partial_symtab *) %s)\n",
2111                                        dep->filename,
2112                                        host_address_to_string (dep));
2113                     }
2114                   printf_filtered ("    }\n");
2115                 }
2116               else
2117                 printf_filtered ("(none)\n");
2118               printf_filtered ("  }\n");
2119             }
2120         }
2121
2122       if (printed_objfile_start)
2123         printf_filtered ("}\n");
2124     }
2125 }
2126
2127 /* Check consistency of currently expanded psymtabs vs symtabs.  */
2128
2129 static void
2130 maintenance_check_psymtabs (const char *ignore, int from_tty)
2131 {
2132   struct symbol *sym;
2133   struct compunit_symtab *cust = NULL;
2134   struct partial_symtab *ps;
2135   const struct blockvector *bv;
2136   struct objfile *objfile;
2137   struct block *b;
2138   int length;
2139
2140   ALL_PSYMTABS (objfile, ps)
2141   {
2142     struct gdbarch *gdbarch = get_objfile_arch (objfile);
2143
2144     /* We don't call psymtab_to_symtab here because that may cause symtab
2145        expansion.  When debugging a problem it helps if checkers leave
2146        things unchanged.  */
2147     cust = ps->compunit_symtab;
2148
2149     /* First do some checks that don't require the associated symtab.  */
2150     if (ps->texthigh < ps->textlow)
2151       {
2152         printf_filtered ("Psymtab ");
2153         puts_filtered (ps->filename);
2154         printf_filtered (" covers bad range ");
2155         fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2156         printf_filtered (" - ");
2157         fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2158         printf_filtered ("\n");
2159         continue;
2160       }
2161
2162     /* Now do checks requiring the associated symtab.  */
2163     if (cust == NULL)
2164       continue;
2165     bv = COMPUNIT_BLOCKVECTOR (cust);
2166     b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
2167     partial_symbol **psym = &objfile->static_psymbols[ps->statics_offset];
2168     length = ps->n_static_syms;
2169     while (length--)
2170       {
2171         sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
2172                                    SYMBOL_DOMAIN (*psym));
2173         if (!sym)
2174           {
2175             printf_filtered ("Static symbol `");
2176             puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
2177             printf_filtered ("' only found in ");
2178             puts_filtered (ps->filename);
2179             printf_filtered (" psymtab\n");
2180           }
2181         psym++;
2182       }
2183     b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2184     psym = &objfile->global_psymbols[ps->globals_offset];
2185     length = ps->n_global_syms;
2186     while (length--)
2187       {
2188         sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
2189                                    SYMBOL_DOMAIN (*psym));
2190         if (!sym)
2191           {
2192             printf_filtered ("Global symbol `");
2193             puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
2194             printf_filtered ("' only found in ");
2195             puts_filtered (ps->filename);
2196             printf_filtered (" psymtab\n");
2197           }
2198         psym++;
2199       }
2200     if (ps->texthigh != 0
2201         && (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b)))
2202       {
2203         printf_filtered ("Psymtab ");
2204         puts_filtered (ps->filename);
2205         printf_filtered (" covers ");
2206         fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2207         printf_filtered (" - ");
2208         fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2209         printf_filtered (" but symtab covers only ");
2210         fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
2211         printf_filtered (" - ");
2212         fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
2213         printf_filtered ("\n");
2214       }
2215   }
2216 }
2217
2218 void
2219 _initialize_psymtab (void)
2220 {
2221   add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
2222 Print dump of current partial symbol definitions.\n\
2223 Usage: mt print psymbols [-objfile objfile] [-pc address] [--] [outfile]\n\
2224        mt print psymbols [-objfile objfile] [-source source] [--] [outfile]\n\
2225 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2226 or the terminal if OUTFILE is unspecified.\n\
2227 If ADDRESS is provided, dump only the file for that address.\n\
2228 If SOURCE is provided, dump only that file's symbols.\n\
2229 If OBJFILE is provided, dump only that file's minimal symbols."),
2230            &maintenanceprintlist);
2231
2232   add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
2233 List the partial symbol tables for all object files.\n\
2234 This does not include information about individual partial symbols,\n\
2235 just the symbol table structures themselves."),
2236            &maintenanceinfolist);
2237
2238   add_cmd ("check-psymtabs", class_maintenance, maintenance_check_psymtabs,
2239            _("\
2240 Check consistency of currently expanded psymtabs versus symtabs."),
2241            &maintenancelist);
2242 }