gdb/psymtab.c

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