to figure out what full symbol table entries need to be read in. */
-#include <stdio.h>
#include "defs.h"
#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,, 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
a pointer to the minimal symbol that matches, or NULL if no match is found.
- Note: One instance where their may be duplicate minimal symbols with
+ 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). */
struct objfile *objfile;
struct minimal_symbol *msymbol;
struct minimal_symbol *found_symbol = NULL;
+#ifdef IBM6000_TARGET
+ struct minimal_symbol *trampoline_symbol = NULL;
+#endif
for (objfile = object_files;
objfile != NULL && found_symbol == NULL;
{
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 */
+ /* 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)
+ found_symbol = msymbol;
+ else if (msymbol->type == mst_unknown && !trampoline_symbol)
+ trampoline_symbol = msymbol;
+
+#else
found_symbol = msymbol;
+#endif
}
}
}
}
+#ifdef IBM6000_TARGET
+ return found_symbol ? found_symbol : trampoline_symbol;
+#endif
+
return (found_symbol);
}
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;
}
}
register int mcount;
register struct msym_bunch *bunch;
register struct minimal_symbol *msymbols;
- int nbytes;
int alloc_count;
if (msym_count > 0)
projects / deliverable / binutils-gdb.git / blobdiff