/* GDB routines for manipulating the minimal symbol tables.
- Copyright (C) 1992-2014 Free Software Foundation, Inc.
+ Copyright (C) 1992-2015 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 <string.h>
#include "symtab.h"
#include "bfd.h"
#include "filenames.h"
#include "cp-support.h"
#include "language.h"
#include "cli/cli-utils.h"
+#include "symbol.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
- symbol obstack. */
+ per-BFD storage obstack. */
#define BUNCH_SIZE 127
and the second over the demangled hash table. */
int pass;
+ if (symbol_lookup_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "lookup_minimal_symbol (%s, %s, %s)\n",
+ name, sfile != NULL ? sfile : "NULL",
+ objfile_debug_name (objfile));
+ }
+
for (pass = 1; pass <= 2 && found_symbol.minsym == NULL; pass++)
{
/* Select hash list according to pass. */
if (pass == 1)
- msymbol = objfile->msymbol_hash[hash];
+ msymbol = objfile->per_bfd->msymbol_hash[hash];
else
- msymbol = objfile->msymbol_demangled_hash[dem_hash];
+ msymbol = objfile->per_bfd->msymbol_demangled_hash[dem_hash];
while (msymbol != NULL && found_symbol.minsym == NULL)
{
/* External symbols are best. */
if (found_symbol.minsym != NULL)
- return found_symbol;
+ {
+ if (symbol_lookup_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "lookup_minimal_symbol (...) = %s"
+ " (external)\n",
+ host_address_to_string (found_symbol.minsym));
+ }
+ return found_symbol;
+ }
/* File-local symbols are next best. */
if (found_file_symbol.minsym != NULL)
- return found_file_symbol;
+ {
+ if (symbol_lookup_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "lookup_minimal_symbol (...) = %s"
+ " (file-local)\n",
+ host_address_to_string
+ (found_file_symbol.minsym));
+ }
+ return found_file_symbol;
+ }
/* Symbols for shared library trampolines are next best. */
+ if (symbol_lookup_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "lookup_minimal_symbol (...) = %s%s\n",
+ trampoline_symbol.minsym != NULL
+ ? host_address_to_string (trampoline_symbol.minsym)
+ : "NULL",
+ trampoline_symbol.minsym != NULL
+ ? " (trampoline)" : "");
+ }
return trampoline_symbol;
}
return lookup_minimal_symbol (name, NULL, NULL);
}
+/* See common/symbol.h. */
+
+int
+find_minimal_symbol_address (const char *name, CORE_ADDR *addr,
+ struct objfile *objfile)
+{
+ struct bound_minimal_symbol sym
+ = lookup_minimal_symbol (name, NULL, objfile);
+
+ if (sym.minsym != NULL)
+ *addr = BMSYMBOL_VALUE_ADDRESS (sym);
+
+ return sym.minsym == NULL;
+}
+
/* See minsyms.h. */
void
/* The first pass is over the ordinary hash table. */
hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
- iter = objf->msymbol_hash[hash];
+ iter = objf->per_bfd->msymbol_hash[hash];
cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
while (iter)
{
/* The second pass is over the demangled table. */
hash = msymbol_hash_iw (name) % MINIMAL_SYMBOL_HASH_SIZE;
- iter = objf->msymbol_demangled_hash[hash];
+ iter = objf->per_bfd->msymbol_demangled_hash[hash];
while (iter)
{
if (MSYMBOL_MATCHES_SEARCH_NAME (iter, name))
if (objf == NULL || objf == objfile
|| objf == objfile->separate_debug_objfile_backlink)
{
- for (msymbol = objfile->msymbol_hash[hash];
+ for (msymbol = objfile->per_bfd->msymbol_hash[hash];
msymbol != NULL && found_symbol.minsym == NULL;
msymbol = msymbol->hash_next)
{
if (objf == NULL || objf == objfile
|| objf == objfile->separate_debug_objfile_backlink)
{
- for (msymbol = objfile->msymbol_hash[hash];
+ for (msymbol = objfile->per_bfd->msymbol_hash[hash];
msymbol != NULL;
msymbol = msymbol->hash_next)
{
if (objf == NULL || objf == objfile
|| objf == objfile->separate_debug_objfile_backlink)
{
- for (msymbol = objfile->msymbol_hash[hash];
+ for (msymbol = objfile->per_bfd->msymbol_hash[hash];
msymbol != NULL;
msymbol = msymbol->hash_next)
{
{
int lo;
int hi;
- int new;
+ int newobj;
struct objfile *objfile;
struct minimal_symbol *msymbol;
struct minimal_symbol *best_symbol = NULL;
"null symbol". If there are no real symbols, then there is no
minimal symbol table at all. */
- if (objfile->minimal_symbol_count > 0)
+ if (objfile->per_bfd->minimal_symbol_count > 0)
{
int best_zero_sized = -1;
- msymbol = objfile->msymbols;
+ msymbol = objfile->per_bfd->msymbols;
lo = 0;
- hi = objfile->minimal_symbol_count - 1;
+ hi = objfile->per_bfd->minimal_symbol_count - 1;
/* This code assumes that the minimal symbols are sorted by
ascending address values. If the pc value is greater than or
{
/* pc is still strictly less than highest address. */
/* Note "new" will always be >= lo. */
- new = (lo + hi) / 2;
- if ((MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[new]) >= pc)
- || (lo == new))
+ newobj = (lo + hi) / 2;
+ if ((MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[newobj]) >= pc)
+ || (lo == newobj))
{
- hi = new;
+ hi = newobj;
}
else
{
- lo = new;
+ lo = newobj;
}
}
/* If we have multiple symbols at the same address, we want
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
+ while (hi < objfile->per_bfd->minimal_symbol_count - 1
&& (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi])
== MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi + 1])))
hi++;
{
struct minimal_symbol *msym;
- for (msym = objfile->msymbol_hash[hash];
+ for (msym = objfile->per_bfd->msymbol_hash[hash];
msym != NULL;
msym = msym->hash_next)
{
struct objfile *objfile)
{
struct obj_section *obj_section;
- struct msym_bunch *new;
+ struct msym_bunch *newobj;
struct minimal_symbol *msymbol;
/* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
--name_len;
}
- if (ms_type == mst_file_text && strncmp (name, "__gnu_compiled", 14) == 0)
+ if (ms_type == mst_file_text && startswith (name, "__gnu_compiled"))
return (NULL);
if (msym_bunch_index == BUNCH_SIZE)
{
- new = XCNEW (struct msym_bunch);
+ newobj = XCNEW (struct msym_bunch);
msym_bunch_index = 0;
- new->next = msym_bunch;
- msym_bunch = new;
+ newobj->next = msym_bunch;
+ msym_bunch = newobj;
}
msymbol = &msym_bunch->contents[msym_bunch_index];
- MSYMBOL_SET_LANGUAGE (msymbol, language_auto, &objfile->objfile_obstack);
+ MSYMBOL_SET_LANGUAGE (msymbol, language_auto,
+ &objfile->per_bfd->storage_obstack);
MSYMBOL_SET_NAMES (msymbol, name, name_len, copy_name, objfile);
SET_MSYMBOL_VALUE_ADDRESS (msymbol, address);
msymbol->hash_next = NULL;
msymbol->demangled_hash_next = NULL;
- msym_bunch_index++;
+ /* If we already read minimal symbols for this objfile, then don't
+ ever allocate a new one. */
+ if (!objfile->per_bfd->minsyms_read)
+ {
+ msym_bunch_index++;
+ objfile->per_bfd->n_minsyms++;
+ }
msym_count++;
- OBJSTAT (objfile, n_minsyms++);
return msymbol;
}
Note that we are not concerned here about recovering the space that
is potentially freed up, because the strings themselves are allocated
- on the objfile_obstack, and will get automatically freed when the symbol
+ on the storage_obstack, and will get automatically freed when the symbol
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.
/* Clear the hash tables. */
for (i = 0; i < MINIMAL_SYMBOL_HASH_SIZE; i++)
{
- objfile->msymbol_hash[i] = 0;
- objfile->msymbol_demangled_hash[i] = 0;
+ objfile->per_bfd->msymbol_hash[i] = 0;
+ objfile->per_bfd->msymbol_demangled_hash[i] = 0;
}
/* Now, (re)insert the actual entries. */
- for (i = objfile->minimal_symbol_count, msym = objfile->msymbols;
+ for ((i = objfile->per_bfd->minimal_symbol_count,
+ msym = objfile->per_bfd->msymbols);
i > 0;
i--, msym++)
{
msym->hash_next = 0;
- add_minsym_to_hash_table (msym, objfile->msymbol_hash);
+ add_minsym_to_hash_table (msym, objfile->per_bfd->msymbol_hash);
msym->demangled_hash_next = 0;
if (MSYMBOL_SEARCH_NAME (msym) != MSYMBOL_LINKAGE_NAME (msym))
add_minsym_to_demangled_hash_table (msym,
- objfile->msymbol_demangled_hash);
+ objfile->per_bfd->msymbol_demangled_hash);
}
}
struct minimal_symbol *msymbols;
int alloc_count;
+ if (objfile->per_bfd->minsyms_read)
+ return;
+
if (msym_count > 0)
{
if (symtab_create_debug)
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->objfile_obstack,
+ alloc_count = msym_count + objfile->per_bfd->minimal_symbol_count + 1;
+ obstack_blank (&objfile->per_bfd->storage_obstack,
alloc_count * sizeof (struct minimal_symbol));
msymbols = (struct minimal_symbol *)
- obstack_base (&objfile->objfile_obstack);
+ obstack_base (&objfile->per_bfd->storage_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));
+ if (objfile->per_bfd->minimal_symbol_count)
+ memcpy ((char *) msymbols, (char *) objfile->per_bfd->msymbols,
+ objfile->per_bfd->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
msym_bunch_index for the first bunch we copy over), and thereafter
each bunch is full. */
- mcount = objfile->minimal_symbol_count;
+ mcount = objfile->per_bfd->minimal_symbol_count;
for (bunch = msym_bunch; bunch != NULL; bunch = bunch->next)
{
mcount = compact_minimal_symbols (msymbols, mcount, objfile);
- obstack_blank (&objfile->objfile_obstack,
+ obstack_blank_fast (&objfile->per_bfd->storage_obstack,
(mcount + 1 - alloc_count) * sizeof (struct minimal_symbol));
msymbols = (struct minimal_symbol *)
- obstack_finish (&objfile->objfile_obstack);
+ obstack_finish (&objfile->per_bfd->storage_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
memset (&msymbols[mcount], 0, sizeof (struct minimal_symbol));
/* Attach the minimal symbol table to the specified objfile.
- The strings themselves are also located in the objfile_obstack
+ The strings themselves are also located in the storage_obstack
of this objfile. */
- objfile->minimal_symbol_count = mcount;
- objfile->msymbols = msymbols;
+ objfile->per_bfd->minimal_symbol_count = mcount;
+ objfile->per_bfd->msymbols = msymbols;
/* Now build the hash tables; we can't do this incrementally
at an earlier point since we weren't finished with the obstack
void
terminate_minimal_symbol_table (struct objfile *objfile)
{
- if (! objfile->msymbols)
- objfile->msymbols = ((struct minimal_symbol *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (objfile->msymbols[0])));
+ if (! objfile->per_bfd->msymbols)
+ objfile->per_bfd->msymbols
+ = ((struct minimal_symbol *)
+ obstack_alloc (&objfile->per_bfd->storage_obstack,
+ sizeof (struct minimal_symbol)));
{
struct minimal_symbol *m
- = &objfile->msymbols[objfile->minimal_symbol_count];
+ = &objfile->per_bfd->msymbols[objfile->per_bfd->minimal_symbol_count];
memset (m, 0, sizeof (*m));
/* Don't rely on these enumeration values being 0's. */
MSYMBOL_TYPE (m) = mst_unknown;
- MSYMBOL_SET_LANGUAGE (m, language_unknown, &objfile->objfile_obstack);
+ MSYMBOL_SET_LANGUAGE (m, language_unknown,
+ &objfile->per_bfd->storage_obstack);
}
}
-/* Sort all the minimal symbols in OBJFILE. */
-
-void
-msymbols_sort (struct objfile *objfile)
-{
- qsort (objfile->msymbols, objfile->minimal_symbol_count,
- sizeof (struct minimal_symbol), compare_minimal_symbols);
- build_minimal_symbol_hash_tables (objfile);
-}
-
/* 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. */