/* GDB routines for manipulating the minimal symbol tables.
- Copyright 1992, 93, 94, 96, 97, 1998 Free Software Foundation, Inc.
+ Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+ 2002, 2003
+ Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
This file is part of GDB.
#include "symfile.h"
#include "objfiles.h"
#include "demangle.h"
-#include "gdb-stabs.h"
+#include "value.h"
+#include "cp-abi.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
static int msym_count;
-/* Prototypes for local functions. */
-
-static int compare_minimal_symbols (const void *, const void *);
-
-static int
-compact_minimal_symbols (struct minimal_symbol *, int, struct objfile *);
-
-static void add_minsym_to_demangled_hash_table (struct minimal_symbol *sym,
- struct minimal_symbol **table);
-
/* Compute a hash code based using the same criteria as `strcmp_iw'. */
unsigned int
while (isspace (*string))
++string;
if (*string && *string != '(')
- hash = (31 * hash) + *string;
- ++string;
+ {
+ hash = hash * 67 + *string - 113;
+ ++string;
+ }
}
- return hash % MINIMAL_SYMBOL_HASH_SIZE;
+ return hash;
}
/* Compute a hash code for a string. */
{
unsigned int hash = 0;
for (; *string; ++string)
- hash = (31 * hash) + *string;
- return hash % MINIMAL_SYMBOL_HASH_SIZE;
+ hash = hash * 67 + *string - 113;
+ return hash;
}
/* Add the minimal symbol SYM to an objfile's minsym hash table, TABLE. */
{
if (sym->hash_next == NULL)
{
- unsigned int hash = msymbol_hash (SYMBOL_NAME (sym));
+ unsigned int hash = msymbol_hash (SYMBOL_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE;
sym->hash_next = table[hash];
table[hash] = sym;
}
{
if (sym->demangled_hash_next == NULL)
{
- unsigned int hash = msymbol_hash_iw (SYMBOL_DEMANGLED_NAME (sym));
+ unsigned int hash = msymbol_hash_iw (SYMBOL_DEMANGLED_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE;
sym->demangled_hash_next = table[hash];
table[hash] = sym;
}
/* 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, limit the search
- to that source file. Returns a pointer to the minimal symbol that
+ 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). */
+ names (the dynamic linker deals with the duplication). */
struct minimal_symbol *
lookup_minimal_symbol (register const char *name, const char *sfile,
struct minimal_symbol *found_file_symbol = NULL;
struct minimal_symbol *trampoline_symbol = NULL;
- unsigned int hash = msymbol_hash (name);
- unsigned int dem_hash = msymbol_hash_iw (name);
+ unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
+ unsigned int dem_hash = msymbol_hash_iw (name) % MINIMAL_SYMBOL_HASH_SIZE;
#ifdef SOFUN_ADDRESS_MAYBE_MISSING
if (sfile != NULL)
}
/* Look through all the current minimal symbol tables and find the
- first minimal symbol that matches NAME and of text type.
- If OBJF is non-NULL, limit
- the search to that objfile. If SFILE is non-NULL, limit the search
- to that source file. Returns a pointer to the minimal symbol that
- matches, or NULL if no match is found.
- */
+ first minimal symbol that matches NAME and has text type. 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.
+
+ This function only searches the mangled (linkage) names. */
struct minimal_symbol *
lookup_minimal_symbol_text (register const char *name, const char *sfile,
struct minimal_symbol *found_symbol = NULL;
struct minimal_symbol *found_file_symbol = NULL;
+ unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
+
#ifdef SOFUN_ADDRESS_MAYBE_MISSING
if (sfile != NULL)
{
{
if (objf == NULL || objf == objfile)
{
- for (msymbol = objfile->msymbols;
- msymbol != NULL && SYMBOL_NAME (msymbol) != NULL &&
- found_symbol == NULL;
- msymbol++)
+ for (msymbol = objfile->msymbol_hash[hash];
+ msymbol != NULL && found_symbol == NULL;
+ msymbol = msymbol->hash_next)
{
if (SYMBOL_MATCHES_NAME (msymbol, name) &&
(MSYMBOL_TYPE (msymbol) == mst_text ||
}
/* Look through all the current minimal symbol tables and find the
- first minimal symbol that matches NAME and of solib trampoline type.
- If OBJF is non-NULL, limit
- the search to that objfile. If SFILE is non-NULL, limit the search
- to that source file. Returns a pointer to the minimal symbol that
- matches, or NULL if no match is found.
- */
+ first minimal symbol that matches NAME and is a solib trampoline. 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.
+
+ This function only searches the mangled (linkage) names. */
struct minimal_symbol *
lookup_minimal_symbol_solib_trampoline (register const char *name,
struct minimal_symbol *msymbol;
struct minimal_symbol *found_symbol = NULL;
+ unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
+
#ifdef SOFUN_ADDRESS_MAYBE_MISSING
if (sfile != NULL)
{
{
if (objf == NULL || objf == objfile)
{
- for (msymbol = objfile->msymbols;
- msymbol != NULL && SYMBOL_NAME (msymbol) != NULL &&
- found_symbol == NULL;
- msymbol++)
+ for (msymbol = objfile->msymbol_hash[hash];
+ msymbol != NULL && found_symbol == NULL;
+ msymbol = msymbol->hash_next)
{
if (SYMBOL_MATCHES_NAME (msymbol, name) &&
MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
"null symbol". If there are no real symbols, then there is no
minimal symbol table at all. */
- if ((msymbol = objfile->msymbols) != NULL)
+ if (objfile->minimal_symbol_count > 0)
{
+ msymbol = objfile->msymbols;
lo = 0;
hi = objfile->minimal_symbol_count - 1;
/* This is the new code that distinguishes it from the old function */
if (section)
while (hi >= 0
+ /* 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_BFD_SECTION (&msymbol[hi]) != NULL
&& SYMBOL_BFD_SECTION (&msymbol[hi]) != section)
--hi;
{
return lookup_minimal_symbol_by_pc_section (pc, find_pc_mapped_section (pc));
}
-
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
-CORE_ADDR
-find_stab_function_addr (char *namestring, char *filename,
- struct objfile *objfile)
-{
- struct minimal_symbol *msym;
- char *p;
- int n;
-
- p = strchr (namestring, ':');
- if (p == NULL)
- p = namestring;
- n = p - namestring;
- p = alloca (n + 2);
- strncpy (p, namestring, n);
- p[n] = 0;
-
- msym = lookup_minimal_symbol (p, filename, objfile);
- if (msym == NULL)
- {
- /* Sun Fortran appends an underscore to the minimal symbol name,
- try again with an appended underscore if the minimal symbol
- was not found. */
- p[n] = '_';
- p[n + 1] = 0;
- msym = lookup_minimal_symbol (p, filename, objfile);
- }
-
- if (msym == NULL && filename != NULL)
- {
- /* Try again without the filename. */
- p[n] = 0;
- msym = lookup_minimal_symbol (p, 0, objfile);
- }
- if (msym == NULL && filename != NULL)
- {
- /* And try again for Sun Fortran, but without the filename. */
- p[n] = '_';
- p[n + 1] = 0;
- msym = lookup_minimal_symbol (p, 0, objfile);
- }
-
- return msym == NULL ? 0 : SYMBOL_VALUE_ADDRESS (msym);
-}
-#endif /* SOFUN_ADDRESS_MAYBE_MISSING */
\f
/* Return leading symbol character for a BFD. If BFD is NULL,
msym_bunch = new;
}
msymbol = &msym_bunch->contents[msym_bunch_index];
- SYMBOL_NAME (msymbol) = obsavestring ((char *) name, strlen (name),
- &objfile->symbol_obstack);
SYMBOL_INIT_LANGUAGE_SPECIFIC (msymbol, language_unknown);
+ SYMBOL_LANGUAGE (msymbol) = language_auto;
+ SYMBOL_SET_NAMES (msymbol, (char *)name, strlen (name), objfile);
+
SYMBOL_VALUE_ADDRESS (msymbol) = address;
SYMBOL_SECTION (msymbol) = section;
SYMBOL_BFD_SECTION (msymbol) = bfd_section;
Within groups with the same address, sort by name. */
static int
-compare_minimal_symbols (const PTR fn1p, const PTR fn2p)
+compare_minimal_symbols (const void *fn1p, const void *fn2p)
{
register const struct minimal_symbol *fn1;
register const struct minimal_symbol *fn2;
while (msym_bunch != NULL)
{
next = msym_bunch->next;
- free ((PTR) msym_bunch);
+ xfree (msym_bunch);
msym_bunch = next;
}
}
copyfrom++;
}
else
- {
- *copyto++ = *copyfrom++;
-
- add_minsym_to_hash_table (copyto - 1, objfile->msymbol_hash);
- }
+ *copyto++ = *copyfrom++;
}
*copyto++ = *copyfrom++;
mcount = copyto - msymbol;
return (mcount);
}
+/* Build (or rebuild) the minimal symbol hash tables. This is necessary
+ after compacting or sorting the table since the entries move around
+ thus causing the internal minimal_symbol pointers to become jumbled. */
+
+static void
+build_minimal_symbol_hash_tables (struct objfile *objfile)
+{
+ int i;
+ struct minimal_symbol *msym;
+
+ /* Clear the hash tables. */
+ for (i = 0; i < MINIMAL_SYMBOL_HASH_SIZE; i++)
+ {
+ objfile->msymbol_hash[i] = 0;
+ objfile->msymbol_demangled_hash[i] = 0;
+ }
+
+ /* Now, (re)insert the actual entries. */
+ for (i = objfile->minimal_symbol_count, msym = objfile->msymbols;
+ i > 0;
+ i--, msym++)
+ {
+ msym->hash_next = 0;
+ add_minsym_to_hash_table (msym, objfile->msymbol_hash);
+
+ msym->demangled_hash_next = 0;
+ if (SYMBOL_DEMANGLED_NAME (msym) != NULL)
+ add_minsym_to_demangled_hash_table (msym,
+ objfile->msymbol_demangled_hash);
+ }
+}
+
/* Add the minimal symbols in the existing bunches to the objfile's official
minimal symbol table. In most cases there is no minimal symbol table yet
for this objfile, and the existing bunches are used to create one. Once
for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++)
{
msymbols[mcount] = bunch->contents[bindex];
- SYMBOL_LANGUAGE (&msymbols[mcount]) = language_auto;
if (SYMBOL_NAME (&msymbols[mcount])[0] == leading_char)
{
SYMBOL_NAME (&msymbols[mcount])++;
objfile->minimal_symbol_count = mcount;
objfile->msymbols = msymbols;
- /* Now walk through all the minimal symbols, selecting the newly added
- ones and attempting to cache their C++ demangled names. */
+ /* Try to guess the appropriate C++ ABI by looking at the names
+ of the minimal symbols in the table. */
+ {
+ int i;
+
+ for (i = 0; i < mcount; i++)
+ {
+ const char *name = SYMBOL_NAME (&objfile->msymbols[i]);
+ if (name[0] == '_' && name[1] == 'Z')
+ {
+ switch_to_cp_abi ("gnu-v3");
+ break;
+ }
+ }
+ }
- for (; mcount-- > 0; msymbols++)
- {
- SYMBOL_INIT_DEMANGLED_NAME (msymbols, &objfile->symbol_obstack);
- if (SYMBOL_DEMANGLED_NAME (msymbols) != NULL)
- add_minsym_to_demangled_hash_table (msymbols,
- objfile->msymbol_demangled_hash);
- }
+ /* Now build the hash tables; we can't do this incrementally
+ at an earlier point since we weren't finished with the obstack
+ yet. (And if the msymbol obstack gets moved, all the internal
+ pointers to other msymbols need to be adjusted.) */
+ build_minimal_symbol_hash_tables (objfile);
}
}
{
qsort (objfile->msymbols, objfile->minimal_symbol_count,
sizeof (struct minimal_symbol), compare_minimal_symbols);
+ build_minimal_symbol_hash_tables (objfile);
}
/* Check if PC is in a shared library trampoline code stub.