gdb/psymtab.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Partial symbol tables.

  3.    Copyright (C) 2009-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  39. #ifndef DEV_TTY
  40. ‌#define DEV_TTY "/dev/tty"
  41. #endif

  43. ‌struct psymbol_bcache
  44. {
  45.   struct bcache *bcache;
  46. };

  48. static struct partial_symbol *match_partial_symbol (struct objfile *,
  49.                                                     struct partial_symtab *,
  50.                                                     int,
  51.                                                     const char *, domain_enum,
  52.                                                     symbol_compare_ftype *,
  53.                                                     symbol_compare_ftype *);

  55. static struct partial_symbol *lookup_partial_symbol (struct objfile *,
  56.                                                      struct partial_symtab *,
  57.                                                      const char *, int,
  58.                                                      domain_enum);

  60. static const char *psymtab_to_fullname (struct partial_symtab *ps);

  62. static struct partial_symbol *find_pc_sect_psymbol (struct objfile *,
  63.                                                     struct partial_symtab *,
  64.                                                     CORE_ADDR,
  65.                                                     struct obj_section *);

  67. static void fixup_psymbol_section (struct partial_symbol *psym,
  68.                                    struct objfile *objfile);

  70. static struct compunit_symtab *psymtab_to_symtab (struct objfile *objfile,
  71.                                                   struct partial_symtab *pst);

  73. /* Ensure that the partial symbols for OBJFILE have been loaded.  This
  74.    function always returns its argument, as a convenience.  */

  76. struct objfile *
  77. ‌require_partial_symbols (struct objfile *objfile, int verbose)
  78. {
  79.   if ((objfile->flags & OBJF_PSYMTABS_READ) == 0)
  80.     {
  81.       objfile->flags |= OBJF_PSYMTABS_READ;

  83.       if (objfile->sf->sym_read_psymbols)
  84.         {
  85.           if (verbose)
  86.             {
  87.               printf_unfiltered (_("Reading symbols from %s..."),
  88.                                  objfile_name (objfile));
  89.               gdb_flush (gdb_stdout);
  90.             }
  91.           (*objfile->sf->sym_read_psymbols) (objfile);
  92.           if (verbose)
  93.             {
  94.               if (!objfile_has_symbols (objfile))
  95.                 {
  96.                   wrap_here ("");
  97.                   printf_unfiltered (_("(no debugging symbols found)..."));
  98.                   wrap_here ("");
  99.                 }

  101.               printf_unfiltered (_("done.\n"));
  102.             }
  103.         }
  104.     }

  106.   return objfile;
  107. }

  109. /* Traverse all psymtabs in one objfile, requiring that the psymtabs
  110.    be read in.  */

  112. ‌#define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p)                \
  113.     for ((p) = require_partial_symbols (objfile, 1)->psymtabs;        \
  114.          (p) != NULL;                                                \
  115.          (p) = (p)->next)

  117. /* We want to make sure this file always requires psymtabs.  */

  119. ‌#undef ALL_OBJFILE_PSYMTABS

  121. /* Traverse all psymtabs in all objfiles.  */

  123. ‌#define ALL_PSYMTABS(objfile, p) \
  124.   ALL_OBJFILES (objfile)         \
  125.     ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)

  127. /* Helper function for psym_map_symtabs_matching_filename that
  128.    expands the symtabs and calls the iterator.  */

  130. static int
  131. ‌partial_map_expand_apply (struct objfile *objfile,
  132.                           const char *name,
  133.                           const char *real_path,
  134.                           struct partial_symtab *pst,
  135.                           int (*callback) (struct symtab *, void *),
  136.                           void *data)
  137. {
  138.   struct compunit_symtab *last_made = objfile->compunit_symtabs;

  140.   /* Shared psymtabs should never be seen here.  Instead they should
  141.      be handled properly by the caller.  */
  142.   gdb_assert (pst->user == NULL);

  144.   /* Don't visit already-expanded psymtabs.  */
  145.   if (pst->readin)
  146.     return 0;

  148.   /* This may expand more than one symtab, and we want to iterate over
  149.      all of them.  */
  150.   psymtab_to_symtab (objfile, pst);

  152.   return iterate_over_some_symtabs (name, real_path, callback, data,
  153.                                     objfile->compunit_symtabs, last_made);
  154. }

  156. /*  Psymtab version of map_symtabs_matching_filename.  See its definition in
  157.     the definition of quick_symbol_functions in symfile.h.  */

  159. static int
  160. ‌psym_map_symtabs_matching_filename (struct objfile *objfile,
  161.                                     const char *name,
  162.                                     const char *real_path,
  163.                                     int (*callback) (struct symtab *,
  164.                                                      void *),
  165.                                     void *data)
  166. {
  167.   struct partial_symtab *pst;
  168.   const char *name_basename = lbasename (name);

  170.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
  171.   {
  172.     /* We can skip shared psymtabs here, because any file name will be
  173.        attached to the unshared psymtab.  */
  174.     if (pst->user != NULL)
  175.       continue;

  177.     /* Anonymous psymtabs don't have a file name.  */
  178.     if (pst->anonymous)
  179.       continue;

  181.     if (compare_filenames_for_search (pst->filename, name))
  182.       {
  183.         if (partial_map_expand_apply (objfile, name, real_path,
  184.                                       pst, callback, data))
  185.           return 1;
  186.         continue;
  187.       }

  189.     /* Before we invoke realpath, which can get expensive when many
  190.        files are involved, do a quick comparison of the basenames.  */
  191.     if (! basenames_may_differ
  192.         && FILENAME_CMP (name_basename, lbasename (pst->filename)) != 0)
  193.       continue;

  195.     if (compare_filenames_for_search (psymtab_to_fullname (pst), name))
  196.       {
  197.         if (partial_map_expand_apply (objfile, name, real_path,
  198.                                       pst, callback, data))
  199.           return 1;
  200.         continue;
  201.       }

  203.     /* If the user gave us an absolute path, try to find the file in
  204.        this symtab and use its absolute path.  */
  205.     if (real_path != NULL)
  206.       {
  207.         gdb_assert (IS_ABSOLUTE_PATH (real_path));
  208.         gdb_assert (IS_ABSOLUTE_PATH (name));
  209.         if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0)
  210.           {
  211.             if (partial_map_expand_apply (objfile, name, real_path,
  212.                                           pst, callback, data))
  213.               return 1;
  214.             continue;
  215.           }
  216.       }
  217.   }

  219.   return 0;
  220. }

  222. /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
  223.    We may find a different psymtab than PST.  See FIND_PC_SECT_PSYMTAB.  */

  225. static struct partial_symtab *
  226. ‌find_pc_sect_psymtab_closer (struct objfile *objfile,
  227.                              CORE_ADDR pc, struct obj_section *section,
  228.                              struct partial_symtab *pst,
  229.                              struct bound_minimal_symbol msymbol)
  230. {
  231.   struct partial_symtab *tpst;
  232.   struct partial_symtab *best_pst = pst;
  233.   CORE_ADDR best_addr = pst->textlow;

  235.   gdb_assert (!pst->psymtabs_addrmap_supported);

  237.   /* An objfile that has its functions reordered might have
  238.      many partial symbol tables containing the PC, but
  239.      we want the partial symbol table that contains the
  240.      function containing the PC.  */
  241.   if (!(objfile->flags & OBJF_REORDERED) &&
  242.       section == 0)        /* Can't validate section this way.  */
  243.     return pst;

  245.   if (msymbol.minsym == NULL)
  246.     return (pst);

  248.   /* The code range of partial symtabs sometimes overlap, so, in
  249.      the loop below, we need to check all partial symtabs and
  250.      find the one that fits better for the given PC address.  We
  251.      select the partial symtab that contains a symbol whose
  252.      address is closest to the PC address.  By closest we mean
  253.      that find_pc_sect_symbol returns the symbol with address
  254.      that is closest and still less than the given PC.  */
  255.   for (tpst = pst; tpst != NULL; tpst = tpst->next)
  256.     {
  257.       if (pc >= tpst->textlow && pc < tpst->texthigh)
  258.         {
  259.           struct partial_symbol *p;
  260.           CORE_ADDR this_addr;

  262.           /* NOTE: This assumes that every psymbol has a
  263.              corresponding msymbol, which is not necessarily
  264.              true; the debug info might be much richer than the
  265.              object's symbol table.  */
  266.           p = find_pc_sect_psymbol (objfile, tpst, pc, section);
  267.           if (p != NULL
  268.               && SYMBOL_VALUE_ADDRESS (p)
  269.               == BMSYMBOL_VALUE_ADDRESS (msymbol))
  270.             return tpst;

  272.           /* Also accept the textlow value of a psymtab as a
  273.              "symbol", to provide some support for partial
  274.              symbol tables with line information but no debug
  275.              symbols (e.g. those produced by an assembler).  */
  276.           if (p != NULL)
  277.             this_addr = SYMBOL_VALUE_ADDRESS (p);
  278.           else
  279.             this_addr = tpst->textlow;

  281.           /* Check whether it is closer than our current
  282.              BEST_ADDR.  Since this symbol address is
  283.              necessarily lower or equal to PC, the symbol closer
  284.              to PC is the symbol which address is the highest.
  285.              This way we return the psymtab which contains such
  286.              best match symbol.  This can help in cases where the
  287.              symbol information/debuginfo is not complete, like
  288.              for instance on IRIX6 with gcc, where no debug info
  289.              is emitted for statics.  (See also the nodebug.exp
  290.              testcase.)  */
  291.           if (this_addr > best_addr)
  292.             {
  293.               best_addr = this_addr;
  294.               best_pst = tpst;
  295.             }
  296.         }
  297.     }
  298.   return best_pst;
  299. }

  301. /* Find which partial symtab contains PC and SECTION.  Return 0 if
  302.    none.  We return the psymtab that contains a symbol whose address
  303.    exactly matches PC, or, if we cannot find an exact match, the
  304.    psymtab that contains a symbol whose address is closest to PC.  */
  305. static struct partial_symtab *
  306. ‌find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
  307.                       struct obj_section *section,
  308.                       struct bound_minimal_symbol msymbol)
  309. {
  310.   struct partial_symtab *pst;

  312.   /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
  313.      than the later used TEXTLOW/TEXTHIGH one.  */

  315.   if (objfile->psymtabs_addrmap != NULL)
  316.     {
  317.       pst = addrmap_find (objfile->psymtabs_addrmap, pc);
  318.       if (pst != NULL)
  319.         {
  320.           /* FIXME: addrmaps currently do not handle overlayed sections,
  321.              so fall back to the non-addrmap case if we're debugging
  322.              overlays and the addrmap returned the wrong section.  */
  323.           if (overlay_debugging && msymbol.minsym && section)
  324.             {
  325.               struct partial_symbol *p;

  327.               /* NOTE: This assumes that every psymbol has a
  328.                  corresponding msymbol, which is not necessarily
  329.                  true; the debug info might be much richer than the
  330.                  object's symbol table.  */
  331.               p = find_pc_sect_psymbol (objfile, pst, pc, section);
  332.               if (!p
  333.                   || SYMBOL_VALUE_ADDRESS (p)
  334.                   != BMSYMBOL_VALUE_ADDRESS (msymbol))
  335.                 goto next;
  336.             }

  338.           /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
  339.              PSYMTABS_ADDRMAP we used has already the best 1-byte
  340.              granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
  341.              a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
  342.              overlap.  */

  344.           return pst;
  345.         }
  346.     }

  348. next:

  350.   /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
  351.      which still have no corresponding full SYMTABs read.  But it is not
  352.      present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
  353.      so far.  */

  355.   /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
  356.      its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
  357.      debug info type in single OBJFILE.  */

  359.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
  360.     if (!pst->psymtabs_addrmap_supported
  361.         && pc >= pst->textlow && pc < pst->texthigh)
  362.       {
  363.         struct partial_symtab *best_pst;

  365.         best_pst = find_pc_sect_psymtab_closer (objfile, pc, section, pst,
  366.                                                 msymbol);
  367.         if (best_pst != NULL)
  368.           return best_pst;
  369.       }

  371.   return NULL;
  372. }

  374. /*  Psymtab version of find_pc_sect_compunit_symtab.  See its definition in
  375.     the definition of quick_symbol_functions in symfile.h.  */

  377. static struct compunit_symtab *
  378. ‌psym_find_pc_sect_compunit_symtab (struct objfile *objfile,
  379.                                    struct bound_minimal_symbol msymbol,
  380.                                    CORE_ADDR pc,
  381.                                    struct obj_section *section,
  382.                                    int warn_if_readin)
  383. {
  384.   struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section,
  385.                                                     msymbol);
  386.   if (ps)
  387.     {
  388.       if (warn_if_readin && ps->readin)
  389.         /* Might want to error() here (in case symtab is corrupt and
  390.            will cause a core dump), but maybe we can successfully
  391.            continue, so let's not.  */
  392.         warning (_("\
  393. (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
  394.                  paddress (get_objfile_arch (objfile), pc));
  395.       psymtab_to_symtab (objfile, ps);
  396.       return ps->compunit_symtab;
  397.     }
  398.   return NULL;
  399. }

  401. /* Find which partial symbol within a psymtab matches PC and SECTION.
  402.    Return 0 if none.  */

  404. static struct partial_symbol *
  405. ‌find_pc_sect_psymbol (struct objfile *objfile,
  406.                       struct partial_symtab *psymtab, CORE_ADDR pc,
  407.                       struct obj_section *section)
  408. {
  409.   struct partial_symbol *best = NULL, *p, **pp;
  410.   CORE_ADDR best_pc;

  412.   gdb_assert (psymtab != NULL);

  414.   /* Cope with programs that start at address 0.  */
  415.   best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;

  417.   /* Search the global symbols as well as the static symbols, so that
  418.      find_pc_partial_function doesn't use a minimal symbol and thus
  419.      cache a bad endaddr.  */
  420.   for (pp = objfile->global_psymbols.list + psymtab->globals_offset;
  421.     (pp - (objfile->global_psymbols.list + psymtab->globals_offset)
  422.      < psymtab->n_global_syms);
  423.        pp++)
  424.     {
  425.       p = *pp;
  426.       if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
  427.           && PSYMBOL_CLASS (p) == LOC_BLOCK
  428.           && pc >= SYMBOL_VALUE_ADDRESS (p)
  429.           && (SYMBOL_VALUE_ADDRESS (p) > best_pc
  430.               || (psymtab->textlow == 0
  431.                   && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
  432.         {
  433.           if (section)                /* Match on a specific section.  */
  434.             {
  435.               fixup_psymbol_section (p, objfile);
  436.               if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
  437.                                           section))
  438.                 continue;
  439.             }
  440.           best_pc = SYMBOL_VALUE_ADDRESS (p);
  441.           best = p;
  442.         }
  443.     }

  445.   for (pp = objfile->static_psymbols.list + psymtab->statics_offset;
  446.     (pp - (objfile->static_psymbols.list + psymtab->statics_offset)
  447.      < psymtab->n_static_syms);
  448.        pp++)
  449.     {
  450.       p = *pp;
  451.       if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
  452.           && PSYMBOL_CLASS (p) == LOC_BLOCK
  453.           && pc >= SYMBOL_VALUE_ADDRESS (p)
  454.           && (SYMBOL_VALUE_ADDRESS (p) > best_pc
  455.               || (psymtab->textlow == 0
  456.                   && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
  457.         {
  458.           if (section)                /* Match on a specific section.  */
  459.             {
  460.               fixup_psymbol_section (p, objfile);
  461.               if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
  462.                                           section))
  463.                 continue;
  464.             }
  465.           best_pc = SYMBOL_VALUE_ADDRESS (p);
  466.           best = p;
  467.         }
  468.     }

  470.   return best;
  471. }

  473. static void
  474. ‌fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
  475. {
  476.   CORE_ADDR addr;

  478.   if (!psym)
  479.     return;

  481.   if (SYMBOL_SECTION (psym) >= 0)
  482.     return;

  484.   gdb_assert (objfile);

  486.   switch (PSYMBOL_CLASS (psym))
  487.     {
  488.     case LOC_STATIC:
  489.     case LOC_LABEL:
  490.     case LOC_BLOCK:
  491.       addr = SYMBOL_VALUE_ADDRESS (psym);
  492.       break;
  493.     default:
  494.       /* Nothing else will be listed in the minsyms -- no use looking
  495.          it up.  */
  496.       return;
  497.     }

  499.   fixup_section (&psym->ginfo, addr, objfile);
  500. }

  502. /*  Psymtab version of lookup_symbol.  See its definition in
  503.     the definition of quick_symbol_functions in symfile.h.  */

  505. static struct compunit_symtab *
  506. ‌psym_lookup_symbol (struct objfile *objfile,
  507.                     int block_index, const char *name,
  508.                     const domain_enum domain)
  509. {
  510.   struct partial_symtab *ps;
  511.   const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
  512.   struct compunit_symtab *stab_best = NULL;

  514.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
  515.   {
  516.     if (!ps->readin && lookup_partial_symbol (objfile, ps, name,
  517.                                               psymtab_index, domain))
  518.       {
  519.         struct symbol *sym = NULL;
  520.         struct compunit_symtab *stab = psymtab_to_symtab (objfile, ps);
  521.         /* Note: While psymtab_to_symtab can return NULL if the partial symtab
  522.            is empty, we can assume it won't here because lookup_partial_symbol
  523.            succeeded.  */
  524.         const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
  525.         struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);

  527.         /* Some caution must be observed with overloaded functions
  528.            and methods, since the psymtab will not contain any overload
  529.            information (but NAME might contain it).  */
  530.         sym = block_lookup_symbol (block, name, domain);

  532.         if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
  533.           {
  534.             if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
  535.               return stab;

  537.             stab_best = stab;
  538.           }

  540.         /* Keep looking through other psymtabs.  */
  541.       }
  542.   }

  544.   return stab_best;
  545. }

  547. /* Look in PST for a symbol in DOMAIN whose name matches NAME.  Search
  548.    the global block of PST if GLOBAL, and otherwise the static block.
  549.    MATCH is the comparison operation that returns true iff MATCH (s,
  550.    NAME), where s is a SYMBOL_SEARCH_NAME.  If ORDERED_COMPARE is
  551.    non-null, the symbols in the block are assumed to be ordered
  552.    according to it (allowing binary search).  It must be compatible
  553.    with MATCH.  Returns the symbol, if found, and otherwise NULL.  */

  555. static struct partial_symbol *
  556. ‌match_partial_symbol (struct objfile *objfile,
  557.                       struct partial_symtab *pst, int global,
  558.                       const char *name, domain_enum domain,
  559.                       symbol_compare_ftype *match,
  560.                       symbol_compare_ftype *ordered_compare)
  561. {
  562.   struct partial_symbol **start, **psym;
  563.   struct partial_symbol **top, **real_top, **bottom, **center;
  564.   int length = (global ? pst->n_global_syms : pst->n_static_syms);
  565.   int do_linear_search = 1;

  567.   if (length == 0)
  568.       return NULL;
  569.   start = (global ?
  570.            objfile->global_psymbols.list + pst->globals_offset :
  571.            objfile->static_psymbols.list + pst->statics_offset);

  573.   if (global && ordered_compare)  /* Can use a binary search.  */
  574.     {
  575.       do_linear_search = 0;

  577.       /* Binary search.  This search is guaranteed to end with center
  578.          pointing at the earliest partial symbol whose name might be
  579.          correct.  At that point *all* partial symbols with an
  580.          appropriate name will be checked against the correct
  581.          domain.  */

  583.       bottom = start;
  584.       top = start + length - 1;
  585.       real_top = top;
  586.       while (top > bottom)
  587.         {
  588.           center = bottom + (top - bottom) / 2;
  589.           gdb_assert (center < top);
  590.           if (!do_linear_search
  591.               && (SYMBOL_LANGUAGE (*center) == language_java))
  592.             do_linear_search = 1;
  593.           if (ordered_compare (SYMBOL_SEARCH_NAME (*center), name) >= 0)
  594.             top = center;
  595.           else
  596.             bottom = center + 1;
  597.         }
  598.       gdb_assert (top == bottom);

  600.       while (top <= real_top
  601.              && match (SYMBOL_SEARCH_NAME (*top), name) == 0)
  602.         {
  603.           if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
  604.                                      SYMBOL_DOMAIN (*top), domain))
  605.             return *top;
  606.           top++;
  607.         }
  608.     }

  610.   /* Can't use a binary search or else we found during the binary search that
  611.      we should also do a linear search.  */

  613.   if (do_linear_search)
  614.     {
  615.       for (psym = start; psym < start + length; psym++)
  616.         {
  617.           if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
  618.                                      SYMBOL_DOMAIN (*psym), domain)
  619.               && match (SYMBOL_SEARCH_NAME (*psym), name) == 0)
  620.             return *psym;
  621.         }
  622.     }

  624.   return NULL;
  625. }

  627. /* Returns the name used to search psymtabs.  Unlike symtabs, psymtabs do
  628.    not contain any method/function instance information (since this would
  629.    force reading type information while reading psymtabs).  Therefore,
  630.    if NAME contains overload information, it must be stripped before searching
  631.    psymtabs.

  633.    The caller is responsible for freeing the return result.  */

  635. static char *
  636. ‌psymtab_search_name (const char *name)
  637. {
  638.   switch (current_language->la_language)
  639.     {
  640.     case language_cplus:
  641.     case language_java:
  642.       {
  643.         if (strchr (name, '('))
  644.           {
  645.             char *ret = cp_remove_params (name);

  647.             if (ret)
  648.               return ret;
  649.           }
  650.       }
  651.       break;

  653.     default:
  654.       break;
  655.     }

  657.   return xstrdup (name);
  658. }

  660. /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
  661.    Check the global symbols if GLOBAL, the static symbols if not.  */

  663. static struct partial_symbol *
  664. ‌lookup_partial_symbol (struct objfile *objfile,
  665.                        struct partial_symtab *pst, const char *name,
  666.                        int global, domain_enum domain)
  667. {
  668.   struct partial_symbol **start, **psym;
  669.   struct partial_symbol **top, **real_top, **bottom, **center;
  670.   int length = (global ? pst->n_global_syms : pst->n_static_syms);
  671.   int do_linear_search = 1;
  672.   char *search_name;
  673.   struct cleanup *cleanup;

  675.   if (length == 0)
  676.     {
  677.       return (NULL);
  678.     }

  680.   search_name = psymtab_search_name (name);
  681.   cleanup = make_cleanup (xfree, search_name);
  682.   start = (global ?
  683.            objfile->global_psymbols.list + pst->globals_offset :
  684.            objfile->static_psymbols.list + pst->statics_offset);

  686.   if (global)                        /* This means we can use a binary search.  */
  687.     {
  688.       do_linear_search = 0;

  690.       /* Binary search.  This search is guaranteed to end with center
  691.          pointing at the earliest partial symbol whose name might be
  692.          correct.  At that point *all* partial symbols with an
  693.          appropriate name will be checked against the correct
  694.          domain.  */

  696.       bottom = start;
  697.       top = start + length - 1;
  698.       real_top = top;
  699.       while (top > bottom)
  700.         {
  701.           center = bottom + (top - bottom) / 2;
  702.           if (!(center < top))
  703.             internal_error (__FILE__, __LINE__,
  704.                             _("failed internal consistency check"));
  705.           if (!do_linear_search
  706.               && SYMBOL_LANGUAGE (*center) == language_java)
  707.             {
  708.               do_linear_search = 1;
  709.             }
  710.           if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
  711.                                  search_name) >= 0)
  712.             {
  713.               top = center;
  714.             }
  715.           else
  716.             {
  717.               bottom = center + 1;
  718.             }
  719.         }
  720.       if (!(top == bottom))
  721.         internal_error (__FILE__, __LINE__,
  722.                         _("failed internal consistency check"));

  724.       /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
  725.          search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME.  */
  726.       while (top >= start && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
  727.         top--;

  729.       /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME.  */
  730.       top++;

  732.       while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
  733.         {
  734.           if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
  735.                                      SYMBOL_DOMAIN (*top), domain))
  736.             {
  737.               do_cleanups (cleanup);
  738.               return (*top);
  739.             }
  740.           top++;
  741.         }
  742.     }

  744.   /* Can't use a binary search or else we found during the binary search that
  745.      we should also do a linear search.  */

  747.   if (do_linear_search)
  748.     {
  749.       for (psym = start; psym < start + length; psym++)
  750.         {
  751.           if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
  752.                                      SYMBOL_DOMAIN (*psym), domain)
  753.               && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name))
  754.             {
  755.               do_cleanups (cleanup);
  756.               return (*psym);
  757.             }
  758.         }
  759.     }

  761.   do_cleanups (cleanup);
  762.   return (NULL);
  763. }

  765. /* Get the symbol table that corresponds to a partial_symtab.
  766.    This is fast after the first time you do it.
  767.    The result will be NULL if the primary symtab has no symbols,
  768.    which can happen.  Otherwise the result is the primary symtab
  769.    that contains PST.  */

  771. static struct compunit_symtab *
  772. ‌psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
  773. {
  774.   /* If it is a shared psymtab, find an unshared psymtab that includes
  775.      it.  Any such psymtab will do.  */
  776.   while (pst->user != NULL)
  777.     pst = pst->user;

  779.   /* If it's been looked up before, return it.  */
  780.   if (pst->compunit_symtab)
  781.     return pst->compunit_symtab;

  783.   /* If it has not yet been read in, read it.  */
  784.   if (!pst->readin)
  785.     {
  786.       struct cleanup *back_to = increment_reading_symtab ();

  788.       (*pst->read_symtab) (pst, objfile);
  789.       do_cleanups (back_to);
  790.     }

  792.   return pst->compunit_symtab;
  793. }

  795. /*  Psymtab version of relocate.  See its definition in
  796.     the definition of quick_symbol_functions in symfile.h.  */

  798. static void
  799. ‌psym_relocate (struct objfile *objfile,
  800.                const struct section_offsets *new_offsets,
  801.                const struct section_offsets *delta)
  802. {
  803.   struct partial_symbol **psym;
  804.   struct partial_symtab *p;

  806.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
  807.     {
  808.       p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
  809.       p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
  810.     }

  812.   for (psym = objfile->global_psymbols.list;
  813.        psym < objfile->global_psymbols.next;
  814.        psym++)
  815.     {
  816.       fixup_psymbol_section (*psym, objfile);
  817.       if (SYMBOL_SECTION (*psym) >= 0)
  818.         SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
  819.                                                   SYMBOL_SECTION (*psym));
  820.     }
  821.   for (psym = objfile->static_psymbols.list;
  822.        psym < objfile->static_psymbols.next;
  823.        psym++)
  824.     {
  825.       fixup_psymbol_section (*psym, objfile);
  826.       if (SYMBOL_SECTION (*psym) >= 0)
  827.         SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
  828.                                                   SYMBOL_SECTION (*psym));
  829.     }
  830. }

  832. /*  Psymtab version of find_last_source_symtab.  See its definition in
  833.     the definition of quick_symbol_functions in symfile.h.  */

  835. static struct symtab *
  836. ‌psym_find_last_source_symtab (struct objfile *ofp)
  837. {
  838.   struct partial_symtab *ps;
  839.   struct partial_symtab *cs_pst = 0;

  841.   ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)
  842.     {
  843.       const char *name = ps->filename;
  844.       int len = strlen (name);

  846.       if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
  847.                         || strcmp (name, "<<C++-namespaces>>") == 0)))
  848.         cs_pst = ps;
  849.     }

  851.   if (cs_pst)
  852.     {
  853.       if (cs_pst->readin)
  854.         {
  855.           internal_error (__FILE__, __LINE__,
  856.                           _("select_source_symtab: "
  857.                           "readin pst found and no symtabs."));
  858.         }
  859.       else
  860.         {
  861.           struct compunit_symtab *cust = psymtab_to_symtab (ofp, cs_pst);

  863.           if (cust == NULL)
  864.             return NULL;
  865.           return compunit_primary_filetab (cust);
  866.         }
  867.     }
  868.   return NULL;
  869. }

  871. /*  Psymtab version of forget_cached_source_info.  See its definition in
  872.     the definition of quick_symbol_functions in symfile.h.  */

  874. static void
  875. ‌psym_forget_cached_source_info (struct objfile *objfile)
  876. {
  877.   struct partial_symtab *pst;

  879.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
  880.     {
  881.       if (pst->fullname != NULL)
  882.         {
  883.           xfree (pst->fullname);
  884.           pst->fullname = NULL;
  885.         }
  886.     }
  887. }

  889. static void
  890. ‌print_partial_symbols (struct gdbarch *gdbarch,
  891.                        struct partial_symbol **p, int count, char *what,
  892.                        struct ui_file *outfile)
  893. {
  894.   fprintf_filtered (outfile, "  %s partial symbols:\n", what);
  895.   while (count-- > 0)
  896.     {
  897.       QUIT;
  898.       fprintf_filtered (outfile, "    `%s'", SYMBOL_LINKAGE_NAME (*p));
  899.       if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
  900.         {
  901.           fprintf_filtered (outfile, "  `%s'", SYMBOL_DEMANGLED_NAME (*p));
  902.         }
  903.       fputs_filtered (", ", outfile);
  904.       switch (SYMBOL_DOMAIN (*p))
  905.         {
  906.         case UNDEF_DOMAIN:
  907.           fputs_filtered ("undefined domain, ", outfile);
  908.           break;
  909.         case VAR_DOMAIN:
  910.           /* This is the usual thing -- don't print it.  */
  911.           break;
  912.         case STRUCT_DOMAIN:
  913.           fputs_filtered ("struct domain, ", outfile);
  914.           break;
  915.         case LABEL_DOMAIN:
  916.           fputs_filtered ("label domain, ", outfile);
  917.           break;
  918.         default:
  919.           fputs_filtered ("<invalid domain>, ", outfile);
  920.           break;
  921.         }
  922.       switch (PSYMBOL_CLASS (*p))
  923.         {
  924.         case LOC_UNDEF:
  925.           fputs_filtered ("undefined", outfile);
  926.           break;
  927.         case LOC_CONST:
  928.           fputs_filtered ("constant int", outfile);
  929.           break;
  930.         case LOC_STATIC:
  931.           fputs_filtered ("static", outfile);
  932.           break;
  933.         case LOC_REGISTER:
  934.           fputs_filtered ("register", outfile);
  935.           break;
  936.         case LOC_ARG:
  937.           fputs_filtered ("pass by value", outfile);
  938.           break;
  939.         case LOC_REF_ARG:
  940.           fputs_filtered ("pass by reference", outfile);
  941.           break;
  942.         case LOC_REGPARM_ADDR:
  943.           fputs_filtered ("register address parameter", outfile);
  944.           break;
  945.         case LOC_LOCAL:
  946.           fputs_filtered ("stack parameter", outfile);
  947.           break;
  948.         case LOC_TYPEDEF:
  949.           fputs_filtered ("type", outfile);
  950.           break;
  951.         case LOC_LABEL:
  952.           fputs_filtered ("label", outfile);
  953.           break;
  954.         case LOC_BLOCK:
  955.           fputs_filtered ("function", outfile);
  956.           break;
  957.         case LOC_CONST_BYTES:
  958.           fputs_filtered ("constant bytes", outfile);
  959.           break;
  960.         case LOC_UNRESOLVED:
  961.           fputs_filtered ("unresolved", outfile);
  962.           break;
  963.         case LOC_OPTIMIZED_OUT:
  964.           fputs_filtered ("optimized out", outfile);
  965.           break;
  966.         case LOC_COMPUTED:
  967.           fputs_filtered ("computed at runtime", outfile);
  968.           break;
  969.         default:
  970.           fputs_filtered ("<invalid location>", outfile);
  971.           break;
  972.         }
  973.       fputs_filtered (", ", outfile);
  974.       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile);
  975.       fprintf_filtered (outfile, "\n");
  976.       p++;
  977.     }
  978. }

  980. static void
  981. ‌dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
  982.               struct ui_file *outfile)
  983. {
  984.   struct gdbarch *gdbarch = get_objfile_arch (objfile);
  985.   int i;

  987.   if (psymtab->anonymous)
  988.     {
  989.       fprintf_filtered (outfile, "\nAnonymous partial symtab (%s) ",
  990.                         psymtab->filename);
  991.     }
  992.   else
  993.     {
  994.       fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
  995.                         psymtab->filename);
  996.     }
  997.   fprintf_filtered (outfile, "(object ");
  998.   gdb_print_host_address (psymtab, outfile);
  999.   fprintf_filtered (outfile, ")\n\n");
  1000.   fprintf_unfiltered (outfile, "  Read from object file %s (",
  1001.                       objfile_name (objfile));
  1002.   gdb_print_host_address (objfile, outfile);
  1003.   fprintf_unfiltered (outfile, ")\n");

  1005.   if (psymtab->readin)
  1006.     {
  1007.       fprintf_filtered (outfile,
  1008.                         "  Full symtab was read (at ");
  1009.       gdb_print_host_address (psymtab->compunit_symtab, outfile);
  1010.       fprintf_filtered (outfile, " by function at ");
  1011.       gdb_print_host_address (psymtab->read_symtab, outfile);
  1012.       fprintf_filtered (outfile, ")\n");
  1013.     }

  1015.   fprintf_filtered (outfile, "  Relocate symbols by ");
  1016.   for (i = 0; i < objfile->num_sections; ++i)
  1017.     {
  1018.       if (i != 0)
  1019.         fprintf_filtered (outfile, ", ");
  1020.       wrap_here ("    ");
  1021.       fputs_filtered (paddress (gdbarch,
  1022.                                 ANOFFSET (psymtab->section_offsets, i)),
  1023.                       outfile);
  1024.     }
  1025.   fprintf_filtered (outfile, "\n");

  1027.   fprintf_filtered (outfile, "  Symbols cover text addresses ");
  1028.   fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
  1029.   fprintf_filtered (outfile, "-");
  1030.   fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
  1031.   fprintf_filtered (outfile, "\n");
  1032.   fprintf_filtered (outfile, "  Address map supported - %s.\n",
  1033.                     psymtab->psymtabs_addrmap_supported ? "yes" : "no");
  1034.   fprintf_filtered (outfile, "  Depends on %d other partial symtabs.\n",
  1035.                     psymtab->number_of_dependencies);
  1036.   for (i = 0; i < psymtab->number_of_dependencies; i++)
  1037.     {
  1038.       fprintf_filtered (outfile, "    %d ", i);
  1039.       gdb_print_host_address (psymtab->dependencies[i], outfile);
  1040.       fprintf_filtered (outfile, " %s\n",
  1041.                         psymtab->dependencies[i]->filename);
  1042.     }
  1043.   if (psymtab->user != NULL)
  1044.     {
  1045.       fprintf_filtered (outfile, "  Shared partial symtab with user ");
  1046.       gdb_print_host_address (psymtab->user, outfile);
  1047.       fprintf_filtered (outfile, "\n");
  1048.     }
  1049.   if (psymtab->n_global_syms > 0)
  1050.     {
  1051.       print_partial_symbols (gdbarch,
  1052.                              objfile->global_psymbols.list
  1053.                              + psymtab->globals_offset,
  1054.                              psymtab->n_global_syms, "Global", outfile);
  1055.     }
  1056.   if (psymtab->n_static_syms > 0)
  1057.     {
  1058.       print_partial_symbols (gdbarch,
  1059.                              objfile->static_psymbols.list
  1060.                              + psymtab->statics_offset,
  1061.                              psymtab->n_static_syms, "Static", outfile);
  1062.     }
  1063.   fprintf_filtered (outfile, "\n");
  1064. }

  1066. /*  Psymtab version of print_stats.  See its definition in
  1067.     the definition of quick_symbol_functions in symfile.h.  */

  1069. static void
  1070. ‌psym_print_stats (struct objfile *objfile)
  1071. {
  1072.   int i;
  1073.   struct partial_symtab *ps;

  1075.   i = 0;
  1076.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
  1077.     {
  1078.       if (ps->readin == 0)
  1079.         i++;
  1080.     }
  1081.   printf_filtered (_("  Number of psym tables (not yet expanded): %d\n"), i);
  1082. }

  1084. /*  Psymtab version of dump.  See its definition in
  1085.     the definition of quick_symbol_functions in symfile.h.  */

  1087. static void
  1088. ‌psym_dump (struct objfile *objfile)
  1089. {
  1090.   struct partial_symtab *psymtab;

  1092.   if (objfile->psymtabs)
  1093.     {
  1094.       printf_filtered ("Psymtabs:\n");
  1095.       for (psymtab = objfile->psymtabs;
  1096.            psymtab != NULL;
  1097.            psymtab = psymtab->next)
  1098.         {
  1099.           printf_filtered ("%s at ",
  1100.                            psymtab->filename);
  1101.           gdb_print_host_address (psymtab, gdb_stdout);
  1102.           printf_filtered (", ");
  1103.           wrap_here ("  ");
  1104.         }
  1105.       printf_filtered ("\n\n");
  1106.     }
  1107. }

  1109. /*  Psymtab version of expand_symtabs_for_function.  See its definition in
  1110.     the definition of quick_symbol_functions in symfile.h.  */

  1112. static void
  1113. ‌psym_expand_symtabs_for_function (struct objfile *objfile,
  1114.                                   const char *func_name)
  1115. {
  1116.   struct partial_symtab *ps;

  1118.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
  1119.   {
  1120.     if (ps->readin)
  1121.       continue;

  1123.     if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)
  1124.          != NULL)
  1125.         || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)
  1126.             != NULL))
  1127.       psymtab_to_symtab (objfile, ps);
  1128.   }
  1129. }

  1131. /*  Psymtab version of expand_all_symtabs.  See its definition in
  1132.     the definition of quick_symbol_functions in symfile.h.  */

  1134. static void
  1135. ‌psym_expand_all_symtabs (struct objfile *objfile)
  1136. {
  1137.   struct partial_symtab *psymtab;

  1139.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
  1140.     {
  1141.       psymtab_to_symtab (objfile, psymtab);
  1142.     }
  1143. }

  1145. /*  Psymtab version of expand_symtabs_with_fullname.  See its definition in
  1146.     the definition of quick_symbol_functions in symfile.h.  */

  1148. static void
  1149. ‌psym_expand_symtabs_with_fullname (struct objfile *objfile,
  1150.                                    const char *fullname)
  1151. {
  1152.   struct partial_symtab *p;

  1154.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
  1155.     {
  1156.       /* Anonymous psymtabs don't have a name of a source file.  */
  1157.       if (p->anonymous)
  1158.         continue;

  1160.       /* psymtab_to_fullname tries to open the file which is slow.
  1161.          Don't call it if we know the basenames don't match.  */
  1162.       if ((basenames_may_differ
  1163.            || filename_cmp (lbasename (fullname), lbasename (p->filename)) == 0)
  1164.           && filename_cmp (fullname, psymtab_to_fullname (p)) == 0)
  1165.         psymtab_to_symtab (objfile, p);
  1166.     }
  1167. }

  1169. /*  Psymtab version of map_symbol_filenames.  See its definition in
  1170.     the definition of quick_symbol_functions in symfile.h.  */

  1172. static void
  1173. ‌psym_map_symbol_filenames (struct objfile *objfile,
  1174.                            symbol_filename_ftype *fun, void *data,
  1175.                            int need_fullname)
  1176. {
  1177.   struct partial_symtab *ps;

  1179.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
  1180.     {
  1181.       const char *fullname;

  1183.       if (ps->readin)
  1184.         continue;

  1186.       /* We can skip shared psymtabs here, because any file name will be
  1187.          attached to the unshared psymtab.  */
  1188.       if (ps->user != NULL)
  1189.         continue;

  1191.       /* Anonymous psymtabs don't have a file name.  */
  1192.       if (ps->anonymous)
  1193.         continue;

  1195.       QUIT;
  1196.       if (need_fullname)
  1197.         fullname = psymtab_to_fullname (ps);
  1198.       else
  1199.         fullname = NULL;
  1200.       (*fun) (ps->filename, fullname, data);
  1201.     }
  1202. }

  1204. /* Finds the fullname that a partial_symtab represents.

  1206.    If this functions finds the fullname, it will save it in ps->fullname
  1207.    and it will also return the value.

  1209.    If this function fails to find the file that this partial_symtab represents,
  1210.    NULL will be returned and ps->fullname will be set to NULL.  */

  1212. static const char *
  1213. ‌psymtab_to_fullname (struct partial_symtab *ps)
  1214. {
  1215.   gdb_assert (!ps->anonymous);

  1217.   /* Use cached copy if we have it.
  1218.      We rely on forget_cached_source_info being called appropriately
  1219.      to handle cases like the file being moved.  */
  1220.   if (ps->fullname == NULL)
  1221.     {
  1222.       int fd = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);

  1224.       if (fd >= 0)
  1225.         close (fd);
  1226.       else
  1227.         {
  1228.           char *fullname;
  1229.           struct cleanup *back_to;

  1231.           /* rewrite_source_path would be applied by find_and_open_source, we
  1232.              should report the pathname where GDB tried to find the file.  */

  1234.           if (ps->dirname == NULL || IS_ABSOLUTE_PATH (ps->filename))
  1235.             fullname = xstrdup (ps->filename);
  1236.           else
  1237.             fullname = concat (ps->dirname, SLASH_STRING, ps->filename, NULL);

  1239.           back_to = make_cleanup (xfree, fullname);
  1240.           ps->fullname = rewrite_source_path (fullname);
  1241.           if (ps->fullname == NULL)
  1242.             ps->fullname = xstrdup (fullname);
  1243.           do_cleanups (back_to);
  1244.         }
  1245.     }

  1247.   return ps->fullname;
  1248. }

  1250. /*  For all symbols, s, in BLOCK that are in NAMESPACE and match NAME
  1251.     according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
  1252.     BLOCK is assumed to come from OBJFILE.  Returns 1 iff CALLBACK
  1253.     ever returns non-zero, and otherwise returns 0.  */

  1255. static int
  1256. ‌map_block (const char *name, domain_enum namespace, struct objfile *objfile,
  1257.            struct block *block,
  1258.            int (*callback) (struct block *, struct symbol *, void *),
  1259.            void *data, symbol_compare_ftype *match)
  1260. {
  1261.   struct block_iterator iter;
  1262.   struct symbol *sym;

  1264.   for (sym = block_iter_match_first (block, name, match, &iter);
  1265.        sym != NULL; sym = block_iter_match_next (name, match, &iter))
  1266.     {
  1267.       if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
  1268.                                  SYMBOL_DOMAIN (sym), namespace))
  1269.         {
  1270.           if (callback (block, sym, data))
  1271.             return 1;
  1272.         }
  1273.     }

  1275.   return 0;
  1276. }

  1278. /*  Psymtab version of map_matching_symbols.  See its definition in
  1279.     the definition of quick_symbol_functions in symfile.h.  */

  1281. static void
  1282. ‌psym_map_matching_symbols (struct objfile *objfile,
  1283.                            const char *name, domain_enum namespace,
  1284.                            int global,
  1285.                            int (*callback) (struct block *,
  1286.                                             struct symbol *, void *),
  1287.                            void *data,
  1288.                            symbol_compare_ftype *match,
  1289.                            symbol_compare_ftype *ordered_compare)
  1290. {
  1291.   const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
  1292.   struct partial_symtab *ps;

  1294.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
  1295.     {
  1296.       QUIT;
  1297.       if (ps->readin
  1298.           || match_partial_symbol (objfile, ps, global, name, namespace, match,
  1299.                                    ordered_compare))
  1300.         {
  1301.           struct compunit_symtab *cust = psymtab_to_symtab (objfile, ps);
  1302.           struct block *block;

  1304.           if (cust == NULL)
  1305.             continue;
  1306.           block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), block_kind);
  1307.           if (map_block (name, namespace, objfile, block,
  1308.                          callback, data, match))
  1309.             return;
  1310.           if (callback (block, NULL, data))
  1311.             return;
  1312.         }
  1313.     }
  1314. }

  1316. /* A helper for psym_expand_symtabs_matching that handles
  1317.    searching included psymtabs.  This returns 1 if a symbol is found,
  1318.    and zero otherwise.  It also updates the 'searched_flag' on the
  1319.    various psymtabs that it searches.  */

  1321. static int
  1322. ‌recursively_search_psymtabs (struct partial_symtab *ps,
  1323.                              struct objfile *objfile,
  1324.                              enum search_domain kind,
  1325.                              expand_symtabs_symbol_matcher_ftype *sym_matcher,
  1326.                              void *data)
  1327. {
  1328.   struct partial_symbol **psym;
  1329.   struct partial_symbol **bound, **gbound, **sbound;
  1330.   int keep_going = 1;
  1331.   int result = PST_SEARCHED_AND_NOT_FOUND;
  1332.   int i;

  1334.   if (ps->searched_flag != PST_NOT_SEARCHED)
  1335.     return ps->searched_flag == PST_SEARCHED_AND_FOUND;

  1337.   /* Recurse into shared psymtabs first, because they may have already
  1338.      been searched, and this could save some time.  */
  1339.   for (i = 0; i < ps->number_of_dependencies; ++i)
  1340.     {
  1341.       int r;

  1343.       /* Skip non-shared dependencies, these are handled elsewhere.  */
  1344.       if (ps->dependencies[i]->user == NULL)
  1345.         continue;

  1347.       r = recursively_search_psymtabs (ps->dependencies[i],
  1348.                                        objfile, kind, sym_matcher, data);
  1349.       if (r != 0)
  1350.         {
  1351.           ps->searched_flag = PST_SEARCHED_AND_FOUND;
  1352.           return 1;
  1353.         }
  1354.     }

  1356.   gbound = (objfile->global_psymbols.list
  1357.             + ps->globals_offset + ps->n_global_syms);
  1358.   sbound = (objfile->static_psymbols.list
  1359.             + ps->statics_offset + ps->n_static_syms);
  1360.   bound = gbound;

  1362.   /* Go through all of the symbols stored in a partial
  1363.      symtab in one loop.  */
  1364.   psym = objfile->global_psymbols.list + ps->globals_offset;
  1365.   while (keep_going)
  1366.     {
  1367.       if (psym >= bound)
  1368.         {
  1369.           if (bound == gbound && ps->n_static_syms != 0)
  1370.             {
  1371.               psym = objfile->static_psymbols.list + ps->statics_offset;
  1372.               bound = sbound;
  1373.             }
  1374.           else
  1375.             keep_going = 0;
  1376.           continue;
  1377.         }
  1378.       else
  1379.         {
  1380.           QUIT;

  1382.           if ((kind == ALL_DOMAIN
  1383.                || (kind == VARIABLES_DOMAIN
  1384.                    && PSYMBOL_CLASS (*psym) != LOC_TYPEDEF
  1385.                    && PSYMBOL_CLASS (*psym) != LOC_BLOCK)
  1386.                || (kind == FUNCTIONS_DOMAIN
  1387.                    && PSYMBOL_CLASS (*psym) == LOC_BLOCK)
  1388.                || (kind == TYPES_DOMAIN
  1389.                    && PSYMBOL_CLASS (*psym) == LOC_TYPEDEF))
  1390.               && (*sym_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
  1391.             {
  1392.               /* Found a match, so notify our caller.  */
  1393.               result = PST_SEARCHED_AND_FOUND;
  1394.               keep_going = 0;
  1395.             }
  1396.         }
  1397.       psym++;
  1398.     }

  1400.   ps->searched_flag = result;
  1401.   return result == PST_SEARCHED_AND_FOUND;
  1402. }

  1404. /*  Psymtab version of expand_symtabs_matching.  See its definition in
  1405.     the definition of quick_symbol_functions in symfile.h.  */

  1407. static void
  1408. ‌psym_expand_symtabs_matching
  1409.   (struct objfile *objfile,
  1410.    expand_symtabs_file_matcher_ftype *file_matcher,
  1411.    expand_symtabs_symbol_matcher_ftype *symbol_matcher,
  1412.    enum search_domain kind,
  1413.    void *data)
  1414. {
  1415.   struct partial_symtab *ps;

  1417.   /* Clear the search flags.  */
  1418.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
  1419.     {
  1420.       ps->searched_flag = PST_NOT_SEARCHED;
  1421.     }

  1423.   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
  1424.     {
  1425.       if (ps->readin)
  1426.         continue;

  1428.       /* We skip shared psymtabs because file-matching doesn't apply
  1429.          to them; but we search them later in the loop.  */
  1430.       if (ps->user != NULL)
  1431.         continue;

  1433.       if (file_matcher)
  1434.         {
  1435.           int match;

  1437.           if (ps->anonymous)
  1438.             continue;

  1440.           match = (*file_matcher) (ps->filename, data, 0);
  1441.           if (!match)
  1442.             {
  1443.               /* Before we invoke realpath, which can get expensive when many
  1444.                  files are involved, do a quick comparison of the basenames.  */
  1445.               if (basenames_may_differ
  1446.                   || (*file_matcher) (lbasename (ps->filename), data, 1))
  1447.                 match = (*file_matcher) (psymtab_to_fullname (ps), data, 0);
  1448.             }
  1449.           if (!match)
  1450.             continue;
  1451.         }

  1453.       if (recursively_search_psymtabs (ps, objfile, kind, symbol_matcher, data))
  1454.         psymtab_to_symtab (objfile, ps);
  1455.     }
  1456. }

  1458. /*  Psymtab version of has_symbols.  See its definition in
  1459.     the definition of quick_symbol_functions in symfile.h.  */

  1461. static int
  1462. ‌psym_has_symbols (struct objfile *objfile)
  1463. {
  1464.   return objfile->psymtabs != NULL;
  1465. }

  1467. ‌const struct quick_symbol_functions psym_functions =
  1468. {
  1469.   psym_has_symbols,
  1470.   psym_find_last_source_symtab,
  1471.   psym_forget_cached_source_info,
  1472.   psym_map_symtabs_matching_filename,
  1473.   psym_lookup_symbol,
  1474.   psym_print_stats,
  1475.   psym_dump,
  1476.   psym_relocate,
  1477.   psym_expand_symtabs_for_function,
  1478.   psym_expand_all_symtabs,
  1479.   psym_expand_symtabs_with_fullname,
  1480.   psym_map_matching_symbols,
  1481.   psym_expand_symtabs_matching,
  1482.   psym_find_pc_sect_compunit_symtab,
  1483.   psym_map_symbol_filenames
  1484. };



  1488. /* This compares two partial symbols by names, using strcmp_iw_ordered
  1489.    for the comparison.  */

  1491. static int
  1492. ‌compare_psymbols (const void *s1p, const void *s2p)
  1493. {
  1494.   struct partial_symbol *const *s1 = s1p;
  1495.   struct partial_symbol *const *s2 = s2p;

  1497.   return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
  1498.                             SYMBOL_SEARCH_NAME (*s2));
  1499. }

  1501. void
  1502. ‌sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
  1503. {
  1504.   /* Sort the global list; don't sort the static list.  */

  1506.   qsort (objfile->global_psymbols.list + pst->globals_offset,
  1507.          pst->n_global_syms, sizeof (struct partial_symbol *),
  1508.          compare_psymbols);
  1509. }

  1511. /* Allocate and partially fill a partial symtab.  It will be
  1512.    completely filled at the end of the symbol list.

  1514.    FILENAME is the name of the symbol-file we are reading from.  */

  1516. struct partial_symtab *
  1517. ‌start_psymtab_common (struct objfile *objfile,
  1518.                       struct section_offsets *section_offsets,
  1519.                       const char *filename,
  1520.                       CORE_ADDR textlow, struct partial_symbol **global_syms,
  1521.                       struct partial_symbol **static_syms)
  1522. {
  1523.   struct partial_symtab *psymtab;

  1525.   psymtab = allocate_psymtab (filename, objfile);
  1526.   psymtab->section_offsets = section_offsets;
  1527.   psymtab->textlow = textlow;
  1528.   psymtab->texthigh = psymtab->textlow;                /* default */
  1529.   psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
  1530.   psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
  1531.   return (psymtab);
  1532. }

  1534. /* Calculate a hash code for the given partial symbol.  The hash is
  1535.    calculated using the symbol's value, language, domain, class
  1536.    and name.  These are the values which are set by
  1537.    add_psymbol_to_bcache.  */

  1539. static unsigned long
  1540. ‌psymbol_hash (const void *addr, int length)
  1541. {
  1542.   unsigned long h = 0;
  1543.   struct partial_symbol *psymbol = (struct partial_symbol *) addr;
  1544.   unsigned int lang = psymbol->ginfo.language;
  1545.   unsigned int domain = PSYMBOL_DOMAIN (psymbol);
  1546.   unsigned int class = PSYMBOL_CLASS (psymbol);

  1548.   h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
  1549.   h = hash_continue (&lang, sizeof (unsigned int), h);
  1550.   h = hash_continue (&domain, sizeof (unsigned int), h);
  1551.   h = hash_continue (&class, sizeof (unsigned int), h);
  1552.   h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h);

  1554.   return h;
  1555. }

  1557. /* Returns true if the symbol at addr1 equals the symbol at addr2.
  1558.    For the comparison this function uses a symbols value,
  1559.    language, domain, class and name.  */

  1561. static int
  1562. ‌psymbol_compare (const void *addr1, const void *addr2, int length)
  1563. {
  1564.   struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
  1565.   struct partial_symbol *sym2 = (struct partial_symbol *) addr2;

  1567.   return (memcmp (&sym1->ginfo.value, &sym1->ginfo.value,
  1568.                   sizeof (sym1->ginfo.value)) == 0
  1569.           && sym1->ginfo.language == sym2->ginfo.language
  1570.           && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2)
  1571.           && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2)
  1572.           && sym1->ginfo.name == sym2->ginfo.name);
  1573. }

  1575. /* Initialize a partial symbol bcache.  */

  1577. struct psymbol_bcache *
  1578. ‌psymbol_bcache_init (void)
  1579. {
  1580.   struct psymbol_bcache *bcache = XCNEW (struct psymbol_bcache);
  1581.   bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
  1582.   return bcache;
  1583. }

  1585. /* Free a partial symbol bcache.  */
  1586. void
  1587. ‌psymbol_bcache_free (struct psymbol_bcache *bcache)
  1588. {
  1589.   if (bcache == NULL)
  1590.     return;

  1592.   bcache_xfree (bcache->bcache);
  1593.   xfree (bcache);
  1594. }

  1596. /* Return the internal bcache of the psymbol_bcache BCACHE.  */

  1598. struct bcache *
  1599. ‌psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
  1600. {
  1601.   return bcache->bcache;
  1602. }

  1604. /* Find a copy of the SYM in BCACHE.  If BCACHE has never seen this
  1605.    symbol before, add a copy to BCACHE.  In either case, return a pointer
  1606.    to BCACHE's copy of the symbol.  If optional ADDED is not NULL, return
  1607.    1 in case of new entry or 0 if returning an old entry.  */

  1609. static const struct partial_symbol *
  1610. ‌psymbol_bcache_full (struct partial_symbol *sym,
  1611.                      struct psymbol_bcache *bcache,
  1612.                      int *added)
  1613. {
  1614.   return bcache_full (sym,
  1615.                       sizeof (struct partial_symbol),
  1616.                       bcache->bcache,
  1617.                       added);
  1618. }

  1620. /* Helper function, initialises partial symbol structure and stashes
  1621.    it into objfile's bcache.  Note that our caching mechanism will
  1622.    use all fields of struct partial_symbol to determine hash value of the
  1623.    structure.  In other words, having two symbols with the same name but
  1624.    different domain (or address) is possible and correct.  */

  1626. static const struct partial_symbol *
  1627. ‌add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
  1628.                        domain_enum domain,
  1629.                        enum address_class class,
  1630.                        long val,        /* Value as a long */
  1631.                        CORE_ADDR coreaddr,        /* Value as a CORE_ADDR */
  1632.                        enum language language, struct objfile *objfile,
  1633.                        int *added)
  1634. {
  1635.   struct partial_symbol psymbol;

  1637.   /* We must ensure that the entire struct has been zeroed before
  1638.      assigning to it, because an assignment may not touch some of the
  1639.      holes.  */
  1640.   memset (&psymbol, 0, sizeof (psymbol));

  1642.   /* val and coreaddr are mutually exclusive, one of them *will* be zero.  */
  1643.   if (val != 0)
  1644.     {
  1645.       SYMBOL_VALUE (&psymbol) = val;
  1646.     }
  1647.   else
  1648.     {
  1649.       SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
  1650.     }
  1651.   SYMBOL_SECTION (&psymbol) = -1;
  1652.   SYMBOL_SET_LANGUAGE (&psymbol, language, &objfile->objfile_obstack);
  1653.   PSYMBOL_DOMAIN (&psymbol) = domain;
  1654.   PSYMBOL_CLASS (&psymbol) = class;

  1656.   SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);

  1658.   /* Stash the partial symbol away in the cache.  */
  1659.   return psymbol_bcache_full (&psymbol,
  1660.                               objfile->psymbol_cache,
  1661.                               added);
  1662. }

  1664. /* Increase the space allocated for LISTP, which is probably
  1665.    global_psymbols or static_psymbols.  This space will eventually
  1666.    be freed in free_objfile().  */

  1668. static void
  1669. ‌extend_psymbol_list (struct psymbol_allocation_list *listp,
  1670.                      struct objfile *objfile)
  1671. {
  1672.   int new_size;

  1674.   if (listp->size == 0)
  1675.     {
  1676.       new_size = 255;
  1677.       listp->list = (struct partial_symbol **)
  1678.         xmalloc (new_size * sizeof (struct partial_symbol *));
  1679.     }
  1680.   else
  1681.     {
  1682.       new_size = listp->size * 2;
  1683.       listp->list = (struct partial_symbol **)
  1684.         xrealloc ((char *) listp->list,
  1685.                   new_size * sizeof (struct partial_symbol *));
  1686.     }
  1687.   /* Next assumes we only went one over.  Should be good if
  1688.      program works correctly.  */
  1689.   listp->next = listp->list + listp->size;
  1690.   listp->size = new_size;
  1691. }

  1693. /* Helper function, adds partial symbol to the given partial symbol
  1694.    list.  */

  1696. static void
  1697. ‌append_psymbol_to_list (struct psymbol_allocation_list *list,
  1698.                         const struct partial_symbol *psym,
  1699.                         struct objfile *objfile)
  1700. {
  1701.   if (list->next >= list->list + list->size)
  1702.     extend_psymbol_list (list, objfile);
  1703.   *list->next++ = (struct partial_symbol *) psym;
  1704.   OBJSTAT (objfile, n_psyms++);
  1705. }

  1707. /* Add a symbol with a long value to a psymtab.
  1708.    Since one arg is a struct, we pass in a ptr and deref it (sigh).
  1709.    Return the partial symbol that has been added.  */

  1711. void
  1712. ‌add_psymbol_to_list (const char *name, int namelength, int copy_name,
  1713.                      domain_enum domain,
  1714.                      enum address_class class,
  1715.                      struct psymbol_allocation_list *list,
  1716.                      long val,        /* Value as a long */
  1717.                      CORE_ADDR coreaddr,        /* Value as a CORE_ADDR */
  1718.                      enum language language, struct objfile *objfile)
  1719. {
  1720.   const struct partial_symbol *psym;

  1722.   int added;

  1724.   /* Stash the partial symbol away in the cache.  */
  1725.   psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, class,
  1726.                                 val, coreaddr, language, objfile, &added);

  1728.   /* Do not duplicate global partial symbols.  */
  1729.   if (list == &objfile->global_psymbols
  1730.       && !added)
  1731.     return;

  1733.   /* Save pointer to partial symbol in psymtab, growing symtab if needed.  */
  1734.   append_psymbol_to_list (list, psym, objfile);
  1735. }

  1737. /* Initialize storage for partial symbols.  */

  1739. void
  1740. ‌init_psymbol_list (struct objfile *objfile, int total_symbols)
  1741. {
  1742.   /* Free any previously allocated psymbol lists.  */

  1744.   if (objfile->global_psymbols.list)
  1745.     {
  1746.       xfree (objfile->global_psymbols.list);
  1747.     }
  1748.   if (objfile->static_psymbols.list)
  1749.     {
  1750.       xfree (objfile->static_psymbols.list);
  1751.     }

  1753.   /* Current best guess is that approximately a twentieth
  1754.      of the total symbols (in a debugging file) are global or static
  1755.      oriented symbols, then multiply that by slop factor of two.  */

  1757.   objfile->global_psymbols.size = total_symbols / 10;
  1758.   objfile->static_psymbols.size = total_symbols / 10;

  1760.   if (objfile->global_psymbols.size > 0)
  1761.     {
  1762.       objfile->global_psymbols.next =
  1763.         objfile->global_psymbols.list = (struct partial_symbol **)
  1764.         xmalloc ((objfile->global_psymbols.size
  1765.                   * sizeof (struct partial_symbol *)));
  1766.     }
  1767.   if (objfile->static_psymbols.size > 0)
  1768.     {
  1769.       objfile->static_psymbols.next =
  1770.         objfile->static_psymbols.list = (struct partial_symbol **)
  1771.         xmalloc ((objfile->static_psymbols.size
  1772.                   * sizeof (struct partial_symbol *)));
  1773.     }
  1774. }

  1776. struct partial_symtab *
  1777. ‌allocate_psymtab (const char *filename, struct objfile *objfile)
  1778. {
  1779.   struct partial_symtab *psymtab;

  1781.   if (objfile->free_psymtabs)
  1782.     {
  1783.       psymtab = objfile->free_psymtabs;
  1784.       objfile->free_psymtabs = psymtab->next;
  1785.     }
  1786.   else
  1787.     psymtab = (struct partial_symtab *)
  1788.       obstack_alloc (&objfile->objfile_obstack,
  1789.                      sizeof (struct partial_symtab));

  1791.   memset (psymtab, 0, sizeof (struct partial_symtab));
  1792.   psymtab->filename = bcache (filename, strlen (filename) + 1,
  1793.                               objfile->per_bfd->filename_cache);
  1794.   psymtab->compunit_symtab = NULL;

  1796.   /* Prepend it to the psymtab list for the objfile it belongs to.
  1797.      Psymtabs are searched in most recent inserted -> least recent
  1798.      inserted order.  */

  1800.   psymtab->next = objfile->psymtabs;
  1801.   objfile->psymtabs = psymtab;

  1803.   if (symtab_create_debug)
  1804.     {
  1805.       /* Be a bit clever with debugging messages, and don't print objfile
  1806.          every time, only when it changes.  */
  1807.       static char *last_objfile_name = NULL;

  1809.       if (last_objfile_name == NULL
  1810.           || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
  1811.         {
  1812.           xfree (last_objfile_name);
  1813.           last_objfile_name = xstrdup (objfile_name (objfile));
  1814.           fprintf_unfiltered (gdb_stdlog,
  1815.                               "Creating one or more psymtabs for objfile %s ...\n",
  1816.                               last_objfile_name);
  1817.         }
  1818.       fprintf_unfiltered (gdb_stdlog,
  1819.                           "Created psymtab %s for module %s.\n",
  1820.                           host_address_to_string (psymtab), filename);
  1821.     }

  1823.   return (psymtab);
  1824. }

  1826. void
  1827. ‌discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
  1828. {
  1829.   struct partial_symtab **prev_pst;

  1831.   /* From dbxread.c:
  1832.      Empty psymtabs happen as a result of header files which don't
  1833.      have any symbols in them.  There can be a lot of them.  But this
  1834.      check is wrong, in that a psymtab with N_SLINE entries but
  1835.      nothing else is not empty, but we don't realize that.  Fixing
  1836.      that without slowing things down might be tricky.  */

  1838.   /* First, snip it out of the psymtab chain.  */

  1840.   prev_pst = &(objfile->psymtabs);
  1841.   while ((*prev_pst) != pst)
  1842.     prev_pst = &((*prev_pst)->next);
  1843.   (*prev_pst) = pst->next;

  1845.   /* Next, put it on a free list for recycling.  */

  1847.   pst->next = objfile->free_psymtabs;
  1848.   objfile->free_psymtabs = pst;
  1849. }

  1851. /* An object of this type is passed to discard_psymtabs_upto.  */

  1853. ‌struct psymtab_state
  1854. {
  1855.   /* The objfile where psymtabs are discarded.  */

  1857.   struct objfile *objfile;

  1859.   /* The first psymtab to save.  */

  1861.   struct partial_symtab *save;
  1862. };

  1864. /* A cleanup function used by make_cleanup_discard_psymtabs.  */

  1866. static void
  1867. ‌discard_psymtabs_upto (void *arg)
  1868. {
  1869.   struct psymtab_state *state = arg;

  1871.   while (state->objfile->psymtabs != state->save)
  1872.     discard_psymtab (state->objfile, state->objfile->psymtabs);
  1873. }

  1875. /* Return a new cleanup that discards all psymtabs created in OBJFILE
  1876.    after this function is called.  */

  1878. struct cleanup *
  1879. ‌make_cleanup_discard_psymtabs (struct objfile *objfile)
  1880. {
  1881.   struct psymtab_state *state = XNEW (struct psymtab_state);

  1883.   state->objfile = objfile;
  1884.   state->save = objfile->psymtabs;

  1886.   return make_cleanup_dtor (discard_psymtabs_upto, state, xfree);
  1887. }



  1891. static void
  1892. ‌maintenance_print_psymbols (char *args, int from_tty)
  1893. {
  1894.   char **argv;
  1895.   struct ui_file *outfile;
  1896.   struct cleanup *cleanups;
  1897.   char *symname = NULL;
  1898.   char *filename = DEV_TTY;
  1899.   struct objfile *objfile;
  1900.   struct partial_symtab *ps;

  1902.   dont_repeat ();

  1904.   if (args == NULL)
  1905.     {
  1906.       error (_("\
  1907. print-psymbols takes an output file name and optional symbol file name"));
  1908.     }
  1909.   argv = gdb_buildargv (args);
  1910.   cleanups = make_cleanup_freeargv (argv);

  1912.   if (argv[0] != NULL)
  1913.     {
  1914.       filename = argv[0];
  1915.       /* If a second arg is supplied, it is a source file name to match on.  */
  1916.       if (argv[1] != NULL)
  1917.         {
  1918.           symname = argv[1];
  1919.         }
  1920.     }

  1922.   filename = tilde_expand (filename);
  1923.   make_cleanup (xfree, filename);

  1925.   outfile = gdb_fopen (filename, FOPEN_WT);
  1926.   if (outfile == 0)
  1927.     perror_with_name (filename);
  1928.   make_cleanup_ui_file_delete (outfile);

  1930.   ALL_PSYMTABS (objfile, ps)
  1931.     {
  1932.       QUIT;
  1933.       if (symname == NULL || filename_cmp (symname, ps->filename) == 0)
  1934.         dump_psymtab (objfile, ps, outfile);
  1935.     }
  1936.   do_cleanups (cleanups);
  1937. }

  1939. /* List all the partial symbol tables whose names match REGEXP (optional).  */
  1940. static void
  1941. ‌maintenance_info_psymtabs (char *regexp, int from_tty)
  1942. {
  1943.   struct program_space *pspace;
  1944.   struct objfile *objfile;

  1946.   if (regexp)
  1947.     re_comp (regexp);

  1949.   ALL_PSPACES (pspace)
  1950.     ALL_PSPACE_OBJFILES (pspace, objfile)
  1951.     {
  1952.       struct gdbarch *gdbarch = get_objfile_arch (objfile);
  1953.       struct partial_symtab *psymtab;

  1955.       /* We don't want to print anything for this objfile until we
  1956.          actually find a symtab whose name matches.  */
  1957.       int printed_objfile_start = 0;

  1959.       ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
  1960.         {
  1961.           QUIT;

  1963.           if (! regexp
  1964.               || re_exec (psymtab->filename))
  1965.             {
  1966.               if (! printed_objfile_start)
  1967.                 {
  1968.                   printf_filtered ("{ objfile %s ", objfile_name (objfile));
  1969.                   wrap_here ("  ");
  1970.                   printf_filtered ("((struct objfile *) %s)\n",
  1971.                                    host_address_to_string (objfile));
  1972.                   printed_objfile_start = 1;
  1973.                 }

  1975.               printf_filtered ("  { psymtab %s ", psymtab->filename);
  1976.               wrap_here ("    ");
  1977.               printf_filtered ("((struct partial_symtab *) %s)\n",
  1978.                                host_address_to_string (psymtab));

  1980.               printf_filtered ("    readin %s\n",
  1981.                                psymtab->readin ? "yes" : "no");
  1982.               printf_filtered ("    fullname %s\n",
  1983.                                psymtab->fullname
  1984.                                ? psymtab->fullname : "(null)");
  1985.               printf_filtered ("    text addresses ");
  1986.               fputs_filtered (paddress (gdbarch, psymtab->textlow),
  1987.                               gdb_stdout);
  1988.               printf_filtered (" -- ");
  1989.               fputs_filtered (paddress (gdbarch, psymtab->texthigh),
  1990.                               gdb_stdout);
  1991.               printf_filtered ("\n");
  1992.               printf_filtered ("    psymtabs_addrmap_supported %s\n",
  1993.                                (psymtab->psymtabs_addrmap_supported
  1994.                                 ? "yes" : "no"));
  1995.               printf_filtered ("    globals ");
  1996.               if (psymtab->n_global_syms)
  1997.                 {
  1998.                   printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
  1999.                                    host_address_to_string (objfile->global_psymbols.list
  2000.                                     + psymtab->globals_offset),
  2001.                                    psymtab->n_global_syms);
  2002.                 }
  2003.               else
  2004.                 printf_filtered ("(none)\n");
  2005.               printf_filtered ("    statics ");
  2006.               if (psymtab->n_static_syms)
  2007.                 {
  2008.                   printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
  2009.                                    host_address_to_string (objfile->static_psymbols.list
  2010.                                     + psymtab->statics_offset),
  2011.                                    psymtab->n_static_syms);
  2012.                 }
  2013.               else
  2014.                 printf_filtered ("(none)\n");
  2015.               printf_filtered ("    dependencies ");
  2016.               if (psymtab->number_of_dependencies)
  2017.                 {
  2018.                   int i;

  2020.                   printf_filtered ("{\n");
  2021.                   for (i = 0; i < psymtab->number_of_dependencies; i++)
  2022.                     {
  2023.                       struct partial_symtab *dep = psymtab->dependencies[i];

  2025.                       /* Note the string concatenation there --- no comma.  */
  2026.                       printf_filtered ("      psymtab %s "
  2027.                                        "((struct partial_symtab *) %s)\n",
  2028.                                        dep->filename,
  2029.                                        host_address_to_string (dep));
  2030.                     }
  2031.                   printf_filtered ("    }\n");
  2032.                 }
  2033.               else
  2034.                 printf_filtered ("(none)\n");
  2035.               printf_filtered ("  }\n");
  2036.             }
  2037.         }

  2039.       if (printed_objfile_start)
  2040.         printf_filtered ("}\n");
  2041.     }
  2042. }

  2044. /* Check consistency of currently expanded psymtabs vs symtabs.  */

  2046. static void
  2047. ‌maintenance_check_psymtabs (char *ignore, int from_tty)
  2048. {
  2049.   struct symbol *sym;
  2050.   struct partial_symbol **psym;
  2051.   struct compunit_symtab *cust = NULL;
  2052.   struct partial_symtab *ps;
  2053.   const struct blockvector *bv;
  2054.   struct objfile *objfile;
  2055.   struct block *b;
  2056.   int length;

  2058.   ALL_PSYMTABS (objfile, ps)
  2059.   {
  2060.     struct gdbarch *gdbarch = get_objfile_arch (objfile);

  2062.     /* We don't call psymtab_to_symtab here because that may cause symtab
  2063.        expansion.  When debugging a problem it helps if checkers leave
  2064.        things unchanged.  */
  2065.     cust = ps->compunit_symtab;

  2067.     /* First do some checks that don't require the associated symtab.  */
  2068.     if (ps->texthigh < ps->textlow)
  2069.       {
  2070.         printf_filtered ("Psymtab ");
  2071.         puts_filtered (ps->filename);
  2072.         printf_filtered (" covers bad range ");
  2073.         fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
  2074.         printf_filtered (" - ");
  2075.         fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
  2076.         printf_filtered ("\n");
  2077.         continue;
  2078.       }

  2080.     /* Now do checks requiring the associated symtab.  */
  2081.     if (cust == NULL)
  2082.       continue;
  2083.     bv = COMPUNIT_BLOCKVECTOR (cust);
  2084.     b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
  2085.     psym = objfile->static_psymbols.list + ps->statics_offset;
  2086.     length = ps->n_static_syms;
  2087.     while (length--)
  2088.       {
  2089.         sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
  2090.                                    SYMBOL_DOMAIN (*psym));
  2091.         if (!sym)
  2092.           {
  2093.             printf_filtered ("Static symbol `");
  2094.             puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
  2095.             printf_filtered ("' only found in ");
  2096.             puts_filtered (ps->filename);
  2097.             printf_filtered (" psymtab\n");
  2098.           }
  2099.         psym++;
  2100.       }
  2101.     b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
  2102.     psym = objfile->global_psymbols.list + ps->globals_offset;
  2103.     length = ps->n_global_syms;
  2104.     while (length--)
  2105.       {
  2106.         sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
  2107.                                    SYMBOL_DOMAIN (*psym));
  2108.         if (!sym)
  2109.           {
  2110.             printf_filtered ("Global symbol `");
  2111.             puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
  2112.             printf_filtered ("' only found in ");
  2113.             puts_filtered (ps->filename);
  2114.             printf_filtered (" psymtab\n");
  2115.           }
  2116.         psym++;
  2117.       }
  2118.     if (ps->texthigh != 0
  2119.         && (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b)))
  2120.       {
  2121.         printf_filtered ("Psymtab ");
  2122.         puts_filtered (ps->filename);
  2123.         printf_filtered (" covers ");
  2124.         fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
  2125.         printf_filtered (" - ");
  2126.         fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
  2127.         printf_filtered (" but symtab covers only ");
  2128.         fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
  2129.         printf_filtered (" - ");
  2130.         fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
  2131.         printf_filtered ("\n");
  2132.       }
  2133.   }
  2134. }



  2138. extern initialize_file_ftype _initialize_psymtab;

  2140. void
  2141. ‌_initialize_psymtab (void)
  2142. {
  2143.   add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
  2144. Print dump of current partial symbol definitions.\n\
  2145. Entries in the partial symbol table are dumped to file OUTFILE.\n\
  2146. If a SOURCE file is specified, dump only that file's partial symbols."),
  2147.            &maintenanceprintlist);

  2149.   add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
  2150. List the partial symbol tables for all object files.\n\
  2151. This does not include information about individual partial symbols,\n\
  2152. just the symbol table structures themselves."),
  2153.            &maintenanceinfolist);

  2155.   add_cmd ("check-psymtabs", class_maintenance, maintenance_check_psymtabs,
  2156.            _("\
  2157. Check consistency of currently expanded psymtabs versus symtabs."),
  2158.            &maintenancelist);
  2159. }