forked from Imagelibrary/binutils-gdb
* defs.h (STRCMP, STREQ, STREQN): New macros.
* defs.h (demangle_and_match): Remove prototype. * dwarfread.c (STREQ, STREQN): Remove macros, replaced with STREQ and STREQN defined in defs.h. * dwarfread.c (set_cu_language): For completely unknown languages, try to deduce the language from the filename. Retain behavior that for known languages we don't know how to handle, we use language_unknown. * dwarfread.c (enum_type, symthesize_typedef): Initialize language and demangled name fields in symbol. * dwarfread.c, mipsread.c, partial-stab.h: For all usages of ADD_PSYMBOL_TO_LIST, add language and objfile parameters. * dwarfread.c (new_symbol): Attempt to demangle C++ symbol names and cache the results in SYMBOL_DEMANGLED_NAME for the symbol. * elfread.c (STREQ): Remove macro, use STREQ defined in defs.h. Replace usages throughout. * elfread.c (demangle.h): Include. * elfread.c (record_minimal_symbol): Remove prototype and function. * gdbtypes.h, symtab.h (B_SET, B_CLR, B_TST, B_TYPE, B_BYTES, B_CLRALL): Moved from symtab.h to gdbtypes.h. * infcmd.c (jump_command): Remove code to demangle name and add it to a cleanup list. Now just use SYMBOL_DEMANGLED_NAME. * minsyms.c (demangle.h): Include. * minsyms.c (lookup_minimal_symbol): Indent comment to match code. * minsyms.c (install_minimal_symbols): Attempt to demangle symbol names as C++ names, and cache them in SYMBOL_DEMANGLED_NAME. * mipsread.c (psymtab_language): Add static variable. * stabsread.c (demangle.h): Include. * stabsread.c (define_symbol): Attempt to demangle C++ symbol names and cache them in the SYMBOL_DEMANGLED_NAME field. * stack.c (return_command): Remove explicit demangling of name and use of cleanups. Just use SYMBOL_DEMANGLED_NAME. * symfile.c (demangle.h): Include. * symfile.c (add_psymbol_to_list, add_psymbol_addr_to_list): Fix to match macros in symfile.h and allow them to be compiled if INLINE_ADD_PSYMBOL is not true. * symfile.h (INLINE_ADD_PSYMBOL): Default to true if not set. * symfile.h (ADD_PSYMBOL_*): Add language and objfile parameters. Add code to demangle and cache C++ symbol names. Use macro form if INLINE_ADD_PSYMBOL is true, otherwise use C function form. * symmisc.c (add_psymbol_to_list, add_psymbol_addr_to_list): Remove, also defined in symfile.c, which we already fixed. * symtab.c (expensive_mangler): Remove prototype and function. * symtab.c (find_methods): Remove physnames parameter and fix prototype to match. * symtab.c (completion_list_add_symbol): Name changed to completion_list_add_name. * symtab.c (COMPLETION_LIST_ADD_SYMBOL): New macro, adds both the normal symbol name and the cached C++ demangled name. * symtab.c (lookup_demangled_partial_symbol, lookup_demangled_block_symbol): Remove prototypes and functions. * symtab.c (lookup_symbol): Remove use of expensive_mangler, use lookup_block_symbol instead of lookup_demangled_block_symbol. Remove code to try demangling names and matching them. * symtab.c (lookup_partial_symbol, lookup_block_symbol): Fix to try matching the cached demangled name if no match is found using the regular symbol name. * symtab.c (find_methods): Remove unused physnames array. * symtab.c (name_match, NAME_MATCH): Remove function and macro, replaced with SYMBOL_MATCHES_REGEXP from symtab.h. * symtab.c (completion_list_add_symbol): Rewrite to use cached C++ demangled symbol names. * symtab.h: Much reformatting of structures and such to add whitespace to make them more readable, and make them more consistent with other gdb structure definitions. * symtab.h (general_symbol_info): New struct containing fields common to all symbols. * symtab.h (SYMBOL_LANGUAGE, SYMBOL_DEMANGLED_NAME, SYMBOL_SOURCE_NAME, SYMBOL_LINKAGE_NAME, SYMBOL_MATCHES_NAME, SYMBOL_MATCHES_REGEXP, MSYMBOL_INFO, MSYMBOL_TYPE): New macros. * symtab. (struct minimal_symbol, struct partial_symbol, struct symbol): Use general_symbol_info struct. * utils.c (demangle_and_match): Remove, no longer used. * valops.c (demangle.h): Include. * xcoffexec.c (eq): Remove macro, replace usages with STREQ. * blockframe.c, breakpoint.c, c-exp.y, c-valprint.c, dbxread.c, infcmd.c, m2-exp.y, minsyms.c, objfiles.h, solib.c, stack.c, symmisc.c, symtab.c, valops.c: Replace references to minimal symbol fields with appropriate macros. * breakpoint.c, buildsym.c, c-exp.y, c-typeprint.c, c-valprint.c, coffread.c, command.c, convex-tdep.c, cp-valprint.c, dbxread.c, demangle.c, elfread.c, energize.c, environ.c, exec.c, gdbtypes.c, i960-tdep.c, infrun.c, infrun-hacked.c, language.c, main.c, minsyms.c, mipsread.c, partial-stab.h, remote-es1800.c, remote-nindy.c, remote-udi.c, rs6000-tdep.c, solib.c, source.c, sparc-pinsn.c, stabsread.c, standalone.c, state.c, stuff.c, symfile.c, symmisc.c, symtab.c, symtab.h, tm-sysv4.h, tm-ultra3.h, values.c, xcoffexec.c, xcoffread.c: Replace strcmp and strncmp usages with STREQ, STREQN, or STRCMP as appropriate. * breakpoint.c, buildsym.c, c-typeprint.c, expprint.c, findvar.c, mipsread.c, printcmd.c, source.c, stabsread.c, stack.c, symmisc.c, tm-29k.h, valops.c, values.c: Replace SYMBOL_NAME references with SYMBOL_SOURCE_NAME or SYMBOL_LINKAGE_NAME as appropriate. * buildsym.c (start_subfile, patch_subfile_names): Default the source language to what can be deduced from the filename. * buildsym.c (end_symtab): Update the source language in the allocated symtab to match what we have been using. * buildsym.h (struct subfile): Add a language field. * c-typeprint.c (c_print_type): Remove code to do explicit demangling. * dbxread.c (psymtab_language): Add static variable. * dbxread.c (start_psymtab): Initialize psymtab_language using deduce_language_from_filename.
This commit is contained in:
Fred Fish
181
gdb/minsyms.c
181
gdb/minsyms.c
@@ -42,6 +42,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
#include "bfd.h"
|
||||
#include "symfile.h"
|
||||
#include "objfiles.h"
|
||||
#include "demangle.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
|
||||
@@ -105,29 +106,32 @@ lookup_minimal_symbol (name, objf)
|
||||
if (objf == NULL || objf == objfile)
|
||||
{
|
||||
for (msymbol = objfile -> msymbols;
|
||||
msymbol != NULL && msymbol -> name != NULL &&
|
||||
msymbol != NULL && SYMBOL_NAME (msymbol) != NULL &&
|
||||
found_symbol == NULL;
|
||||
msymbol++)
|
||||
{
|
||||
if (strcmp (msymbol -> name, name) == 0)
|
||||
if (SYMBOL_MATCHES_NAME (msymbol, name))
|
||||
{
|
||||
#ifdef IBM6000_TARGET
|
||||
/* I *think* all platforms using shared libraries (and trampoline code)
|
||||
* will suffer this problem. Consider a case where there are 5 shared
|
||||
* libraries, each referencing `foo' with a trampoline entry. When someone
|
||||
* wants to put a breakpoint on `foo' and the only info we have is minimal
|
||||
* symbol vector, we want to use the real `foo', rather than one of those
|
||||
* trampoline entries. MGO */
|
||||
/* If a trampoline symbol is found, we prefer to keep looking
|
||||
for the *real* symbol. If the actual symbol not found,
|
||||
then we'll use the trampoline entry. Sorry for the machine
|
||||
dependent code here, but I hope this will benefit other
|
||||
platforms as well. For trampoline entries, we used mst_unknown
|
||||
earlier. Perhaps we should define a `mst_trampoline' type?? */
|
||||
/* I *think* all platforms using shared libraries (and
|
||||
trampoline code) will suffer this problem. Consider a
|
||||
case where there are 5 shared libraries, each referencing
|
||||
`foo' with a trampoline entry. When someone wants to put
|
||||
a breakpoint on `foo' and the only info we have is minimal
|
||||
symbol vector, we want to use the real `foo', rather than
|
||||
one of those trampoline entries. MGO */
|
||||
/* If a trampoline symbol is found, we prefer to keep looking
|
||||
for the *real* symbol. If the actual symbol not found,
|
||||
then we'll use the trampoline entry. Sorry for the machine
|
||||
dependent code here, but I hope this will benefit other
|
||||
platforms as well. For trampoline entries, we used
|
||||
mst_unknown earlier. Perhaps we should define a
|
||||
`mst_trampoline' type?? */
|
||||
|
||||
if (msymbol->type != mst_unknown)
|
||||
if (MSYMBOL_TYPE (msymbol) != mst_unknown)
|
||||
found_symbol = msymbol;
|
||||
else if (msymbol->type == mst_unknown && !trampoline_symbol)
|
||||
else if (MSYMBOL_TYPE (msymbol) == mst_unknown &&
|
||||
!trampoline_symbol)
|
||||
trampoline_symbol = msymbol;
|
||||
|
||||
#else
|
||||
@@ -197,14 +201,15 @@ lookup_minimal_symbol_by_pc (pc)
|
||||
Warning: this code is trickier than it would appear at first. */
|
||||
|
||||
/* Should also requires that pc is <= end of objfile. FIXME! */
|
||||
if (pc >= msymbol[lo].address)
|
||||
if (pc >= SYMBOL_VALUE_ADDRESS (&msymbol[lo]))
|
||||
{
|
||||
while (msymbol[hi].address > pc)
|
||||
while (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) > pc)
|
||||
{
|
||||
/* pc is still strictly less than highest address */
|
||||
/* Note "new" will always be >= lo */
|
||||
new = (lo + hi) / 2;
|
||||
if ((msymbol[new].address >= pc) || (lo == new))
|
||||
if ((SYMBOL_VALUE_ADDRESS (&msymbol[new]) >= pc) ||
|
||||
(lo == new))
|
||||
{
|
||||
hi = new;
|
||||
}
|
||||
@@ -218,7 +223,8 @@ lookup_minimal_symbol_by_pc (pc)
|
||||
overall. */
|
||||
|
||||
if ((best_symbol == NULL) ||
|
||||
(best_symbol -> address < msymbol[hi].address))
|
||||
(SYMBOL_VALUE_ADDRESS (best_symbol) <
|
||||
SYMBOL_VALUE_ADDRESS (&msymbol[hi])))
|
||||
{
|
||||
best_symbol = &msymbol[hi];
|
||||
}
|
||||
@@ -247,6 +253,7 @@ prim_record_minimal_symbol (name, address, ms_type)
|
||||
enum minimal_symbol_type ms_type;
|
||||
{
|
||||
register struct msym_bunch *new;
|
||||
register struct minimal_symbol *msymbol;
|
||||
|
||||
if (msym_bunch_index == BUNCH_SIZE)
|
||||
{
|
||||
@@ -255,14 +262,25 @@ prim_record_minimal_symbol (name, address, ms_type)
|
||||
new -> next = msym_bunch;
|
||||
msym_bunch = new;
|
||||
}
|
||||
msym_bunch -> contents[msym_bunch_index].name = (char *) name;
|
||||
msym_bunch -> contents[msym_bunch_index].address = address;
|
||||
msym_bunch -> contents[msym_bunch_index].info = NULL;
|
||||
msym_bunch -> contents[msym_bunch_index].type = ms_type;
|
||||
msymbol = &msym_bunch -> contents[msym_bunch_index];
|
||||
SYMBOL_NAME (msymbol) = (char *) name;
|
||||
/* Note that SYMBOL_LANGUAGE and SYMBOL_DEMANGLED_NAME are not initialized
|
||||
to their final values until the minimal symbols are actually added to
|
||||
the minimal symbol table. We just set them to a known state here so
|
||||
random values won't confuse anyone debugging the debugger. */
|
||||
SYMBOL_LANGUAGE (msymbol) = language_unknown;
|
||||
SYMBOL_DEMANGLED_NAME (msymbol) = NULL;
|
||||
SYMBOL_VALUE_ADDRESS (msymbol) = address;
|
||||
MSYMBOL_TYPE (msymbol) = ms_type;
|
||||
/* FIXME: This info, if it remains, needs its own field. */
|
||||
MSYMBOL_INFO (msymbol) = NULL; /* FIXME! */
|
||||
msym_bunch_index++;
|
||||
msym_count++;
|
||||
}
|
||||
|
||||
/* FIXME: Why don't we just combine this function with the one above
|
||||
and pass it a NULL info pointer value if info is not needed? */
|
||||
|
||||
void
|
||||
prim_record_minimal_symbol_and_info (name, address, ms_type, info)
|
||||
const char *name;
|
||||
@@ -271,6 +289,7 @@ prim_record_minimal_symbol_and_info (name, address, ms_type, info)
|
||||
char *info;
|
||||
{
|
||||
register struct msym_bunch *new;
|
||||
register struct minimal_symbol *msymbol;
|
||||
|
||||
if (msym_bunch_index == BUNCH_SIZE)
|
||||
{
|
||||
@@ -279,12 +298,18 @@ prim_record_minimal_symbol_and_info (name, address, ms_type, info)
|
||||
new -> next = msym_bunch;
|
||||
msym_bunch = new;
|
||||
}
|
||||
msym_bunch -> contents[msym_bunch_index].name = (char *) name;
|
||||
msym_bunch -> contents[msym_bunch_index].address = address;
|
||||
msym_bunch -> contents[msym_bunch_index].info = NULL;
|
||||
msym_bunch -> contents[msym_bunch_index].type = ms_type;
|
||||
/* FIXME: This info, if it remains, needs its own field. */
|
||||
msym_bunch -> contents[msym_bunch_index].info = info; /* FIXME! */
|
||||
msymbol = &msym_bunch -> contents[msym_bunch_index];
|
||||
SYMBOL_NAME (msymbol) = (char *) name;
|
||||
/* Note that SYMBOL_LANGUAGE and SYMBOL_DEMANGLED_NAME are not initialized
|
||||
to their final values until the minimal symbols are actually added to
|
||||
the minimal symbol table. We just set them to a known state here so
|
||||
random values won't confuse anyone debugging the debugger. */
|
||||
SYMBOL_LANGUAGE (msymbol) = language_unknown;
|
||||
SYMBOL_DEMANGLED_NAME (msymbol) = NULL;
|
||||
SYMBOL_VALUE_ADDRESS (msymbol) = address;
|
||||
MSYMBOL_TYPE (msymbol) = ms_type;
|
||||
/* FIXME: This info, if it remains, needs its own field. */
|
||||
MSYMBOL_INFO (msymbol) = info; /* FIXME! */
|
||||
msym_bunch_index++;
|
||||
msym_count++;
|
||||
}
|
||||
@@ -303,11 +328,11 @@ compare_minimal_symbols (fn1p, fn2p)
|
||||
fn1 = (const struct minimal_symbol *) fn1p;
|
||||
fn2 = (const struct minimal_symbol *) fn2p;
|
||||
|
||||
if (fn1 -> address < fn2 -> address)
|
||||
if (SYMBOL_VALUE_ADDRESS (fn1) < SYMBOL_VALUE_ADDRESS (fn2))
|
||||
{
|
||||
return (-1);
|
||||
}
|
||||
else if (fn1 -> address > fn2 -> address)
|
||||
else if (SYMBOL_VALUE_ADDRESS (fn1) > SYMBOL_VALUE_ADDRESS (fn2))
|
||||
{
|
||||
return (1);
|
||||
}
|
||||
@@ -389,12 +414,13 @@ compact_minimal_symbols (msymbol, mcount)
|
||||
copyfrom = copyto = msymbol;
|
||||
while (copyfrom < msymbol + mcount - 1)
|
||||
{
|
||||
if (copyfrom -> address == (copyfrom + 1) -> address
|
||||
&& (strcmp (copyfrom -> name, (copyfrom + 1) -> name) == 0))
|
||||
if (SYMBOL_VALUE_ADDRESS (copyfrom) ==
|
||||
SYMBOL_VALUE_ADDRESS ((copyfrom + 1)) &&
|
||||
(STREQ (SYMBOL_NAME (copyfrom), SYMBOL_NAME ((copyfrom + 1)))))
|
||||
{
|
||||
if ((copyfrom + 1) -> type == mst_unknown)
|
||||
if (MSYMBOL_TYPE((copyfrom + 1)) == mst_unknown)
|
||||
{
|
||||
(copyfrom + 1) -> type = copyfrom -> type;
|
||||
MSYMBOL_TYPE ((copyfrom + 1)) = MSYMBOL_TYPE (copyfrom);
|
||||
}
|
||||
copyfrom++;
|
||||
}
|
||||
@@ -409,11 +435,28 @@ compact_minimal_symbols (msymbol, mcount)
|
||||
return (mcount);
|
||||
}
|
||||
|
||||
/* Add the minimal symbols in the existing bunches to the objfile's
|
||||
official minimal symbol table. 99% of the time, this adds the
|
||||
bunches to NO existing symbols. Once in a while for shared
|
||||
libraries, we add symbols (e.g. common symbols) to an existing
|
||||
objfile. */
|
||||
/* 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
|
||||
in a while (for shared libraries for example), we add symbols (e.g. common
|
||||
symbols) to an existing objfile.
|
||||
|
||||
Because of the way minimal symbols are collected, we generally have no way
|
||||
of knowing what source language applies to any particular minimal symbol.
|
||||
Specifically, we have no way of knowing if the minimal symbol comes from a
|
||||
C++ compilation unit or not. So for the sake of supporting cached
|
||||
demangled C++ names, we have no choice but to try and demangle each new one
|
||||
that comes in. If the demangling succeeds, then we assume it is a C++
|
||||
symbol and set the symbol's language and demangled name fields
|
||||
appropriately. Note that in order to avoid unnecessary demanglings, and
|
||||
allocating obstack space that subsequently can't be freed for the demangled
|
||||
names, we mark all newly added symbols with language_auto. After
|
||||
compaction of the minimal symbols, we go back and scan the entire minimal
|
||||
symbol table looking for these new symbols. For each new symbol we attempt
|
||||
to demangle it, and if successful, record it as a language_cplus symbol
|
||||
and cache the demangled form on the symbol obstack. Symbols which don't
|
||||
demangle are marked as language_unknown symbols, which inhibits future
|
||||
attempts to demangle them if we later add more minimal symbols. */
|
||||
|
||||
void
|
||||
install_minimal_symbols (objfile)
|
||||
@@ -425,6 +468,7 @@ install_minimal_symbols (objfile)
|
||||
register struct minimal_symbol *msymbols;
|
||||
int alloc_count;
|
||||
register char leading_char;
|
||||
char *demangled_name;
|
||||
|
||||
if (msym_count > 0)
|
||||
{
|
||||
@@ -459,9 +503,10 @@ install_minimal_symbols (objfile)
|
||||
for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++)
|
||||
{
|
||||
msymbols[mcount] = bunch -> contents[bindex];
|
||||
if (msymbols[mcount].name[0] == leading_char)
|
||||
SYMBOL_LANGUAGE (&msymbols[mcount]) = language_auto;
|
||||
if (SYMBOL_NAME (&msymbols[mcount])[0] == leading_char)
|
||||
{
|
||||
msymbols[mcount].name++;
|
||||
SYMBOL_NAME(&msymbols[mcount])++;
|
||||
}
|
||||
}
|
||||
msym_bunch_index = BUNCH_SIZE;
|
||||
@@ -482,19 +527,20 @@ install_minimal_symbols (objfile)
|
||||
msymbols = (struct minimal_symbol *)
|
||||
obstack_finish (&objfile->symbol_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 easier to find the end of the table
|
||||
when we are handed a pointer to some symbol in the middle of it.
|
||||
Zero out the fields in the "null symbol" allocated at the end
|
||||
of the array. Note that the symbol count does *not* include
|
||||
this null symbol, which is why it is indexed by mcount and not
|
||||
mcount-1. */
|
||||
/* We also terminate the minimal symbol table with a "null symbol",
|
||||
which is *not* included in the size of the table. This makes it
|
||||
easier to find the end of the table when we are handed a pointer
|
||||
to some symbol in the middle of it. Zero out the fields in the
|
||||
"null symbol" allocated at the end of the array. Note that the
|
||||
symbol count does *not* include this null symbol, which is why it
|
||||
is indexed by mcount and not mcount-1. */
|
||||
|
||||
msymbols[mcount].name = NULL;
|
||||
msymbols[mcount].address = 0;
|
||||
msymbols[mcount].info = NULL;
|
||||
msymbols[mcount].type = mst_unknown;
|
||||
SYMBOL_NAME (&msymbols[mcount]) = NULL;
|
||||
SYMBOL_VALUE_ADDRESS (&msymbols[mcount]) = 0;
|
||||
MSYMBOL_INFO (&msymbols[mcount]) = NULL;
|
||||
MSYMBOL_TYPE (&msymbols[mcount]) = mst_unknown;
|
||||
SYMBOL_LANGUAGE (&msymbols[mcount]) = language_unknown;
|
||||
SYMBOL_DEMANGLED_NAME (&msymbols[mcount]) = NULL;
|
||||
|
||||
/* Attach the minimal symbol table to the specified objfile.
|
||||
The strings themselves are also located in the symbol_obstack
|
||||
@@ -502,6 +548,31 @@ install_minimal_symbols (objfile)
|
||||
|
||||
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. */
|
||||
|
||||
for ( ; mcount-- > 0 ; msymbols++)
|
||||
{
|
||||
if (SYMBOL_LANGUAGE (msymbols) == language_auto)
|
||||
{
|
||||
demangled_name = cplus_demangle (SYMBOL_NAME (msymbols),
|
||||
DMGL_PARAMS | DMGL_ANSI);
|
||||
if (demangled_name == NULL)
|
||||
{
|
||||
SYMBOL_LANGUAGE (msymbols) = language_unknown;
|
||||
}
|
||||
else
|
||||
{
|
||||
SYMBOL_LANGUAGE (msymbols) = language_cplus;
|
||||
SYMBOL_DEMANGLED_NAME (msymbols) =
|
||||
obsavestring (demangled_name, strlen (demangled_name),
|
||||
&objfile->symbol_obstack);
|
||||
|
||||
free (demangled_name);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user