Merge GDB 7.5.1

gdb/psymtab.c

 /* Partial symbol tables.
    
    Copyright (C) 2009-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 27 matching lines @@
 
 #ifndef DEV_TTY
 #define DEV_TTY "/dev/tty"
 #endif
 
 struct psymbol_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 partial_symtab *,
                                                     int,
                                                     const char *, domain_enum,
                                                     symbol_compare_ftype *,
                                                     symbol_compare_ftype *);
 
 static struct partial_symbol *lookup_partial_symbol (struct partial_symtab *,
                                                      const char *, int,
                                                      domain_enum);
 
@@ skipping 70 matching lines @@
 partial_map_expand_apply (struct objfile *objfile,
                           const char *name,
                           const char *full_path,
                           const char *real_path,
                           struct partial_symtab *pst,
                           int (*callback) (struct symtab *, void *),
                           void *data)
 {
   struct symtab *last_made = objfile->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 (pst);
 
   return iterate_over_some_symtabs (name, full_path, real_path, callback, data,
                                     objfile->symtabs, last_made);
 }
 
 /* Implementation of the map_symtabs_matching_filename method.  */
 
 static int
 partial_map_symtabs_matching_filename (struct objfile *objfile,
                                        const char *name,
                                        const char *full_path,
                                        const char *real_path,
                                        int (*callback) (struct symtab *,
                                                         void *),
                                        void *data)
 {
   struct partial_symtab *pst;
   const char *name_basename = lbasename (name);
+  int name_len = strlen (name);
+  int is_abs = IS_ABSOLUTE_PATH (name);
 
   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 (FILENAME_CMP (name, pst->filename) == 0
+        || (!is_abs && compare_filenames_for_search (pst->filename,
+                                                     name, name_len)))
       {
         if (partial_map_expand_apply (objfile, name, full_path, real_path,
                                       pst, callback, data))
           return 1;
       }
 
     /* 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 the user gave us an absolute path, try to find the file in
        this symtab and use its absolute path.  */
     if (full_path != NULL)
       {
         psymtab_to_fullname (pst);
         if (pst->fullname != NULL
-            && FILENAME_CMP (full_path, pst->fullname) == 0)
+            && (FILENAME_CMP (full_path, pst->fullname) == 0
+                || (!is_abs && compare_filenames_for_search (pst->fullname,
+                                                             name, name_len))))
           {
             if (partial_map_expand_apply (objfile, name, full_path, real_path,
                                           pst, callback, data))
               return 1;
           }
       }
 
     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)
+        if (rp != NULL
+            && (FILENAME_CMP (real_path, rp) == 0
+                || (!is_abs && compare_filenames_for_search (real_path,
+                                                             name, name_len))))
           {
             if (partial_map_expand_apply (objfile, name, full_path, real_path,
                                           pst, callback, data))
               return 1;
           }
       }
   }
 
-  /* Now, search for a matching tail (only if name doesn't have any dirs).  */
-
-  if (name_basename == name)
-    ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
-    {
-      if (FILENAME_CMP (lbasename (pst->filename), name) == 0)
-        if (partial_map_expand_apply (objfile, name, full_path, real_path, pst,
-                                      callback, data))
-          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_pc_sect_psymtab_closer (CORE_ADDR pc, struct obj_section *section,
                              struct partial_symtab *pst,
                              struct minimal_symbol *msymbol)
@@ skipping 151 matching lines @@
                                                     msymbol);
   if (ps)
     {
       if (warn_if_readin && ps->readin)
         /* Might want to error() here (in case symtab is corrupt and
            will cause a core dump), but maybe we can successfully
            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);
+      psymtab_to_symtab (ps);
+      return ps->symtab;
     }
   return NULL;
 }
 
 /* Find which partial symbol within a psymtab matches PC and SECTION.
    Return 0 if none.  */
 
 static struct partial_symbol *
 find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc,
                       struct obj_section *section)
@@ skipping 91 matching lines @@
   return psym;
 }
 
 static struct symtab *
 lookup_symbol_aux_psymtabs (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 symtab *stab_best = NULL;
 
   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
   {
     if (!ps->readin && lookup_partial_symbol (ps, name, psymtab_index, domain))
       {
         struct symbol *sym = NULL;
-        struct symtab *stab = PSYMTAB_TO_SYMTAB (ps);
+        struct symtab *stab = psymtab_to_symtab (ps);
 
         /* Some caution must be observed with overloaded functions
            and methods, since the psymtab will not contain any overload
            information (but NAME might contain it).  */
         if (stab->primary)
           {
             struct blockvector *bv = BLOCKVECTOR (stab);
             struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
 
             sym = lookup_block_symbol (block, name, domain);
           }
 
         if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
-          return stab;
+          {
+            if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
+              return stab;
+
+            stab_best = stab;
+          }
 
         /* Keep looking through other psymtabs.  */
       }
   }
 
-  return NULL;
+  return stab_best;
 }
 
 /* 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.  */
 
@@ skipping 208 matching lines @@
               return (*psym);
             }
         }
     }
 
   do_cleanups (cleanup);
   return (NULL);
 }
 
 /* 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.  */
 
 static struct symtab *
 psymtab_to_symtab (struct partial_symtab *pst)
 {
+  /* 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->symtab)
     return pst->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);
@@ skipping 55 matching lines @@
 
   if (cs_pst)
     {
       if (cs_pst->readin)
         {
           internal_error (__FILE__, __LINE__,
                           _("select_source_symtab: "
                           "readin pst found and no symtabs."));
         }
       else
-        return PSYMTAB_TO_SYMTAB (cs_pst);
+        return psymtab_to_symtab (cs_pst);
     }
   return NULL;
 }
 
 static void
 forget_cached_source_info_partial (struct objfile *objfile)
 {
   struct partial_symtab *pst;
 
   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
@@ skipping 96 matching lines @@
     }
 }
 
 static void
 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
               struct ui_file *outfile)
 {
   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 (",
                       objfile->name);
   gdb_print_host_address (objfile, outfile);
   fprintf_unfiltered (outfile, ")\n");
 
   if (psymtab->readin)
     {
@@ skipping 26 matching lines @@
                     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, "    %d ", i);
       gdb_print_host_address (psymtab->dependencies[i], outfile);
       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,
                              objfile->global_psymbols.list
                              + psymtab->globals_offset,
                              psymtab->n_global_syms, "Global", outfile);
     }
   if (psymtab->n_static_syms > 0)
     {
       print_partial_symbols (gdbarch,
@@ skipping 77 matching lines @@
     }
 }
 
 static void
 read_psymtabs_with_filename (struct objfile *objfile, const char *filename)
 {
   struct partial_symtab *p;
 
   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
     {
+      /* Anonymous psymtabs don't have a name of a source file.  */
+      if (p->anonymous)
+        continue;
+
       if (filename_cmp (filename, p->filename) == 0)
-        PSYMTAB_TO_SYMTAB (p);
+        psymtab_to_symtab (p);
     }
 }
 
 static void
 map_symbol_filenames_psymtab (struct objfile *objfile,
                               symbol_filename_ftype *fun, void *data,
                               int need_fullname)
 {
   struct partial_symtab *ps;
 
   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
     {
       const char *fullname;
 
       if (ps->readin)
         continue;
 
+      /* 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);
     }
 }
 
-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
    and it will also return the value.
 
    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 *
 psymtab_to_fullname (struct partial_symtab *ps)
 {
   int r;
 
   if (!ps)
     return NULL;
+  if (ps->anonymous)
+    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)
     return ps->fullname;
 
   r = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
 
   if (r >= 0)
@@ skipping 22 matching lines @@
     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 namespace, struct objfile *objfile,
            struct block *block,
            int (*callback) (struct block *, struct symbol *, void *),
            void *data, symbol_compare_ftype *match)
 {
-  struct dict_iterator iter;
+  struct block_iterator iter;
   struct symbol *sym;
 
-  for (sym = dict_iter_match_first (BLOCK_DICT (block), name, match, &iter);
-       sym != NULL; sym = dict_iter_match_next (name, match, &iter))
+  for (sym = block_iter_match_first (block, name, match, &iter);
+       sym != NULL; sym = block_iter_match_next (name, match, &iter))
     {
       if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), 
                                  SYMBOL_DOMAIN (sym), namespace))
         {
           if (callback (block, sym, data))
             return 1;
         }
     }
 
   return 0;
@@ skipping 14 matching lines @@
   const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
   struct partial_symtab *ps;
 
   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
     {
       QUIT;
       if (ps->readin
           || match_partial_symbol (ps, global, name, namespace, match,
                                    ordered_compare))
         {
-          struct symtab *s = PSYMTAB_TO_SYMTAB (ps);
+          struct symtab *s = psymtab_to_symtab (ps);
           struct block *block;
 
           if (s == NULL || !s->primary)
             continue;
           block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind);
           if (map_block (name, namespace, objfile, block,
                          callback, data, match))
             return;
           if (callback (block, NULL, data))
             return;
         }
     }
 }           
 
+/* A helper for expand_symtabs_matching_via_partial 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.  */
+
+static int
+recursively_search_psymtabs (struct partial_symtab *ps,
+                             struct objfile *objfile,
+                             enum search_domain kind,
+                             int (*name_matcher) (const char *, void *),
+                             void *data)
+{
+  struct partial_symbol **psym;
+  struct partial_symbol **bound, **gbound, **sbound;
+  int keep_going = 1;
+  int 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)
+    {
+      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, name_matcher, data);
+      if (r != 0)
+        {
+          ps->searched_flag = PST_SEARCHED_AND_FOUND;
+          return 1;
+        }
+    }
+
+  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 (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
+        {
+          QUIT;
+
+          if ((kind == ALL_DOMAIN
+               || (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))
+              && (*name_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;
+}
+
 static void
 expand_symtabs_matching_via_partial
   (struct objfile *objfile,
    int (*file_matcher) (const char *, void *),
-   int (*name_matcher) (const struct language_defn *, const char *, void *),
+   int (*name_matcher) (const char *, void *),
    enum search_domain kind,
    void *data)
 {
   struct partial_symtab *ps;
 
+  /* Clear the search flags.  */
   ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
     {
-      struct partial_symbol **psym;
-      struct partial_symbol **bound, **gbound, **sbound;
-      int keep_going = 1;
+      ps->searched_flag = PST_NOT_SEARCHED;
+    }
 
+  ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
+    {
       if (ps->readin)
         continue;
 
-      if (file_matcher && ! (*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;
 
-      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;
+      if (file_matcher)
+        {
+          if (ps->anonymous)
+            continue;
+          if (! (*file_matcher) (ps->filename, data))
+            continue;
+        }
 
-      /* 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 (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
-            {
-              QUIT;
-
-              if ((kind == ALL_DOMAIN
-                   || (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))
-                  && (*name_matcher) (current_language,
-                                      SYMBOL_NATURAL_NAME (*psym), data))
-                {
-                  PSYMTAB_TO_SYMTAB (ps);
-                  keep_going = 0;
-                }
-            }
-          psym++;
-        }
+      if (recursively_search_psymtabs (ps, objfile, kind, name_matcher, data))
+        psymtab_to_symtab (ps);
     }
 }
 
 static int
 objfile_has_psyms (struct objfile *objfile)
 {
   return objfile->psymtabs != NULL;
 }
 
 const struct quick_symbol_functions psym_functions =
@@ skipping 233 matching lines @@
 append_psymbol_to_list (struct psymbol_allocation_list *list,
                         const struct partial_symbol *psym,
                         struct objfile *objfile)
 {
   if (list->next >= list->list + list->size)
     extend_psymbol_list (list, objfile);
   *list->next++ = (struct partial_symbol *) psym;
   OBJSTAT (objfile, n_psyms++);
 }