/* GDB routines for manipulating the minimal symbol tables.
- Copyright (C) 1992-2004, 2007-2012 Free Software Foundation, Inc.
+ Copyright (C) 1992-2014 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
This file is part of GDB.
#include "defs.h"
#include <ctype.h>
-#include "gdb_string.h"
+#include <string.h>
#include "symtab.h"
#include "bfd.h"
#include "filenames.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
while (*string && *string != '(')
{
- while (isspace (*string))
- ++string;
+ string = skip_spaces_const (string);
if (*string && *string != '(')
{
hash = SYMBOL_HASH_NEXT (hash, *string);
if (sym->hash_next == NULL)
{
unsigned int hash
- = msymbol_hash (SYMBOL_LINKAGE_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE;
+ = msymbol_hash (MSYMBOL_LINKAGE_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_SEARCH_NAME (sym))
+ unsigned int hash = msymbol_hash_iw (MSYMBOL_SEARCH_NAME (sym))
% MINIMAL_SYMBOL_HASH_SIZE;
sym->demangled_hash_next = table[hash];
}
}
-/* 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
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 *
+struct bound_minimal_symbol
lookup_minimal_symbol (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;
}
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)
{
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)
else
msymbol = objfile->msymbol_demangled_hash[dem_hash];
- while (msymbol != NULL && found_symbol == NULL)
+ while (msymbol != NULL && found_symbol.minsym == NULL)
{
int match;
cmp = (case_sensitivity == case_sensitive_on
? strcmp : strcasecmp);
- match = cmp (SYMBOL_LINKAGE_NAME (msymbol),
+ match = cmp (MSYMBOL_LINKAGE_NAME (msymbol),
modified_name) == 0;
}
else
{
/* The function respects CASE_SENSITIVITY. */
- match = SYMBOL_MATCHES_SEARCH_NAME (msymbol,
+ match = MSYMBOL_MATCHES_SEARCH_NAME (msymbol,
modified_name);
}
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:
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;
}
}
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 trampoline_symbol;
+}
- return NULL;
+/* See minsyms.h. */
+
+struct bound_minimal_symbol
+lookup_bound_minimal_symbol (const char *name)
+{
+ return lookup_minimal_symbol (name, NULL, NULL);
}
/* See minsyms.h. */
cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
while (iter)
{
- if (cmp (SYMBOL_LINKAGE_NAME (iter), name) == 0)
+ if (cmp (MSYMBOL_LINKAGE_NAME (iter), name) == 0)
(*callback) (iter, user_data);
iter = iter->hash_next;
}
iter = objf->msymbol_demangled_hash[hash];
while (iter)
{
- if (SYMBOL_MATCHES_SEARCH_NAME (iter, name))
+ if (MSYMBOL_MATCHES_SEARCH_NAME (iter, name))
(*callback) (iter, user_data);
iter = iter->demangled_hash_next;
}
/* See minsyms.h. */
-struct minimal_symbol *
+struct bound_minimal_symbol
lookup_minimal_symbol_text (const char *name, struct objfile *objf)
{
struct objfile *objfile;
struct minimal_symbol *msymbol;
- struct minimal_symbol *found_symbol = NULL;
- struct minimal_symbol *found_file_symbol = NULL;
+ struct bound_minimal_symbol found_symbol = { NULL, NULL };
+ struct bound_minimal_symbol found_file_symbol = { NULL, NULL };
unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
for (objfile = object_files;
- objfile != NULL && found_symbol == NULL;
+ objfile != NULL && found_symbol.minsym == NULL;
objfile = objfile->next)
{
if (objf == NULL || objf == objfile
|| objf == objfile->separate_debug_objfile_backlink)
{
for (msymbol = objfile->msymbol_hash[hash];
- msymbol != NULL && found_symbol == NULL;
+ msymbol != NULL && found_symbol.minsym == NULL;
msymbol = msymbol->hash_next)
{
- if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
+ if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
(MSYMBOL_TYPE (msymbol) == mst_text
|| MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc
|| MSYMBOL_TYPE (msymbol) == mst_file_text))
switch (MSYMBOL_TYPE (msymbol))
{
case mst_file_text:
- found_file_symbol = msymbol;
+ found_file_symbol.minsym = msymbol;
+ found_file_symbol.objfile = objfile;
break;
default:
- found_symbol = msymbol;
+ found_symbol.minsym = msymbol;
+ found_symbol.objfile = objfile;
break;
}
}
}
}
/* External symbols are best. */
- if (found_symbol)
+ if (found_symbol.minsym)
return found_symbol;
/* File-local symbols are next best. */
- if (found_file_symbol)
- return found_file_symbol;
-
- return NULL;
+ return found_file_symbol;
}
/* See minsyms.h. */
msymbol != NULL;
msymbol = msymbol->hash_next)
{
- if (SYMBOL_VALUE_ADDRESS (msymbol) == pc
- && strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0)
+ if (MSYMBOL_VALUE_ADDRESS (msymbol) == pc
+ && strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0)
return msymbol;
}
}
/* See minsyms.h. */
-struct minimal_symbol *
+struct bound_minimal_symbol
lookup_minimal_symbol_solib_trampoline (const char *name,
struct objfile *objf)
{
struct objfile *objfile;
struct minimal_symbol *msymbol;
- struct minimal_symbol *found_symbol = NULL;
+ struct bound_minimal_symbol found_symbol = { NULL, NULL };
unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
for (objfile = object_files;
- objfile != NULL && found_symbol == NULL;
+ objfile != NULL;
objfile = objfile->next)
{
if (objf == NULL || objf == objfile
|| objf == objfile->separate_debug_objfile_backlink)
{
for (msymbol = objfile->msymbol_hash[hash];
- msymbol != NULL && found_symbol == NULL;
+ msymbol != NULL;
msymbol = msymbol->hash_next)
{
- if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
+ if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
- return msymbol;
+ {
+ found_symbol.objfile = objfile;
+ found_symbol.minsym = msymbol;
+ return found_symbol;
+ }
}
}
}
- return NULL;
+ return found_symbol;
}
/* Search through the minimal symbol table for each objfile and find
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)
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;
Warning: this code is trickier than it would appear at first. */
/* Should also require that pc is <= end of objfile. FIXME! */
- if (pc >= SYMBOL_VALUE_ADDRESS (&msymbol[lo]))
+ if (pc >= MSYMBOL_VALUE_ADDRESS (&msymbol[lo]))
{
- while (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) > pc)
+ while (MSYMBOL_VALUE_ADDRESS (&msymbol[hi]) > pc)
{
/* pc is still strictly less than highest address. */
/* Note "new" will always be >= lo. */
new = (lo + hi) / 2;
- if ((SYMBOL_VALUE_ADDRESS (&msymbol[new]) >= pc) ||
+ if ((MSYMBOL_VALUE_ADDRESS (&msymbol[new]) >= pc) ||
(lo == new))
{
hi = new;
hi to point to the last one. That way we can find the
right symbol if it has an index greater than hi. */
while (hi < objfile->minimal_symbol_count - 1
- && (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
- == SYMBOL_VALUE_ADDRESS (&msymbol[hi + 1])))
+ && (MSYMBOL_VALUE_ADDRESS (&msymbol[hi])
+ == MSYMBOL_VALUE_ADDRESS (&msymbol[hi + 1])))
hi++;
/* Skip various undesirable symbols. */
/* 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
+ && MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi]) != NULL
&& (!matching_obj_sections
- (SYMBOL_OBJ_SECTION (&msymbol[hi]), section)))
+ (MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi]),
+ section)))
{
hi--;
continue;
&& 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])))
+ && (MSYMBOL_VALUE_ADDRESS (&msymbol[hi])
+ == MSYMBOL_VALUE_ADDRESS (&msymbol[hi - 1]))
+ && (MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi])
+ == MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi - 1])))
{
hi--;
continue;
the cancellable variants, but both have sizes. */
if (hi > 0
&& MSYMBOL_SIZE (&msymbol[hi]) != 0
- && pc >= (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
+ && pc >= (MSYMBOL_VALUE_ADDRESS (&msymbol[hi])
+ MSYMBOL_SIZE (&msymbol[hi]))
- && pc < (SYMBOL_VALUE_ADDRESS (&msymbol[hi - 1])
+ && pc < (MSYMBOL_VALUE_ADDRESS (&msymbol[hi - 1])
+ MSYMBOL_SIZE (&msymbol[hi - 1])))
{
hi--;
if (hi >= 0
&& MSYMBOL_SIZE (&msymbol[hi]) != 0
- && pc >= (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
+ && pc >= (MSYMBOL_VALUE_ADDRESS (&msymbol[hi])
+ MSYMBOL_SIZE (&msymbol[hi])))
{
if (best_zero_sized != -1)
if (hi >= 0
&& ((best_symbol == NULL) ||
- (SYMBOL_VALUE_ADDRESS (best_symbol) <
- SYMBOL_VALUE_ADDRESS (&msymbol[hi]))))
+ (MSYMBOL_VALUE_ADDRESS (best_symbol) <
+ MSYMBOL_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)
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. */
/* 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;
msym != NULL;
msym = msym->hash_next)
{
- if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0)
+ if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
{
- *objfile_p = objfile;
- return msym;
+ result.minsym = msym;
+ result.objfile = objfile;
+ return result;
}
}
}
- return 0;
+ memset (&result, 0, sizeof (result));
+ return result;
}
\f
/* Return leading symbol character for a BFD. If BFD is NULL,
return the leading symbol character from the main objfile. */
-static int get_symbol_leading_char (bfd *);
-
static int
get_symbol_leading_char (bfd *abfd)
{
}
prim_record_minimal_symbol_and_info (name, address, ms_type,
- section, NULL, objfile);
+ section, objfile);
}
/* See minsyms.h. */
CORE_ADDR address,
enum minimal_symbol_type ms_type,
int section,
- asection *bfd_section,
struct objfile *objfile)
{
struct obj_section *obj_section;
if (msym_bunch_index == BUNCH_SIZE)
{
- new = XCALLOC (1, struct msym_bunch);
+ new = XCNEW (struct msym_bunch);
msym_bunch_index = 0;
new->next = msym_bunch;
msym_bunch = new;
}
msymbol = &msym_bunch->contents[msym_bunch_index];
- SYMBOL_SET_LANGUAGE (msymbol, language_auto);
- SYMBOL_SET_NAMES (msymbol, name, name_len, copy_name, objfile);
+ MSYMBOL_SET_LANGUAGE (msymbol, language_auto, &objfile->objfile_obstack);
+ MSYMBOL_SET_NAMES (msymbol, name, name_len, copy_name, objfile);
- SYMBOL_VALUE_ADDRESS (msymbol) = address;
- SYMBOL_SECTION (msymbol) = section;
- SYMBOL_OBJ_SECTION (msymbol) = NULL;
-
- /* Find obj_section corresponding to bfd_section. */
- if (bfd_section)
- ALL_OBJFILE_OSECTIONS (objfile, obj_section)
- {
- if (obj_section->the_bfd_section == bfd_section)
- {
- SYMBOL_OBJ_SECTION (msymbol) = obj_section;
- break;
- }
- }
+ SET_MSYMBOL_VALUE_ADDRESS (msymbol, address);
+ MSYMBOL_SECTION (msymbol) = section;
MSYMBOL_TYPE (msymbol) = ms_type;
MSYMBOL_TARGET_FLAG_1 (msymbol) = 0;
prim_record_minimal_symbol_and_info (const char *name, CORE_ADDR address,
enum minimal_symbol_type ms_type,
int section,
- asection *bfd_section,
struct objfile *objfile)
{
return prim_record_minimal_symbol_full (name, strlen (name), 1,
- address, ms_type, section,
- bfd_section, objfile);
+ address, ms_type,
+ section, objfile);
}
/* Compare two minimal symbols by address and return a signed result based
fn1 = (const struct minimal_symbol *) fn1p;
fn2 = (const struct minimal_symbol *) fn2p;
- if (SYMBOL_VALUE_ADDRESS (fn1) < SYMBOL_VALUE_ADDRESS (fn2))
+ if (MSYMBOL_VALUE_ADDRESS (fn1) < MSYMBOL_VALUE_ADDRESS (fn2))
{
return (-1); /* addr 1 is less than addr 2. */
}
- else if (SYMBOL_VALUE_ADDRESS (fn1) > SYMBOL_VALUE_ADDRESS (fn2))
+ else if (MSYMBOL_VALUE_ADDRESS (fn1) > MSYMBOL_VALUE_ADDRESS (fn2))
{
return (1); /* addr 1 is greater than addr 2. */
}
else
/* addrs are equal: sort by name */
{
- const char *name1 = SYMBOL_LINKAGE_NAME (fn1);
- const char *name2 = SYMBOL_LINKAGE_NAME (fn2);
+ const char *name1 = MSYMBOL_LINKAGE_NAME (fn1);
+ const char *name2 = MSYMBOL_LINKAGE_NAME (fn2);
if (name1 && name2) /* both have names */
return strcmp (name1, name2);
copyfrom = copyto = msymbol;
while (copyfrom < msymbol + mcount - 1)
{
- if (SYMBOL_VALUE_ADDRESS (copyfrom)
- == SYMBOL_VALUE_ADDRESS ((copyfrom + 1))
- && strcmp (SYMBOL_LINKAGE_NAME (copyfrom),
- SYMBOL_LINKAGE_NAME ((copyfrom + 1))) == 0)
+ if (MSYMBOL_VALUE_ADDRESS (copyfrom)
+ == MSYMBOL_VALUE_ADDRESS ((copyfrom + 1))
+ && strcmp (MSYMBOL_LINKAGE_NAME (copyfrom),
+ MSYMBOL_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_SEARCH_NAME (msym) != SYMBOL_LINKAGE_NAME (msym))
+ if (MSYMBOL_SEARCH_NAME (msym) != MSYMBOL_LINKAGE_NAME (msym))
add_minsym_to_demangled_hash_table (msym,
objfile->msymbol_demangled_hash);
}
{
fprintf_unfiltered (gdb_stdlog,
"Installing %d minimal symbols of objfile %s.\n",
- msym_count, objfile->name);
+ msym_count, objfile_name (objfile));
}
/* Allocate enough space in the obstack, into which we will gather the
objfile->minimal_symbol_count = mcount;
objfile->msymbols = msymbols;
- /* 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++)
- {
- /* If a symbol's name starts with _Z and was successfully
- demangled, then we can assume we've found a GNU v3 symbol.
- For now we set the C++ ABI globally; if the user is
- mixing ABIs then the user will need to "set cp-abi"
- manually. */
- const char *name = SYMBOL_LINKAGE_NAME (&objfile->msymbols[i]);
-
- if (name[0] == '_' && name[1] == 'Z'
- && SYMBOL_DEMANGLED_NAME (&objfile->msymbols[i]) != NULL)
- {
- set_cp_abi_as_auto_default ("gnu-v3");
- break;
- }
- }
- }
-
/* 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
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);
+ MSYMBOL_SET_LANGUAGE (m, language_unknown, &objfile->objfile_obstack);
}
}
build_minimal_symbol_hash_tables (objfile);
}
-/* See minsyms.h. */
+/* 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. */
-struct minimal_symbol *
+static struct minimal_symbol *
lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc)
{
struct obj_section *section = find_pc_section (pc);
- struct minimal_symbol *msymbol;
+ struct bound_minimal_symbol msymbol;
if (section == NULL)
return NULL;
msymbol = lookup_minimal_symbol_by_pc_section_1 (pc, section, 1);
- if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
- return msymbol;
+ if (msymbol.minsym != NULL
+ && MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
+ return msymbol.minsym;
return NULL;
}
{
if ((MSYMBOL_TYPE (msymbol) == mst_text
|| MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc)
- && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
- SYMBOL_LINKAGE_NAME (tsymbol)) == 0)
- return SYMBOL_VALUE_ADDRESS (msymbol);
+ && strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
+ MSYMBOL_LINKAGE_NAME (tsymbol)) == 0)
+ return MSYMBOL_VALUE_ADDRESS (msymbol);
/* Also handle minimal symbols pointing to function descriptors. */
if (MSYMBOL_TYPE (msymbol) == mst_data
- && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
- SYMBOL_LINKAGE_NAME (tsymbol)) == 0)
+ && strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
+ MSYMBOL_LINKAGE_NAME (tsymbol)) == 0)
{
CORE_ADDR func;
func = gdbarch_convert_from_func_ptr_addr
(get_objfile_arch (objfile),
- SYMBOL_VALUE_ADDRESS (msymbol),
+ MSYMBOL_VALUE_ADDRESS (msymbol),
¤t_target);
/* Ignore data symbols that are not function descriptors. */
- if (func != SYMBOL_VALUE_ADDRESS (msymbol))
+ if (func != MSYMBOL_VALUE_ADDRESS (msymbol))
return func;
}
}
}
return 0;
}
+
+/* See minsyms.h. */
+
+CORE_ADDR
+minimal_symbol_upper_bound (struct bound_minimal_symbol minsym)
+{
+ int i;
+ short section;
+ struct obj_section *obj_section;
+ CORE_ADDR result;
+ struct minimal_symbol *msymbol;
+
+ gdb_assert (minsym.minsym != NULL);
+
+ /* If the minimal symbol has a size, use it. Otherwise use the
+ lesser of the next minimal symbol in the same section, or the end
+ of the section, as the end of the function. */
+
+ if (MSYMBOL_SIZE (minsym.minsym) != 0)
+ return MSYMBOL_VALUE_ADDRESS (minsym.minsym) + MSYMBOL_SIZE (minsym.minsym);
+
+ /* Step over other symbols at this same address, and symbols in
+ other sections, to find the next symbol in this section with a
+ different address. */
+
+ msymbol = minsym.minsym;
+ section = MSYMBOL_SECTION (msymbol);
+ for (i = 1; MSYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
+ {
+ if (MSYMBOL_VALUE_ADDRESS (msymbol + i) != MSYMBOL_VALUE_ADDRESS (msymbol)
+ && MSYMBOL_SECTION (msymbol + i) == section)
+ break;
+ }
+
+ obj_section = MSYMBOL_OBJ_SECTION (minsym.objfile, minsym.minsym);
+ if (MSYMBOL_LINKAGE_NAME (msymbol + i) != NULL
+ && (MSYMBOL_VALUE_ADDRESS (msymbol + i)
+ < obj_section_endaddr (obj_section)))
+ result = MSYMBOL_VALUE_ADDRESS (msymbol + i);
+ else
+ /* We got the start address from the last msymbol in the objfile.
+ So the end address is the end of the section. */
+ result = obj_section_endaddr (obj_section);
+
+ return result;
+}
projects / deliverable / binutils-gdb.git / blobdiff