/* GDB routines for manipulating the minimal symbol tables.
- Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- 2002, 2003
+ Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+ 2002, 2003, 2004
Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
/* This file contains support routines for creating, manipulating, and
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).
+
+ 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 (register const char *name, const char *sfile,
+lookup_minimal_symbol (const char *name, const char *sfile,
struct objfile *objf)
{
struct objfile *objfile;
while (msymbol != NULL && found_symbol == NULL)
{
- if (DEPRECATED_SYMBOL_MATCHES_NAME (msymbol, name))
+ /* FIXME: carlton/2003-02-27: This is an unholy
+ mixture of linkage names and natural names. If
+ you want to test the linkage names with strcmp,
+ do that. If you want to test the natural names
+ with strcmp_iw, use SYMBOL_MATCHES_NATURAL_NAME. */
+ if (strcmp (DEPRECATED_SYMBOL_NAME (msymbol), (name)) == 0
+ || (SYMBOL_DEMANGLED_NAME (msymbol) != NULL
+ && strcmp_iw (SYMBOL_DEMANGLED_NAME (msymbol),
+ (name)) == 0))
{
switch (MSYMBOL_TYPE (msymbol))
{
case mst_file_data:
case mst_file_bss:
#ifdef SOFUN_ADDRESS_MAYBE_MISSING
- if (sfile == NULL || STREQ (msymbol->filename, sfile))
+ if (sfile == NULL
+ || strcmp (msymbol->filename, sfile) == 0)
found_file_symbol = msymbol;
#else
/* We have neither the ability nor the need to
/* 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. 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.
+ 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. */
struct minimal_symbol *
-lookup_minimal_symbol_text (register const char *name, const char *sfile,
- struct objfile *objf)
+lookup_minimal_symbol_text (const char *name, struct objfile *objf)
{
struct objfile *objfile;
struct minimal_symbol *msymbol;
unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
- if (sfile != NULL)
- {
- char *p = strrchr (sfile, '/');
- if (p != NULL)
- sfile = p + 1;
- }
-#endif
-
for (objfile = object_files;
objfile != NULL && found_symbol == NULL;
objfile = objfile->next)
switch (MSYMBOL_TYPE (msymbol))
{
case mst_file_text:
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
- if (sfile == NULL || STREQ (msymbol->filename, sfile))
- found_file_symbol = msymbol;
-#else
- /* We have neither the ability nor the need to
- deal with the SFILE parameter. If we find
- more than one symbol, just return the latest
- one (the user can't expect useful behavior in
- that case). */
found_file_symbol = msymbol;
-#endif
break;
default:
found_symbol = msymbol;
}
/* 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. 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.
+ 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. */
struct minimal_symbol *
-lookup_minimal_symbol_solib_trampoline (register const char *name,
- const char *sfile, struct objfile *objf)
+lookup_minimal_symbol_solib_trampoline (const char *name,
+ struct objfile *objf)
{
struct objfile *objfile;
struct minimal_symbol *msymbol;
unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
- if (sfile != NULL)
- {
- char *p = strrchr (sfile, '/');
- if (p != NULL)
- sfile = p + 1;
- }
-#endif
-
for (objfile = object_files;
objfile != NULL && found_symbol == NULL;
objfile = objfile->next)
/* Search through the minimal symbol table for each objfile and find
the symbol whose address is the largest address that is still less
- than or equal to PC, and matches SECTION (if non-null). Returns a
+ than or equal to PC, and matches SECTION (if non-NULL). Returns a
pointer to the minimal symbol if such a symbol is found, or NULL if
PC is not in a suitable range. Note that we need to look through
ALL the minimal symbol tables before deciding on the symbol that
struct objfile *objfile;
struct minimal_symbol *msymbol;
struct minimal_symbol *best_symbol = NULL;
+ struct obj_section *pc_section;
- /* pc has to be in a known section. This ensures that anything beyond
- the end of the last segment doesn't appear to be part of the last
- function in the last segment. */
- if (find_pc_section (pc) == NULL)
+ /* PC has to be in a known section. This ensures that anything
+ beyond the end of the last segment doesn't appear to be part of
+ the last function in the last segment. */
+ pc_section = find_pc_section (pc);
+ if (pc_section == NULL)
return NULL;
+ /* NOTE: cagney/2004-01-27: Removed code (added 2003-07-19) that was
+ trying to force the PC into a valid section as returned by
+ find_pc_section. It broke IRIX 6.5 mdebug which relies on this
+ code returning an absolute symbol - the problem was that
+ find_pc_section wasn't returning an absolute section and hence
+ the code below would skip over absolute symbols. Since the
+ original problem was with finding a frame's function, and that
+ uses [indirectly] lookup_minimal_symbol_by_pc, the original
+ problem has been fixed by having that function use
+ find_pc_section. */
+
for (objfile = object_files;
objfile != NULL;
objfile = objfile->next)
struct minimal_symbol *
lookup_minimal_symbol_by_pc (CORE_ADDR pc)
{
- return lookup_minimal_symbol_by_pc_section (pc, find_pc_mapped_section (pc));
+ /* 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. */
+ struct obj_section *section = find_pc_section (pc);
+ if (section == NULL)
+ return NULL;
+ return lookup_minimal_symbol_by_pc_section (pc, section->the_bfd_section);
}
\f
asection *bfd_section,
struct objfile *objfile)
{
- register struct msym_bunch *new;
- register struct minimal_symbol *msymbol;
+ struct msym_bunch *new;
+ struct minimal_symbol *msymbol;
- if (ms_type == mst_file_text)
- {
- /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
- the minimal symbols, because if there is also another symbol
- at the same address (e.g. the first function of the file),
- lookup_minimal_symbol_by_pc would have no way of getting the
- right one. */
- if (name[0] == 'g'
- && (strcmp (name, GCC_COMPILED_FLAG_SYMBOL) == 0
- || strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0))
- return (NULL);
+ /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
+ the minimal symbols, because if there is also another symbol
+ at the same address (e.g. the first function of the file),
+ lookup_minimal_symbol_by_pc would have no way of getting the
+ right one. */
+ if (ms_type == mst_file_text && name[0] == 'g'
+ && (strcmp (name, GCC_COMPILED_FLAG_SYMBOL) == 0
+ || strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0))
+ return (NULL);
- {
- const char *tempstring = name;
- if (tempstring[0] == get_symbol_leading_char (objfile->obfd))
- ++tempstring;
- if (STREQN (tempstring, "__gnu_compiled", 14))
- return (NULL);
- }
- }
+ /* It's safe to strip the leading char here once, since the name
+ is also stored stripped in the minimal symbol table. */
+ if (name[0] == get_symbol_leading_char (objfile->obfd))
+ ++name;
+
+ if (ms_type == mst_file_text && strncmp (name, "__gnu_compiled", 14) == 0)
+ return (NULL);
if (msym_bunch_index == BUNCH_SIZE)
{
MSYMBOL_TYPE (msymbol) = ms_type;
/* FIXME: This info, if it remains, needs its own field. */
MSYMBOL_INFO (msymbol) = info; /* FIXME! */
+ MSYMBOL_SIZE (msymbol) = 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. */
static int
compare_minimal_symbols (const void *fn1p, const void *fn2p)
{
- register const struct minimal_symbol *fn1;
- register const struct minimal_symbol *fn2;
+ const struct minimal_symbol *fn1;
+ const struct minimal_symbol *fn2;
fn1 = (const struct minimal_symbol *) fn1p;
fn2 = (const struct minimal_symbol *) fn2p;
static void
do_discard_minimal_symbols_cleanup (void *arg)
{
- register struct msym_bunch *next;
+ struct msym_bunch *next;
while (msym_bunch != NULL)
{
Note that we are not concerned here about recovering the space that
is potentially freed up, because the strings themselves are allocated
- on the symbol_obstack, and will get automatically freed when the symbol
+ on the objfile_obstack, and will get automatically freed when the symbol
table is freed. The caller can free up the unused minimal symbols at
the end of the compacted region if their allocation strategy allows it.
copyfrom = copyto = msymbol;
while (copyfrom < msymbol + mcount - 1)
{
- if (SYMBOL_VALUE_ADDRESS (copyfrom) ==
- SYMBOL_VALUE_ADDRESS ((copyfrom + 1)) &&
- (STREQ (SYMBOL_LINKAGE_NAME (copyfrom),
- SYMBOL_LINKAGE_NAME ((copyfrom + 1)))))
+ if (SYMBOL_VALUE_ADDRESS (copyfrom)
+ == SYMBOL_VALUE_ADDRESS ((copyfrom + 1))
+ && strcmp (SYMBOL_LINKAGE_NAME (copyfrom),
+ SYMBOL_LINKAGE_NAME ((copyfrom + 1))) == 0)
{
if (MSYMBOL_TYPE ((copyfrom + 1)) == mst_unknown)
{
add_minsym_to_hash_table (msym, objfile->msymbol_hash);
msym->demangled_hash_next = 0;
- if (SYMBOL_DEMANGLED_NAME (msym) != NULL)
+ if (SYMBOL_SEARCH_NAME (msym) != SYMBOL_LINKAGE_NAME (msym))
add_minsym_to_demangled_hash_table (msym,
objfile->msymbol_demangled_hash);
}
void
install_minimal_symbols (struct objfile *objfile)
{
- register int bindex;
- register int mcount;
- register struct msym_bunch *bunch;
- register struct minimal_symbol *msymbols;
+ int bindex;
+ int mcount;
+ struct msym_bunch *bunch;
+ struct minimal_symbol *msymbols;
int alloc_count;
- register char leading_char;
if (msym_count > 0)
{
we will give back the excess space. */
alloc_count = msym_count + objfile->minimal_symbol_count + 1;
- obstack_blank (&objfile->symbol_obstack,
+ obstack_blank (&objfile->objfile_obstack,
alloc_count * sizeof (struct minimal_symbol));
msymbols = (struct minimal_symbol *)
- obstack_base (&objfile->symbol_obstack);
+ obstack_base (&objfile->objfile_obstack);
/* Copy in the existing minimal symbols, if there are any. */
each bunch is full. */
mcount = objfile->minimal_symbol_count;
- leading_char = get_symbol_leading_char (objfile->obfd);
for (bunch = msym_bunch; bunch != NULL; bunch = bunch->next)
{
for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++)
- {
- msymbols[mcount] = bunch->contents[bindex];
- if (SYMBOL_LINKAGE_NAME (&msymbols[mcount])[0] == leading_char)
- {
- SYMBOL_LINKAGE_NAME (&msymbols[mcount])++;
- }
- }
+ msymbols[mcount] = bunch->contents[bindex];
msym_bunch_index = BUNCH_SIZE;
}
mcount = compact_minimal_symbols (msymbols, mcount, objfile);
- obstack_blank (&objfile->symbol_obstack,
+ obstack_blank (&objfile->objfile_obstack,
(mcount + 1 - alloc_count) * sizeof (struct minimal_symbol));
msymbols = (struct minimal_symbol *)
- obstack_finish (&objfile->symbol_obstack);
+ obstack_finish (&objfile->objfile_obstack);
/* We also terminate the minimal symbol table with a "null symbol",
which is *not* included in the size of the table. This makes it
SYMBOL_LINKAGE_NAME (&msymbols[mcount]) = NULL;
SYMBOL_VALUE_ADDRESS (&msymbols[mcount]) = 0;
MSYMBOL_INFO (&msymbols[mcount]) = NULL;
+ MSYMBOL_SIZE (&msymbols[mcount]) = 0;
MSYMBOL_TYPE (&msymbols[mcount]) = mst_unknown;
SYMBOL_INIT_LANGUAGE_SPECIFIC (&msymbols[mcount], language_unknown);
/* Attach the minimal symbol table to the specified objfile.
- The strings themselves are also located in the symbol_obstack
+ The strings themselves are also located in the objfile_obstack
of this objfile. */
objfile->minimal_symbol_count = mcount;
ALL_MSYMBOLS (objfile, msymbol)
{
if (MSYMBOL_TYPE (msymbol) == mst_text
- && STREQ (SYMBOL_LINKAGE_NAME (msymbol),
- SYMBOL_LINKAGE_NAME (tsymbol)))
+ && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
+ SYMBOL_LINKAGE_NAME (tsymbol)) == 0)
return SYMBOL_VALUE_ADDRESS (msymbol);
}
}
projects / deliverable / binutils-gdb.git / blobdiff