/* GDB routines for manipulating the minimal symbol tables.
- Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- 2002, 2003, 2004, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ 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.
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)
++string;
if (*string && *string != '(')
{
- hash = hash * 67 + *string - 113;
+ 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 = hash * 67 + *string - 113;
+ 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)
{
}
}
+/* See minsyms.h. */
-/* Return OBJFILE where minimal symbol SYM is defined. */
struct objfile *
msymbol_objfile (struct minimal_symbol *sym)
{
if (pass == 1)
{
- match = strcmp (SYMBOL_LINKAGE_NAME (msymbol),
- modified_name) == 0;
+ 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);
}
return NULL;
}
-/* 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.
+/* 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 *);
+
+ /* The first pass is over the ordinary hash table. */
+ hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
+ iter = objf->msymbol_hash[hash];
+ cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
+ while (iter)
+ {
+ if (cmp (SYMBOL_LINKAGE_NAME (iter), name) == 0)
+ (*callback) (iter, user_data);
+ iter = iter->hash_next;
+ }
- This function only searches the mangled (linkage) names. */
+ /* The second pass is over the demangled table. */
+ 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;
+ }
+}
+
+/* See minsyms.h. */
struct minimal_symbol *
lookup_minimal_symbol_text (const char *name, struct objfile *objf)
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,
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,
/* If we are looking for a trampoline and this is a
text symbol, or the other way around, check the
- preceeding symbol too. If they are otherwise
+ preceding symbol too. If they are otherwise
identical prefer that one. */
if (hi > 0
&& MSYMBOL_TYPE (&msymbol[hi]) == other_type
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)
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,
return 0;
}
-/* Prepare to start collecting minimal symbols. Note that presetting
- msym_bunch_index to BUNCH_SIZE causes the first call to save a minimal
- symbol to allocate the memory for the first bunch. */
+/* See minsyms.h. */
void
init_minimal_symbol_collection (void)
{
msym_count = 0;
msym_bunch = NULL;
+ /* Note that presetting msym_bunch_index to BUNCH_SIZE causes the
+ first call to save a minimal symbol to allocate the memory for
+ the first bunch. */
msym_bunch_index = BUNCH_SIZE;
}
+/* See minsyms.h. */
+
void
prim_record_minimal_symbol (const char *name, CORE_ADDR address,
enum minimal_symbol_type ms_type,
section, NULL, objfile);
}
-/* Record a minimal symbol in the msym bunches. Returns the symbol
- newly created. */
+/* See minsyms.h. */
struct minimal_symbol *
prim_record_minimal_symbol_full (const char *name, int name_len, int copy_name,
MSYMBOL_TYPE (msymbol) = ms_type;
MSYMBOL_TARGET_FLAG_1 (msymbol) = 0;
MSYMBOL_TARGET_FLAG_2 (msymbol) = 0;
- MSYMBOL_SIZE (msymbol) = 0;
+ /* Do not use the SET_MSYMBOL_SIZE macro to initialize the size,
+ as it would also set the has_size flag. */
+ msymbol->size = 0;
/* The hash pointers must be cleared! If they're not,
add_minsym_to_hash_table will NOT add this msymbol to the hash table. */
return msymbol;
}
-/* Record a minimal symbol in the msym bunches. Returns the symbol
- newly created. */
+/* See minsyms.h. */
struct minimal_symbol *
prim_record_minimal_symbol_and_info (const char *name, CORE_ADDR address,
else
/* addrs are equal: sort by name */
{
- char *name1 = SYMBOL_LINKAGE_NAME (fn1);
- char *name2 = SYMBOL_LINKAGE_NAME (fn2);
+ const char *name1 = SYMBOL_LINKAGE_NAME (fn1);
+ const char *name2 = SYMBOL_LINKAGE_NAME (fn2);
if (name1 && name2) /* both have names */
return strcmp (name1, name2);
}
}
+/* See minsyms.h. */
+
struct cleanup *
make_cleanup_discard_minimal_symbols (void)
{
if (msym_count > 0)
{
+ if (symtab_create_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "Installing %d minimal symbols of objfile %s.\n",
+ msym_count, objfile->name);
+ }
+
/* Allocate enough space in the obstack, into which we will gather the
bunches of new and existing minimal symbols, sort them, and then
compact out the duplicate entries. Once we have a final table,
symbol count does *not* include this null symbol, which is why it
is indexed by mcount and not mcount-1. */
- SYMBOL_LINKAGE_NAME (&msymbols[mcount]) = NULL;
- SYMBOL_VALUE_ADDRESS (&msymbols[mcount]) = 0;
- MSYMBOL_TARGET_FLAG_1 (&msymbols[mcount]) = 0;
- MSYMBOL_TARGET_FLAG_2 (&msymbols[mcount]) = 0;
- MSYMBOL_SIZE (&msymbols[mcount]) = 0;
- MSYMBOL_TYPE (&msymbols[mcount]) = mst_unknown;
- SYMBOL_SET_LANGUAGE (&msymbols[mcount], language_unknown);
+ memset (&msymbols[mcount], 0, sizeof (struct minimal_symbol));
/* Attach the minimal symbol table to the specified objfile.
The strings themselves are also located in the objfile_obstack
}
}
+/* See minsyms.h. */
+
+void
+terminate_minimal_symbol_table (struct objfile *objfile)
+{
+ if (! objfile->msymbols)
+ objfile->msymbols = ((struct minimal_symbol *)
+ obstack_alloc (&objfile->objfile_obstack,
+ sizeof (objfile->msymbols[0])));
+
+ {
+ struct minimal_symbol *m
+ = &objfile->msymbols[objfile->minimal_symbol_count];
+
+ memset (m, 0, sizeof (*m));
+ /* Don't rely on these enumeration values being 0's. */
+ MSYMBOL_TYPE (m) = mst_unknown;
+ SYMBOL_SET_LANGUAGE (m, language_unknown);
+ }
+}
+
/* Sort all the minimal symbols in OBJFILE. */
void
build_minimal_symbol_hash_tables (objfile);
}
-/* Check if PC is in a shared library trampoline code stub.
- Return minimal symbol for the trampoline entry or NULL if PC is not
- in a trampoline code stub. */
+/* See minsyms.h. */
struct minimal_symbol *
lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc)