#include "symtab.h"
#include "bfd.h"
#include "symfile.h"
+#include "objfiles.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
static int
compact_minimal_symbols PARAMS ((struct minimal_symbol *, int));
-/* Call the function specified by FUNC for each currently available minimal
- symbol, for as long as this function continues to return NULL. If the
- function ever returns non-NULL, then the iteration over the minimal
- symbols is terminated and the result is returned to the caller.
-
- The function called has full control over the form and content of the
- information returned via the non-NULL result, which may be as simple as a
- pointer to the minimal symbol that the iteration terminated on, or as
- complex as a pointer to a private structure containing multiple results. */
-
-PTR
-iterate_over_msymbols (func, arg1, arg2, arg3)
- PTR (*func) PARAMS ((struct objfile *, struct minimal_symbol *,
- PTR, PTR, PTR));
- PTR arg1;
- PTR arg2;
- PTR arg3;
-{
- register struct objfile *objfile;
- register struct minimal_symbol *msymbol;
- char *result = NULL;
-
- for (objfile = object_files;
- objfile != NULL && result == NULL;
- objfile = objfile -> next)
- {
- for (msymbol = objfile -> msymbols;
- msymbol != NULL && msymbol -> name != NULL && result == NULL;
- msymbol++)
- {
- result = (*func)(objfile, msymbol, arg1, arg2, arg3);
- }
- }
- return (result);
-}
-
/* Look through all the current minimal symbol tables and find the first
minimal symbol that matches NAME. If OBJF is non-NULL, it specifies a
particular objfile and the search is limited to that objfile. Returns
struct objfile *objfile;
struct minimal_symbol *msymbol;
struct minimal_symbol *found_symbol = NULL;
-#ifdef IBM6000
+#ifdef IBM6000_TARGET
struct minimal_symbol *trampoline_symbol = NULL;
#endif
{
if (strcmp (msymbol -> name, name) == 0)
{
+#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 */
-#ifdef IBM6000
/* 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
}
}
}
-#ifdef IBM6000
+#ifdef IBM6000_TARGET
return found_symbol ? found_symbol : trampoline_symbol;
#endif
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)
{
while (msymbol[hi].address > pc)
msym_count++;
}
+void
+prim_record_minimal_symbol_and_info (name, address, ms_type, info)
+ const char *name;
+ CORE_ADDR address;
+ enum minimal_symbol_type ms_type;
+ char *info;
+{
+ register struct msym_bunch *new;
+
+ if (msym_bunch_index == BUNCH_SIZE)
+ {
+ new = (struct msym_bunch *) xmalloc (sizeof (struct msym_bunch));
+ msym_bunch_index = 0;
+ 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! */
+ msym_bunch_index++;
+ msym_count++;
+}
+
/* Compare two minimal symbols by address and return a signed result based
on unsigned comparisons, so that we sort into unsigned numeric order. */
while (msym_bunch != NULL)
{
next = msym_bunch -> next;
- free (msym_bunch);
+ free ((PTR)msym_bunch);
msym_bunch = next;
}
}