gdb/psymtab.c

   1 /* Partial symbol tables.
   2
   3    Copyright (C) 2009-2012 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
  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 /* A fast way to get from a psymtab to its symtab (after the first time).  */
  49 #define PSYMTAB_TO_SYMTAB(pst)  \
  50     ((pst) -> symtab != NULL ? (pst) -> symtab : psymtab_to_symtab (pst))
  51
  52 static struct partial_symbol *match_partial_symbol (struct partial_symtab *,
  53                                                     int,
  54                                                     const char *, domain_enum,
  55                                                     symbol_compare_ftype *,
  56                                                     symbol_compare_ftype *);
  57
  58 static struct partial_symbol *lookup_partial_symbol (struct partial_symtab *,
  59                                                      const char *, int,
  60                                                      domain_enum);
  61
  62 static char *psymtab_to_fullname (struct partial_symtab *ps);
  63
  64 static struct partial_symbol *find_pc_sect_psymbol (struct partial_symtab *,
  65                                                     CORE_ADDR,
  66                                                     struct obj_section *);
  67
  68 static struct partial_symbol *fixup_psymbol_section (struct partial_symbol
  69                                                      *psym,
  70                                                      struct objfile *objfile);
  71
  72 static struct symtab *psymtab_to_symtab (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 *full_path,
 135                           const char *real_path,
 136                           struct partial_symtab *pst,
 137                           int (*callback) (struct symtab *, void *),
 138                           void *data)
 139 {
 140   struct symtab *last_made = objfile->symtabs;
 141
 142   /* Don't visit already-expanded psymtabs.  */
 143   if (pst->readin)
 144     return 0;
 145
 146   /* This may expand more than one symtab, and we want to iterate over
 147      all of them.  */
 148   psymtab_to_symtab (pst);
 149
 150   return iterate_over_some_symtabs (name, full_path, real_path, callback, data,
 151                                     objfile->symtabs, last_made);
 152 }
 153
 154 /* Implementation of the map_symtabs_matching_filename method.  */
 155
 156 static int
 157 partial_map_symtabs_matching_filename (struct objfile *objfile,
 158                                        const char *name,
 159                                        const char *full_path,
 160                                        const char *real_path,
 161                                        int (*callback) (struct symtab *,
 162                                                         void *),
 163                                        void *data)
 164 {
 165   struct partial_symtab *pst;
 166   const char *name_basename = lbasename (name);
 167   int name_len = strlen (name);
 168   int is_abs = IS_ABSOLUTE_PATH (name);
 169
 170   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
 171   {
 172     if (FILENAME_CMP (name, pst->filename) == 0
 173         || (!is_abs && compare_filenames_for_search (pst->filename,
 174                                                      name, name_len)))
 175       {
 176         if (partial_map_expand_apply (objfile, name, full_path, real_path,
 177                                       pst, callback, data))
 178           return 1;
 179       }
 180
 181     /* Before we invoke realpath, which can get expensive when many
 182        files are involved, do a quick comparison of the basenames.  */
 183     if (! basenames_may_differ
 184         && FILENAME_CMP (name_basename, lbasename (pst->filename)) != 0)
 185       continue;
 186
 187     /* If the user gave us an absolute path, try to find the file in
 188        this symtab and use its absolute path.  */
 189     if (full_path != NULL)
 190       {
 191         psymtab_to_fullname (pst);
 192         if (pst->fullname != NULL
 193             && (FILENAME_CMP (full_path, pst->fullname) == 0
 194                 || (!is_abs && compare_filenames_for_search (pst->fullname,
 195                                                              name, name_len))))
 196           {
 197             if (partial_map_expand_apply (objfile, name, full_path, real_path,
 198                                           pst, callback, data))
 199               return 1;
 200           }
 201       }
 202
 203     if (real_path != NULL)
 204       {
 205         char *rp = NULL;
 206         psymtab_to_fullname (pst);
 207         if (pst->fullname != NULL)
 208           {
 209             rp = gdb_realpath (pst->fullname);
 210             make_cleanup (xfree, rp);
 211           }
 212         if (rp != NULL
 213             && (FILENAME_CMP (real_path, rp) == 0
 214                 || (!is_abs && compare_filenames_for_search (real_path,
 215                                                              name, name_len))))
 216           {
 217             if (partial_map_expand_apply (objfile, name, full_path, real_path,
 218                                           pst, callback, data))
 219               return 1;
 220           }
 221       }
 222   }
 223
 224   return 0;
 225 }
 226
 227 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
 228    We may find a different psymtab than PST.  See FIND_PC_SECT_PSYMTAB.  */
 229
 230 static struct partial_symtab *
 231 find_pc_sect_psymtab_closer (CORE_ADDR pc, struct obj_section *section,
 232                              struct partial_symtab *pst,
 233                              struct minimal_symbol *msymbol)
 234 {
 235   struct objfile *objfile = pst->objfile;
 236   struct partial_symtab *tpst;
 237   struct partial_symtab *best_pst = pst;
 238   CORE_ADDR best_addr = pst->textlow;
 239
 240   gdb_assert (!pst->psymtabs_addrmap_supported);
 241
 242   /* An objfile that has its functions reordered might have
 243      many partial symbol tables containing the PC, but
 244      we want the partial symbol table that contains the
 245      function containing the PC.  */
 246   if (!(objfile->flags & OBJF_REORDERED) &&
 247       section == 0)     /* Can't validate section this way.  */
 248     return pst;
 249
 250   if (msymbol == NULL)
 251     return (pst);
 252
 253   /* The code range of partial symtabs sometimes overlap, so, in
 254      the loop below, we need to check all partial symtabs and
 255      find the one that fits better for the given PC address.  We
 256      select the partial symtab that contains a symbol whose
 257      address is closest to the PC address.  By closest we mean
 258      that find_pc_sect_symbol returns the symbol with address
 259      that is closest and still less than the given PC.  */
 260   for (tpst = pst; tpst != NULL; tpst = tpst->next)
 261     {
 262       if (pc >= tpst->textlow && pc < tpst->texthigh)
 263         {
 264           struct partial_symbol *p;
 265           CORE_ADDR this_addr;
 266
 267           /* NOTE: This assumes that every psymbol has a
 268              corresponding msymbol, which is not necessarily
 269              true; the debug info might be much richer than the
 270              object's symbol table.  */
 271           p = find_pc_sect_psymbol (tpst, pc, section);
 272           if (p != NULL
 273               && SYMBOL_VALUE_ADDRESS (p)
 274               == SYMBOL_VALUE_ADDRESS (msymbol))
 275             return tpst;
 276
 277           /* Also accept the textlow value of a psymtab as a
 278              "symbol", to provide some support for partial
 279              symbol tables with line information but no debug
 280              symbols (e.g. those produced by an assembler).  */
 281           if (p != NULL)
 282             this_addr = SYMBOL_VALUE_ADDRESS (p);
 283           else
 284             this_addr = tpst->textlow;
 285
 286           /* Check whether it is closer than our current
 287              BEST_ADDR.  Since this symbol address is
 288              necessarily lower or equal to PC, the symbol closer
 289              to PC is the symbol which address is the highest.
 290              This way we return the psymtab which contains such
 291              best match symbol.  This can help in cases where the
 292              symbol information/debuginfo is not complete, like
 293              for instance on IRIX6 with gcc, where no debug info
 294              is emitted for statics.  (See also the nodebug.exp
 295              testcase.)  */
 296           if (this_addr > best_addr)
 297             {
 298               best_addr = this_addr;
 299               best_pst = tpst;
 300             }
 301         }
 302     }
 303   return best_pst;
 304 }
 305
 306 /* Find which partial symtab contains PC and SECTION.  Return 0 if
 307    none.  We return the psymtab that contains a symbol whose address
 308    exactly matches PC, or, if we cannot find an exact match, the
 309    psymtab that contains a symbol whose address is closest to PC.  */
 310 static struct partial_symtab *
 311 find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
 312                       struct obj_section *section,
 313                       struct minimal_symbol *msymbol)
 314 {
 315   struct partial_symtab *pst;
 316
 317   /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
 318      than the later used TEXTLOW/TEXTHIGH one.  */
 319
 320   if (objfile->psymtabs_addrmap != NULL)
 321     {
 322       pst = addrmap_find (objfile->psymtabs_addrmap, pc);
 323       if (pst != NULL)
 324         {
 325           /* FIXME: addrmaps currently do not handle overlayed sections,
 326              so fall back to the non-addrmap case if we're debugging
 327              overlays and the addrmap returned the wrong section.  */
 328           if (overlay_debugging && msymbol && section)
 329             {
 330               struct partial_symbol *p;
 331
 332               /* NOTE: This assumes that every psymbol has a
 333                  corresponding msymbol, which is not necessarily
 334                  true; the debug info might be much richer than the
 335                  object's symbol table.  */
 336               p = find_pc_sect_psymbol (pst, pc, section);
 337               if (!p
 338                   || SYMBOL_VALUE_ADDRESS (p)
 339                   != SYMBOL_VALUE_ADDRESS (msymbol))
 340                 goto next;
 341             }
 342
 343           /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
 344              PSYMTABS_ADDRMAP we used has already the best 1-byte
 345              granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
 346              a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
 347              overlap.  */
 348
 349           return pst;
 350         }
 351     }
 352
 353  next:
 354
 355   /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
 356      which still have no corresponding full SYMTABs read.  But it is not
 357      present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
 358      so far.  */
 359
 360   /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
 361      its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
 362      debug info type in single OBJFILE.  */
 363
 364   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
 365     if (!pst->psymtabs_addrmap_supported
 366         && pc >= pst->textlow && pc < pst->texthigh)
 367       {
 368         struct partial_symtab *best_pst;
 369
 370         best_pst = find_pc_sect_psymtab_closer (pc, section, pst, msymbol);
 371         if (best_pst != NULL)
 372           return best_pst;
 373       }
 374
 375   return NULL;
 376 }
 377
 378 static struct symtab *
 379 find_pc_sect_symtab_from_partial (struct objfile *objfile,
 380                                   struct minimal_symbol *msymbol,
 381                                   CORE_ADDR pc, struct obj_section *section,
 382                                   int warn_if_readin)
 383 {
 384   struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section,
 385                                                     msymbol);
 386   if (ps)
 387     {
 388       if (warn_if_readin && ps->readin)
 389         /* Might want to error() here (in case symtab is corrupt and
 390            will cause a core dump), but maybe we can successfully
 391            continue, so let's not.  */
 392         warning (_("\
 393 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
 394                  paddress (get_objfile_arch (ps->objfile), pc));
 395       return PSYMTAB_TO_SYMTAB (ps);
 396     }
 397   return NULL;
 398 }
 399
 400 /* Find which partial symbol within a psymtab matches PC and SECTION.
 401    Return 0 if none.  */
 402
 403 static struct partial_symbol *
 404 find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc,
 405                       struct obj_section *section)
 406 {
 407   struct partial_symbol *best = NULL, *p, **pp;
 408   CORE_ADDR best_pc;
 409
 410   gdb_assert (psymtab != NULL);
 411
 412   /* Cope with programs that start at address 0.  */
 413   best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
 414
 415   /* Search the global symbols as well as the static symbols, so that
 416      find_pc_partial_function doesn't use a minimal symbol and thus
 417      cache a bad endaddr.  */
 418   for (pp = psymtab->objfile->global_psymbols.list + psymtab->globals_offset;
 419     (pp - (psymtab->objfile->global_psymbols.list + psymtab->globals_offset)
 420      < psymtab->n_global_syms);
 421        pp++)
 422     {
 423       p = *pp;
 424       if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
 425           && SYMBOL_CLASS (p) == LOC_BLOCK
 426           && pc >= SYMBOL_VALUE_ADDRESS (p)
 427           && (SYMBOL_VALUE_ADDRESS (p) > best_pc
 428               || (psymtab->textlow == 0
 429                   && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
 430         {
 431           if (section)          /* Match on a specific section.  */
 432             {
 433               fixup_psymbol_section (p, psymtab->objfile);
 434               if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
 435                 continue;
 436             }
 437           best_pc = SYMBOL_VALUE_ADDRESS (p);
 438           best = p;
 439         }
 440     }
 441
 442   for (pp = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
 443     (pp - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)
 444      < psymtab->n_static_syms);
 445        pp++)
 446     {
 447       p = *pp;
 448       if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
 449           && SYMBOL_CLASS (p) == LOC_BLOCK
 450           && pc >= SYMBOL_VALUE_ADDRESS (p)
 451           && (SYMBOL_VALUE_ADDRESS (p) > best_pc
 452               || (psymtab->textlow == 0
 453                   && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
 454         {
 455           if (section)          /* Match on a specific section.  */
 456             {
 457               fixup_psymbol_section (p, psymtab->objfile);
 458               if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
 459                 continue;
 460             }
 461           best_pc = SYMBOL_VALUE_ADDRESS (p);
 462           best = p;
 463         }
 464     }
 465
 466   return best;
 467 }
 468
 469 static struct partial_symbol *
 470 fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
 471 {
 472   CORE_ADDR addr;
 473
 474   if (!psym)
 475     return NULL;
 476
 477   if (SYMBOL_OBJ_SECTION (psym))
 478     return psym;
 479
 480   gdb_assert (objfile);
 481
 482   switch (SYMBOL_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 psym;
 493     }
 494
 495   fixup_section (&psym->ginfo, addr, objfile);
 496
 497   return psym;
 498 }
 499
 500 static struct symtab *
 501 lookup_symbol_aux_psymtabs (struct objfile *objfile,
 502                             int block_index, const char *name,
 503                             const domain_enum domain)
 504 {
 505   struct partial_symtab *ps;
 506   const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
 507
 508   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
 509   {
 510     if (!ps->readin && lookup_partial_symbol (ps, name, psymtab_index, domain))
 511       {
 512         struct symbol *sym = NULL;
 513         struct symtab *stab = PSYMTAB_TO_SYMTAB (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           return stab;
 528
 529         /* Keep looking through other psymtabs.  */
 530       }
 531   }
 532
 533   return NULL;
 534 }
 535
 536 /* Look in PST for a symbol in DOMAIN whose name matches NAME.  Search
 537    the global block of PST if GLOBAL, and otherwise the static block.
 538    MATCH is the comparison operation that returns true iff MATCH (s,
 539    NAME), where s is a SYMBOL_SEARCH_NAME.  If ORDERED_COMPARE is
 540    non-null, the symbols in the block are assumed to be ordered
 541    according to it (allowing binary search).  It must be compatible
 542    with MATCH.  Returns the symbol, if found, and otherwise NULL.  */
 543
 544 static struct partial_symbol *
 545 match_partial_symbol (struct partial_symtab *pst, int global,
 546                       const char *name, domain_enum domain,
 547                       symbol_compare_ftype *match,
 548                       symbol_compare_ftype *ordered_compare)
 549 {
 550   struct partial_symbol **start, **psym;
 551   struct partial_symbol **top, **real_top, **bottom, **center;
 552   int length = (global ? pst->n_global_syms : pst->n_static_syms);
 553   int do_linear_search = 1;
 554
 555   if (length == 0)
 556       return NULL;
 557   start = (global ?
 558            pst->objfile->global_psymbols.list + pst->globals_offset :
 559            pst->objfile->static_psymbols.list + pst->statics_offset);
 560
 561   if (global && ordered_compare)  /* Can use a binary search.  */
 562     {
 563       do_linear_search = 0;
 564
 565       /* Binary search.  This search is guaranteed to end with center
 566          pointing at the earliest partial symbol whose name might be
 567          correct.  At that point *all* partial symbols with an
 568          appropriate name will be checked against the correct
 569          domain.  */
 570
 571       bottom = start;
 572       top = start + length - 1;
 573       real_top = top;
 574       while (top > bottom)
 575         {
 576           center = bottom + (top - bottom) / 2;
 577           gdb_assert (center < top);
 578           if (!do_linear_search
 579               && (SYMBOL_LANGUAGE (*center) == language_java))
 580             do_linear_search = 1;
 581           if (ordered_compare (SYMBOL_SEARCH_NAME (*center), name) >= 0)
 582             top = center;
 583           else
 584             bottom = center + 1;
 585         }
 586       gdb_assert (top == bottom);
 587
 588       while (top <= real_top
 589              && match (SYMBOL_SEARCH_NAME (*top), name) == 0)
 590         {
 591           if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
 592                                      SYMBOL_DOMAIN (*top), domain))
 593             return *top;
 594           top++;
 595         }
 596     }
 597
 598   /* Can't use a binary search or else we found during the binary search that
 599      we should also do a linear search.  */
 600
 601   if (do_linear_search)
 602     {
 603       for (psym = start; psym < start + length; psym++)
 604         {
 605           if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
 606                                      SYMBOL_DOMAIN (*psym), domain)
 607               && match (SYMBOL_SEARCH_NAME (*psym), name) == 0)
 608             return *psym;
 609         }
 610     }
 611
 612   return NULL;
 613 }
 614
 615 static void
 616 pre_expand_symtabs_matching_psymtabs (struct objfile *objfile,
 617                                       enum block_enum block_kind,
 618                                       const char *name,
 619                                       domain_enum domain)
 620 {
 621   /* Nothing.  */
 622 }
 623
 624 /* Returns the name used to search psymtabs.  Unlike symtabs, psymtabs do
 625    not contain any method/function instance information (since this would
 626    force reading type information while reading psymtabs).  Therefore,
 627    if NAME contains overload information, it must be stripped before searching
 628    psymtabs.
 629
 630    The caller is responsible for freeing the return result.  */
 631
 632 static char *
 633 psymtab_search_name (const char *name)
 634 {
 635   switch (current_language->la_language)
 636     {
 637     case language_cplus:
 638     case language_java:
 639       {
 640        if (strchr (name, '('))
 641          {
 642            char *ret = cp_remove_params (name);
 643
 644            if (ret)
 645              return ret;
 646          }
 647       }
 648       break;
 649
 650     default:
 651       break;
 652     }
 653
 654   return xstrdup (name);
 655 }
 656
 657 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
 658    Check the global symbols if GLOBAL, the static symbols if not.  */
 659
 660 static struct partial_symbol *
 661 lookup_partial_symbol (struct partial_symtab *pst, const char *name,
 662                        int global, domain_enum domain)
 663 {
 664   struct partial_symbol **start, **psym;
 665   struct partial_symbol **top, **real_top, **bottom, **center;
 666   int length = (global ? pst->n_global_syms : pst->n_static_syms);
 667   int do_linear_search = 1;
 668   char *search_name;
 669   struct cleanup *cleanup;
 670
 671   if (length == 0)
 672     {
 673       return (NULL);
 674     }
 675
 676   search_name = psymtab_search_name (name);
 677   cleanup = make_cleanup (xfree, search_name);
 678   start = (global ?
 679            pst->objfile->global_psymbols.list + pst->globals_offset :
 680            pst->objfile->static_psymbols.list + pst->statics_offset);
 681
 682   if (global)                   /* This means we can use a binary search.  */
 683     {
 684       do_linear_search = 0;
 685
 686       /* Binary search.  This search is guaranteed to end with center
 687          pointing at the earliest partial symbol whose name might be
 688          correct.  At that point *all* partial symbols with an
 689          appropriate name will be checked against the correct
 690          domain.  */
 691
 692       bottom = start;
 693       top = start + length - 1;
 694       real_top = top;
 695       while (top > bottom)
 696         {
 697           center = bottom + (top - bottom) / 2;
 698           if (!(center < top))
 699             internal_error (__FILE__, __LINE__,
 700                             _("failed internal consistency check"));
 701           if (!do_linear_search
 702               && SYMBOL_LANGUAGE (*center) == language_java)
 703             {
 704               do_linear_search = 1;
 705             }
 706           if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
 707                                  search_name) >= 0)
 708             {
 709               top = center;
 710             }
 711           else
 712             {
 713               bottom = center + 1;
 714             }
 715         }
 716       if (!(top == bottom))
 717         internal_error (__FILE__, __LINE__,
 718                         _("failed internal consistency check"));
 719
 720       /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
 721          search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME.  */
 722       while (top >= start && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
 723         top--;
 724
 725       /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME.  */
 726       top++;
 727
 728       while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
 729         {
 730           if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
 731                                      SYMBOL_DOMAIN (*top), domain))
 732             {
 733               do_cleanups (cleanup);
 734               return (*top);
 735             }
 736           top++;
 737         }
 738     }
 739
 740   /* Can't use a binary search or else we found during the binary search that
 741      we should also do a linear search.  */
 742
 743   if (do_linear_search)
 744     {
 745       for (psym = start; psym < start + length; psym++)
 746         {
 747           if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
 748                                      SYMBOL_DOMAIN (*psym), domain)
 749               && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name))
 750             {
 751               do_cleanups (cleanup);
 752               return (*psym);
 753             }
 754         }
 755     }
 756
 757   do_cleanups (cleanup);
 758   return (NULL);
 759 }
 760
 761 /* Get the symbol table that corresponds to a partial_symtab.
 762    This is fast after the first time you do it.  In fact, there
 763    is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
 764    case inline.  */
 765
 766 static struct symtab *
 767 psymtab_to_symtab (struct partial_symtab *pst)
 768 {
 769   /* If it's been looked up before, return it.  */
 770   if (pst->symtab)
 771     return pst->symtab;
 772
 773   /* If it has not yet been read in, read it.  */
 774   if (!pst->readin)
 775     {
 776       struct cleanup *back_to = increment_reading_symtab ();
 777
 778       (*pst->read_symtab) (pst);
 779       do_cleanups (back_to);
 780     }
 781
 782   return pst->symtab;
 783 }
 784
 785 static void
 786 relocate_psymtabs (struct objfile *objfile,
 787                    struct section_offsets *new_offsets,
 788                    struct section_offsets *delta)
 789 {
 790   struct partial_symbol **psym;
 791   struct partial_symtab *p;
 792
 793   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
 794     {
 795       p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 796       p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 797     }
 798
 799   for (psym = objfile->global_psymbols.list;
 800        psym < objfile->global_psymbols.next;
 801        psym++)
 802     {
 803       fixup_psymbol_section (*psym, objfile);
 804       if (SYMBOL_SECTION (*psym) >= 0)
 805         SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
 806                                                   SYMBOL_SECTION (*psym));
 807     }
 808   for (psym = objfile->static_psymbols.list;
 809        psym < objfile->static_psymbols.next;
 810        psym++)
 811     {
 812       fixup_psymbol_section (*psym, objfile);
 813       if (SYMBOL_SECTION (*psym) >= 0)
 814         SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
 815                                                   SYMBOL_SECTION (*psym));
 816     }
 817 }
 818
 819 static struct symtab *
 820 find_last_source_symtab_from_partial (struct objfile *ofp)
 821 {
 822   struct partial_symtab *ps;
 823   struct partial_symtab *cs_pst = 0;
 824
 825   ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)
 826     {
 827       const char *name = ps->filename;
 828       int len = strlen (name);
 829
 830       if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
 831                         || strcmp (name, "<<C++-namespaces>>") == 0)))
 832         cs_pst = ps;
 833     }
 834
 835   if (cs_pst)
 836     {
 837       if (cs_pst->readin)
 838         {
 839           internal_error (__FILE__, __LINE__,
 840                           _("select_source_symtab: "
 841                           "readin pst found and no symtabs."));
 842         }
 843       else
 844         return PSYMTAB_TO_SYMTAB (cs_pst);
 845     }
 846   return NULL;
 847 }
 848
 849 static void
 850 forget_cached_source_info_partial (struct objfile *objfile)
 851 {
 852   struct partial_symtab *pst;
 853
 854   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
 855     {
 856       if (pst->fullname != NULL)
 857         {
 858           xfree (pst->fullname);
 859           pst->fullname = NULL;
 860         }
 861     }
 862 }
 863
 864 static void
 865 print_partial_symbols (struct gdbarch *gdbarch,
 866                        struct partial_symbol **p, int count, char *what,
 867                        struct ui_file *outfile)
 868 {
 869   fprintf_filtered (outfile, "  %s partial symbols:\n", what);
 870   while (count-- > 0)
 871     {
 872       fprintf_filtered (outfile, "    `%s'", SYMBOL_LINKAGE_NAME (*p));
 873       if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
 874         {
 875           fprintf_filtered (outfile, "  `%s'", SYMBOL_DEMANGLED_NAME (*p));
 876         }
 877       fputs_filtered (", ", outfile);
 878       switch (SYMBOL_DOMAIN (*p))
 879         {
 880         case UNDEF_DOMAIN:
 881           fputs_filtered ("undefined domain, ", outfile);
 882           break;
 883         case VAR_DOMAIN:
 884           /* This is the usual thing -- don't print it.  */
 885           break;
 886         case STRUCT_DOMAIN:
 887           fputs_filtered ("struct domain, ", outfile);
 888           break;
 889         case LABEL_DOMAIN:
 890           fputs_filtered ("label domain, ", outfile);
 891           break;
 892         default:
 893           fputs_filtered ("<invalid domain>, ", outfile);
 894           break;
 895         }
 896       switch (SYMBOL_CLASS (*p))
 897         {
 898         case LOC_UNDEF:
 899           fputs_filtered ("undefined", outfile);
 900           break;
 901         case LOC_CONST:
 902           fputs_filtered ("constant int", outfile);
 903           break;
 904         case LOC_STATIC:
 905           fputs_filtered ("static", outfile);
 906           break;
 907         case LOC_REGISTER:
 908           fputs_filtered ("register", outfile);
 909           break;
 910         case LOC_ARG:
 911           fputs_filtered ("pass by value", outfile);
 912           break;
 913         case LOC_REF_ARG:
 914           fputs_filtered ("pass by reference", outfile);
 915           break;
 916         case LOC_REGPARM_ADDR:
 917           fputs_filtered ("register address parameter", outfile);
 918           break;
 919         case LOC_LOCAL:
 920           fputs_filtered ("stack parameter", outfile);
 921           break;
 922         case LOC_TYPEDEF:
 923           fputs_filtered ("type", outfile);
 924           break;
 925         case LOC_LABEL:
 926           fputs_filtered ("label", outfile);
 927           break;
 928         case LOC_BLOCK:
 929           fputs_filtered ("function", outfile);
 930           break;
 931         case LOC_CONST_BYTES:
 932           fputs_filtered ("constant bytes", outfile);
 933           break;
 934         case LOC_UNRESOLVED:
 935           fputs_filtered ("unresolved", outfile);
 936           break;
 937         case LOC_OPTIMIZED_OUT:
 938           fputs_filtered ("optimized out", outfile);
 939           break;
 940         case LOC_COMPUTED:
 941           fputs_filtered ("computed at runtime", outfile);
 942           break;
 943         default:
 944           fputs_filtered ("<invalid location>", outfile);
 945           break;
 946         }
 947       fputs_filtered (", ", outfile);
 948       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile);
 949       fprintf_filtered (outfile, "\n");
 950       p++;
 951     }
 952 }
 953
 954 static void
 955 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
 956               struct ui_file *outfile)
 957 {
 958   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 959   int i;
 960
 961   fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
 962                     psymtab->filename);
 963   fprintf_filtered (outfile, "(object ");
 964   gdb_print_host_address (psymtab, outfile);
 965   fprintf_filtered (outfile, ")\n\n");
 966   fprintf_unfiltered (outfile, "  Read from object file %s (",
 967                       objfile->name);
 968   gdb_print_host_address (objfile, outfile);
 969   fprintf_unfiltered (outfile, ")\n");
 970
 971   if (psymtab->readin)
 972     {
 973       fprintf_filtered (outfile,
 974                         "  Full symtab was read (at ");
 975       gdb_print_host_address (psymtab->symtab, outfile);
 976       fprintf_filtered (outfile, " by function at ");
 977       gdb_print_host_address (psymtab->read_symtab, outfile);
 978       fprintf_filtered (outfile, ")\n");
 979     }
 980
 981   fprintf_filtered (outfile, "  Relocate symbols by ");
 982   for (i = 0; i < psymtab->objfile->num_sections; ++i)
 983     {
 984       if (i != 0)
 985         fprintf_filtered (outfile, ", ");
 986       wrap_here ("    ");
 987       fputs_filtered (paddress (gdbarch,
 988                                 ANOFFSET (psymtab->section_offsets, i)),
 989                       outfile);
 990     }
 991   fprintf_filtered (outfile, "\n");
 992
 993   fprintf_filtered (outfile, "  Symbols cover text addresses ");
 994   fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
 995   fprintf_filtered (outfile, "-");
 996   fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
 997   fprintf_filtered (outfile, "\n");
 998   fprintf_filtered (outfile, "  Address map supported - %s.\n",
 999                     psymtab->psymtabs_addrmap_supported ? "yes" : "no");
1000   fprintf_filtered (outfile, "  Depends on %d other partial symtabs.\n",
1001                     psymtab->number_of_dependencies);
1002   for (i = 0; i < psymtab->number_of_dependencies; i++)
1003     {
1004       fprintf_filtered (outfile, "    %d ", i);
1005       gdb_print_host_address (psymtab->dependencies[i], outfile);
1006       fprintf_filtered (outfile, " %s\n",
1007                         psymtab->dependencies[i]->filename);
1008     }
1009   if (psymtab->n_global_syms > 0)
1010     {
1011       print_partial_symbols (gdbarch,
1012                              objfile->global_psymbols.list
1013                              + psymtab->globals_offset,
1014                              psymtab->n_global_syms, "Global", outfile);
1015     }
1016   if (psymtab->n_static_syms > 0)
1017     {
1018       print_partial_symbols (gdbarch,
1019                              objfile->static_psymbols.list
1020                              + psymtab->statics_offset,
1021                              psymtab->n_static_syms, "Static", outfile);
1022     }
1023   fprintf_filtered (outfile, "\n");
1024 }
1025
1026 static void
1027 print_psymtab_stats_for_objfile (struct objfile *objfile)
1028 {
1029   int i;
1030   struct partial_symtab *ps;
1031
1032   i = 0;
1033   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1034     {
1035       if (ps->readin == 0)
1036         i++;
1037     }
1038   printf_filtered (_("  Number of psym tables (not yet expanded): %d\n"), i);
1039 }
1040
1041 static void
1042 dump_psymtabs_for_objfile (struct objfile *objfile)
1043 {
1044   struct partial_symtab *psymtab;
1045
1046   if (objfile->psymtabs)
1047     {
1048       printf_filtered ("Psymtabs:\n");
1049       for (psymtab = objfile->psymtabs;
1050            psymtab != NULL;
1051            psymtab = psymtab->next)
1052         {
1053           printf_filtered ("%s at ",
1054                            psymtab->filename);
1055           gdb_print_host_address (psymtab, gdb_stdout);
1056           printf_filtered (", ");
1057           if (psymtab->objfile != objfile)
1058             {
1059               printf_filtered ("NOT ON CHAIN!  ");
1060             }
1061           wrap_here ("  ");
1062         }
1063       printf_filtered ("\n\n");
1064     }
1065 }
1066
1067 /* Look through the partial symtabs for all symbols which begin
1068    by matching FUNC_NAME.  Make sure we read that symbol table in.  */
1069
1070 static void
1071 read_symtabs_for_function (struct objfile *objfile, const char *func_name)
1072 {
1073   struct partial_symtab *ps;
1074
1075   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1076   {
1077     if (ps->readin)
1078       continue;
1079
1080     if ((lookup_partial_symbol (ps, func_name, 1, VAR_DOMAIN)
1081          != NULL)
1082         || (lookup_partial_symbol (ps, func_name, 0, VAR_DOMAIN)
1083             != NULL))
1084       psymtab_to_symtab (ps);
1085   }
1086 }
1087
1088 static void
1089 expand_partial_symbol_tables (struct objfile *objfile)
1090 {
1091   struct partial_symtab *psymtab;
1092
1093   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1094     {
1095       psymtab_to_symtab (psymtab);
1096     }
1097 }
1098
1099 static void
1100 read_psymtabs_with_filename (struct objfile *objfile, const char *filename)
1101 {
1102   struct partial_symtab *p;
1103
1104   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
1105     {
1106       if (filename_cmp (filename, p->filename) == 0)
1107         PSYMTAB_TO_SYMTAB (p);
1108     }
1109 }
1110
1111 static void
1112 map_symbol_filenames_psymtab (struct objfile *objfile,
1113                               symbol_filename_ftype *fun, void *data,
1114                               int need_fullname)
1115 {
1116   struct partial_symtab *ps;
1117
1118   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1119     {
1120       const char *fullname;
1121
1122       if (ps->readin)
1123         continue;
1124
1125       QUIT;
1126       if (need_fullname)
1127         fullname = psymtab_to_fullname (ps);
1128       else
1129         fullname = NULL;
1130       (*fun) (ps->filename, fullname, data);
1131     }
1132 }
1133
1134 int find_and_open_source (const char *filename,
1135                           const char *dirname,
1136                           char **fullname);
1137
1138 /* Finds the fullname that a partial_symtab represents.
1139
1140    If this functions finds the fullname, it will save it in ps->fullname
1141    and it will also return the value.
1142
1143    If this function fails to find the file that this partial_symtab represents,
1144    NULL will be returned and ps->fullname will be set to NULL.  */
1145
1146 static char *
1147 psymtab_to_fullname (struct partial_symtab *ps)
1148 {
1149   int r;
1150
1151   if (!ps)
1152     return NULL;
1153
1154   /* Use cached copy if we have it.
1155      We rely on forget_cached_source_info being called appropriately
1156      to handle cases like the file being moved.  */
1157   if (ps->fullname)
1158     return ps->fullname;
1159
1160   r = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
1161
1162   if (r >= 0)
1163     {
1164       close (r);
1165       return ps->fullname;
1166     }
1167
1168   return NULL;
1169 }
1170
1171 static const char *
1172 find_symbol_file_from_partial (struct objfile *objfile, const char *name)
1173 {
1174   struct partial_symtab *pst;
1175
1176   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
1177     {
1178       if (lookup_partial_symbol (pst, name, 1, VAR_DOMAIN))
1179         return pst->filename;
1180     }
1181   return NULL;
1182 }
1183
1184 /*  For all symbols, s, in BLOCK that are in NAMESPACE and match NAME
1185     according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1186     BLOCK is assumed to come from OBJFILE.  Returns 1 iff CALLBACK
1187     ever returns non-zero, and otherwise returns 0.  */
1188
1189 static int
1190 map_block (const char *name, domain_enum namespace, struct objfile *objfile,
1191            struct block *block,
1192            int (*callback) (struct block *, struct symbol *, void *),
1193            void *data, symbol_compare_ftype *match)
1194 {
1195   struct dict_iterator iter;
1196   struct symbol *sym;
1197
1198   for (sym = dict_iter_match_first (BLOCK_DICT (block), name, match, &iter);
1199        sym != NULL; sym = dict_iter_match_next (name, match, &iter))
1200     {
1201       if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1202                                  SYMBOL_DOMAIN (sym), namespace))
1203         {
1204           if (callback (block, sym, data))
1205             return 1;
1206         }
1207     }
1208
1209   return 0;
1210 }
1211
1212 /*  Psymtab version of map_matching_symbols.  See its definition in
1213     the definition of quick_symbol_functions in symfile.h.  */
1214
1215 static void
1216 map_matching_symbols_psymtab (const char *name, domain_enum namespace,
1217                               struct objfile *objfile, int global,
1218                               int (*callback) (struct block *,
1219                                                struct symbol *, void *),
1220                               void *data,
1221                               symbol_compare_ftype *match,
1222                               symbol_compare_ftype *ordered_compare)
1223 {
1224   const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
1225   struct partial_symtab *ps;
1226
1227   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1228     {
1229       QUIT;
1230       if (ps->readin
1231           || match_partial_symbol (ps, global, name, namespace, match,
1232                                    ordered_compare))
1233         {
1234           struct symtab *s = PSYMTAB_TO_SYMTAB (ps);
1235           struct block *block;
1236
1237           if (s == NULL || !s->primary)
1238             continue;
1239           block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind);
1240           if (map_block (name, namespace, objfile, block,
1241                          callback, data, match))
1242             return;
1243           if (callback (block, NULL, data))
1244             return;
1245         }
1246     }
1247 }
1248
1249 static void
1250 expand_symtabs_matching_via_partial
1251   (struct objfile *objfile,
1252    int (*file_matcher) (const char *, void *),
1253    int (*name_matcher) (const char *, void *),
1254    enum search_domain kind,
1255    void *data)
1256 {
1257   struct partial_symtab *ps;
1258
1259   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1260     {
1261       struct partial_symbol **psym;
1262       struct partial_symbol **bound, **gbound, **sbound;
1263       int keep_going = 1;
1264
1265       if (ps->readin)
1266         continue;
1267
1268       if (file_matcher && ! (*file_matcher) (ps->filename, data))
1269         continue;
1270
1271       gbound = objfile->global_psymbols.list
1272         + ps->globals_offset + ps->n_global_syms;
1273       sbound = objfile->static_psymbols.list
1274         + ps->statics_offset + ps->n_static_syms;
1275       bound = gbound;
1276
1277       /* Go through all of the symbols stored in a partial
1278          symtab in one loop.  */
1279       psym = objfile->global_psymbols.list + ps->globals_offset;
1280       while (keep_going)
1281         {
1282           if (psym >= bound)
1283             {
1284               if (bound == gbound && ps->n_static_syms != 0)
1285                 {
1286                   psym = objfile->static_psymbols.list + ps->statics_offset;
1287                   bound = sbound;
1288                 }
1289               else
1290                 keep_going = 0;
1291               continue;
1292             }
1293           else
1294             {
1295               QUIT;
1296
1297               if ((kind == ALL_DOMAIN
1298                    || (kind == VARIABLES_DOMAIN
1299                        && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
1300                        && SYMBOL_CLASS (*psym) != LOC_BLOCK)
1301                    || (kind == FUNCTIONS_DOMAIN
1302                        && SYMBOL_CLASS (*psym) == LOC_BLOCK)
1303                    || (kind == TYPES_DOMAIN
1304                        && SYMBOL_CLASS (*psym) == LOC_TYPEDEF))
1305                   && (*name_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
1306                 {
1307                   PSYMTAB_TO_SYMTAB (ps);
1308                   keep_going = 0;
1309                 }
1310             }
1311           psym++;
1312         }
1313     }
1314 }
1315
1316 static int
1317 objfile_has_psyms (struct objfile *objfile)
1318 {
1319   return objfile->psymtabs != NULL;
1320 }
1321
1322 const struct quick_symbol_functions psym_functions =
1323 {
1324   objfile_has_psyms,
1325   find_last_source_symtab_from_partial,
1326   forget_cached_source_info_partial,
1327   partial_map_symtabs_matching_filename,
1328   lookup_symbol_aux_psymtabs,
1329   pre_expand_symtabs_matching_psymtabs,
1330   print_psymtab_stats_for_objfile,
1331   dump_psymtabs_for_objfile,
1332   relocate_psymtabs,
1333   read_symtabs_for_function,
1334   expand_partial_symbol_tables,
1335   read_psymtabs_with_filename,
1336   find_symbol_file_from_partial,
1337   map_matching_symbols_psymtab,
1338   expand_symtabs_matching_via_partial,
1339   find_pc_sect_symtab_from_partial,
1340   map_symbol_filenames_psymtab
1341 };
1342
1343 \f
1344
1345 /* This compares two partial symbols by names, using strcmp_iw_ordered
1346    for the comparison.  */
1347
1348 static int
1349 compare_psymbols (const void *s1p, const void *s2p)
1350 {
1351   struct partial_symbol *const *s1 = s1p;
1352   struct partial_symbol *const *s2 = s2p;
1353
1354   return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
1355                             SYMBOL_SEARCH_NAME (*s2));
1356 }
1357
1358 void
1359 sort_pst_symbols (struct partial_symtab *pst)
1360 {
1361   /* Sort the global list; don't sort the static list.  */
1362
1363   qsort (pst->objfile->global_psymbols.list + pst->globals_offset,
1364          pst->n_global_syms, sizeof (struct partial_symbol *),
1365          compare_psymbols);
1366 }
1367
1368 /* Allocate and partially fill a partial symtab.  It will be
1369    completely filled at the end of the symbol list.
1370
1371    FILENAME is the name of the symbol-file we are reading from.  */
1372
1373 struct partial_symtab *
1374 start_psymtab_common (struct objfile *objfile,
1375                       struct section_offsets *section_offsets,
1376                       const char *filename,
1377                       CORE_ADDR textlow, struct partial_symbol **global_syms,
1378                       struct partial_symbol **static_syms)
1379 {
1380   struct partial_symtab *psymtab;
1381
1382   psymtab = allocate_psymtab (filename, objfile);
1383   psymtab->section_offsets = section_offsets;
1384   psymtab->textlow = textlow;
1385   psymtab->texthigh = psymtab->textlow;         /* default */
1386   psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
1387   psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
1388   return (psymtab);
1389 }
1390
1391 /* Calculate a hash code for the given partial symbol.  The hash is
1392    calculated using the symbol's value, language, domain, class
1393    and name.  These are the values which are set by
1394    add_psymbol_to_bcache.  */
1395
1396 static unsigned long
1397 psymbol_hash (const void *addr, int length)
1398 {
1399   unsigned long h = 0;
1400   struct partial_symbol *psymbol = (struct partial_symbol *) addr;
1401   unsigned int lang = psymbol->ginfo.language;
1402   unsigned int domain = PSYMBOL_DOMAIN (psymbol);
1403   unsigned int class = PSYMBOL_CLASS (psymbol);
1404
1405   h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
1406   h = hash_continue (&lang, sizeof (unsigned int), h);
1407   h = hash_continue (&domain, sizeof (unsigned int), h);
1408   h = hash_continue (&class, sizeof (unsigned int), h);
1409   h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h);
1410
1411   return h;
1412 }
1413
1414 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1415    For the comparison this function uses a symbols value,
1416    language, domain, class and name.  */
1417
1418 static int
1419 psymbol_compare (const void *addr1, const void *addr2, int length)
1420 {
1421   struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1422   struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
1423
1424   return (memcmp (&sym1->ginfo.value, &sym1->ginfo.value,
1425                   sizeof (sym1->ginfo.value)) == 0
1426           && sym1->ginfo.language == sym2->ginfo.language
1427           && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2)
1428           && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2)
1429           && sym1->ginfo.name == sym2->ginfo.name);
1430 }
1431
1432 /* Initialize a partial symbol bcache.  */
1433
1434 struct psymbol_bcache *
1435 psymbol_bcache_init (void)
1436 {
1437   struct psymbol_bcache *bcache = XCALLOC (1, struct psymbol_bcache);
1438   bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
1439   return bcache;
1440 }
1441
1442 /* Free a partial symbol bcache.  */
1443 void
1444 psymbol_bcache_free (struct psymbol_bcache *bcache)
1445 {
1446   if (bcache == NULL)
1447     return;
1448
1449   bcache_xfree (bcache->bcache);
1450   xfree (bcache);
1451 }
1452
1453 /* Return the internal bcache of the psymbol_bcache BCACHE.  */
1454
1455 struct bcache *
1456 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
1457 {
1458   return bcache->bcache;
1459 }
1460
1461 /* Find a copy of the SYM in BCACHE.  If BCACHE has never seen this
1462    symbol before, add a copy to BCACHE.  In either case, return a pointer
1463    to BCACHE's copy of the symbol.  If optional ADDED is not NULL, return
1464    1 in case of new entry or 0 if returning an old entry.  */
1465
1466 static const struct partial_symbol *
1467 psymbol_bcache_full (struct partial_symbol *sym,
1468                      struct psymbol_bcache *bcache,
1469                      int *added)
1470 {
1471   return bcache_full (sym,
1472                       sizeof (struct partial_symbol),
1473                       bcache->bcache,
1474                       added);
1475 }
1476
1477 /* Helper function, initialises partial symbol structure and stashes
1478    it into objfile's bcache.  Note that our caching mechanism will
1479    use all fields of struct partial_symbol to determine hash value of the
1480    structure.  In other words, having two symbols with the same name but
1481    different domain (or address) is possible and correct.  */
1482
1483 static const struct partial_symbol *
1484 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
1485                        domain_enum domain,
1486                        enum address_class class,
1487                        long val,        /* Value as a long */
1488                        CORE_ADDR coreaddr,      /* Value as a CORE_ADDR */
1489                        enum language language, struct objfile *objfile,
1490                        int *added)
1491 {
1492   struct partial_symbol psymbol;
1493
1494   /* We must ensure that the entire 'value' field has been zeroed
1495      before assigning to it, because an assignment may not write the
1496      entire field.  */
1497   memset (&psymbol.ginfo.value, 0, sizeof (psymbol.ginfo.value));
1498
1499   /* val and coreaddr are mutually exclusive, one of them *will* be zero.  */
1500   if (val != 0)
1501     {
1502       SYMBOL_VALUE (&psymbol) = val;
1503     }
1504   else
1505     {
1506       SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
1507     }
1508   SYMBOL_SECTION (&psymbol) = 0;
1509   SYMBOL_OBJ_SECTION (&psymbol) = NULL;
1510   SYMBOL_SET_LANGUAGE (&psymbol, language);
1511   PSYMBOL_DOMAIN (&psymbol) = domain;
1512   PSYMBOL_CLASS (&psymbol) = class;
1513
1514   SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
1515
1516   /* Stash the partial symbol away in the cache.  */
1517   return psymbol_bcache_full (&psymbol,
1518                               objfile->psymbol_cache,
1519                               added);
1520 }
1521
1522 /* Increase the space allocated for LISTP, which is probably
1523    global_psymbols or static_psymbols.  This space will eventually
1524    be freed in free_objfile().  */
1525
1526 static void
1527 extend_psymbol_list (struct psymbol_allocation_list *listp,
1528                      struct objfile *objfile)
1529 {
1530   int new_size;
1531
1532   if (listp->size == 0)
1533     {
1534       new_size = 255;
1535       listp->list = (struct partial_symbol **)
1536         xmalloc (new_size * sizeof (struct partial_symbol *));
1537     }
1538   else
1539     {
1540       new_size = listp->size * 2;
1541       listp->list = (struct partial_symbol **)
1542         xrealloc ((char *) listp->list,
1543                   new_size * sizeof (struct partial_symbol *));
1544     }
1545   /* Next assumes we only went one over.  Should be good if
1546      program works correctly.  */
1547   listp->next = listp->list + listp->size;
1548   listp->size = new_size;
1549 }
1550
1551 /* Helper function, adds partial symbol to the given partial symbol
1552    list.  */
1553
1554 static void
1555 append_psymbol_to_list (struct psymbol_allocation_list *list,
1556                         const struct partial_symbol *psym,
1557                         struct objfile *objfile)
1558 {
1559   if (list->next >= list->list + list->size)
1560     extend_psymbol_list (list, objfile);
1561   *list->next++ = (struct partial_symbol *) psym;
1562   OBJSTAT (objfile, n_psyms++);
1563 }
1564
1565 /* Add a symbol with a long value to a psymtab.
1566    Since one arg is a struct, we pass in a ptr and deref it (sigh).
1567    Return the partial symbol that has been added.  */
1568
1569 /* NOTE: carlton/2003-09-11: The reason why we return the partial
1570    symbol is so that callers can get access to the symbol's demangled
1571    name, which they don't have any cheap way to determine otherwise.
1572    (Currenly, dwarf2read.c is the only file who uses that information,
1573    though it's possible that other readers might in the future.)
1574    Elena wasn't thrilled about that, and I don't blame her, but we
1575    couldn't come up with a better way to get that information.  If
1576    it's needed in other situations, we could consider breaking up
1577    SYMBOL_SET_NAMES to provide access to the demangled name lookup
1578    cache.  */
1579
1580 const struct partial_symbol *
1581 add_psymbol_to_list (const char *name, int namelength, int copy_name,
1582                      domain_enum domain,
1583                      enum address_class class,
1584                      struct psymbol_allocation_list *list,
1585                      long val,  /* Value as a long */
1586                      CORE_ADDR coreaddr,        /* Value as a CORE_ADDR */
1587                      enum language language, struct objfile *objfile)
1588 {
1589   const struct partial_symbol *psym;
1590
1591   int added;
1592
1593   /* Stash the partial symbol away in the cache.  */
1594   psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, class,
1595                                 val, coreaddr, language, objfile, &added);
1596
1597   /* Do not duplicate global partial symbols.  */
1598   if (list == &objfile->global_psymbols
1599       && !added)
1600     return psym;
1601
1602   /* Save pointer to partial symbol in psymtab, growing symtab if needed.  */
1603   append_psymbol_to_list (list, psym, objfile);
1604   return psym;
1605 }
1606
1607 /* Initialize storage for partial symbols.  */
1608
1609 void
1610 init_psymbol_list (struct objfile *objfile, int total_symbols)
1611 {
1612   /* Free any previously allocated psymbol lists.  */
1613
1614   if (objfile->global_psymbols.list)
1615     {
1616       xfree (objfile->global_psymbols.list);
1617     }
1618   if (objfile->static_psymbols.list)
1619     {
1620       xfree (objfile->static_psymbols.list);
1621     }
1622
1623   /* Current best guess is that approximately a twentieth
1624      of the total symbols (in a debugging file) are global or static
1625      oriented symbols.  */
1626
1627   objfile->global_psymbols.size = total_symbols / 10;
1628   objfile->static_psymbols.size = total_symbols / 10;
1629
1630   if (objfile->global_psymbols.size > 0)
1631     {
1632       objfile->global_psymbols.next =
1633         objfile->global_psymbols.list = (struct partial_symbol **)
1634         xmalloc ((objfile->global_psymbols.size
1635                   * sizeof (struct partial_symbol *)));
1636     }
1637   if (objfile->static_psymbols.size > 0)
1638     {
1639       objfile->static_psymbols.next =
1640         objfile->static_psymbols.list = (struct partial_symbol **)
1641         xmalloc ((objfile->static_psymbols.size
1642                   * sizeof (struct partial_symbol *)));
1643     }
1644 }
1645
1646 struct partial_symtab *
1647 allocate_psymtab (const char *filename, struct objfile *objfile)
1648 {
1649   struct partial_symtab *psymtab;
1650
1651   if (objfile->free_psymtabs)
1652     {
1653       psymtab = objfile->free_psymtabs;
1654       objfile->free_psymtabs = psymtab->next;
1655     }
1656   else
1657     psymtab = (struct partial_symtab *)
1658       obstack_alloc (&objfile->objfile_obstack,
1659                      sizeof (struct partial_symtab));
1660
1661   memset (psymtab, 0, sizeof (struct partial_symtab));
1662   psymtab->filename = obsavestring (filename, strlen (filename),
1663                                     &objfile->objfile_obstack);
1664   psymtab->symtab = NULL;
1665
1666   /* Prepend it to the psymtab list for the objfile it belongs to.
1667      Psymtabs are searched in most recent inserted -> least recent
1668      inserted order.  */
1669
1670   psymtab->objfile = objfile;
1671   psymtab->next = objfile->psymtabs;
1672   objfile->psymtabs = psymtab;
1673
1674   return (psymtab);
1675 }
1676
1677 void
1678 discard_psymtab (struct partial_symtab *pst)
1679 {
1680   struct partial_symtab **prev_pst;
1681
1682   /* From dbxread.c:
1683      Empty psymtabs happen as a result of header files which don't
1684      have any symbols in them.  There can be a lot of them.  But this
1685      check is wrong, in that a psymtab with N_SLINE entries but
1686      nothing else is not empty, but we don't realize that.  Fixing
1687      that without slowing things down might be tricky.  */
1688
1689   /* First, snip it out of the psymtab chain.  */
1690
1691   prev_pst = &(pst->objfile->psymtabs);
1692   while ((*prev_pst) != pst)
1693     prev_pst = &((*prev_pst)->next);
1694   (*prev_pst) = pst->next;
1695
1696   /* Next, put it on a free list for recycling.  */
1697
1698   pst->next = pst->objfile->free_psymtabs;
1699   pst->objfile->free_psymtabs = pst;
1700 }
1701
1702 \f
1703
1704 void
1705 maintenance_print_psymbols (char *args, int from_tty)
1706 {
1707   char **argv;
1708   struct ui_file *outfile;
1709   struct cleanup *cleanups;
1710   char *symname = NULL;
1711   char *filename = DEV_TTY;
1712   struct objfile *objfile;
1713   struct partial_symtab *ps;
1714
1715   dont_repeat ();
1716
1717   if (args == NULL)
1718     {
1719       error (_("\
1720 print-psymbols takes an output file name and optional symbol file name"));
1721     }
1722   argv = gdb_buildargv (args);
1723   cleanups = make_cleanup_freeargv (argv);
1724
1725   if (argv[0] != NULL)
1726     {
1727       filename = argv[0];
1728       /* If a second arg is supplied, it is a source file name to match on.  */
1729       if (argv[1] != NULL)
1730         {
1731           symname = argv[1];
1732         }
1733     }
1734
1735   filename = tilde_expand (filename);
1736   make_cleanup (xfree, filename);
1737
1738   outfile = gdb_fopen (filename, FOPEN_WT);
1739   if (outfile == 0)
1740     perror_with_name (filename);
1741   make_cleanup_ui_file_delete (outfile);
1742
1743   immediate_quit++;
1744   ALL_PSYMTABS (objfile, ps)
1745     if (symname == NULL || filename_cmp (symname, ps->filename) == 0)
1746     dump_psymtab (objfile, ps, outfile);
1747   immediate_quit--;
1748   do_cleanups (cleanups);
1749 }
1750
1751 /* List all the partial symbol tables whose names match REGEXP (optional).  */
1752 void
1753 maintenance_info_psymtabs (char *regexp, int from_tty)
1754 {
1755   struct program_space *pspace;
1756   struct objfile *objfile;
1757
1758   if (regexp)
1759     re_comp (regexp);
1760
1761   ALL_PSPACES (pspace)
1762     ALL_PSPACE_OBJFILES (pspace, objfile)
1763     {
1764       struct gdbarch *gdbarch = get_objfile_arch (objfile);
1765       struct partial_symtab *psymtab;
1766
1767       /* We don't want to print anything for this objfile until we
1768          actually find a symtab whose name matches.  */
1769       int printed_objfile_start = 0;
1770
1771       ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1772         {
1773           QUIT;
1774
1775           if (! regexp
1776               || re_exec (psymtab->filename))
1777             {
1778               if (! printed_objfile_start)
1779                 {
1780                   printf_filtered ("{ objfile %s ", objfile->name);
1781                   wrap_here ("  ");
1782                   printf_filtered ("((struct objfile *) %s)\n",
1783                                    host_address_to_string (objfile));
1784                   printed_objfile_start = 1;
1785                 }
1786
1787               printf_filtered ("  { psymtab %s ", psymtab->filename);
1788               wrap_here ("    ");
1789               printf_filtered ("((struct partial_symtab *) %s)\n",
1790                                host_address_to_string (psymtab));
1791
1792               printf_filtered ("    readin %s\n",
1793                                psymtab->readin ? "yes" : "no");
1794               printf_filtered ("    fullname %s\n",
1795                                psymtab->fullname
1796                                ? psymtab->fullname : "(null)");
1797               printf_filtered ("    text addresses ");
1798               fputs_filtered (paddress (gdbarch, psymtab->textlow),
1799                               gdb_stdout);
1800               printf_filtered (" -- ");
1801               fputs_filtered (paddress (gdbarch, psymtab->texthigh),
1802                               gdb_stdout);
1803               printf_filtered ("\n");
1804               printf_filtered ("    psymtabs_addrmap_supported %s\n",
1805                                (psymtab->psymtabs_addrmap_supported
1806                                 ? "yes" : "no"));
1807               printf_filtered ("    globals ");
1808               if (psymtab->n_global_syms)
1809                 {
1810                   printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1811                                    host_address_to_string (psymtab->objfile->global_psymbols.list
1812                                     + psymtab->globals_offset),
1813                                    psymtab->n_global_syms);
1814                 }
1815               else
1816                 printf_filtered ("(none)\n");
1817               printf_filtered ("    statics ");
1818               if (psymtab->n_static_syms)
1819                 {
1820                   printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1821                                    host_address_to_string (psymtab->objfile->static_psymbols.list
1822                                     + psymtab->statics_offset),
1823                                    psymtab->n_static_syms);
1824                 }
1825               else
1826                 printf_filtered ("(none)\n");
1827               printf_filtered ("    dependencies ");
1828               if (psymtab->number_of_dependencies)
1829                 {
1830                   int i;
1831
1832                   printf_filtered ("{\n");
1833                   for (i = 0; i < psymtab->number_of_dependencies; i++)
1834                     {
1835                       struct partial_symtab *dep = psymtab->dependencies[i];
1836
1837                       /* Note the string concatenation there --- no comma.  */
1838                       printf_filtered ("      psymtab %s "
1839                                        "((struct partial_symtab *) %s)\n",
1840                                        dep->filename,
1841                                        host_address_to_string (dep));
1842                     }
1843                   printf_filtered ("    }\n");
1844                 }
1845               else
1846                 printf_filtered ("(none)\n");
1847               printf_filtered ("  }\n");
1848             }
1849         }
1850
1851       if (printed_objfile_start)
1852         printf_filtered ("}\n");
1853     }
1854 }
1855
1856 /* Check consistency of psymtabs and symtabs.  */
1857
1858 void
1859 maintenance_check_symtabs (char *ignore, int from_tty)
1860 {
1861   struct symbol *sym;
1862   struct partial_symbol **psym;
1863   struct symtab *s = NULL;
1864   struct partial_symtab *ps;
1865   struct blockvector *bv;
1866   struct objfile *objfile;
1867   struct block *b;
1868   int length;
1869
1870   ALL_PSYMTABS (objfile, ps)
1871   {
1872     struct gdbarch *gdbarch = get_objfile_arch (objfile);
1873
1874     s = PSYMTAB_TO_SYMTAB (ps);
1875     if (s == NULL)
1876       continue;
1877     bv = BLOCKVECTOR (s);
1878     b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1879     psym = ps->objfile->static_psymbols.list + ps->statics_offset;
1880     length = ps->n_static_syms;
1881     while (length--)
1882       {
1883         sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
1884                                    SYMBOL_DOMAIN (*psym));
1885         if (!sym)
1886           {
1887             printf_filtered ("Static symbol `");
1888             puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
1889             printf_filtered ("' only found in ");
1890             puts_filtered (ps->filename);
1891             printf_filtered (" psymtab\n");
1892           }
1893         psym++;
1894       }
1895     b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1896     psym = ps->objfile->global_psymbols.list + ps->globals_offset;
1897     length = ps->n_global_syms;
1898     while (length--)
1899       {
1900         sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
1901                                    SYMBOL_DOMAIN (*psym));
1902         if (!sym)
1903           {
1904             printf_filtered ("Global symbol `");
1905             puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
1906             printf_filtered ("' only found in ");
1907             puts_filtered (ps->filename);
1908             printf_filtered (" psymtab\n");
1909           }
1910         psym++;
1911       }
1912     if (ps->texthigh < ps->textlow)
1913       {
1914         printf_filtered ("Psymtab ");
1915         puts_filtered (ps->filename);
1916         printf_filtered (" covers bad range ");
1917         fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
1918         printf_filtered (" - ");
1919         fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
1920         printf_filtered ("\n");
1921         continue;
1922       }
1923     if (ps->texthigh == 0)
1924       continue;
1925     if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
1926       {
1927         printf_filtered ("Psymtab ");
1928         puts_filtered (ps->filename);
1929         printf_filtered (" covers ");
1930         fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
1931         printf_filtered (" - ");
1932         fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
1933         printf_filtered (" but symtab covers only ");
1934         fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
1935         printf_filtered (" - ");
1936         fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
1937         printf_filtered ("\n");
1938       }
1939   }
1940 }
1941
1942 \f
1943
1944 void
1945 expand_partial_symbol_names (int (*fun) (const char *, void *),
1946                              void *data)
1947 {
1948   struct objfile *objfile;
1949
1950   ALL_OBJFILES (objfile)
1951   {
1952     if (objfile->sf)
1953       objfile->sf->qf->expand_symtabs_matching (objfile, NULL, fun,
1954                                                 ALL_DOMAIN, data);
1955   }
1956 }
1957
1958 void
1959 map_partial_symbol_filenames (symbol_filename_ftype *fun, void *data,
1960                               int need_fullname)
1961 {
1962   struct objfile *objfile;
1963
1964   ALL_OBJFILES (objfile)
1965   {
1966     if (objfile->sf)
1967       objfile->sf->qf->map_symbol_filenames (objfile, fun, data,
1968                                              need_fullname);
1969   }
1970 }