gdb/psymtab.c

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