Pass Ctrl-C to the target in target_terminal_inferior

[deliverable/binutils-gdb.git] / gdb / psymtab.c

diff --git a/gdb/psymtab.c b/gdb/psymtab.c
index b1a7fc9581fa5d0252ed320619d420735b0d482d..94b5e7eaf76ca2a6f58cf993f441ebca5f564ad3 100644 (file)
--- a/gdb/psymtab.c
+++ b/gdb/psymtab.c
@@ -1,6 +1,6 @@
 /* Partial symbol tables.
 /* Partial symbol tables.

-   
-   Copyright (C) 2009, 2010 Free Software Foundation, Inc.
+
+   Copyright (C) 2009-2016 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -21,7 +21,6 @@
 #include "symtab.h"
 #include "psympriv.h"
 #include "objfiles.h"
 #include "symtab.h"
 #include "psympriv.h"
 #include "objfiles.h"

-#include "gdb_assert.h"

 #include "block.h"
 #include "filenames.h"
 #include "source.h"
 #include "block.h"
 #include "filenames.h"
 #include "source.h"


@@ -32,6 +31,10 @@
 #include "command.h"
 #include "readline/readline.h"
 #include "gdb_regex.h"
 #include "command.h"
 #include "readline/readline.h"
 #include "gdb_regex.h"

+#include "dictionary.h"
+#include "language.h"
+#include "cp-support.h"
+#include "gdbcmd.h"

 
 #ifndef DEV_TTY
 #define DEV_TTY "/dev/tty"
 
 #ifndef DEV_TTY
 #define DEV_TTY "/dev/tty"


@@ -42,130 +45,209 @@ struct psymbol_bcache
   struct bcache *bcache;
 };
 
   struct bcache *bcache;
 };
 

-/* A fast way to get from a psymtab to its symtab (after the first time).  */
-#define PSYMTAB_TO_SYMTAB(pst)  \
-    ((pst) -> symtab != NULL ? (pst) -> symtab : psymtab_to_symtab (pst))
+static struct partial_symbol *match_partial_symbol (struct objfile *,
+                                                   struct partial_symtab *,
+                                                   int,
+                                                   const char *, domain_enum,
+                                                   symbol_compare_ftype *,
+                                                   symbol_compare_ftype *);

 
 

-/* Lookup a partial symbol.  */
-static struct partial_symbol *lookup_partial_symbol (struct partial_symtab *,
+static struct partial_symbol *lookup_partial_symbol (struct objfile *,
+                                                    struct partial_symtab *,

                                                     const char *, int,
                                                     domain_enum);
 
                                                     const char *, int,
                                                     domain_enum);
 

-static char *psymtab_to_fullname (struct partial_symtab *ps);
+static const char *psymtab_to_fullname (struct partial_symtab *ps);

 
 

-static struct partial_symbol *find_pc_sect_psymbol (struct partial_symtab *,
+static struct partial_symbol *find_pc_sect_psymbol (struct objfile *,
+                                                   struct partial_symtab *,

                                                    CORE_ADDR,
                                                    struct obj_section *);
 
                                                    CORE_ADDR,
                                                    struct obj_section *);
 

-static struct partial_symbol *fixup_psymbol_section (struct partial_symbol
-                                                    *psym,
-                                                    struct objfile *objfile);
+static void fixup_psymbol_section (struct partial_symbol *psym,
+                                  struct objfile *objfile);

 
 

-static struct symtab *psymtab_to_symtab (struct partial_symtab *pst);
+static struct compunit_symtab *psymtab_to_symtab (struct objfile *objfile,
+                                                 struct partial_symtab *pst);

 
 

-/* Lookup the partial symbol table of a source file named NAME.
-   *If* there is no '/' in the name, a match after a '/'
-   in the psymtab filename will also work.  */
+/* Ensure that the partial symbols for OBJFILE have been loaded.  This
+   function always returns its argument, as a convenience.  */

 
 

-static struct partial_symtab *
-lookup_partial_symtab (struct objfile *objfile, const char *name,
-                      const char *full_path, const char *real_path)
+struct objfile *
+require_partial_symbols (struct objfile *objfile, int verbose)
+{
+  if ((objfile->flags & OBJF_PSYMTABS_READ) == 0)
+    {
+      objfile->flags |= OBJF_PSYMTABS_READ;
+
+      if (objfile->sf->sym_read_psymbols)
+       {
+         if (verbose)
+           {
+             printf_unfiltered (_("Reading symbols from %s..."),
+                                objfile_name (objfile));
+             gdb_flush (gdb_stdout);
+           }
+         (*objfile->sf->sym_read_psymbols) (objfile);
+         if (verbose)
+           {
+             if (!objfile_has_symbols (objfile))
+               {
+                 wrap_here ("");
+                 printf_unfiltered (_("(no debugging symbols found)..."));
+                 wrap_here ("");
+               }
+
+             printf_unfiltered (_("done.\n"));
+           }
+       }
+    }
+
+  return objfile;
+}
+
+/* Traverse all psymtabs in one objfile, requiring that the psymtabs
+   be read in.  */
+
+#define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p)              \
+    for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \
+        (p) != NULL;                                           \
+        (p) = (p)->next)
+
+/* We want to make sure this file always requires psymtabs.  */
+
+#undef ALL_OBJFILE_PSYMTABS
+
+/* Traverse all psymtabs in all objfiles.  */
+
+#define ALL_PSYMTABS(objfile, p) \
+  ALL_OBJFILES (objfile)        \
+    ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
+
+/* Helper function for psym_map_symtabs_matching_filename that
+   expands the symtabs and calls the iterator.  */
+
+static int
+partial_map_expand_apply (struct objfile *objfile,
+                         const char *name,
+                         const char *real_path,
+                         struct partial_symtab *pst,
+                         int (*callback) (struct symtab *, void *),
+                         void *data)
+{
+  struct compunit_symtab *last_made = objfile->compunit_symtabs;
+
+  /* Shared psymtabs should never be seen here.  Instead they should
+     be handled properly by the caller.  */
+  gdb_assert (pst->user == NULL);
+
+  /* Don't visit already-expanded psymtabs.  */
+  if (pst->readin)
+    return 0;
+
+  /* This may expand more than one symtab, and we want to iterate over
+     all of them.  */
+  psymtab_to_symtab (objfile, pst);
+
+  return iterate_over_some_symtabs (name, real_path, callback, data,
+                                   objfile->compunit_symtabs, last_made);
+}
+
+/*  Psymtab version of map_symtabs_matching_filename.  See its definition in
+    the definition of quick_symbol_functions in symfile.h.  */
+
+static int
+psym_map_symtabs_matching_filename (struct objfile *objfile,
+                                   const char *name,
+                                   const char *real_path,
+                                   int (*callback) (struct symtab *,
+                                                    void *),
+                                   void *data)

 {
   struct partial_symtab *pst;
 {
   struct partial_symtab *pst;

+  const char *name_basename = lbasename (name);

 
 

-  ALL_OBJFILE_PSYMTABS (objfile, pst)
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)

   {
   {

-    if (FILENAME_CMP (name, pst->filename) == 0)
+    /* We can skip shared psymtabs here, because any file name will be
+       attached to the unshared psymtab.  */
+    if (pst->user != NULL)
+      continue;
+
+    /* Anonymous psymtabs don't have a file name.  */
+    if (pst->anonymous)
+      continue;
+
+    if (compare_filenames_for_search (pst->filename, name))

       {
       {

-       return (pst);
+       if (partial_map_expand_apply (objfile, name, real_path,
+                                     pst, callback, data))
+         return 1;
+       continue;

       }
 
       }
 

-    /* If the user gave us an absolute path, try to find the file in
-       this symtab and use its absolute path.  */
-    if (full_path != NULL)
+    /* Before we invoke realpath, which can get expensive when many
+       files are involved, do a quick comparison of the basenames.  */
+    if (! basenames_may_differ
+       && FILENAME_CMP (name_basename, lbasename (pst->filename)) != 0)
+      continue;
+
+    if (compare_filenames_for_search (psymtab_to_fullname (pst), name))

       {
       {

-       psymtab_to_fullname (pst);
-       if (pst->fullname != NULL
-           && FILENAME_CMP (full_path, pst->fullname) == 0)
-         {
-           return pst;
-         }
+       if (partial_map_expand_apply (objfile, name, real_path,
+                                     pst, callback, data))
+         return 1;
+       continue;

       }
 
       }
 

+    /* If the user gave us an absolute path, try to find the file in
+       this symtab and use its absolute path.  */

     if (real_path != NULL)
       {
     if (real_path != NULL)
       {

-        char *rp = NULL;
-       psymtab_to_fullname (pst);
-        if (pst->fullname != NULL)
-          {
-            rp = gdb_realpath (pst->fullname);
-            make_cleanup (xfree, rp);
-          }
-       if (rp != NULL && FILENAME_CMP (real_path, rp) == 0)
+       gdb_assert (IS_ABSOLUTE_PATH (real_path));
+       gdb_assert (IS_ABSOLUTE_PATH (name));
+       if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0)

          {
          {

-           return pst;
+           if (partial_map_expand_apply (objfile, name, real_path,
+                                         pst, callback, data))
+             return 1;
+           continue;

          }
       }
   }
 
          }
       }
   }
 

-  /* Now, search for a matching tail (only if name doesn't have any dirs) */
-
-  if (lbasename (name) == name)
-    ALL_OBJFILE_PSYMTABS (objfile, pst)
-    {
-      if (FILENAME_CMP (lbasename (pst->filename), name) == 0)
-       return (pst);
-    }
-
-  return (NULL);
-}
-
-static int
-lookup_symtab_via_partial_symtab (struct objfile *objfile, const char *name,
-                                 const char *full_path, const char *real_path,
-                                 struct symtab **result)
-{
-  struct partial_symtab *ps;
-
-  ps = lookup_partial_symtab (objfile, name, full_path, real_path);
-  if (!ps)
-    return 0;
-
-  if (ps->readin)
-    error (_("Internal: readin %s pst for `%s' found when no symtab found."),
-          ps->filename, name);
-
-  *result = PSYMTAB_TO_SYMTAB (ps);
-  return 1;
+  return 0;

 }
 
 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
    We may find a different psymtab than PST.  See FIND_PC_SECT_PSYMTAB.  */
 
 static struct partial_symtab *
 }
 
 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
    We may find a different psymtab than PST.  See FIND_PC_SECT_PSYMTAB.  */
 
 static struct partial_symtab *

-find_pc_sect_psymtab_closer (CORE_ADDR pc, struct obj_section *section,
+find_pc_sect_psymtab_closer (struct objfile *objfile,
+                            CORE_ADDR pc, struct obj_section *section,

                             struct partial_symtab *pst,
                             struct partial_symtab *pst,

-                            struct minimal_symbol *msymbol)
+                            struct bound_minimal_symbol msymbol)

 {
 {

-  struct objfile *objfile = pst->objfile;

   struct partial_symtab *tpst;
   struct partial_symtab *best_pst = pst;
   CORE_ADDR best_addr = pst->textlow;
 
   struct partial_symtab *tpst;
   struct partial_symtab *best_pst = pst;
   CORE_ADDR best_addr = pst->textlow;
 

+  gdb_assert (!pst->psymtabs_addrmap_supported);
+

   /* An objfile that has its functions reordered might have
      many partial symbol tables containing the PC, but
      we want the partial symbol table that contains the
      function containing the PC.  */
   /* An objfile that has its functions reordered might have
      many partial symbol tables containing the PC, but
      we want the partial symbol table that contains the
      function containing the PC.  */

-  if (!(objfile->flags & OBJF_REORDERED) &&
-      section == 0)    /* can't validate section this way */
+  if (!(objfile->flags & OBJF_REORDERED)
+      && section == NULL)  /* Can't validate section this way.  */

     return pst;
 
     return pst;
 

-  if (msymbol == NULL)
-    return (pst);
+  if (msymbol.minsym == NULL)
+    return pst;

 
   /* The code range of partial symtabs sometimes overlap, so, in
      the loop below, we need to check all partial symtabs and
 
   /* The code range of partial symtabs sometimes overlap, so, in
      the loop below, we need to check all partial symtabs and

-     find the one that fits better for the given PC address. We
+     find the one that fits better for the given PC address.  We

      select the partial symtab that contains a symbol whose
      address is closest to the PC address.  By closest we mean
      that find_pc_sect_symbol returns the symbol with address
      select the partial symtab that contains a symbol whose
      address is closest to the PC address.  By closest we mean
      that find_pc_sect_symbol returns the symbol with address


@@ -181,10 +263,10 @@ find_pc_sect_psymtab_closer (CORE_ADDR pc, struct obj_section *section,
             corresponding msymbol, which is not necessarily
             true; the debug info might be much richer than the
             object's symbol table.  */
             corresponding msymbol, which is not necessarily
             true; the debug info might be much richer than the
             object's symbol table.  */

-         p = find_pc_sect_psymbol (tpst, pc, section);
+         p = find_pc_sect_psymbol (objfile, tpst, pc, section);

          if (p != NULL
          if (p != NULL

-             && SYMBOL_VALUE_ADDRESS (p)
-             == SYMBOL_VALUE_ADDRESS (msymbol))
+             && (SYMBOL_VALUE_ADDRESS (p)
+                 == BMSYMBOL_VALUE_ADDRESS (msymbol)))

            return tpst;
 
          /* Also accept the textlow value of a psymtab as a
            return tpst;
 
          /* Also accept the textlow value of a psymtab as a


@@ -201,11 +283,11 @@ find_pc_sect_psymtab_closer (CORE_ADDR pc, struct obj_section *section,
             necessarily lower or equal to PC, the symbol closer
             to PC is the symbol which address is the highest.
             This way we return the psymtab which contains such
             necessarily lower or equal to PC, the symbol closer
             to PC is the symbol which address is the highest.
             This way we return the psymtab which contains such

-            best match symbol. This can help in cases where the
+            best match symbol.  This can help in cases where the

             symbol information/debuginfo is not complete, like
             for instance on IRIX6 with gcc, where no debug info
             symbol information/debuginfo is not complete, like
             for instance on IRIX6 with gcc, where no debug info

-            is emitted for statics. (See also the nodebug.exp
-            testcase.) */
+            is emitted for statics.  (See also the nodebug.exp
+            testcase.)  */

          if (this_addr > best_addr)
            {
              best_addr = this_addr;
          if (this_addr > best_addr)
            {
              best_addr = this_addr;


@@ -216,14 +298,15 @@ find_pc_sect_psymtab_closer (CORE_ADDR pc, struct obj_section *section,
   return best_pst;
 }
 
   return best_pst;
 }
 

-/* Find which partial symtab contains PC and SECTION.  Return 0 if
+/* Find which partial symtab contains PC and SECTION.  Return NULL if

    none.  We return the psymtab that contains a symbol whose address
    exactly matches PC, or, if we cannot find an exact match, the
    psymtab that contains a symbol whose address is closest to PC.  */
    none.  We return the psymtab that contains a symbol whose address
    exactly matches PC, or, if we cannot find an exact match, the
    psymtab that contains a symbol whose address is closest to PC.  */

+

 static struct partial_symtab *
 find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
                      struct obj_section *section,
 static struct partial_symtab *
 find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
                      struct obj_section *section,

-                     struct minimal_symbol *msymbol)
+                     struct bound_minimal_symbol msymbol)

 {
   struct partial_symtab *pst;
 
 {
   struct partial_symtab *pst;
 


@@ -232,13 +315,14 @@ find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
 
   if (objfile->psymtabs_addrmap != NULL)
     {
 
   if (objfile->psymtabs_addrmap != NULL)
     {

-      pst = addrmap_find (objfile->psymtabs_addrmap, pc);
+      pst = ((struct partial_symtab *)
+            addrmap_find (objfile->psymtabs_addrmap, pc));

       if (pst != NULL)
        {
          /* FIXME: addrmaps currently do not handle overlayed sections,
             so fall back to the non-addrmap case if we're debugging
             overlays and the addrmap returned the wrong section.  */
       if (pst != NULL)
        {
          /* FIXME: addrmaps currently do not handle overlayed sections,
             so fall back to the non-addrmap case if we're debugging
             overlays and the addrmap returned the wrong section.  */

-         if (overlay_debugging && msymbol && section)
+         if (overlay_debugging && msymbol.minsym != NULL && section != NULL)

            {
              struct partial_symbol *p;
 
            {
              struct partial_symbol *p;
 


@@ -246,10 +330,10 @@ find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
                 corresponding msymbol, which is not necessarily
                 true; the debug info might be much richer than the
                 object's symbol table.  */
                 corresponding msymbol, which is not necessarily
                 true; the debug info might be much richer than the
                 object's symbol table.  */

-             p = find_pc_sect_psymbol (pst, pc, section);
-             if (!p
-                 || SYMBOL_VALUE_ADDRESS (p)
-                 != SYMBOL_VALUE_ADDRESS (msymbol))
+             p = find_pc_sect_psymbol (objfile, pst, pc, section);
+             if (p == NULL
+                 || (SYMBOL_VALUE_ADDRESS (p)
+                     != BMSYMBOL_VALUE_ADDRESS (msymbol)))

                goto next;
            }
 
                goto next;
            }
 


@@ -274,12 +358,14 @@ find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
      its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
      debug info type in single OBJFILE.  */
 
      its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
      debug info type in single OBJFILE.  */
 

-  ALL_OBJFILE_PSYMTABS (objfile, pst)
-    if (pc >= pst->textlow && pc < pst->texthigh)
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
+    if (!pst->psymtabs_addrmap_supported
+       && pc >= pst->textlow && pc < pst->texthigh)

       {
        struct partial_symtab *best_pst;
 
       {
        struct partial_symtab *best_pst;
 

-       best_pst = find_pc_sect_psymtab_closer (pc, section, pst, msymbol);
+       best_pst = find_pc_sect_psymtab_closer (objfile, pc, section, pst,
+                                               msymbol);

        if (best_pst != NULL)
          return best_pst;
       }
        if (best_pst != NULL)
          return best_pst;
       }


@@ -287,15 +373,19 @@ find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
   return NULL;
 }
 
   return NULL;
 }
 

-static struct symtab *
-find_pc_sect_symtab_from_partial (struct objfile *objfile,
-                                 struct minimal_symbol *msymbol,
-                                 CORE_ADDR pc, struct obj_section *section,
-                                 int warn_if_readin)
+/* Psymtab version of find_pc_sect_compunit_symtab.  See its definition in
+   the definition of quick_symbol_functions in symfile.h.  */
+
+static struct compunit_symtab *
+psym_find_pc_sect_compunit_symtab (struct objfile *objfile,
+                                  struct bound_minimal_symbol msymbol,
+                                  CORE_ADDR pc,
+                                  struct obj_section *section,
+                                  int warn_if_readin)

 {
   struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section,
                                                    msymbol);
 {
   struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section,
                                                    msymbol);

-  if (ps)
+  if (ps != NULL)

     {
       if (warn_if_readin && ps->readin)
        /* Might want to error() here (in case symtab is corrupt and
     {
       if (warn_if_readin && ps->readin)
        /* Might want to error() here (in case symtab is corrupt and


@@ -303,17 +393,19 @@ find_pc_sect_symtab_from_partial (struct objfile *objfile,
           continue, so let's not.  */
        warning (_("\
 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
           continue, so let's not.  */
        warning (_("\
 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),

-                paddress (get_objfile_arch (ps->objfile), pc));
-      return PSYMTAB_TO_SYMTAB (ps);
+                paddress (get_objfile_arch (objfile), pc));
+      psymtab_to_symtab (objfile, ps);
+      return ps->compunit_symtab;

     }
   return NULL;
 }
 
 /* Find which partial symbol within a psymtab matches PC and SECTION.
     }
   return NULL;
 }
 
 /* Find which partial symbol within a psymtab matches PC and SECTION.

-   Return 0 if none.  */
+   Return NULL if none.  */

 
 static struct partial_symbol *
 
 static struct partial_symbol *

-find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc,
+find_pc_sect_psymbol (struct objfile *objfile,
+                     struct partial_symtab *psymtab, CORE_ADDR pc,

                      struct obj_section *section)
 {
   struct partial_symbol *best = NULL, *p, **pp;
                      struct obj_section *section)
 {
   struct partial_symbol *best = NULL, *p, **pp;


@@ -321,29 +413,30 @@ find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc,
 
   gdb_assert (psymtab != NULL);
 
 
   gdb_assert (psymtab != NULL);
 

-  /* Cope with programs that start at address 0 */
+  /* Cope with programs that start at address 0.  */

   best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
 
   /* Search the global symbols as well as the static symbols, so that
      find_pc_partial_function doesn't use a minimal symbol and thus
      cache a bad endaddr.  */
   best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
 
   /* Search the global symbols as well as the static symbols, so that
      find_pc_partial_function doesn't use a minimal symbol and thus
      cache a bad endaddr.  */

-  for (pp = psymtab->objfile->global_psymbols.list + psymtab->globals_offset;
-    (pp - (psymtab->objfile->global_psymbols.list + psymtab->globals_offset)
-     < psymtab->n_global_syms);
+  for (pp = objfile->global_psymbols.list + psymtab->globals_offset;
+       (pp - (objfile->global_psymbols.list + psymtab->globals_offset)
+       < psymtab->n_global_syms);

        pp++)
     {
       p = *pp;
       if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
        pp++)
     {
       p = *pp;
       if (SYMBOL_DOMAIN (p) == VAR_DOMAIN

-         && SYMBOL_CLASS (p) == LOC_BLOCK
+         && PSYMBOL_CLASS (p) == LOC_BLOCK

          && pc >= SYMBOL_VALUE_ADDRESS (p)
          && (SYMBOL_VALUE_ADDRESS (p) > best_pc
              || (psymtab->textlow == 0
                  && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
        {
          && pc >= SYMBOL_VALUE_ADDRESS (p)
          && (SYMBOL_VALUE_ADDRESS (p) > best_pc
              || (psymtab->textlow == 0
                  && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
        {

-         if (section)          /* match on a specific section */
+         if (section != NULL)  /* Match on a specific section.  */

            {
            {

-             fixup_psymbol_section (p, psymtab->objfile);
-             if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
+             fixup_psymbol_section (p, objfile);
+             if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
+                                         section))

                continue;
            }
          best_pc = SYMBOL_VALUE_ADDRESS (p);
                continue;
            }
          best_pc = SYMBOL_VALUE_ADDRESS (p);


@@ -351,23 +444,24 @@ find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc,
        }
     }
 
        }
     }
 

-  for (pp = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
-    (pp - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)
-     < psymtab->n_static_syms);
+  for (pp = objfile->static_psymbols.list + psymtab->statics_offset;
+       (pp - (objfile->static_psymbols.list + psymtab->statics_offset)
+       < psymtab->n_static_syms);

        pp++)
     {
       p = *pp;
       if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
        pp++)
     {
       p = *pp;
       if (SYMBOL_DOMAIN (p) == VAR_DOMAIN

-         && SYMBOL_CLASS (p) == LOC_BLOCK
+         && PSYMBOL_CLASS (p) == LOC_BLOCK

          && pc >= SYMBOL_VALUE_ADDRESS (p)
          && (SYMBOL_VALUE_ADDRESS (p) > best_pc
              || (psymtab->textlow == 0
                  && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
        {
          && pc >= SYMBOL_VALUE_ADDRESS (p)
          && (SYMBOL_VALUE_ADDRESS (p) > best_pc
              || (psymtab->textlow == 0
                  && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
        {

-         if (section)          /* match on a specific section */
+         if (section != NULL)  /* Match on a specific section.  */

            {
            {

-             fixup_psymbol_section (p, psymtab->objfile);
-             if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
+             fixup_psymbol_section (p, objfile);
+             if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
+                                         section))

                continue;
            }
          best_pc = SYMBOL_VALUE_ADDRESS (p);
                continue;
            }
          best_pc = SYMBOL_VALUE_ADDRESS (p);


@@ -378,20 +472,20 @@ find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc,
   return best;
 }
 
   return best;
 }
 

-static struct partial_symbol *
+static void

 fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
 {
   CORE_ADDR addr;
 
 fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
 {
   CORE_ADDR addr;
 

-  if (!psym)
-    return NULL;
+  if (psym == NULL)
+    return;

 
 

-  if (SYMBOL_OBJ_SECTION (psym))
-    return psym;
+  if (SYMBOL_SECTION (psym) >= 0)
+    return;

 
   gdb_assert (objfile);
 
 
   gdb_assert (objfile);
 

-  switch (SYMBOL_CLASS (psym))
+  switch (PSYMBOL_CLASS (psym))

     {
     case LOC_STATIC:
     case LOC_LABEL:
     {
     case LOC_STATIC:
     case LOC_LABEL:


@@ -401,66 +495,197 @@ fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
     default:
       /* Nothing else will be listed in the minsyms -- no use looking
         it up.  */
     default:
       /* Nothing else will be listed in the minsyms -- no use looking
         it up.  */

-      return psym;
+      return;

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

-
-  return psym;

 }
 
 }
 

-static struct symtab *
-lookup_symbol_aux_psymtabs (struct objfile *objfile,
-                           int block_index, const char *name,
-                           const domain_enum domain)
+/* Psymtab version of lookup_symbol.  See its definition in
+   the definition of quick_symbol_functions in symfile.h.  */
+
+static struct compunit_symtab *
+psym_lookup_symbol (struct objfile *objfile,
+                   int block_index, const char *name,
+                   const domain_enum domain)

 {
   struct partial_symtab *ps;
   const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
 {
   struct partial_symtab *ps;
   const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);

+  struct compunit_symtab *stab_best = NULL;

 
 

-  ALL_OBJFILE_PSYMTABS (objfile, ps)
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)

   {
   {

-    if (!ps->readin && lookup_partial_symbol (ps, name, psymtab_index, domain))
-      return PSYMTAB_TO_SYMTAB (ps);
+    if (!ps->readin && lookup_partial_symbol (objfile, ps, name,
+                                             psymtab_index, domain))
+      {
+       struct symbol *sym, *with_opaque = NULL;
+       struct compunit_symtab *stab = psymtab_to_symtab (objfile, ps);
+       /* Note: While psymtab_to_symtab can return NULL if the partial symtab
+          is empty, we can assume it won't here because lookup_partial_symbol
+          succeeded.  */
+       const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
+       struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
+
+       sym = block_find_symbol (block, name, domain,
+                                block_find_non_opaque_type_preferred,
+                                &with_opaque);
+
+       /* Some caution must be observed with overloaded functions
+          and methods, since the index will not contain any overload
+          information (but NAME might contain it).  */
+
+       if (sym != NULL
+           && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
+         return stab;
+       if (with_opaque != NULL
+           && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
+         stab_best = stab;
+
+       /* Keep looking through other psymtabs.  */
+      }

   }
 
   }
 

-  return NULL;
+  return stab_best;

 }
 
 }
 

-static struct symbol *
-expand_one_symtab_matching_psymtabs (struct objfile *objfile,
-                                    int kind, const char *name,
-                                    domain_enum domain,
-                                    struct symbol *(*matcher) (struct symtab *,
-                                                               int,
-                                                               const char *,
-                                                               domain_enum,
-                                                               void *),
-                                    void *data)
+/* Look in PST for a symbol in DOMAIN whose name matches NAME.  Search
+   the global block of PST if GLOBAL, and otherwise the static block.
+   MATCH is the comparison operation that returns true iff MATCH (s,
+   NAME), where s is a SYMBOL_SEARCH_NAME.  If ORDERED_COMPARE is
+   non-null, the symbols in the block are assumed to be ordered
+   according to it (allowing binary search).  It must be compatible
+   with MATCH.  Returns the symbol, if found, and otherwise NULL.  */
+
+static struct partial_symbol *
+match_partial_symbol (struct objfile *objfile,
+                     struct partial_symtab *pst, int global,
+                     const char *name, domain_enum domain,
+                     symbol_compare_ftype *match,
+                     symbol_compare_ftype *ordered_compare)

 {
 {

+  struct partial_symbol **start, **psym;
+  struct partial_symbol **top, **real_top, **bottom, **center;
+  int length = (global ? pst->n_global_syms : pst->n_static_syms);
+  int do_linear_search = 1;
+
+  if (length == 0)
+      return NULL;
+  start = (global ?
+          objfile->global_psymbols.list + pst->globals_offset :
+          objfile->static_psymbols.list + pst->statics_offset);
+
+  if (global && ordered_compare)  /* Can use a binary search.  */
+    {
+      do_linear_search = 0;
+
+      /* Binary search.  This search is guaranteed to end with center
+         pointing at the earliest partial symbol whose name might be
+         correct.  At that point *all* partial symbols with an
+         appropriate name will be checked against the correct
+         domain.  */
+
+      bottom = start;
+      top = start + length - 1;
+      real_top = top;
+      while (top > bottom)
+       {
+         center = bottom + (top - bottom) / 2;
+         gdb_assert (center < top);
+         if (!do_linear_search
+             && (SYMBOL_LANGUAGE (*center) == language_java))
+           do_linear_search = 1;
+         if (ordered_compare (SYMBOL_SEARCH_NAME (*center), name) >= 0)
+           top = center;
+         else
+           bottom = center + 1;
+       }
+      gdb_assert (top == bottom);
+
+      while (top <= real_top
+            && match (SYMBOL_SEARCH_NAME (*top), name) == 0)
+       {
+         if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
+                                    SYMBOL_DOMAIN (*top), domain))
+           return *top;
+         top++;
+       }
+    }
+
+  /* Can't use a binary search or else we found during the binary search that
+     we should also do a linear search.  */
+
+  if (do_linear_search)
+    {
+      for (psym = start; psym < start + length; psym++)
+       {
+         if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
+                                    SYMBOL_DOMAIN (*psym), domain)
+             && match (SYMBOL_SEARCH_NAME (*psym), name) == 0)
+           return *psym;
+       }
+    }
+

   return NULL;
 }
 
   return NULL;
 }
 

+/* Returns the name used to search psymtabs.  Unlike symtabs, psymtabs do
+   not contain any method/function instance information (since this would
+   force reading type information while reading psymtabs).  Therefore,
+   if NAME contains overload information, it must be stripped before searching
+   psymtabs.
+
+   The caller is responsible for freeing the return result.  */
+
+static char *
+psymtab_search_name (const char *name)
+{
+  switch (current_language->la_language)
+    {
+    case language_cplus:
+    case language_java:
+      {
+       if (strchr (name, '('))
+         {
+           char *ret = cp_remove_params (name);
+
+           if (ret)
+             return ret;
+         }
+      }
+      break;
+
+    default:
+      break;
+    }
+
+  return xstrdup (name);
+}
+

 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.

-   Check the global symbols if GLOBAL, the static symbols if not. */
+   Check the global symbols if GLOBAL, the static symbols if not.  */

 
 static struct partial_symbol *
 
 static struct partial_symbol *

-lookup_partial_symbol (struct partial_symtab *pst, const char *name,
+lookup_partial_symbol (struct objfile *objfile,
+                      struct partial_symtab *pst, const char *name,

                       int global, domain_enum domain)
 {
   struct partial_symbol **start, **psym;
   struct partial_symbol **top, **real_top, **bottom, **center;
   int length = (global ? pst->n_global_syms : pst->n_static_syms);
   int do_linear_search = 1;
                       int global, domain_enum domain)
 {
   struct partial_symbol **start, **psym;
   struct partial_symbol **top, **real_top, **bottom, **center;
   int length = (global ? pst->n_global_syms : pst->n_static_syms);
   int do_linear_search = 1;

+  char *search_name;
+  struct cleanup *cleanup;

 
   if (length == 0)
 
   if (length == 0)

-    {
-      return (NULL);
-    }
+    return NULL;
+
+  search_name = psymtab_search_name (name);
+  cleanup = make_cleanup (xfree, search_name);

   start = (global ?
   start = (global ?

-          pst->objfile->global_psymbols.list + pst->globals_offset :
-          pst->objfile->static_psymbols.list + pst->statics_offset);
+          objfile->global_psymbols.list + pst->globals_offset :
+          objfile->static_psymbols.list + pst->statics_offset);

 
 

-  if (global)                  /* This means we can use a binary search. */
+  if (global)                  /* This means we can use a binary search.  */

     {
       do_linear_search = 0;
 
     {
       do_linear_search = 0;
 


@@ -477,13 +702,15 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name,
        {
          center = bottom + (top - bottom) / 2;
          if (!(center < top))
        {
          center = bottom + (top - bottom) / 2;
          if (!(center < top))

-           internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
+           internal_error (__FILE__, __LINE__,
+                           _("failed internal consistency check"));

          if (!do_linear_search
          if (!do_linear_search

-             && (SYMBOL_LANGUAGE (*center) == language_java))
+             && SYMBOL_LANGUAGE (*center) == language_java)

            {
              do_linear_search = 1;
            }
            {
              do_linear_search = 1;
            }

-         if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center), name) >= 0)
+         if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
+                                search_name) >= 0)

            {
              top = center;
            }
            {
              top = center;
            }


@@ -493,20 +720,31 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name,
            }
        }
       if (!(top == bottom))
            }
        }
       if (!(top == bottom))

-       internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
+       internal_error (__FILE__, __LINE__,
+                       _("failed internal consistency check"));

 
 

-      while (top <= real_top
-            && SYMBOL_MATCHES_SEARCH_NAME (*top, name))
+      /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
+        search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME.  */
+      while (top >= start && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
+       top--;
+
+      /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME.  */
+      top++;
+
+      while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))

        {
          if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
                                     SYMBOL_DOMAIN (*top), domain))
        {
          if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
                                     SYMBOL_DOMAIN (*top), domain))

-           return (*top);
+           {
+             do_cleanups (cleanup);
+             return *top;
+           }

          top++;
        }
     }
 
   /* Can't use a binary search or else we found during the binary search that
          top++;
        }
     }
 
   /* Can't use a binary search or else we found during the binary search that

-     we should also do a linear search. */
+     we should also do a linear search.  */

 
   if (do_linear_search)
     {
 
   if (do_linear_search)
     {


@@ -514,47 +752,60 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name,
        {
          if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
                                     SYMBOL_DOMAIN (*psym), domain)
        {
          if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
                                     SYMBOL_DOMAIN (*psym), domain)

-             && SYMBOL_MATCHES_SEARCH_NAME (*psym, name))
-           return (*psym);
+             && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name))
+           {
+             do_cleanups (cleanup);
+             return *psym;
+           }

        }
     }
 
        }
     }
 

-  return (NULL);
+  do_cleanups (cleanup);
+  return NULL;

 }
 
 /* Get the symbol table that corresponds to a partial_symtab.
 }
 
 /* Get the symbol table that corresponds to a partial_symtab.

-   This is fast after the first time you do it.  In fact, there
-   is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
-   case inline.  */
+   This is fast after the first time you do it.
+   The result will be NULL if the primary symtab has no symbols,
+   which can happen.  Otherwise the result is the primary symtab
+   that contains PST.  */

 
 

-static struct symtab *
-psymtab_to_symtab (struct partial_symtab *pst)
+static struct compunit_symtab *
+psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)

 {
 {

-  /* If it's been looked up before, return it. */
-  if (pst->symtab)
-    return pst->symtab;
+  /* If it is a shared psymtab, find an unshared psymtab that includes
+     it.  Any such psymtab will do.  */
+  while (pst->user != NULL)
+    pst = pst->user;
+
+  /* If it's been looked up before, return it.  */
+  if (pst->compunit_symtab)
+    return pst->compunit_symtab;

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

-      (*pst->read_symtab) (pst);
+      (*pst->read_symtab) (pst, objfile);

       do_cleanups (back_to);
     }
 
       do_cleanups (back_to);
     }
 

-  return pst->symtab;
+  return pst->compunit_symtab;

 }
 
 }
 

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

 static void
 static void

-relocate_psymtabs (struct objfile *objfile,
-                  struct section_offsets *new_offsets,
-                  struct section_offsets *delta)
+psym_relocate (struct objfile *objfile,
+              const struct section_offsets *new_offsets,
+              const struct section_offsets *delta)

 {
   struct partial_symbol **psym;
   struct partial_symtab *p;
 
 {
   struct partial_symbol **psym;
   struct partial_symtab *p;
 

-  ALL_OBJFILE_PSYMTABS (objfile, p)
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)

     {
       p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
       p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
     {
       p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
       p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));


@@ -580,13 +831,16 @@ relocate_psymtabs (struct objfile *objfile,
     }
 }
 
     }
 }
 

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

 static struct symtab *
 static struct symtab *

-find_last_source_symtab_from_partial (struct objfile *ofp)
+psym_find_last_source_symtab (struct objfile *ofp)

 {
   struct partial_symtab *ps;
 {
   struct partial_symtab *ps;

-  struct partial_symtab *cs_pst = 0;
+  struct partial_symtab *cs_pst = NULL;

 
 

-  ALL_OBJFILE_PSYMTABS (ofp, ps)
+  ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)

     {
       const char *name = ps->filename;
       int len = strlen (name);
     {
       const char *name = ps->filename;
       int len = strlen (name);


@@ -605,17 +859,26 @@ find_last_source_symtab_from_partial (struct objfile *ofp)
                          "readin pst found and no symtabs."));
        }
       else
                          "readin pst found and no symtabs."));
        }
       else

-       return PSYMTAB_TO_SYMTAB (cs_pst);
+       {
+         struct compunit_symtab *cust = psymtab_to_symtab (ofp, cs_pst);
+
+         if (cust == NULL)
+           return NULL;
+         return compunit_primary_filetab (cust);
+       }

     }
   return NULL;
 }
 
     }
   return NULL;
 }
 

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

 static void
 static void

-forget_cached_source_info_partial (struct objfile *objfile)
+psym_forget_cached_source_info (struct objfile *objfile)

 {
   struct partial_symtab *pst;
 
 {
   struct partial_symtab *pst;
 

-  ALL_OBJFILE_PSYMTABS (objfile, pst)
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)

     {
       if (pst->fullname != NULL)
        {
     {
       if (pst->fullname != NULL)
        {


@@ -633,6 +896,7 @@ print_partial_symbols (struct gdbarch *gdbarch,
   fprintf_filtered (outfile, "  %s partial symbols:\n", what);
   while (count-- > 0)
     {
   fprintf_filtered (outfile, "  %s partial symbols:\n", what);
   while (count-- > 0)
     {

+      QUIT;

       fprintf_filtered (outfile, "    `%s'", SYMBOL_LINKAGE_NAME (*p));
       if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
        {
       fprintf_filtered (outfile, "    `%s'", SYMBOL_LINKAGE_NAME (*p));
       if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
        {


@@ -645,7 +909,7 @@ print_partial_symbols (struct gdbarch *gdbarch,
          fputs_filtered ("undefined domain, ", outfile);
          break;
        case VAR_DOMAIN:
          fputs_filtered ("undefined domain, ", outfile);
          break;
        case VAR_DOMAIN:

-         /* This is the usual thing -- don't print it */
+         /* This is the usual thing -- don't print it.  */

          break;
        case STRUCT_DOMAIN:
          fputs_filtered ("struct domain, ", outfile);
          break;
        case STRUCT_DOMAIN:
          fputs_filtered ("struct domain, ", outfile);


@@ -657,7 +921,7 @@ print_partial_symbols (struct gdbarch *gdbarch,
          fputs_filtered ("<invalid domain>, ", outfile);
          break;
        }
          fputs_filtered ("<invalid domain>, ", outfile);
          break;
        }

-      switch (SYMBOL_CLASS (*p))
+      switch (PSYMBOL_CLASS (*p))

        {
        case LOC_UNDEF:
          fputs_filtered ("undefined", outfile);
        {
        case LOC_UNDEF:
          fputs_filtered ("undefined", outfile);


@@ -722,13 +986,21 @@ dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   int i;
 
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   int i;
 

-  fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
-                   psymtab->filename);
+  if (psymtab->anonymous)
+    {
+      fprintf_filtered (outfile, "\nAnonymous partial symtab (%s) ",
+                       psymtab->filename);
+    }
+  else
+    {
+      fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
+                       psymtab->filename);
+    }

   fprintf_filtered (outfile, "(object ");
   gdb_print_host_address (psymtab, outfile);
   fprintf_filtered (outfile, ")\n\n");
   fprintf_unfiltered (outfile, "  Read from object file %s (",
   fprintf_filtered (outfile, "(object ");
   gdb_print_host_address (psymtab, outfile);
   fprintf_filtered (outfile, ")\n\n");
   fprintf_unfiltered (outfile, "  Read from object file %s (",

-                     objfile->name);
+                     objfile_name (objfile));

   gdb_print_host_address (objfile, outfile);
   fprintf_unfiltered (outfile, ")\n");
 
   gdb_print_host_address (objfile, outfile);
   fprintf_unfiltered (outfile, ")\n");
 


@@ -736,29 +1008,19 @@ dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
     {
       fprintf_filtered (outfile,
                        "  Full symtab was read (at ");
     {
       fprintf_filtered (outfile,
                        "  Full symtab was read (at ");

-      gdb_print_host_address (psymtab->symtab, outfile);
+      gdb_print_host_address (psymtab->compunit_symtab, outfile);

       fprintf_filtered (outfile, " by function at ");
       gdb_print_host_address (psymtab->read_symtab, outfile);
       fprintf_filtered (outfile, ")\n");
     }
 
       fprintf_filtered (outfile, " by function at ");
       gdb_print_host_address (psymtab->read_symtab, outfile);
       fprintf_filtered (outfile, ")\n");
     }
 

-  fprintf_filtered (outfile, "  Relocate symbols by ");
-  for (i = 0; i < psymtab->objfile->num_sections; ++i)
-    {
-      if (i != 0)
-       fprintf_filtered (outfile, ", ");
-      wrap_here ("    ");
-      fputs_filtered (paddress (gdbarch,
-                               ANOFFSET (psymtab->section_offsets, i)),
-                     outfile);
-    }
-  fprintf_filtered (outfile, "\n");
-

   fprintf_filtered (outfile, "  Symbols cover text addresses ");
   fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
   fprintf_filtered (outfile, "-");
   fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
   fprintf_filtered (outfile, "\n");
   fprintf_filtered (outfile, "  Symbols cover text addresses ");
   fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
   fprintf_filtered (outfile, "-");
   fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
   fprintf_filtered (outfile, "\n");

+  fprintf_filtered (outfile, "  Address map supported - %s.\n",
+                   psymtab->psymtabs_addrmap_supported ? "yes" : "no");

   fprintf_filtered (outfile, "  Depends on %d other partial symtabs.\n",
                    psymtab->number_of_dependencies);
   for (i = 0; i < psymtab->number_of_dependencies; i++)
   fprintf_filtered (outfile, "  Depends on %d other partial symtabs.\n",
                    psymtab->number_of_dependencies);
   for (i = 0; i < psymtab->number_of_dependencies; i++)


@@ -768,6 +1030,12 @@ dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
       fprintf_filtered (outfile, " %s\n",
                        psymtab->dependencies[i]->filename);
     }
       fprintf_filtered (outfile, " %s\n",
                        psymtab->dependencies[i]->filename);
     }

+  if (psymtab->user != NULL)
+    {
+      fprintf_filtered (outfile, "  Shared partial symtab with user ");
+      gdb_print_host_address (psymtab->user, outfile);
+      fprintf_filtered (outfile, "\n");
+    }

   if (psymtab->n_global_syms > 0)
     {
       print_partial_symbols (gdbarch,
   if (psymtab->n_global_syms > 0)
     {
       print_partial_symbols (gdbarch,


@@ -785,14 +1053,17 @@ dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
   fprintf_filtered (outfile, "\n");
 }
 
   fprintf_filtered (outfile, "\n");
 }
 

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

 static void
 static void

-print_psymtab_stats_for_objfile (struct objfile *objfile)
+psym_print_stats (struct objfile *objfile)

 {
   int i;
   struct partial_symtab *ps;
 
   i = 0;
 {
   int i;
   struct partial_symtab *ps;
 
   i = 0;

-  ALL_OBJFILE_PSYMTABS (objfile, ps)
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)

     {
       if (ps->readin == 0)
        i++;
     {
       if (ps->readin == 0)
        i++;


@@ -800,8 +1071,11 @@ print_psymtab_stats_for_objfile (struct objfile *objfile)
   printf_filtered (_("  Number of psym tables (not yet expanded): %d\n"), i);
 }
 
   printf_filtered (_("  Number of psym tables (not yet expanded): %d\n"), i);
 }
 

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

 static void
 static void

-dump_psymtabs_for_objfile (struct objfile *objfile)
+psym_dump (struct objfile *objfile)

 {
   struct partial_symtab *psymtab;
 
 {
   struct partial_symtab *psymtab;
 


@@ -816,122 +1090,107 @@ dump_psymtabs_for_objfile (struct objfile *objfile)
                           psymtab->filename);
          gdb_print_host_address (psymtab, gdb_stdout);
          printf_filtered (", ");
                           psymtab->filename);
          gdb_print_host_address (psymtab, gdb_stdout);
          printf_filtered (", ");

-         if (psymtab->objfile != objfile)
-           {
-             printf_filtered ("NOT ON CHAIN!  ");
-           }

          wrap_here ("  ");
        }
       printf_filtered ("\n\n");
     }
 }
 
          wrap_here ("  ");
        }
       printf_filtered ("\n\n");
     }
 }
 

-/* Look through the partial symtabs for all symbols which begin
-   by matching FUNC_NAME.  Make sure we read that symbol table in. */
+/* Psymtab version of expand_symtabs_for_function.  See its definition in
+   the definition of quick_symbol_functions in symfile.h.  */

 
 static void
 
 static void

-read_symtabs_for_function (struct objfile *objfile, const char *func_name)
+psym_expand_symtabs_for_function (struct objfile *objfile,
+                                 const char *func_name)

 {
   struct partial_symtab *ps;
 
 {
   struct partial_symtab *ps;
 

-  ALL_OBJFILE_PSYMTABS (objfile, ps)
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)

   {
     if (ps->readin)
       continue;
 
   {
     if (ps->readin)
       continue;
 

-    if ((lookup_partial_symbol (ps, func_name, 1, VAR_DOMAIN)
+    if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)

         != NULL)
         != NULL)

-       || (lookup_partial_symbol (ps, func_name, 0, VAR_DOMAIN)
+       || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)

            != NULL))
            != NULL))

-      psymtab_to_symtab (ps);
+      psymtab_to_symtab (objfile, ps);

   }
 }
 
   }
 }
 

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

 static void
 static void

-expand_partial_symbol_tables (struct objfile *objfile)
+psym_expand_all_symtabs (struct objfile *objfile)

 {
   struct partial_symtab *psymtab;
 
 {
   struct partial_symtab *psymtab;
 

-  for (psymtab = objfile->psymtabs;
-       psymtab != NULL;
-       psymtab = psymtab->next)
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)

     {
     {

-      psymtab_to_symtab (psymtab);
+      psymtab_to_symtab (objfile, psymtab);

     }
 }
 
     }
 }
 

-static void
-read_psymtabs_with_filename (struct objfile *objfile, const char *filename)
-{
-  struct partial_symtab *p;
-
-  ALL_OBJFILE_PSYMTABS (objfile, p)
-    {
-      if (strcmp (filename, p->filename) == 0)
-       PSYMTAB_TO_SYMTAB (p);
-    }
-}
+/* Psymtab version of expand_symtabs_with_fullname.  See its definition in
+   the definition of quick_symbol_functions in symfile.h.  */

 
 static void
 
 static void

-map_symbol_names_psymtab (struct objfile *objfile,
-                         void (*fun) (const char *, void *), void *data)
+psym_expand_symtabs_with_fullname (struct objfile *objfile,
+                                  const char *fullname)

 {
 {

-  struct partial_symtab *ps;
+  struct partial_symtab *p;

 
 

-  ALL_OBJFILE_PSYMTABS (objfile, ps)
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)

     {
     {

-      struct partial_symbol **psym;
-
-      /* If the psymtab's been read in we'll get it when we search
-        through the blockvector.  */
-      if (ps->readin)
+      /* Anonymous psymtabs don't have a name of a source file.  */
+      if (p->anonymous)

        continue;
 
        continue;
 

-      for (psym = objfile->global_psymbols.list + ps->globals_offset;
-          psym < (objfile->global_psymbols.list + ps->globals_offset
-                  + ps->n_global_syms);
-          psym++)
-       {
-         /* If interrupted, then quit. */
-         QUIT;
-         (*fun) (SYMBOL_NATURAL_NAME (*psym), data);
-       }
-
-      for (psym = objfile->static_psymbols.list + ps->statics_offset;
-          psym < (objfile->static_psymbols.list + ps->statics_offset
-                  + ps->n_static_syms);
-          psym++)
-       {
-         QUIT;
-         (*fun) (SYMBOL_NATURAL_NAME (*psym), data);
-       }
+      /* psymtab_to_fullname tries to open the file which is slow.
+        Don't call it if we know the basenames don't match.  */
+      if ((basenames_may_differ
+          || filename_cmp (lbasename (fullname), lbasename (p->filename)) == 0)
+         && filename_cmp (fullname, psymtab_to_fullname (p)) == 0)
+       psymtab_to_symtab (objfile, p);

     }
 }
 
     }
 }
 

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

 static void
 static void

-map_symbol_filenames_psymtab (struct objfile *objfile,
-                             void (*fun) (const char *, const char *,
-                                          void *),
-                             void *data)
+psym_map_symbol_filenames (struct objfile *objfile,
+                          symbol_filename_ftype *fun, void *data,
+                          int need_fullname)

 {
   struct partial_symtab *ps;
 
 {
   struct partial_symtab *ps;
 

-  ALL_OBJFILE_PSYMTABS (objfile, ps)
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)

     {
       const char *fullname;
 
       if (ps->readin)
        continue;
 
     {
       const char *fullname;
 
       if (ps->readin)
        continue;
 

-      fullname = psymtab_to_fullname (ps);
+      /* We can skip shared psymtabs here, because any file name will be
+        attached to the unshared psymtab.  */
+      if (ps->user != NULL)
+       continue;
+
+      /* Anonymous psymtabs don't have a file name.  */
+      if (ps->anonymous)
+       continue;
+
+      QUIT;
+      if (need_fullname)
+       fullname = psymtab_to_fullname (ps);
+      else
+       fullname = NULL;

       (*fun) (ps->filename, fullname, data);
     }
 }
 
       (*fun) (ps->filename, fullname, data);
     }
 }
 

-int find_and_open_source (const char *filename,
-                         const char *dirname,
-                         char **fullname);
-

 /* Finds the fullname that a partial_symtab represents.
 
    If this functions finds the fullname, it will save it in ps->fullname
 /* Finds the fullname that a partial_symtab represents.
 
    If this functions finds the fullname, it will save it in ps->fullname


@@ -939,298 +1198,288 @@ int find_and_open_source (const char *filename,
 
    If this function fails to find the file that this partial_symtab represents,
    NULL will be returned and ps->fullname will be set to NULL.  */
 
    If this function fails to find the file that this partial_symtab represents,
    NULL will be returned and ps->fullname will be set to NULL.  */

-static char *
+
+static const char *

 psymtab_to_fullname (struct partial_symtab *ps)
 {
 psymtab_to_fullname (struct partial_symtab *ps)
 {

-  int r;
+  gdb_assert (!ps->anonymous);

 
 

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

 
 

-  /* Don't check ps->fullname here, the file could have been
-     deleted/moved/..., look for it again */
-  r = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
+      if (fd >= 0)
+       close (fd);
+      else
+       {
+         char *fullname;
+         struct cleanup *back_to;

 
 

-  if (r >= 0)
-    {
-      close (r);
-      return ps->fullname;
+         /* rewrite_source_path would be applied by find_and_open_source, we
+            should report the pathname where GDB tried to find the file.  */
+
+         if (ps->dirname == NULL || IS_ABSOLUTE_PATH (ps->filename))
+           fullname = xstrdup (ps->filename);
+         else
+           fullname = concat (ps->dirname, SLASH_STRING, ps->filename, NULL);
+
+         back_to = make_cleanup (xfree, fullname);
+         ps->fullname = rewrite_source_path (fullname);
+         if (ps->fullname == NULL)
+           ps->fullname = xstrdup (fullname);
+         do_cleanups (back_to);
+       }

     }
 
     }
 

-  return NULL;
+  return ps->fullname;

 }
 
 }
 

-static const char *
-find_symbol_file_from_partial (struct objfile *objfile, const char *name)
+/* For all symbols, s, in BLOCK that are in DOMAIN and match NAME
+   according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
+   BLOCK is assumed to come from OBJFILE.  Returns 1 iff CALLBACK
+   ever returns non-zero, and otherwise returns 0.  */
+
+static int
+map_block (const char *name, domain_enum domain, struct objfile *objfile,
+          struct block *block,
+          int (*callback) (struct block *, struct symbol *, void *),
+          void *data, symbol_compare_ftype *match)

 {
 {

-  struct partial_symtab *pst;
+  struct block_iterator iter;
+  struct symbol *sym;

 
 

-  ALL_OBJFILE_PSYMTABS (objfile, pst)
+  for (sym = block_iter_match_first (block, name, match, &iter);
+       sym != NULL; sym = block_iter_match_next (name, match, &iter))

     {
     {

-      if (lookup_partial_symbol (pst, name, 1, VAR_DOMAIN))
-       return pst->filename;
+      if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
+                                SYMBOL_DOMAIN (sym), domain))
+       {
+         if (callback (block, sym, data))
+           return 1;
+       }

     }
     }

-  return NULL;
+
+  return 0;

 }
 
 }
 

-/* Look, in partial_symtab PST, for symbol NAME in given namespace.
-   Check the global symbols if GLOBAL, the static symbols if not.
-   Do wild-card match if WILD.  */
+/* Psymtab version of map_matching_symbols.  See its definition in
+   the definition of quick_symbol_functions in symfile.h.  */

 
 

-static struct partial_symbol *
-ada_lookup_partial_symbol (struct partial_symtab *pst, const char *name,
-                           int global, domain_enum namespace, int wild,
-                          int (*wild_match) (const char *, int, const char *),
-                          int (*is_name_suffix) (const char *))
+static void
+psym_map_matching_symbols (struct objfile *objfile,
+                          const char *name, domain_enum domain,
+                          int global,
+                          int (*callback) (struct block *,
+                                           struct symbol *, void *),
+                          void *data,
+                          symbol_compare_ftype *match,
+                          symbol_compare_ftype *ordered_compare)

 {
 {

-  struct partial_symbol **start;
-  int name_len = strlen (name);
-  int length = (global ? pst->n_global_syms : pst->n_static_syms);
-  int i;
+  const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
+  struct partial_symtab *ps;

 
 

-  if (length == 0)
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)

     {
     {

-      return (NULL);
+      QUIT;
+      if (ps->readin
+         || match_partial_symbol (objfile, ps, global, name, domain, match,
+                                  ordered_compare))
+       {
+         struct compunit_symtab *cust = psymtab_to_symtab (objfile, ps);
+         struct block *block;
+
+         if (cust == NULL)
+           continue;
+         block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), block_kind);
+         if (map_block (name, domain, objfile, block,
+                        callback, data, match))
+           return;
+         if (callback (block, NULL, data))
+           return;
+       }

     }
     }

+}

 
 

-  start = (global ?
-           pst->objfile->global_psymbols.list + pst->globals_offset :
-           pst->objfile->static_psymbols.list + pst->statics_offset);
+/* A helper for psym_expand_symtabs_matching that handles
+   searching included psymtabs.  This returns 1 if a symbol is found,
+   and zero otherwise.  It also updates the 'searched_flag' on the
+   various psymtabs that it searches.  */

 
 

-  if (wild)
-    {
-      for (i = 0; i < length; i += 1)
-        {
-          struct partial_symbol *psym = start[i];
-
-          if (symbol_matches_domain (SYMBOL_LANGUAGE (psym),
-                                     SYMBOL_DOMAIN (psym), namespace)
-              && (*wild_match) (name, name_len, SYMBOL_LINKAGE_NAME (psym)))
-            return psym;
-        }
-      return NULL;
-    }
-  else
+static int
+recursively_search_psymtabs (struct partial_symtab *ps,
+                            struct objfile *objfile,
+                            enum search_domain kind,
+                            expand_symtabs_symbol_matcher_ftype *sym_matcher,
+                            void *data)
+{
+  struct partial_symbol **psym;
+  struct partial_symbol **bound, **gbound, **sbound;
+  int keep_going = 1;
+  enum psymtab_search_status result = PST_SEARCHED_AND_NOT_FOUND;
+  int i;
+
+  if (ps->searched_flag != PST_NOT_SEARCHED)
+    return ps->searched_flag == PST_SEARCHED_AND_FOUND;
+
+  /* Recurse into shared psymtabs first, because they may have already
+     been searched, and this could save some time.  */
+  for (i = 0; i < ps->number_of_dependencies; ++i)

     {
     {

-      if (global)
-        {
-          int U;
-
-          i = 0;
-          U = length - 1;
-          while (U - i > 4)
-            {
-              int M = (U + i) >> 1;
-              struct partial_symbol *psym = start[M];
-
-              if (SYMBOL_LINKAGE_NAME (psym)[0] < name[0])
-                i = M + 1;
-              else if (SYMBOL_LINKAGE_NAME (psym)[0] > name[0])
-                U = M - 1;
-              else if (strcmp (SYMBOL_LINKAGE_NAME (psym), name) < 0)
-                i = M + 1;
-              else
-                U = M;
-            }
-        }
-      else
-        i = 0;
-
-      while (i < length)
-        {
-          struct partial_symbol *psym = start[i];
-
-          if (symbol_matches_domain (SYMBOL_LANGUAGE (psym),
-                                     SYMBOL_DOMAIN (psym), namespace))
-            {
-              int cmp = strncmp (name, SYMBOL_LINKAGE_NAME (psym), name_len);
-
-              if (cmp < 0)
-                {
-                  if (global)
-                    break;
-                }
-              else if (cmp == 0
-                       && (*is_name_suffix) (SYMBOL_LINKAGE_NAME (psym)
-                                            + name_len))
-                return psym;
-            }
-          i += 1;
-        }
-
-      if (global)
-        {
-          int U;
-
-          i = 0;
-          U = length - 1;
-          while (U - i > 4)
-            {
-              int M = (U + i) >> 1;
-              struct partial_symbol *psym = start[M];
-
-              if (SYMBOL_LINKAGE_NAME (psym)[0] < '_')
-                i = M + 1;
-              else if (SYMBOL_LINKAGE_NAME (psym)[0] > '_')
-                U = M - 1;
-              else if (strcmp (SYMBOL_LINKAGE_NAME (psym), "_ada_") < 0)
-                i = M + 1;
-              else
-                U = M;
-            }
-        }
-      else
-        i = 0;
-
-      while (i < length)
-        {
-          struct partial_symbol *psym = start[i];
-
-          if (symbol_matches_domain (SYMBOL_LANGUAGE (psym),
-                                     SYMBOL_DOMAIN (psym), namespace))
-            {
-              int cmp;
-
-              cmp = (int) '_' - (int) SYMBOL_LINKAGE_NAME (psym)[0];
-              if (cmp == 0)
-                {
-                  cmp = strncmp ("_ada_", SYMBOL_LINKAGE_NAME (psym), 5);
-                  if (cmp == 0)
-                    cmp = strncmp (name, SYMBOL_LINKAGE_NAME (psym) + 5,
-                                   name_len);
-                }
-
-              if (cmp < 0)
-                {
-                  if (global)
-                    break;
-                }
-              else if (cmp == 0
-                       && (*is_name_suffix) (SYMBOL_LINKAGE_NAME (psym)
-                                            + name_len + 5))
-                return psym;
-            }
-          i += 1;
-        }
+      int r;
+
+      /* Skip non-shared dependencies, these are handled elsewhere.  */
+      if (ps->dependencies[i]->user == NULL)
+       continue;
+
+      r = recursively_search_psymtabs (ps->dependencies[i],
+                                      objfile, kind, sym_matcher, data);
+      if (r != 0)
+       {
+         ps->searched_flag = PST_SEARCHED_AND_FOUND;
+         return 1;
+       }

     }
     }

-  return NULL;
-}

 
 

-static void
-map_ada_symtabs (struct objfile *objfile,
-                int (*wild_match) (const char *, int, const char *),
-                int (*is_name_suffix) (const char *),
-                void (*callback) (struct objfile *, struct symtab *, void *),
-                const char *name, int global, domain_enum namespace, int wild,
-                void *data)
-{
-  struct partial_symtab *ps;
+  gbound = (objfile->global_psymbols.list
+           + ps->globals_offset + ps->n_global_syms);
+  sbound = (objfile->static_psymbols.list
+           + ps->statics_offset + ps->n_static_syms);
+  bound = gbound;

 
 

-  ALL_OBJFILE_PSYMTABS (objfile, ps)
+  /* Go through all of the symbols stored in a partial
+     symtab in one loop.  */
+  psym = objfile->global_psymbols.list + ps->globals_offset;
+  while (keep_going)

     {
     {

-      QUIT;
-      if (ps->readin
-         || ada_lookup_partial_symbol (ps, name, global, namespace, wild,
-                                       wild_match, is_name_suffix))
+      if (psym >= bound)

        {
        {

-         struct symtab *s = PSYMTAB_TO_SYMTAB (ps);
+         if (bound == gbound && ps->n_static_syms != 0)
+           {
+             psym = objfile->static_psymbols.list + ps->statics_offset;
+             bound = sbound;
+           }
+         else
+           keep_going = 0;
+         continue;
+       }
+      else
+       {
+         QUIT;

 
 

-         if (s == NULL || !s->primary)
-           continue;
-         (*callback) (objfile, s, data);
+         if ((kind == ALL_DOMAIN
+              || (kind == VARIABLES_DOMAIN
+                  && PSYMBOL_CLASS (*psym) != LOC_TYPEDEF
+                  && PSYMBOL_CLASS (*psym) != LOC_BLOCK)
+              || (kind == FUNCTIONS_DOMAIN
+                  && PSYMBOL_CLASS (*psym) == LOC_BLOCK)
+              || (kind == TYPES_DOMAIN
+                  && PSYMBOL_CLASS (*psym) == LOC_TYPEDEF))
+             && (*sym_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
+           {
+             /* Found a match, so notify our caller.  */
+             result = PST_SEARCHED_AND_FOUND;
+             keep_going = 0;
+           }

        }
        }

+      psym++;

     }
     }

+
+  ps->searched_flag = result;
+  return result == PST_SEARCHED_AND_FOUND;

 }
 
 }
 

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

 static void
 static void

-expand_symtabs_matching_via_partial (struct objfile *objfile,
-                                    int (*file_matcher) (const char *, void *),
-                                    int (*name_matcher) (const char *, void *),
-                                    domain_enum kind,
-                                    void *data)
+psym_expand_symtabs_matching
+  (struct objfile *objfile,
+   expand_symtabs_file_matcher_ftype *file_matcher,
+   expand_symtabs_symbol_matcher_ftype *symbol_matcher,
+   expand_symtabs_exp_notify_ftype *expansion_notify,
+   enum search_domain kind,
+   void *data)

 {
   struct partial_symtab *ps;
 
 {
   struct partial_symtab *ps;
 

-  ALL_OBJFILE_PSYMTABS (objfile, ps)
+  /* Clear the search flags.  */
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
+    {
+      ps->searched_flag = PST_NOT_SEARCHED;
+    }
+
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)

     {
     {

-      struct partial_symbol **psym;
-      struct partial_symbol **bound, **gbound, **sbound;
-      int keep_going = 1;
+      QUIT;

 
       if (ps->readin)
        continue;
 
 
       if (ps->readin)
        continue;
 

-      if (! (*file_matcher) (ps->filename, data))
+      /* We skip shared psymtabs because file-matching doesn't apply
+        to them; but we search them later in the loop.  */
+      if (ps->user != NULL)

        continue;
 
        continue;
 

-      gbound = objfile->global_psymbols.list + ps->globals_offset + ps->n_global_syms;
-      sbound = objfile->static_psymbols.list + ps->statics_offset + ps->n_static_syms;
-      bound = gbound;
-
-      /* Go through all of the symbols stored in a partial
-        symtab in one loop. */
-      psym = objfile->global_psymbols.list + ps->globals_offset;
-      while (keep_going)
+      if (file_matcher)

        {
        {

-         if (psym >= bound)
-           {
-             if (bound == gbound && ps->n_static_syms != 0)
-               {
-                 psym = objfile->static_psymbols.list + ps->statics_offset;
-                 bound = sbound;
-               }
-             else
-               keep_going = 0;
-             continue;
-           }
-         else
+         int match;
+
+         if (ps->anonymous)
+           continue;
+
+         match = (*file_matcher) (ps->filename, data, 0);
+         if (!match)

            {
            {

-             QUIT;
-
-             if ((*name_matcher) (SYMBOL_NATURAL_NAME (*psym), data)
-                 && ((kind == VARIABLES_DOMAIN
-                      && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
-                      && SYMBOL_CLASS (*psym) != LOC_BLOCK)
-                     || (kind == FUNCTIONS_DOMAIN
-                         && SYMBOL_CLASS (*psym) == LOC_BLOCK)
-                     || (kind == TYPES_DOMAIN
-                         && SYMBOL_CLASS (*psym) == LOC_TYPEDEF)))
-               {
-                 PSYMTAB_TO_SYMTAB (ps);
-                 keep_going = 0;
-               }
+             /* Before we invoke realpath, which can get expensive when many
+                files are involved, do a quick comparison of the basenames.  */
+             if (basenames_may_differ
+                 || (*file_matcher) (lbasename (ps->filename), data, 1))
+               match = (*file_matcher) (psymtab_to_fullname (ps), data, 0);

            }
            }

-         psym++;
+         if (!match)
+           continue;
+       }
+
+      if (recursively_search_psymtabs (ps, objfile, kind, symbol_matcher, data))
+       {
+         struct compunit_symtab *symtab =
+           psymtab_to_symtab (objfile, ps);
+
+         if (expansion_notify != NULL)
+           expansion_notify (symtab, data);

        }
     }
 }
 
        }
     }
 }
 

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

 static int
 static int

-objfile_has_psyms (struct objfile *objfile)
+psym_has_symbols (struct objfile *objfile)

 {
   return objfile->psymtabs != NULL;
 }
 
 const struct quick_symbol_functions psym_functions =
 {
 {
   return objfile->psymtabs != NULL;
 }
 
 const struct quick_symbol_functions psym_functions =
 {

-  objfile_has_psyms,
-  find_last_source_symtab_from_partial,
-  forget_cached_source_info_partial,
-  lookup_symtab_via_partial_symtab,
-  lookup_symbol_aux_psymtabs,
-  expand_one_symtab_matching_psymtabs,
-  print_psymtab_stats_for_objfile,
-  dump_psymtabs_for_objfile,
-  relocate_psymtabs,
-  read_symtabs_for_function,
-  expand_partial_symbol_tables,
-  read_psymtabs_with_filename,
-  find_symbol_file_from_partial,
-  map_ada_symtabs,
-  expand_symtabs_matching_via_partial,
-  find_pc_sect_symtab_from_partial,
-  map_symbol_names_psymtab,
-  map_symbol_filenames_psymtab
+  psym_has_symbols,
+  psym_find_last_source_symtab,
+  psym_forget_cached_source_info,
+  psym_map_symtabs_matching_filename,
+  psym_lookup_symbol,
+  psym_print_stats,
+  psym_dump,
+  psym_relocate,
+  psym_expand_symtabs_for_function,
+  psym_expand_all_symtabs,
+  psym_expand_symtabs_with_fullname,
+  psym_map_matching_symbols,
+  psym_expand_symtabs_matching,
+  psym_find_pc_sect_compunit_symtab,
+  psym_map_symbol_filenames

 };
 
 \f
 };
 
 \f


@@ -1241,19 +1490,19 @@ const struct quick_symbol_functions psym_functions =
 static int
 compare_psymbols (const void *s1p, const void *s2p)
 {
 static int
 compare_psymbols (const void *s1p, const void *s2p)
 {

-  struct partial_symbol *const *s1 = s1p;
-  struct partial_symbol *const *s2 = s2p;
+  struct partial_symbol *const *s1 = (struct partial_symbol * const*) s1p;
+  struct partial_symbol *const *s2 = (struct partial_symbol * const*) s2p;

 
   return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
                            SYMBOL_SEARCH_NAME (*s2));
 }
 
 
   return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
                            SYMBOL_SEARCH_NAME (*s2));
 }
 

-void
-sort_pst_symbols (struct partial_symtab *pst)
+static void
+sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)

 {
 {

-  /* Sort the global list; don't sort the static list */
+  /* Sort the global list; don't sort the static list.  */

 
 

-  qsort (pst->objfile->global_psymbols.list + pst->globals_offset,
+  qsort (objfile->global_psymbols.list + pst->globals_offset,

         pst->n_global_syms, sizeof (struct partial_symbol *),
         compare_psymbols);
 }
         pst->n_global_syms, sizeof (struct partial_symbol *),
         compare_psymbols);
 }


@@ -1261,11 +1510,10 @@ sort_pst_symbols (struct partial_symtab *pst)
 /* Allocate and partially fill a partial symtab.  It will be
    completely filled at the end of the symbol list.
 
 /* Allocate and partially fill a partial symtab.  It will be
    completely filled at the end of the symbol list.
 

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

 
 struct partial_symtab *
 start_psymtab_common (struct objfile *objfile,
 
 struct partial_symtab *
 start_psymtab_common (struct objfile *objfile,

-                     struct section_offsets *section_offsets,

                      const char *filename,
                      CORE_ADDR textlow, struct partial_symbol **global_syms,
                      struct partial_symbol **static_syms)
                      const char *filename,
                      CORE_ADDR textlow, struct partial_symbol **global_syms,
                      struct partial_symbol **static_syms)


@@ -1273,17 +1521,31 @@ start_psymtab_common (struct objfile *objfile,
   struct partial_symtab *psymtab;
 
   psymtab = allocate_psymtab (filename, objfile);
   struct partial_symtab *psymtab;
 
   psymtab = allocate_psymtab (filename, objfile);

-  psymtab->section_offsets = section_offsets;

   psymtab->textlow = textlow;
   psymtab->texthigh = psymtab->textlow;                /* default */
   psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
   psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
   psymtab->textlow = textlow;
   psymtab->texthigh = psymtab->textlow;                /* default */
   psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
   psymtab->statics_offset = static_syms - objfile->static_psymbols.list;

-  return (psymtab);
+  return psymtab;
+}
+
+/* Perform "finishing up" operations of a partial symtab.  */
+
+void
+end_psymtab_common (struct objfile *objfile, struct partial_symtab *pst)
+{
+  pst->n_global_syms
+    = objfile->global_psymbols.next - (objfile->global_psymbols.list
+                                      + pst->globals_offset);
+  pst->n_static_syms
+    = objfile->static_psymbols.next - (objfile->static_psymbols.list
+                                      + pst->statics_offset);
+
+  sort_pst_symbols (objfile, pst);

 }
 
 /* Calculate a hash code for the given partial symbol.  The hash is
    calculated using the symbol's value, language, domain, class
 }
 
 /* Calculate a hash code for the given partial symbol.  The hash is
    calculated using the symbol's value, language, domain, class

-   and name. These are the values which are set by
+   and name.  These are the values which are set by

    add_psymbol_to_bcache.  */
 
 static unsigned long
    add_psymbol_to_bcache.  */
 
 static unsigned long


@@ -1293,12 +1555,12 @@ psymbol_hash (const void *addr, int length)
   struct partial_symbol *psymbol = (struct partial_symbol *) addr;
   unsigned int lang = psymbol->ginfo.language;
   unsigned int domain = PSYMBOL_DOMAIN (psymbol);
   struct partial_symbol *psymbol = (struct partial_symbol *) addr;
   unsigned int lang = psymbol->ginfo.language;
   unsigned int domain = PSYMBOL_DOMAIN (psymbol);

-  unsigned int class = PSYMBOL_CLASS (psymbol);
+  unsigned int theclass = PSYMBOL_CLASS (psymbol);

 
   h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
   h = hash_continue (&lang, sizeof (unsigned int), h);
   h = hash_continue (&domain, sizeof (unsigned int), h);
 
   h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
   h = hash_continue (&lang, sizeof (unsigned int), h);
   h = hash_continue (&domain, sizeof (unsigned int), h);

-  h = hash_continue (&class, sizeof (unsigned int), h);
+  h = hash_continue (&theclass, sizeof (unsigned int), h);

   h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h);
 
   return h;
   h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h);
 
   return h;


@@ -1327,12 +1589,14 @@ psymbol_compare (const void *addr1, const void *addr2, int length)
 struct psymbol_bcache *
 psymbol_bcache_init (void)
 {
 struct psymbol_bcache *
 psymbol_bcache_init (void)
 {

-  struct psymbol_bcache *bcache = XCALLOC (1, struct psymbol_bcache);
+  struct psymbol_bcache *bcache = XCNEW (struct psymbol_bcache);
+

   bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
   return bcache;
 }
 
 /* Free a partial symbol bcache.  */
   bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
   return bcache;
 }
 
 /* Free a partial symbol bcache.  */

+

 void
 psymbol_bcache_free (struct psymbol_bcache *bcache)
 {
 void
 psymbol_bcache_free (struct psymbol_bcache *bcache)
 {


@@ -1343,7 +1607,7 @@ psymbol_bcache_free (struct psymbol_bcache *bcache)
   xfree (bcache);
 }
 
   xfree (bcache);
 }
 

-/* Return the internal bcache of the psymbol_bcache BCACHE*/
+/* Return the internal bcache of the psymbol_bcache BCACHE.  */

 
 struct bcache *
 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
 
 struct bcache *
 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)


@@ -1361,53 +1625,73 @@ psymbol_bcache_full (struct partial_symbol *sym,
                      struct psymbol_bcache *bcache,
                      int *added)
 {
                      struct psymbol_bcache *bcache,
                      int *added)
 {

-  return bcache_full (sym,
-                      sizeof (struct partial_symbol),
-                      bcache->bcache,
-                      added);
+  return ((const struct partial_symbol *)
+         bcache_full (sym, sizeof (struct partial_symbol), bcache->bcache,
+                      added));

 }
 
 }
 

-/* Helper function, initialises partial symbol structure and stashes 
+/* Helper function, initialises partial symbol structure and stashes

    it into objfile's bcache.  Note that our caching mechanism will
    use all fields of struct partial_symbol to determine hash value of the
    structure.  In other words, having two symbols with the same name but
    different domain (or address) is possible and correct.  */
 
 static const struct partial_symbol *
    it into objfile's bcache.  Note that our caching mechanism will
    use all fields of struct partial_symbol to determine hash value of the
    structure.  In other words, having two symbols with the same name but
    different domain (or address) is possible and correct.  */
 
 static const struct partial_symbol *

-add_psymbol_to_bcache (char *name, int namelength, int copy_name,
+add_psymbol_to_bcache (const char *name, int namelength, int copy_name,

                       domain_enum domain,
                       domain_enum domain,

-                      enum address_class class,
-                      long val,        /* Value as a long */
-                      CORE_ADDR coreaddr,      /* Value as a CORE_ADDR */
+                      enum address_class theclass,
+                      CORE_ADDR coreaddr,

                       enum language language, struct objfile *objfile,
                       int *added)
 {
   struct partial_symbol psymbol;
 
                       enum language language, struct objfile *objfile,
                       int *added)
 {
   struct partial_symbol psymbol;
 

-  /* val and coreaddr are mutually exclusive, one of them *will* be zero */
-  if (val != 0)
+  /* We must ensure that the entire struct has been zeroed before
+     assigning to it, because an assignment may not touch some of the
+     holes.  */
+  memset (&psymbol, 0, sizeof (psymbol));
+
+  SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
+  SYMBOL_SECTION (&psymbol) = -1;
+  SYMBOL_SET_LANGUAGE (&psymbol, language, &objfile->objfile_obstack);
+  PSYMBOL_DOMAIN (&psymbol) = domain;
+  PSYMBOL_CLASS (&psymbol) = theclass;
+
+  SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
+
+  /* Stash the partial symbol away in the cache.  */
+  return psymbol_bcache_full (&psymbol, objfile->psymbol_cache, added);
+}
+
+/* Increase the space allocated for LISTP, which is probably
+   global_psymbols or static_psymbols.  This space will eventually
+   be freed in free_objfile().  */
+
+static void
+extend_psymbol_list (struct psymbol_allocation_list *listp,
+                    struct objfile *objfile)
+{
+  int new_size;
+
+  if (listp->size == 0)

     {
     {

-      SYMBOL_VALUE (&psymbol) = val;
+      new_size = 255;
+      listp->list = XNEWVEC (struct partial_symbol *, new_size);

     }
   else
     {
     }
   else
     {

-      SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
+      new_size = listp->size * 2;
+      listp->list = (struct partial_symbol **)
+       xrealloc ((char *) listp->list,
+                 new_size * sizeof (struct partial_symbol *));

     }
     }

-  SYMBOL_SECTION (&psymbol) = 0;
-  SYMBOL_SET_LANGUAGE (&psymbol, language);
-  PSYMBOL_DOMAIN (&psymbol) = domain;
-  PSYMBOL_CLASS (&psymbol) = class;
-
-  SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
-
-  /* Stash the partial symbol away in the cache */
-  return psymbol_bcache_full (&psymbol,
-                              objfile->psymbol_cache,
-                              added);
+  /* Next assumes we only went one over.  Should be good if
+     program works correctly.  */
+  listp->next = listp->list + listp->size;
+  listp->size = new_size;

 }
 
 }
 

-/* Helper function, adds partial symbol to the given partial symbol
-   list.  */
+/* Helper function, adds partial symbol to the given partial symbol list.  */

 
 static void
 append_psymbol_to_list (struct psymbol_allocation_list *list,
 
 static void
 append_psymbol_to_list (struct psymbol_allocation_list *list,


@@ -1422,44 +1706,33 @@ append_psymbol_to_list (struct psymbol_allocation_list *list,
 
 /* Add a symbol with a long value to a psymtab.
    Since one arg is a struct, we pass in a ptr and deref it (sigh).
 
 /* Add a symbol with a long value to a psymtab.
    Since one arg is a struct, we pass in a ptr and deref it (sigh).

+   The only value we need to store for psyms is an address.
+   For all other psyms pass zero for COREADDR.

    Return the partial symbol that has been added.  */
 
    Return the partial symbol that has been added.  */
 

-/* NOTE: carlton/2003-09-11: The reason why we return the partial
-   symbol is so that callers can get access to the symbol's demangled
-   name, which they don't have any cheap way to determine otherwise.
-   (Currenly, dwarf2read.c is the only file who uses that information,
-   though it's possible that other readers might in the future.)
-   Elena wasn't thrilled about that, and I don't blame her, but we
-   couldn't come up with a better way to get that information.  If
-   it's needed in other situations, we could consider breaking up
-   SYMBOL_SET_NAMES to provide access to the demangled name lookup
-   cache.  */
-
-const struct partial_symbol *
-add_psymbol_to_list (char *name, int namelength, int copy_name,
+void
+add_psymbol_to_list (const char *name, int namelength, int copy_name,

                     domain_enum domain,
                     domain_enum domain,

-                    enum address_class class,
-                    struct psymbol_allocation_list *list, 
-                    long val,  /* Value as a long */
-                    CORE_ADDR coreaddr,        /* Value as a CORE_ADDR */
+                    enum address_class theclass,
+                    struct psymbol_allocation_list *list,
+                    CORE_ADDR coreaddr,

                     enum language language, struct objfile *objfile)
 {
   const struct partial_symbol *psym;
 
   int added;
 
                     enum language language, struct objfile *objfile)
 {
   const struct partial_symbol *psym;
 
   int added;
 

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

 
   /* Do not duplicate global partial symbols.  */
   if (list == &objfile->global_psymbols
       && !added)
 
   /* Do not duplicate global partial symbols.  */
   if (list == &objfile->global_psymbols
       && !added)

-    return psym;
+    return;

 
 

-  /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
+  /* Save pointer to partial symbol in psymtab, growing symtab if needed.  */

   append_psymbol_to_list (list, psym, objfile);
   append_psymbol_to_list (list, psym, objfile);

-  return psym;

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


@@ -1470,17 +1743,13 @@ init_psymbol_list (struct objfile *objfile, int total_symbols)
   /* Free any previously allocated psymbol lists.  */
 
   if (objfile->global_psymbols.list)
   /* Free any previously allocated psymbol lists.  */
 
   if (objfile->global_psymbols.list)

-    {
-      xfree (objfile->global_psymbols.list);
-    }
+    xfree (objfile->global_psymbols.list);

   if (objfile->static_psymbols.list)
   if (objfile->static_psymbols.list)

-    {
-      xfree (objfile->static_psymbols.list);
-    }
+    xfree (objfile->static_psymbols.list);

 
   /* Current best guess is that approximately a twentieth
      of the total symbols (in a debugging file) are global or static
 
   /* Current best guess is that approximately a twentieth
      of the total symbols (in a debugging file) are global or static

-     oriented symbols */
+     oriented symbols, then multiply that by slop factor of two.  */

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


@@ -1488,16 +1757,14 @@ init_psymbol_list (struct objfile *objfile, int total_symbols)
   if (objfile->global_psymbols.size > 0)
     {
       objfile->global_psymbols.next =
   if (objfile->global_psymbols.size > 0)
     {
       objfile->global_psymbols.next =

-       objfile->global_psymbols.list = (struct partial_symbol **)
-       xmalloc ((objfile->global_psymbols.size
-                 * sizeof (struct partial_symbol *)));
+       objfile->global_psymbols.list =
+         XNEWVEC (struct partial_symbol *, objfile->global_psymbols.size);

     }
   if (objfile->static_psymbols.size > 0)
     {
       objfile->static_psymbols.next =
     }
   if (objfile->static_psymbols.size > 0)
     {
       objfile->static_psymbols.next =

-       objfile->static_psymbols.list = (struct partial_symbol **)
-       xmalloc ((objfile->static_psymbols.size
-                 * sizeof (struct partial_symbol *)));
+       objfile->static_psymbols.list =
+         XNEWVEC (struct partial_symbol *, objfile->static_psymbols.size);

     }
 }
 
     }
 }
 


@@ -1517,23 +1784,43 @@ allocate_psymtab (const char *filename, struct objfile *objfile)
                     sizeof (struct partial_symtab));
 
   memset (psymtab, 0, sizeof (struct partial_symtab));
                     sizeof (struct partial_symtab));
 
   memset (psymtab, 0, sizeof (struct partial_symtab));

-  psymtab->filename = obsavestring (filename, strlen (filename),
-                                   &objfile->objfile_obstack);
-  psymtab->symtab = NULL;
+  psymtab->filename
+    = (const char *) bcache (filename, strlen (filename) + 1,
+                            objfile->per_bfd->filename_cache);
+  psymtab->compunit_symtab = NULL;

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

-     inserted order. */
+     inserted order.  */

 
 

-  psymtab->objfile = objfile;

   psymtab->next = objfile->psymtabs;
   objfile->psymtabs = psymtab;
 
   psymtab->next = objfile->psymtabs;
   objfile->psymtabs = psymtab;
 

-  return (psymtab);
+  if (symtab_create_debug)
+    {
+      /* Be a bit clever with debugging messages, and don't print objfile
+        every time, only when it changes.  */
+      static char *last_objfile_name = NULL;
+
+      if (last_objfile_name == NULL
+         || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
+       {
+         xfree (last_objfile_name);
+         last_objfile_name = xstrdup (objfile_name (objfile));
+         fprintf_unfiltered (gdb_stdlog,
+                             "Creating one or more psymtabs for objfile %s ...\n",
+                             last_objfile_name);
+       }
+      fprintf_unfiltered (gdb_stdlog,
+                         "Created psymtab %s for module %s.\n",
+                         host_address_to_string (psymtab), filename);
+    }
+
+  return psymtab;

 }
 
 void
 }
 
 void

-discard_psymtab (struct partial_symtab *pst)
+discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)

 {
   struct partial_symtab **prev_pst;
 
 {
   struct partial_symtab **prev_pst;
 


@@ -1544,51 +1831,133 @@ discard_psymtab (struct partial_symtab *pst)
      nothing else is not empty, but we don't realize that.  Fixing
      that without slowing things down might be tricky.  */
 
      nothing else is not empty, but we don't realize that.  Fixing
      that without slowing things down might be tricky.  */
 

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

 
 

-  prev_pst = &(pst->objfile->psymtabs);
+  prev_pst = &(objfile->psymtabs);

   while ((*prev_pst) != pst)
     prev_pst = &((*prev_pst)->next);
   (*prev_pst) = pst->next;
 
   while ((*prev_pst) != pst)
     prev_pst = &((*prev_pst)->next);
   (*prev_pst) = pst->next;
 

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

 
 

-  pst->next = pst->objfile->free_psymtabs;
-  pst->objfile->free_psymtabs = pst;
+  pst->next = objfile->free_psymtabs;
+  objfile->free_psymtabs = pst;

 }
 
 }
 

-/* Increase the space allocated for LISTP, which is probably
-   global_psymbols or static_psymbols. This space will eventually
-   be freed in free_objfile().  */
+/* An object of this type is passed to discard_psymtabs_upto.  */

 
 

-void
-extend_psymbol_list (struct psymbol_allocation_list *listp,
-                    struct objfile *objfile)
+struct psymtab_state

 {
 {

-  int new_size;
+  /* The objfile where psymtabs are discarded.  */

 
 

-  if (listp->size == 0)
+  struct objfile *objfile;
+
+  /* The first psymtab to save.  */
+
+  struct partial_symtab *save;
+};
+
+/* A cleanup function used by make_cleanup_discard_psymtabs.  */
+
+static void
+discard_psymtabs_upto (void *arg)
+{
+  struct psymtab_state *state = (struct psymtab_state *) arg;
+
+  while (state->objfile->psymtabs != state->save)
+    discard_psymtab (state->objfile, state->objfile->psymtabs);
+}
+
+/* Return a new cleanup that discards all psymtabs created in OBJFILE
+   after this function is called.  */
+
+struct cleanup *
+make_cleanup_discard_psymtabs (struct objfile *objfile)
+{
+  struct psymtab_state *state = XNEW (struct psymtab_state);
+
+  state->objfile = objfile;
+  state->save = objfile->psymtabs;
+
+  return make_cleanup_dtor (discard_psymtabs_upto, state, xfree);
+}
+
+\f
+
+/* We need to pass a couple of items to the addrmap_foreach function,
+   so use a struct.  */
+
+struct dump_psymtab_addrmap_data
+{
+  struct objfile *objfile;
+  struct partial_symtab *psymtab;
+  struct ui_file *outfile;
+
+  /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
+     If so, we want to print the next one as well (since the next addrmap
+     entry defines the end of the range).  */
+  int previous_matched;
+};
+
+/* Helper function for dump_psymtab_addrmap to print an addrmap entry.  */
+
+static int
+dump_psymtab_addrmap_1 (void *datap, CORE_ADDR start_addr, void *obj)
+{
+  struct dump_psymtab_addrmap_data *data
+    = (struct dump_psymtab_addrmap_data *) datap;
+  struct gdbarch *gdbarch = get_objfile_arch (data->objfile);
+  struct partial_symtab *addrmap_psymtab = (struct partial_symtab *) obj;
+  const char *psymtab_address_or_end = NULL;
+
+  QUIT;
+
+  if (data->psymtab == NULL
+      || data->psymtab == addrmap_psymtab)
+    psymtab_address_or_end = host_address_to_string (addrmap_psymtab);
+  else if (data->previous_matched)
+    psymtab_address_or_end = "<ends here>";
+
+  if (data->psymtab == NULL
+      || data->psymtab == addrmap_psymtab
+      || data->previous_matched)

     {
     {

-      new_size = 255;
-      listp->list = (struct partial_symbol **)
-       xmalloc (new_size * sizeof (struct partial_symbol *));
+      fprintf_filtered (data->outfile, "  %s%s %s\n",
+                       data->psymtab != NULL ? "  " : "",
+                       paddress (gdbarch, start_addr),
+                       psymtab_address_or_end);

     }
     }

-  else
+
+  data->previous_matched = (data->psymtab == NULL
+                           || data->psymtab == addrmap_psymtab);
+
+  return 0;
+}
+
+/* Helper function for maintenance_print_psymbols to print the addrmap
+   of PSYMTAB.  If PSYMTAB is NULL print the entire addrmap.  */
+
+static void
+dump_psymtab_addrmap (struct objfile *objfile, struct partial_symtab *psymtab,
+                     struct ui_file *outfile)
+{
+  struct dump_psymtab_addrmap_data addrmap_dump_data;
+
+  if (psymtab == NULL
+      || psymtab->psymtabs_addrmap_supported)

     {
     {

-      new_size = listp->size * 2;
-      listp->list = (struct partial_symbol **)
-       xrealloc ((char *) listp->list,
-                 new_size * sizeof (struct partial_symbol *));
+      addrmap_dump_data.objfile = objfile;
+      addrmap_dump_data.psymtab = psymtab;
+      addrmap_dump_data.outfile = outfile;
+      addrmap_dump_data.previous_matched = 0;
+      fprintf_filtered (outfile, "%sddress map:\n",
+                       psymtab == NULL ? "Entire a" : "  A");
+      addrmap_foreach (objfile->psymtabs_addrmap, dump_psymtab_addrmap_1,
+                      &addrmap_dump_data);

     }
     }

-  /* Next assumes we only went one over.  Should be good if
-     program works correctly */
-  listp->next = listp->list + listp->size;
-  listp->size = new_size;

 }
 
 }
 

-\f
-
-void
+static void

 maintenance_print_psymbols (char *args, int from_tty)
 {
   char **argv;
 maintenance_print_psymbols (char *args, int from_tty)
 {
   char **argv;


@@ -1603,7 +1972,8 @@ maintenance_print_psymbols (char *args, int from_tty)
 
   if (args == NULL)
     {
 
   if (args == NULL)
     {

-      error (_("print-psymbols takes an output file name and optional symbol file name"));
+      error (_("\
+print-psymbols takes an output file name and optional symbol file name"));

     }
   argv = gdb_buildargv (args);
   cleanups = make_cleanup_freeargv (argv);
     }
   argv = gdb_buildargv (args);
   cleanups = make_cleanup_freeargv (argv);


@@ -1611,7 +1981,7 @@ maintenance_print_psymbols (char *args, int from_tty)
   if (argv[0] != NULL)
     {
       filename = argv[0];
   if (argv[0] != NULL)
     {
       filename = argv[0];

-      /* If a second arg is supplied, it is a source file name to match on */
+      /* If a second arg is supplied, it is a source file name to match on.  */

       if (argv[1] != NULL)
        {
          symname = argv[1];
       if (argv[1] != NULL)
        {
          symname = argv[1];


@@ -1622,20 +1992,40 @@ maintenance_print_psymbols (char *args, int from_tty)
   make_cleanup (xfree, filename);
 
   outfile = gdb_fopen (filename, FOPEN_WT);
   make_cleanup (xfree, filename);
 
   outfile = gdb_fopen (filename, FOPEN_WT);

-  if (outfile == 0)
+  if (outfile == NULL)

     perror_with_name (filename);
   make_cleanup_ui_file_delete (outfile);
 
     perror_with_name (filename);
   make_cleanup_ui_file_delete (outfile);
 

-  immediate_quit++;
-  ALL_PSYMTABS (objfile, ps)
-    if (symname == NULL || strcmp (symname, ps->filename) == 0)
-    dump_psymtab (objfile, ps, outfile);
-  immediate_quit--;
+  ALL_OBJFILES (objfile)
+  {
+    fprintf_filtered (outfile, "\nPartial symtabs for objfile %s\n",
+                     objfile_name (objfile));
+
+    ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
+    {
+      QUIT;
+      if (symname == NULL || filename_cmp (symname, ps->filename) == 0)
+       {
+         dump_psymtab (objfile, ps, outfile);
+         dump_psymtab_addrmap (objfile, ps, outfile);
+       }
+    }
+
+    /* If we're printing all symbols dump the full addrmap.  */
+
+    if (symname == NULL)
+      {
+       fprintf_filtered (outfile, "\n");
+       dump_psymtab_addrmap (objfile, NULL, outfile);
+      }
+  }
+

   do_cleanups (cleanups);
 }
 
 /* List all the partial symbol tables whose names match REGEXP (optional).  */
   do_cleanups (cleanups);
 }
 
 /* List all the partial symbol tables whose names match REGEXP (optional).  */

-void
+
+static void

 maintenance_info_psymtabs (char *regexp, int from_tty)
 {
   struct program_space *pspace;
 maintenance_info_psymtabs (char *regexp, int from_tty)
 {
   struct program_space *pspace;


@@ -1654,7 +2044,7 @@ maintenance_info_psymtabs (char *regexp, int from_tty)
          actually find a symtab whose name matches.  */
       int printed_objfile_start = 0;
 
          actually find a symtab whose name matches.  */
       int printed_objfile_start = 0;
 

-      ALL_OBJFILE_PSYMTABS (objfile, psymtab)
+      ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)

        {
          QUIT;
 
        {
          QUIT;
 


@@ -1663,22 +2053,23 @@ maintenance_info_psymtabs (char *regexp, int from_tty)
            {
              if (! printed_objfile_start)
                {
            {
              if (! printed_objfile_start)
                {

-                 printf_filtered ("{ objfile %s ", objfile->name);
+                 printf_filtered ("{ objfile %s ", objfile_name (objfile));

                  wrap_here ("  ");
                  wrap_here ("  ");

-                 printf_filtered ("((struct objfile *) %s)\n", 
+                 printf_filtered ("((struct objfile *) %s)\n",

                                   host_address_to_string (objfile));
                  printed_objfile_start = 1;
                }
 
              printf_filtered ("  { psymtab %s ", psymtab->filename);
              wrap_here ("    ");
                                   host_address_to_string (objfile));
                  printed_objfile_start = 1;
                }
 
              printf_filtered ("  { psymtab %s ", psymtab->filename);
              wrap_here ("    ");

-             printf_filtered ("((struct partial_symtab *) %s)\n", 
+             printf_filtered ("((struct partial_symtab *) %s)\n",

                               host_address_to_string (psymtab));
 
              printf_filtered ("    readin %s\n",
                               psymtab->readin ? "yes" : "no");
              printf_filtered ("    fullname %s\n",
                               host_address_to_string (psymtab));
 
              printf_filtered ("    readin %s\n",
                               psymtab->readin ? "yes" : "no");
              printf_filtered ("    fullname %s\n",

-                              psymtab->fullname ? psymtab->fullname : "(null)");
+                              psymtab->fullname
+                              ? psymtab->fullname : "(null)");

              printf_filtered ("    text addresses ");
              fputs_filtered (paddress (gdbarch, psymtab->textlow),
                              gdb_stdout);
              printf_filtered ("    text addresses ");
              fputs_filtered (paddress (gdbarch, psymtab->textlow),
                              gdb_stdout);


@@ -1686,11 +2077,14 @@ maintenance_info_psymtabs (char *regexp, int from_tty)
              fputs_filtered (paddress (gdbarch, psymtab->texthigh),
                              gdb_stdout);
              printf_filtered ("\n");
              fputs_filtered (paddress (gdbarch, psymtab->texthigh),
                              gdb_stdout);
              printf_filtered ("\n");

+             printf_filtered ("    psymtabs_addrmap_supported %s\n",
+                              (psymtab->psymtabs_addrmap_supported
+                               ? "yes" : "no"));

              printf_filtered ("    globals ");
              if (psymtab->n_global_syms)
                {
                  printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
              printf_filtered ("    globals ");
              if (psymtab->n_global_syms)
                {
                  printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",

-                                  host_address_to_string (psymtab->objfile->global_psymbols.list
+                                  host_address_to_string (objfile->global_psymbols.list

                                    + psymtab->globals_offset),
                                   psymtab->n_global_syms);
                }
                                    + psymtab->globals_offset),
                                   psymtab->n_global_syms);
                }


@@ -1700,7 +2094,7 @@ maintenance_info_psymtabs (char *regexp, int from_tty)
              if (psymtab->n_static_syms)
                {
                  printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
              if (psymtab->n_static_syms)
                {
                  printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",

-                                  host_address_to_string (psymtab->objfile->static_psymbols.list
+                                  host_address_to_string (objfile->static_psymbols.list

                                    + psymtab->statics_offset),
                                   psymtab->n_static_syms);
                }
                                    + psymtab->statics_offset),
                                   psymtab->n_static_syms);
                }


@@ -1719,7 +2113,7 @@ maintenance_info_psymtabs (char *regexp, int from_tty)
                      /* Note the string concatenation there --- no comma.  */
                      printf_filtered ("      psymtab %s "
                                       "((struct partial_symtab *) %s)\n",
                      /* Note the string concatenation there --- no comma.  */
                      printf_filtered ("      psymtab %s "
                                       "((struct partial_symtab *) %s)\n",

-                                      dep->filename, 
+                                      dep->filename,

                                       host_address_to_string (dep));
                    }
                  printf_filtered ("    }\n");
                                       host_address_to_string (dep));
                    }
                  printf_filtered ("    }\n");


@@ -1735,16 +2129,16 @@ maintenance_info_psymtabs (char *regexp, int from_tty)
     }
 }
 
     }
 }
 

-/* Check consistency of psymtabs and symtabs.  */
+/* Check consistency of currently expanded psymtabs vs symtabs.  */

 
 

-void
-maintenance_check_symtabs (char *ignore, int from_tty)
+static void
+maintenance_check_psymtabs (char *ignore, int from_tty)

 {
   struct symbol *sym;
   struct partial_symbol **psym;
 {
   struct symbol *sym;
   struct partial_symbol **psym;

-  struct symtab *s = NULL;
+  struct compunit_symtab *cust = NULL;

   struct partial_symtab *ps;
   struct partial_symtab *ps;

-  struct blockvector *bv;
+  const struct blockvector *bv;

   struct objfile *objfile;
   struct block *b;
   int length;
   struct objfile *objfile;
   struct block *b;
   int length;


@@ -1753,16 +2147,34 @@ maintenance_check_symtabs (char *ignore, int from_tty)
   {
     struct gdbarch *gdbarch = get_objfile_arch (objfile);
 
   {
     struct gdbarch *gdbarch = get_objfile_arch (objfile);
 

-    s = PSYMTAB_TO_SYMTAB (ps);
-    if (s == NULL)
+    /* We don't call psymtab_to_symtab here because that may cause symtab
+       expansion.  When debugging a problem it helps if checkers leave
+       things unchanged.  */
+    cust = ps->compunit_symtab;
+
+    /* First do some checks that don't require the associated symtab.  */
+    if (ps->texthigh < ps->textlow)
+      {
+       printf_filtered ("Psymtab ");
+       puts_filtered (ps->filename);
+       printf_filtered (" covers bad range ");
+       fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
+       printf_filtered (" - ");
+       fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
+       printf_filtered ("\n");
+       continue;
+      }
+
+    /* Now do checks requiring the associated symtab.  */
+    if (cust == NULL)

       continue;
       continue;

-    bv = BLOCKVECTOR (s);
+    bv = COMPUNIT_BLOCKVECTOR (cust);

     b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
     b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);

-    psym = ps->objfile->static_psymbols.list + ps->statics_offset;
+    psym = objfile->static_psymbols.list + ps->statics_offset;

     length = ps->n_static_syms;
     while (length--)
       {
     length = ps->n_static_syms;
     while (length--)
       {

-       sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
+       sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),

                                   SYMBOL_DOMAIN (*psym));
        if (!sym)
          {
                                   SYMBOL_DOMAIN (*psym));
        if (!sym)
          {


@@ -1775,11 +2187,11 @@ maintenance_check_symtabs (char *ignore, int from_tty)
        psym++;
       }
     b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
        psym++;
       }
     b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);

-    psym = ps->objfile->global_psymbols.list + ps->globals_offset;
+    psym = objfile->global_psymbols.list + ps->globals_offset;

     length = ps->n_global_syms;
     while (length--)
       {
     length = ps->n_global_syms;
     while (length--)
       {

-       sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
+       sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),

                                   SYMBOL_DOMAIN (*psym));
        if (!sym)
          {
                                   SYMBOL_DOMAIN (*psym));
        if (!sym)
          {


@@ -1791,20 +2203,8 @@ maintenance_check_symtabs (char *ignore, int from_tty)
          }
        psym++;
       }
          }
        psym++;
       }

-    if (ps->texthigh < ps->textlow)
-      {
-       printf_filtered ("Psymtab ");
-       puts_filtered (ps->filename);
-       printf_filtered (" covers bad range ");
-       fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
-       printf_filtered (" - ");
-       fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
-       printf_filtered ("\n");
-       continue;
-      }
-    if (ps->texthigh == 0)
-      continue;
-    if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
+    if (ps->texthigh != 0
+       && (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b)))

       {
        printf_filtered ("Psymtab ");
        puts_filtered (ps->filename);
       {
        printf_filtered ("Psymtab ");
        puts_filtered (ps->filename);


@@ -1823,28 +2223,25 @@ maintenance_check_symtabs (char *ignore, int from_tty)
 
 \f
 
 
 \f
 

-void
-map_partial_symbol_names (void (*fun) (const char *, void *), void *data)
-{
-  struct objfile *objfile;
-
-  ALL_OBJFILES (objfile)
-  {
-    if (objfile->sf)
-      objfile->sf->qf->map_symbol_names (objfile, fun, data);
-  }
-}
+extern initialize_file_ftype _initialize_psymtab;

 
 void
 
 void

-map_partial_symbol_filenames (void (*fun) (const char *, const char *,
-                                          void *),
-                             void *data)
+_initialize_psymtab (void)

 {
 {

-  struct objfile *objfile;
-
-  ALL_OBJFILES (objfile)
-  {
-    if (objfile->sf)
-      objfile->sf->qf->map_symbol_filenames (objfile, fun, data);
-  }
+  add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
+Print dump of current partial symbol definitions.\n\
+Entries in the partial symbol table are dumped to file OUTFILE.\n\
+If a SOURCE file is specified, dump only that file's partial symbols."),
+          &maintenanceprintlist);
+
+  add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
+List the partial symbol tables for all object files.\n\
+This does not include information about individual partial symbols,\n\
+just the symbol table structures themselves."),
+          &maintenanceinfolist);
+
+  add_cmd ("check-psymtabs", class_maintenance, maintenance_check_psymtabs,
+          _("\
+Check consistency of currently expanded psymtabs versus symtabs."),
+          &maintenancelist);

 }
 }