Merge GDB 7.5.1

gdb/minsyms.c

 /* GDB routines for manipulating the minimal symbol tables.
    Copyright (C) 1992-2004, 2007-2012 Free Software Foundation, Inc.
    Contributed by Cygnus Support, using pieces from other GDB modules.
 
    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 58 matching lines @@
 static struct msym_bunch *msym_bunch;
 
 /* Number of slots filled in current bunch.  */
 
 static int msym_bunch_index;
 
 /* Total number of minimal symbols recorded so far for the objfile.  */
 
 static int msym_count;
 
-/* Compute a hash code based using the same criteria as `strcmp_iw'.  */
+/* See minsyms.h.  */
 
 unsigned int
 msymbol_hash_iw (const char *string)
 {
   unsigned int hash = 0;
 
   while (*string && *string != '(')
     {
       while (isspace (*string))
         ++string;
       if (*string && *string != '(')
         {
           hash = SYMBOL_HASH_NEXT (hash, *string);
           ++string;
         }
     }
   return hash;
 }
 
-/* Compute a hash code for a string.  */
+/* See minsyms.h.  */
 
 unsigned int
 msymbol_hash (const char *string)
 {
   unsigned int hash = 0;
 
   for (; *string; ++string)
     hash = SYMBOL_HASH_NEXT (hash, *string);
   return hash;
 }
 
 /* Add the minimal symbol SYM to an objfile's minsym hash table, TABLE.  */
-void
+static void
 add_minsym_to_hash_table (struct minimal_symbol *sym,
                           struct minimal_symbol **table)
 {
   if (sym->hash_next == NULL)
     {
       unsigned int hash
         = msymbol_hash (SYMBOL_LINKAGE_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE;
 
       sym->hash_next = table[hash];
       table[hash] = sym;
     }
 }
 
 /* Add the minimal symbol SYM to an objfile's minsym demangled hash table,
    TABLE.  */
 static void
 add_minsym_to_demangled_hash_table (struct minimal_symbol *sym,
                                   struct minimal_symbol **table)
 {
   if (sym->demangled_hash_next == NULL)
     {
       unsigned int hash = msymbol_hash_iw (SYMBOL_SEARCH_NAME (sym))
         % MINIMAL_SYMBOL_HASH_SIZE;
 
       sym->demangled_hash_next = table[hash];
       table[hash] = sym;
     }
 }
 
+/* See minsyms.h.  */
 
-/* Return OBJFILE where minimal symbol SYM is defined.  */
 struct objfile *
 msymbol_objfile (struct minimal_symbol *sym)
 {
   struct objfile *objf;
   struct minimal_symbol *tsym;
 
   unsigned int hash
     = msymbol_hash (SYMBOL_LINKAGE_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE;
 
   for (objf = object_files; objf; objf = objf->next)
@@ skipping 147 matching lines @@
   if (found_file_symbol)
     return found_file_symbol;
 
   /* Symbols for shared library trampolines are next best.  */
   if (trampoline_symbol)
     return trampoline_symbol;
 
   return NULL;
 }
 
-/* Iterate over all the minimal symbols in the objfile OBJF which
-   match NAME.  Both the ordinary and demangled names of each symbol
-   are considered.  The caller is responsible for canonicalizing NAME,
-   should that need to be done.
-   
-   For each matching symbol, CALLBACK is called with the symbol and
-   USER_DATA as arguments.  */
+/* See minsyms.h.  */
 
 void
 iterate_over_minimal_symbols (struct objfile *objf, const char *name,
                               void (*callback) (struct minimal_symbol *,
                                                 void *),
                               void *user_data)
 {
   unsigned int hash;
   struct minimal_symbol *iter;
   int (*cmp) (const char *, const char *);
@@ skipping 13 matching lines @@
   hash = msymbol_hash_iw (name) % MINIMAL_SYMBOL_HASH_SIZE;
   iter = objf->msymbol_demangled_hash[hash];
   while (iter)
     {
       if (SYMBOL_MATCHES_SEARCH_NAME (iter, name))
         (*callback) (iter, user_data);
       iter = iter->demangled_hash_next;
     }
 }
 
-/* Look through all the current minimal symbol tables and find the
-   first minimal symbol that matches NAME and has text type.  If OBJF
-   is non-NULL, limit the search to that objfile.  Returns a pointer
-   to the minimal symbol that matches, or NULL if no match is found.
-
-   This function only searches the mangled (linkage) names.  */
+/* See minsyms.h.  */
 
 struct minimal_symbol *
 lookup_minimal_symbol_text (const char *name, struct objfile *objf)
 {
   struct objfile *objfile;
   struct minimal_symbol *msymbol;
   struct minimal_symbol *found_symbol = NULL;
   struct minimal_symbol *found_file_symbol = NULL;
 
   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
@@ skipping 31 matching lines @@
   if (found_symbol)
     return found_symbol;
 
   /* File-local symbols are next best.  */
   if (found_file_symbol)
     return found_file_symbol;
 
   return NULL;
 }
 
-/* Look through all the current minimal symbol tables and find the
-   first minimal symbol that matches NAME and PC.  If OBJF is non-NULL,
-   limit the search to that objfile.  Returns a pointer to the minimal
-   symbol that matches, or NULL if no match is found.  */
+/* See minsyms.h.  */
 
 struct minimal_symbol *
 lookup_minimal_symbol_by_pc_name (CORE_ADDR pc, const char *name,
                                   struct objfile *objf)
 {
   struct objfile *objfile;
   struct minimal_symbol *msymbol;
 
   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
 
@@ skipping 11 matching lines @@
               if (SYMBOL_VALUE_ADDRESS (msymbol) == pc
                   && strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0)
                 return msymbol;
             }
         }
     }
 
   return NULL;
 }
 
-/* Look through all the current minimal symbol tables and find the
-   first minimal symbol that matches NAME and is a solib trampoline.
-   If OBJF is non-NULL, limit the search to that objfile.  Returns a
-   pointer to the minimal symbol that matches, or NULL if no match is
-   found.
-
-   This function only searches the mangled (linkage) names.  */
+/* See minsyms.h.  */
 
 struct minimal_symbol *
 lookup_minimal_symbol_solib_trampoline (const char *name,
                                         struct objfile *objf)
 {
   struct objfile *objfile;
   struct minimal_symbol *msymbol;
   struct minimal_symbol *found_symbol = NULL;
 
   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
@@ skipping 265 matching lines @@
       /* NOTE: cagney/2004-01-27: This was using find_pc_mapped_section to
          force the section but that (well unless you're doing overlay
          debugging) always returns NULL making the call somewhat useless.  */
       section = find_pc_section (pc);
       if (section == NULL)
         return NULL;
     }
   return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0);
 }
 
-/* Backward compatibility: search through the minimal symbol table 
-   for a matching PC (no section given).  */
+/* See minsyms.h.  */
 
 struct minimal_symbol *
 lookup_minimal_symbol_by_pc (CORE_ADDR pc)
 {
   return lookup_minimal_symbol_by_pc_section (pc, NULL);
 }
 
 /* Return non-zero iff PC is in an STT_GNU_IFUNC function resolver.  */
 
 int
@@ skipping 50 matching lines @@
   stub_gnu_ifunc_resolve_addr,
   stub_gnu_ifunc_resolve_name,
   stub_gnu_ifunc_resolver_stop,
   stub_gnu_ifunc_resolver_return_stop,
 };
 
 /* A placeholder for &elf_gnu_ifunc_fns.  */
 
 const struct gnu_ifunc_fns *gnu_ifunc_fns_p = &stub_gnu_ifunc_fns;
 
-/* Find the minimal symbol named NAME, and return both the minsym
-   struct and its objfile.  This only checks the linkage name.  Sets
-   *OBJFILE_P and returns the minimal symbol, if it is found.  If it
-   is not found, returns NULL.  */
+/* See minsyms.h.  */
 
 struct minimal_symbol *
 lookup_minimal_symbol_and_objfile (const char *name,
                                    struct objfile **objfile_p)
 {
   struct objfile *objfile;
   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
 
   ALL_OBJFILES (objfile)
     {
@@ skipping 20 matching lines @@
    return the leading symbol character from the main objfile.  */
 
 static int get_symbol_leading_char (bfd *);
 
 static int
 get_symbol_leading_char (bfd *abfd)
 {
   if (abfd != NULL)
     return bfd_get_symbol_leading_char (abfd);
   if (symfile_objfile != NULL && symfile_objfile->obfd != NULL)