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;
}
}
/* Compact duplicate entries out of a minimal symbol table by walking
through the table and compacting out entries with duplicate addresses
- and matching names.
+ and matching names. Return the number of entries remaining.
+
+ On entry, the table resides between msymbol[0] and msymbol[mcount].
+ On exit, it resides between msymbol[0] and msymbol[result_count].
When files contain multiple sources of symbol information, it is
possible for the minimal symbol table to contain many duplicate entries.
over a 1000 duplicates, about a third of the total table size. Aside
from the potential trap of not noticing that two successive entries
identify the same location, this duplication impacts the time required
- to linearly scan the table, which is done in a number of places. So
+ to linearly scan the table, which is done in a number of places. So we
just do one linear scan here and toss out the duplicates.
Note that we are not concerned here about recovering the space that
is potentially freed up, because the strings themselves are allocated
on the symbol_obstack, and will get automatically freed when the symbol
- table is freed. Also, the unused minimal symbols at the end of the
- compacted region will get freed automatically as well by whomever
- is responsible for deallocating the entire minimal symbol table. We
- can't diddle with the pointer anywhy, so don't worry about the
- wasted space.
+ table is freed. The caller can free up the unused minimal symbols at
+ the end of the compacted region if their allocation strategy allows it.
Also note we only go up to the next to last entry within the loop
and then copy the last entry explicitly after the loop terminates.
return (mcount);
}
-/* INCLINK nonzero means bunches are from an incrementally-linked file.
- Add them to the existing bunches.
- Otherwise INCLINK is zero, and we start from scratch.
-
- FIXME: INCLINK is currently unused, and is a holdover from when all
- these symbols were stored in a shared, globally available table. If
- it turns out we still need to be able to incrementally add minimal
- symbols to an existing minimal symbol table for a given objfile, then
- we will need to slightly modify this code so that when INCLINK is
- nonzero we copy the existing table to a work area that is allocated
- large enough for all the symbols and add the new ones to the end. */
+/* 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. */
void
-install_minimal_symbols (inclink, objfile)
- int inclink;
+install_minimal_symbols (objfile)
struct objfile *objfile;
{
register int bindex;
register int mcount;
register struct msym_bunch *bunch;
register struct minimal_symbol *msymbols;
- int nbytes;
+ int alloc_count;
if (msym_count > 0)
{
- /* Allocate a temporary work area into which we will gather the
- bunches of minimal symbols, sort them, and then compact out
- duplicate entries. Once we have a final table, it will be attached
- to the specified objfile. */
-
+ /* Allocate enough space in the obstack, into which we will gather the
+ bunches of new and existing minimal symbols, sort them, and then
+ compact out the duplicate entries. Once we have a final table,
+ we will give back the excess space. */
+
+ alloc_count = msym_count + objfile->minimal_symbol_count + 1;
+ obstack_blank (&objfile->symbol_obstack,
+ alloc_count * sizeof (struct minimal_symbol));
msymbols = (struct minimal_symbol *)
- xmalloc (msym_count * sizeof (struct minimal_symbol));
- mcount = 0;
-
+ obstack_base (&objfile->symbol_obstack);
+
+ /* Copy in the existing minimal symbols, if there are any. */
+
+ if (objfile->minimal_symbol_count)
+ memcpy ((char *)msymbols, (char *)objfile->msymbols,
+ objfile->minimal_symbol_count * sizeof (struct minimal_symbol));
+
/* Walk through the list of minimal symbol bunches, adding each symbol
to the new contiguous array of symbols. Note that we start with the
current, possibly partially filled bunch (thus we use the current
msym_bunch_index for the first bunch we copy over), and thereafter
each bunch is full. */
+ mcount = objfile->minimal_symbol_count;
+
for (bunch = msym_bunch; bunch != NULL; bunch = bunch -> next)
{
for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++)
}
msym_bunch_index = BUNCH_SIZE;
}
-
+
/* Sort the minimal symbols by address. */
qsort (msymbols, mcount, sizeof (struct minimal_symbol),
compare_minimal_symbols);
- /* Compact out any duplicates. The table is reallocated to a
- smaller size, even though it is unnecessary here, as we are just
- going to move everything to an obstack anyway. */
+ /* Compact out any duplicates, and free up whatever space we are
+ no longer using. */
mcount = compact_minimal_symbols (msymbols, mcount);
-
- /* Attach the minimal symbol table to the specified objfile, allocating
- the table entries in the symbol_obstack. Note that the strings them-
- selves are already located in the 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. */
-
- objfile -> minimal_symbol_count = mcount;
- nbytes = (mcount + 1) * sizeof (struct minimal_symbol);
- objfile -> msymbols = (struct minimal_symbol *)
- obstack_alloc (&objfile -> symbol_obstack, nbytes);
- memcpy (objfile -> msymbols, msymbols, nbytes);
- free (msymbols);
- /* Zero out the fields in the "null symbol" allocated at the end
+ obstack_blank (&objfile->symbol_obstack,
+ (mcount + 1 - alloc_count) * sizeof (struct minimal_symbol));
+ 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. */
- objfile -> msymbols[mcount].name = NULL;
- objfile -> msymbols[mcount].address = 0;
- objfile -> msymbols[mcount].info = NULL;
- objfile -> msymbols[mcount].type = mst_unknown;
+ msymbols[mcount].name = NULL;
+ msymbols[mcount].address = 0;
+ msymbols[mcount].info = NULL;
+ msymbols[mcount].type = mst_unknown;
+
+ /* Attach the minimal symbol table to the specified objfile.
+ The strings themselves are also located in the symbol_obstack
+ of this objfile. */
+
+ objfile -> minimal_symbol_count = mcount;
+ objfile -> msymbols = msymbols;
}
}
projects / deliverable / binutils-gdb.git / blobdiff