gdb/psymtab.c

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