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];
Obviously, there must be distinct mangled names for each of these,
but the demangled names are all the same: S::S or S::~S. */
-static struct bound_minimal_symbol
-lookup_minimal_symbol_internal (const char *name, const char *sfile,
- struct objfile *objf)
+struct bound_minimal_symbol
+lookup_minimal_symbol (const char *name, const char *sfile,
+ struct objfile *objf)
{
struct objfile *objfile;
struct bound_minimal_symbol found_symbol = { NULL, NULL };
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);
}
/* See minsyms.h. */
-struct minimal_symbol *
-lookup_minimal_symbol (const char *name, const char *sfile,
- struct objfile *objf)
-{
- struct bound_minimal_symbol bms = lookup_minimal_symbol_internal (name,
- sfile,
- objf);
-
- return bms.minsym;
-}
-
-/* See minsyms.h. */
-
struct bound_minimal_symbol
lookup_bound_minimal_symbol (const char *name)
{
- return lookup_minimal_symbol_internal (name, NULL, NULL);
+ 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
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 (objfile, &msymbol[hi]) != NULL
+ && MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi]) != NULL
&& (!matching_obj_sections
- (SYMBOL_OBJ_SECTION (objfile, &msymbol[hi]),
+ (MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi]),
section)))
{
hi--;
&& 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 (objfile, &msymbol[hi])
- == SYMBOL_OBJ_SECTION (objfile, &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;
msym != NULL;
msym = msym->hash_next)
{
- if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0)
+ if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
{
result.minsym = msym;
result.objfile = objfile;
msym_bunch = new;
}
msymbol = &msym_bunch->contents[msym_bunch_index];
- SYMBOL_SET_LANGUAGE (msymbol, language_auto, &objfile->objfile_obstack);
- 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;
+ SET_MSYMBOL_VALUE_ADDRESS (msymbol, address);
+ MSYMBOL_SECTION (msymbol) = section;
MSYMBOL_TYPE (msymbol) = ms_type;
MSYMBOL_TARGET_FLAG_1 (msymbol) = 0;
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);
}
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, &objfile->objfile_obstack);
+ MSYMBOL_SET_LANGUAGE (m, language_unknown, &objfile->objfile_obstack);
}
}
{
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;
}
}
of the section, as the end of the function. */
if (MSYMBOL_SIZE (minsym.minsym) != 0)
- return SYMBOL_VALUE_ADDRESS (minsym.minsym) + MSYMBOL_SIZE (minsym.minsym);
+ 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 = SYMBOL_SECTION (msymbol);
- for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
+ section = MSYMBOL_SECTION (msymbol);
+ for (i = 1; MSYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
{
- if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
- && SYMBOL_SECTION (msymbol + i) == section)
+ if (MSYMBOL_VALUE_ADDRESS (msymbol + i) != MSYMBOL_VALUE_ADDRESS (msymbol)
+ && MSYMBOL_SECTION (msymbol + i) == section)
break;
}
- obj_section = SYMBOL_OBJ_SECTION (minsym.objfile, minsym.minsym);
- if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL
- && SYMBOL_VALUE_ADDRESS (msymbol + i) < obj_section_endaddr (obj_section))
- result = SYMBOL_VALUE_ADDRESS (msymbol + i);
+ 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. */
projects / deliverable / binutils-gdb.git / blobdiff