gdb/psymtab.c

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