GDB 7.6.50

gdb/minsyms.c

 /* GDB routines for manipulating the minimal symbol tables.
-   Copyright (C) 1992-2004, 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 1992-2013 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.
 
    This program is distributed in the hope that it will be useful,
@@ skipping 18 matching lines @@
    information to build useful minimal symbol tables using this structure.
 
    Even when a file contains enough debugging information to build a full
    symbol table, these minimal symbols are still useful for quickly mapping
    between names and addresses, and vice versa.  They are also sometimes used
    to figure out what full symbol table entries need to be read in.  */
 
 
 #include "defs.h"
 #include <ctype.h>
-#include "gdb_string.h"
+#include <string.h>
 #include "symtab.h"
 #include "bfd.h"
 #include "filenames.h"
 #include "symfile.h"
 #include "objfiles.h"
 #include "demangle.h"
 #include "value.h"
 #include "cp-abi.h"
 #include "target.h"
 #include "cp-support.h"
 #include "language.h"
+#include "cli/cli-utils.h"
 
 /* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE.
    At the end, copy them all into one newly allocated location on an objfile's
    symbol obstack.  */
 
 #define BUNCH_SIZE 127
 
 struct msym_bunch
   {
     struct msym_bunch *next;
@@ skipping 15 matching lines @@
 
 /* See minsyms.h.  */
 
 unsigned int
 msymbol_hash_iw (const char *string)
 {
   unsigned int hash = 0;
 
   while (*string && *string != '(')
     {
-      while (isspace (*string))
-        ++string;
+      string = skip_spaces_const (string);
       if (*string && *string != '(')
         {
           hash = SYMBOL_HASH_NEXT (hash, *string);
           ++string;
         }
     }
   return hash;
 }
 
 /* See minsyms.h.  */
@@ skipping 32 matching lines @@
   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.  */
-
-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)
-    for (tsym = objf->msymbol_hash[hash]; tsym; tsym = tsym->hash_next)
-      if (tsym == sym)
-        return objf;
-
-  /* We should always be able to find the objfile ...  */
-  internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
-}
-
-
 /* Look through all the current minimal symbol tables and find the
    first minimal symbol that matches NAME.  If OBJF is non-NULL, limit
    the search to that objfile.  If SFILE is non-NULL, the only file-scope
    symbols considered will be from that source file (global symbols are
    still preferred).  Returns a pointer to the minimal symbol that
    matches, or NULL if no match is found.
 
    Note:  One instance where there may be duplicate minimal symbols with
    the same name is when the symbol tables for a shared library and the
    symbol tables for an executable contain global symbols with the same
    names (the dynamic linker deals with the duplication).
 
    It's also possible to have minimal symbols with different mangled
    names, but identical demangled names.  For example, the GNU C++ v3
    ABI requires the generation of two (or perhaps three) copies of
    constructor functions --- "in-charge", "not-in-charge", and
    "allocate" copies; destructors may be duplicated as well.
    Obviously, there must be distinct mangled names for each of these,
    but the demangled names are all the same: S::S or S::~S.  */
 
-struct minimal_symbol *
-lookup_minimal_symbol (const char *name, const char *sfile,
-                       struct objfile *objf)
+static struct bound_minimal_symbol
+lookup_minimal_symbol_internal (const char *name, const char *sfile,
+                                struct objfile *objf)
 {
   struct objfile *objfile;
-  struct minimal_symbol *msymbol;
-  struct minimal_symbol *found_symbol = NULL;
-  struct minimal_symbol *found_file_symbol = NULL;
-  struct minimal_symbol *trampoline_symbol = NULL;
+  struct bound_minimal_symbol found_symbol = { NULL, NULL };
+  struct bound_minimal_symbol found_file_symbol = { NULL, NULL };
+  struct bound_minimal_symbol trampoline_symbol = { NULL, NULL };
 
   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
   unsigned int dem_hash = msymbol_hash_iw (name) % MINIMAL_SYMBOL_HASH_SIZE;
 
   int needtofreename = 0;
   const char *modified_name;
 
   if (sfile != NULL)
     sfile = lbasename (sfile);
 
   /* For C++, canonicalize the input name.  */
   modified_name = name;
   if (current_language->la_language == language_cplus)
     {
       char *cname = cp_canonicalize_string (name);
 
       if (cname)
         {
           modified_name = cname;
           needtofreename = 1;
         }
     }
 
   for (objfile = object_files;
-       objfile != NULL && found_symbol == NULL;
+       objfile != NULL && found_symbol.minsym == NULL;
        objfile = objfile->next)
     {
+      struct minimal_symbol *msymbol;
+
       if (objf == NULL || objf == objfile
           || objf == objfile->separate_debug_objfile_backlink)
         {
           /* Do two passes: the first over the ordinary hash table,
              and the second over the demangled hash table.  */
         int pass;
 
-        for (pass = 1; pass <= 2 && found_symbol == NULL; pass++)
+        for (pass = 1; pass <= 2 && found_symbol.minsym == NULL; pass++)
             {
             /* Select hash list according to pass.  */
             if (pass == 1)
               msymbol = objfile->msymbol_hash[hash];
             else
               msymbol = objfile->msymbol_demangled_hash[dem_hash];
 
-            while (msymbol != NULL && found_symbol == NULL)
+            while (msymbol != NULL && found_symbol.minsym == NULL)
                 {
                   int match;
 
                   if (pass == 1)
                     {
                       int (*cmp) (const char *, const char *);
 
                       cmp = (case_sensitivity == case_sensitive_on
                              ? strcmp : strcasecmp);
                       match = cmp (SYMBOL_LINKAGE_NAME (msymbol),
                                    modified_name) == 0;
                     }
                   else
                     {
                       /* The function respects CASE_SENSITIVITY.  */
                       match = SYMBOL_MATCHES_SEARCH_NAME (msymbol,
                                                           modified_name);
                     }
 
                   if (match)
                     {
                     switch (MSYMBOL_TYPE (msymbol))
                       {
                       case mst_file_text:
                       case mst_file_data:
                       case mst_file_bss:
                         if (sfile == NULL
                             || filename_cmp (msymbol->filename, sfile) == 0)
-                          found_file_symbol = msymbol;
+                          {
+                            found_file_symbol.minsym = msymbol;
+                            found_file_symbol.objfile = objfile;
+                          }
                         break;
 
                       case mst_solib_trampoline:
 
                         /* If a trampoline symbol is found, we prefer to
                            keep looking for the *real* symbol.  If the
                            actual symbol is not found, then we'll use the
                            trampoline entry.  */
-                        if (trampoline_symbol == NULL)
-                          trampoline_symbol = msymbol;
+                        if (trampoline_symbol.minsym == NULL)
+                          {
+                            trampoline_symbol.minsym = msymbol;
+                            trampoline_symbol.objfile = objfile;
+                          }
                         break;
 
                       case mst_unknown:
                       default:
-                        found_symbol = msymbol;
+                        found_symbol.minsym = msymbol;
+                        found_symbol.objfile = objfile;
                         break;
                       }
                     }
 
                 /* Find the next symbol on the hash chain.  */
                 if (pass == 1)
                   msymbol = msymbol->hash_next;
                 else
                   msymbol = msymbol->demangled_hash_next;
                 }
             }
         }
     }
 
   if (needtofreename)
     xfree ((void *) modified_name);
 
   /* External symbols are best.  */
-  if (found_symbol)
+  if (found_symbol.minsym != NULL)
     return found_symbol;
 
   /* File-local symbols are next best.  */
-  if (found_file_symbol)
+  if (found_file_symbol.minsym != NULL)
     return found_file_symbol;
 
   /* Symbols for shared library trampolines are next best.  */
-  if (trampoline_symbol)
-    return trampoline_symbol;
-
-  return NULL;
+  return trampoline_symbol;
 }
 
 /* See minsyms.h.  */
+
+struct minimal_symbol *
+lookup_minimal_symbol (const char *name, const char *sfile,
+                       struct objfile *objf)
+{
+  struct bound_minimal_symbol bms = lookup_minimal_symbol_internal (name,
+                                                                    sfile,
+                                                                    objf);
+
+  return bms.minsym;
+}
+
+/* See minsyms.h.  */
+
+struct bound_minimal_symbol
+lookup_bound_minimal_symbol (const char *name)
+{
+  return lookup_minimal_symbol_internal (name, NULL, NULL);
+}
+
+/* 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 145 matching lines @@
    Note that we need to look through ALL the minimal symbol tables
    before deciding on the symbol that comes closest to the specified PC.
    This is because objfiles can overlap, for example objfile A has .text
    at 0x100 and .data at 0x40000 and objfile B has .text at 0x234 and
    .data at 0x40048.
 
    If WANT_TRAMPOLINE is set, prefer mst_solib_trampoline symbols when
    there are text and trampoline symbols at the same address.
    Otherwise prefer mst_text symbols.  */
 
-static struct minimal_symbol *
+static struct bound_minimal_symbol
 lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
                                        struct obj_section *section,
                                        int want_trampoline)
 {
   int lo;
   int hi;
   int new;
   struct objfile *objfile;
   struct minimal_symbol *msymbol;
   struct minimal_symbol *best_symbol = NULL;
+  struct objfile *best_objfile = NULL;
+  struct bound_minimal_symbol result;
   enum minimal_symbol_type want_type, other_type;
 
   want_type = want_trampoline ? mst_solib_trampoline : mst_text;
   other_type = want_trampoline ? mst_text : mst_solib_trampoline;
 
   /* We can not require the symbol found to be in section, because
      e.g. IRIX 6.5 mdebug relies on this code returning an absolute
      symbol - but find_pc_section won't return an absolute section and
      hence the code below would skip over absolute symbols.  We can
      still take advantage of the call to find_pc_section, though - the
@@ skipping 86 matching lines @@
                       hi--;
                       continue;
                     }
 
                   /* If SECTION was specified, skip any symbol from
                      wrong section.  */
                   if (section
                       /* Some types of debug info, such as COFF,
                          don't fill the bfd_section member, so don't
                          throw away symbols on those platforms.  */
-                      && SYMBOL_OBJ_SECTION (&msymbol[hi]) != NULL
+                      && SYMBOL_OBJ_SECTION (objfile, &msymbol[hi]) != NULL
                       && (!matching_obj_sections
-                          (SYMBOL_OBJ_SECTION (&msymbol[hi]), section)))
+                          (SYMBOL_OBJ_SECTION (objfile, &msymbol[hi]),
+                           section)))
                     {
                       hi--;
                       continue;
                     }
 
                   /* If we are looking for a trampoline and this is a
                      text symbol, or the other way around, check the
                      preceding symbol too.  If they are otherwise
                      identical prefer that one.  */
                   if (hi > 0
                       && MSYMBOL_TYPE (&msymbol[hi]) == other_type
                       && MSYMBOL_TYPE (&msymbol[hi - 1]) == want_type
                       && (MSYMBOL_SIZE (&msymbol[hi])
                           == MSYMBOL_SIZE (&msymbol[hi - 1]))
                       && (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
                           == SYMBOL_VALUE_ADDRESS (&msymbol[hi - 1]))
-                      && (SYMBOL_OBJ_SECTION (&msymbol[hi])
-                          == SYMBOL_OBJ_SECTION (&msymbol[hi - 1])))
+                      && (SYMBOL_OBJ_SECTION (objfile, &msymbol[hi])
+                          == SYMBOL_OBJ_SECTION (objfile, &msymbol[hi - 1])))
                     {
                       hi--;
                       continue;
                     }
 
                   /* If the minimal symbol has a zero size, save it
                      but keep scanning backwards looking for one with
                      a non-zero size.  A zero size may mean that the
                      symbol isn't an object or function (e.g. a
                      label), or it may just mean that the size was not
@@ skipping 58 matching lines @@
               /* The minimal symbol indexed by hi now is the best one in this
                  objfile's minimal symbol table.  See if it is the best one
                  overall.  */
 
               if (hi >= 0
                   && ((best_symbol == NULL) ||
                       (SYMBOL_VALUE_ADDRESS (best_symbol) <
                        SYMBOL_VALUE_ADDRESS (&msymbol[hi]))))
                 {
                   best_symbol = &msymbol[hi];
+                  best_objfile = objfile;
                 }
             }
         }
     }
-  return (best_symbol);
+
+  result.minsym = best_symbol;
+  result.objfile = best_objfile;
+  return result;
 }
 
-struct minimal_symbol *
+struct bound_minimal_symbol
 lookup_minimal_symbol_by_pc_section (CORE_ADDR pc, struct obj_section *section)
 {
   if (section == NULL)
     {
       /* 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;
+        {
+          struct bound_minimal_symbol result;
+
+          memset (&result, 0, sizeof (result));
+          return result;
+        }
     }
   return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0);
 }
 
 /* See minsyms.h.  */
 
-struct minimal_symbol *
+struct bound_minimal_symbol
 lookup_minimal_symbol_by_pc (CORE_ADDR pc)
 {
-  return lookup_minimal_symbol_by_pc_section (pc, NULL);
+  struct obj_section *section = find_pc_section (pc);
+
+  if (section == NULL)
+    {
+      struct bound_minimal_symbol result;
+
+      memset (&result, 0, sizeof (result));
+      return result;
+    }
+  return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0);
 }
 
 /* Return non-zero iff PC is in an STT_GNU_IFUNC function resolver.  */
 
 int
 in_gnu_ifunc_stub (CORE_ADDR pc)
 {
-  struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
+  struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (pc);
 
-  return msymbol && MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc;
+  return msymbol.minsym && MSYMBOL_TYPE (msymbol.minsym) == mst_text_gnu_ifunc;
 }
 
 /* See elf_gnu_ifunc_resolve_addr for its real implementation.  */
 
 static CORE_ADDR
 stub_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc)
 {
   error (_("GDB cannot resolve STT_GNU_IFUNC symbol at address %s without "
            "the ELF support compiled in."),
          paddress (gdbarch, pc));
@@ skipping 37 matching lines @@
   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;
 
 /* See minsyms.h.  */
 
-struct minimal_symbol *
-lookup_minimal_symbol_and_objfile (const char *name,
-                                   struct objfile **objfile_p)
+struct bound_minimal_symbol
+lookup_minimal_symbol_and_objfile (const char *name)
 {
+  struct bound_minimal_symbol result;
   struct objfile *objfile;
   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
 
   ALL_OBJFILES (objfile)
     {
       struct minimal_symbol *msym;
 
       for (msym = objfile->msymbol_hash[hash];
            msym != NULL;
            msym = msym->hash_next)