/* Partial symbol tables.
- Copyright (C) 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 2009-2014 Free Software Foundation, Inc.
This file is part of GDB.
#include "symtab.h"
#include "psympriv.h"
#include "objfiles.h"
-#include "gdb_assert.h"
#include "block.h"
#include "filenames.h"
#include "source.h"
#include "command.h"
#include "readline/readline.h"
#include "gdb_regex.h"
+#include "dictionary.h"
+#include "language.h"
+#include "cp-support.h"
+#include "gdbcmd.h"
#ifndef DEV_TTY
#define DEV_TTY "/dev/tty"
#endif
-/* A fast way to get from a psymtab to its symtab (after the first time). */
-#define PSYMTAB_TO_SYMTAB(pst) \
- ((pst) -> symtab != NULL ? (pst) -> symtab : psymtab_to_symtab (pst))
+struct psymbol_bcache
+{
+ struct bcache *bcache;
+};
-/* Lookup a partial symbol. */
-static struct partial_symbol *lookup_partial_symbol (struct partial_symtab *,
+static struct partial_symbol *match_partial_symbol (struct objfile *,
+ struct partial_symtab *,
+ int,
+ const char *, domain_enum,
+ symbol_compare_ftype *,
+ symbol_compare_ftype *);
+
+static struct partial_symbol *lookup_partial_symbol (struct objfile *,
+ struct partial_symtab *,
const char *, int,
domain_enum);
-static char *psymtab_to_fullname (struct partial_symtab *ps);
+static const char *psymtab_to_fullname (struct partial_symtab *ps);
-static struct partial_symbol *find_pc_sect_psymbol (struct partial_symtab *,
+static struct partial_symbol *find_pc_sect_psymbol (struct objfile *,
+ struct partial_symtab *,
CORE_ADDR,
struct obj_section *);
-static struct partial_symbol *fixup_psymbol_section (struct partial_symbol
- *psym,
- struct objfile *objfile);
+static void fixup_psymbol_section (struct partial_symbol *psym,
+ struct objfile *objfile);
-static struct symtab *psymtab_to_symtab (struct partial_symtab *pst);
+static struct symtab *psymtab_to_symtab (struct objfile *objfile,
+ struct partial_symtab *pst);
-/* Lookup the partial symbol table of a source file named NAME.
- *If* there is no '/' in the name, a match after a '/'
- in the psymtab filename will also work. */
+/* Ensure that the partial symbols for OBJFILE have been loaded. This
+ function always returns its argument, as a convenience. */
-static struct partial_symtab *
-lookup_partial_symtab (struct objfile *objfile, const char *name,
- const char *full_path, const char *real_path)
+struct objfile *
+require_partial_symbols (struct objfile *objfile, int verbose)
+{
+ if ((objfile->flags & OBJF_PSYMTABS_READ) == 0)
+ {
+ objfile->flags |= OBJF_PSYMTABS_READ;
+
+ if (objfile->sf->sym_read_psymbols)
+ {
+ if (verbose)
+ {
+ printf_unfiltered (_("Reading symbols from %s..."),
+ objfile_name (objfile));
+ gdb_flush (gdb_stdout);
+ }
+ (*objfile->sf->sym_read_psymbols) (objfile);
+ if (verbose)
+ {
+ if (!objfile_has_symbols (objfile))
+ {
+ wrap_here ("");
+ printf_unfiltered (_("(no debugging symbols found)..."));
+ wrap_here ("");
+ }
+
+ printf_unfiltered (_("done.\n"));
+ }
+ }
+ }
+
+ return objfile;
+}
+
+/* Traverse all psymtabs in one objfile, requiring that the psymtabs
+ be read in. */
+
+#define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \
+ for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \
+ (p) != NULL; \
+ (p) = (p)->next)
+
+/* We want to make sure this file always requires psymtabs. */
+
+#undef ALL_OBJFILE_PSYMTABS
+
+/* Traverse all psymtabs in all objfiles. */
+
+#define ALL_PSYMTABS(objfile, p) \
+ ALL_OBJFILES (objfile) \
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
+
+/* Helper function for partial_map_symtabs_matching_filename that
+ expands the symtabs and calls the iterator. */
+
+static int
+partial_map_expand_apply (struct objfile *objfile,
+ const char *name,
+ const char *real_path,
+ struct partial_symtab *pst,
+ int (*callback) (struct symtab *, void *),
+ void *data)
+{
+ struct symtab *last_made = objfile->symtabs;
+
+ /* Shared psymtabs should never be seen here. Instead they should
+ be handled properly by the caller. */
+ gdb_assert (pst->user == NULL);
+
+ /* Don't visit already-expanded psymtabs. */
+ if (pst->readin)
+ return 0;
+
+ /* This may expand more than one symtab, and we want to iterate over
+ all of them. */
+ psymtab_to_symtab (objfile, pst);
+
+ return iterate_over_some_symtabs (name, real_path, callback, data,
+ objfile->symtabs, last_made);
+}
+
+/* Implementation of the map_symtabs_matching_filename method. */
+
+static int
+partial_map_symtabs_matching_filename (struct objfile *objfile,
+ const char *name,
+ const char *real_path,
+ int (*callback) (struct symtab *,
+ void *),
+ void *data)
{
struct partial_symtab *pst;
+ const char *name_basename = lbasename (name);
- ALL_OBJFILE_PSYMTABS (objfile, pst)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
{
- if (FILENAME_CMP (name, pst->filename) == 0)
+ /* We can skip shared psymtabs here, because any file name will be
+ attached to the unshared psymtab. */
+ if (pst->user != NULL)
+ continue;
+
+ /* Anonymous psymtabs don't have a file name. */
+ if (pst->anonymous)
+ continue;
+
+ if (compare_filenames_for_search (pst->filename, name))
{
- return (pst);
+ if (partial_map_expand_apply (objfile, name, real_path,
+ pst, callback, data))
+ return 1;
+ continue;
}
- /* If the user gave us an absolute path, try to find the file in
- this symtab and use its absolute path. */
- if (full_path != NULL)
+ /* Before we invoke realpath, which can get expensive when many
+ files are involved, do a quick comparison of the basenames. */
+ if (! basenames_may_differ
+ && FILENAME_CMP (name_basename, lbasename (pst->filename)) != 0)
+ continue;
+
+ if (compare_filenames_for_search (psymtab_to_fullname (pst), name))
{
- psymtab_to_fullname (pst);
- if (pst->fullname != NULL
- && FILENAME_CMP (full_path, pst->fullname) == 0)
- {
- return pst;
- }
+ if (partial_map_expand_apply (objfile, name, real_path,
+ pst, callback, data))
+ return 1;
+ continue;
}
+ /* If the user gave us an absolute path, try to find the file in
+ this symtab and use its absolute path. */
if (real_path != NULL)
{
- char *rp = NULL;
- psymtab_to_fullname (pst);
- if (pst->fullname != NULL)
- {
- rp = gdb_realpath (pst->fullname);
- make_cleanup (xfree, rp);
- }
- if (rp != NULL && FILENAME_CMP (real_path, rp) == 0)
+ gdb_assert (IS_ABSOLUTE_PATH (real_path));
+ gdb_assert (IS_ABSOLUTE_PATH (name));
+ if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0)
{
- return pst;
+ if (partial_map_expand_apply (objfile, name, real_path,
+ pst, callback, data))
+ return 1;
+ continue;
}
}
}
- /* Now, search for a matching tail (only if name doesn't have any dirs) */
-
- if (lbasename (name) == name)
- ALL_OBJFILE_PSYMTABS (objfile, pst)
- {
- if (FILENAME_CMP (lbasename (pst->filename), name) == 0)
- return (pst);
- }
-
- return (NULL);
-}
-
-static int
-lookup_symtab_via_partial_symtab (struct objfile *objfile, const char *name,
- const char *full_path, const char *real_path,
- struct symtab **result)
-{
- struct partial_symtab *ps;
-
- ps = lookup_partial_symtab (objfile, name, full_path, real_path);
- if (!ps)
- return 0;
-
- if (ps->readin)
- error (_("Internal: readin %s pst for `%s' found when no symtab found."),
- ps->filename, name);
-
- *result = PSYMTAB_TO_SYMTAB (ps);
- return 1;
+ return 0;
}
/* Find which partial symtab contains PC and SECTION starting at psymtab PST.
We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
static struct partial_symtab *
-find_pc_sect_psymtab_closer (CORE_ADDR pc, struct obj_section *section,
+find_pc_sect_psymtab_closer (struct objfile *objfile,
+ CORE_ADDR pc, struct obj_section *section,
struct partial_symtab *pst,
- struct minimal_symbol *msymbol)
+ struct bound_minimal_symbol msymbol)
{
- struct objfile *objfile = pst->objfile;
struct partial_symtab *tpst;
struct partial_symtab *best_pst = pst;
CORE_ADDR best_addr = pst->textlow;
+ gdb_assert (!pst->psymtabs_addrmap_supported);
+
/* An objfile that has its functions reordered might have
many partial symbol tables containing the PC, but
we want the partial symbol table that contains the
function containing the PC. */
if (!(objfile->flags & OBJF_REORDERED) &&
- section == 0) /* can't validate section this way */
+ section == 0) /* Can't validate section this way. */
return pst;
- if (msymbol == NULL)
+ if (msymbol.minsym == NULL)
return (pst);
/* The code range of partial symtabs sometimes overlap, so, in
the loop below, we need to check all partial symtabs and
- find the one that fits better for the given PC address. We
+ find the one that fits better for the given PC address. We
select the partial symtab that contains a symbol whose
address is closest to the PC address. By closest we mean
that find_pc_sect_symbol returns the symbol with address
corresponding msymbol, which is not necessarily
true; the debug info might be much richer than the
object's symbol table. */
- p = find_pc_sect_psymbol (tpst, pc, section);
+ p = find_pc_sect_psymbol (objfile, tpst, pc, section);
if (p != NULL
&& SYMBOL_VALUE_ADDRESS (p)
- == SYMBOL_VALUE_ADDRESS (msymbol))
+ == BMSYMBOL_VALUE_ADDRESS (msymbol))
return tpst;
/* Also accept the textlow value of a psymtab as a
necessarily lower or equal to PC, the symbol closer
to PC is the symbol which address is the highest.
This way we return the psymtab which contains such
- best match symbol. This can help in cases where the
+ best match symbol. This can help in cases where the
symbol information/debuginfo is not complete, like
for instance on IRIX6 with gcc, where no debug info
- is emitted for statics. (See also the nodebug.exp
- testcase.) */
+ is emitted for statics. (See also the nodebug.exp
+ testcase.) */
if (this_addr > best_addr)
{
best_addr = this_addr;
static struct partial_symtab *
find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
struct obj_section *section,
- struct minimal_symbol *msymbol)
+ struct bound_minimal_symbol msymbol)
{
struct partial_symtab *pst;
/* FIXME: addrmaps currently do not handle overlayed sections,
so fall back to the non-addrmap case if we're debugging
overlays and the addrmap returned the wrong section. */
- if (overlay_debugging && msymbol && section)
+ if (overlay_debugging && msymbol.minsym && section)
{
struct partial_symbol *p;
corresponding msymbol, which is not necessarily
true; the debug info might be much richer than the
object's symbol table. */
- p = find_pc_sect_psymbol (pst, pc, section);
+ p = find_pc_sect_psymbol (objfile, pst, pc, section);
if (!p
|| SYMBOL_VALUE_ADDRESS (p)
- != SYMBOL_VALUE_ADDRESS (msymbol))
+ != BMSYMBOL_VALUE_ADDRESS (msymbol))
goto next;
}
its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
debug info type in single OBJFILE. */
- ALL_OBJFILE_PSYMTABS (objfile, pst)
- if (pc >= pst->textlow && pc < pst->texthigh)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
+ if (!pst->psymtabs_addrmap_supported
+ && pc >= pst->textlow && pc < pst->texthigh)
{
struct partial_symtab *best_pst;
- best_pst = find_pc_sect_psymtab_closer (pc, section, pst, msymbol);
+ best_pst = find_pc_sect_psymtab_closer (objfile, pc, section, pst,
+ msymbol);
if (best_pst != NULL)
return best_pst;
}
static struct symtab *
find_pc_sect_symtab_from_partial (struct objfile *objfile,
- struct minimal_symbol *msymbol,
+ struct bound_minimal_symbol msymbol,
CORE_ADDR pc, struct obj_section *section,
int warn_if_readin)
{
continue, so let's not. */
warning (_("\
(Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
- paddress (get_objfile_arch (ps->objfile), pc));
- return PSYMTAB_TO_SYMTAB (ps);
+ paddress (get_objfile_arch (objfile), pc));
+ psymtab_to_symtab (objfile, ps);
+ return ps->symtab;
}
return NULL;
}
Return 0 if none. */
static struct partial_symbol *
-find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc,
+find_pc_sect_psymbol (struct objfile *objfile,
+ struct partial_symtab *psymtab, CORE_ADDR pc,
struct obj_section *section)
{
struct partial_symbol *best = NULL, *p, **pp;
gdb_assert (psymtab != NULL);
- /* Cope with programs that start at address 0 */
+ /* Cope with programs that start at address 0. */
best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
/* Search the global symbols as well as the static symbols, so that
find_pc_partial_function doesn't use a minimal symbol and thus
cache a bad endaddr. */
- for (pp = psymtab->objfile->global_psymbols.list + psymtab->globals_offset;
- (pp - (psymtab->objfile->global_psymbols.list + psymtab->globals_offset)
+ for (pp = objfile->global_psymbols.list + psymtab->globals_offset;
+ (pp - (objfile->global_psymbols.list + psymtab->globals_offset)
< psymtab->n_global_syms);
pp++)
{
p = *pp;
if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
- && SYMBOL_CLASS (p) == LOC_BLOCK
+ && PSYMBOL_CLASS (p) == LOC_BLOCK
&& pc >= SYMBOL_VALUE_ADDRESS (p)
&& (SYMBOL_VALUE_ADDRESS (p) > best_pc
|| (psymtab->textlow == 0
&& best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
{
- if (section) /* match on a specific section */
+ if (section) /* Match on a specific section. */
{
- fixup_psymbol_section (p, psymtab->objfile);
- if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
+ fixup_psymbol_section (p, objfile);
+ if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
+ section))
continue;
}
best_pc = SYMBOL_VALUE_ADDRESS (p);
}
}
- for (pp = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
- (pp - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)
+ for (pp = objfile->static_psymbols.list + psymtab->statics_offset;
+ (pp - (objfile->static_psymbols.list + psymtab->statics_offset)
< psymtab->n_static_syms);
pp++)
{
p = *pp;
if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
- && SYMBOL_CLASS (p) == LOC_BLOCK
+ && PSYMBOL_CLASS (p) == LOC_BLOCK
&& pc >= SYMBOL_VALUE_ADDRESS (p)
&& (SYMBOL_VALUE_ADDRESS (p) > best_pc
|| (psymtab->textlow == 0
&& best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
{
- if (section) /* match on a specific section */
+ if (section) /* Match on a specific section. */
{
- fixup_psymbol_section (p, psymtab->objfile);
- if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
+ fixup_psymbol_section (p, objfile);
+ if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
+ section))
continue;
}
best_pc = SYMBOL_VALUE_ADDRESS (p);
return best;
}
-static struct partial_symbol *
+static void
fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
{
CORE_ADDR addr;
if (!psym)
- return NULL;
+ return;
- if (SYMBOL_OBJ_SECTION (psym))
- return psym;
+ if (SYMBOL_SECTION (psym) >= 0)
+ return;
gdb_assert (objfile);
- switch (SYMBOL_CLASS (psym))
+ switch (PSYMBOL_CLASS (psym))
{
case LOC_STATIC:
case LOC_LABEL:
default:
/* Nothing else will be listed in the minsyms -- no use looking
it up. */
- return psym;
+ return;
}
fixup_section (&psym->ginfo, addr, objfile);
-
- return psym;
}
static struct symtab *
{
struct partial_symtab *ps;
const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
+ struct symtab *stab_best = NULL;
- ALL_OBJFILE_PSYMTABS (objfile, ps)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
{
- if (!ps->readin && lookup_partial_symbol (ps, name, psymtab_index, domain))
- return PSYMTAB_TO_SYMTAB (ps);
+ if (!ps->readin && lookup_partial_symbol (objfile, ps, name,
+ psymtab_index, domain))
+ {
+ struct symbol *sym = NULL;
+ struct symtab *stab = psymtab_to_symtab (objfile, ps);
+
+ /* Some caution must be observed with overloaded functions
+ and methods, since the psymtab will not contain any overload
+ information (but NAME might contain it). */
+ if (stab->primary)
+ {
+ const struct blockvector *bv = BLOCKVECTOR (stab);
+ struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
+
+ sym = lookup_block_symbol (block, name, domain);
+ }
+
+ if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
+ {
+ if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
+ return stab;
+
+ stab_best = stab;
+ }
+
+ /* Keep looking through other psymtabs. */
+ }
}
+ return stab_best;
+}
+
+/* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
+ the global block of PST if GLOBAL, and otherwise the static block.
+ MATCH is the comparison operation that returns true iff MATCH (s,
+ NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
+ non-null, the symbols in the block are assumed to be ordered
+ according to it (allowing binary search). It must be compatible
+ with MATCH. Returns the symbol, if found, and otherwise NULL. */
+
+static struct partial_symbol *
+match_partial_symbol (struct objfile *objfile,
+ struct partial_symtab *pst, int global,
+ const char *name, domain_enum domain,
+ symbol_compare_ftype *match,
+ symbol_compare_ftype *ordered_compare)
+{
+ struct partial_symbol **start, **psym;
+ struct partial_symbol **top, **real_top, **bottom, **center;
+ int length = (global ? pst->n_global_syms : pst->n_static_syms);
+ int do_linear_search = 1;
+
+ if (length == 0)
+ return NULL;
+ start = (global ?
+ objfile->global_psymbols.list + pst->globals_offset :
+ objfile->static_psymbols.list + pst->statics_offset);
+
+ if (global && ordered_compare) /* Can use a binary search. */
+ {
+ do_linear_search = 0;
+
+ /* Binary search. This search is guaranteed to end with center
+ pointing at the earliest partial symbol whose name might be
+ correct. At that point *all* partial symbols with an
+ appropriate name will be checked against the correct
+ domain. */
+
+ bottom = start;
+ top = start + length - 1;
+ real_top = top;
+ while (top > bottom)
+ {
+ center = bottom + (top - bottom) / 2;
+ gdb_assert (center < top);
+ if (!do_linear_search
+ && (SYMBOL_LANGUAGE (*center) == language_java))
+ do_linear_search = 1;
+ if (ordered_compare (SYMBOL_SEARCH_NAME (*center), name) >= 0)
+ top = center;
+ else
+ bottom = center + 1;
+ }
+ gdb_assert (top == bottom);
+
+ while (top <= real_top
+ && match (SYMBOL_SEARCH_NAME (*top), name) == 0)
+ {
+ if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
+ SYMBOL_DOMAIN (*top), domain))
+ return *top;
+ top++;
+ }
+ }
+
+ /* Can't use a binary search or else we found during the binary search that
+ we should also do a linear search. */
+
+ if (do_linear_search)
+ {
+ for (psym = start; psym < start + length; psym++)
+ {
+ if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
+ SYMBOL_DOMAIN (*psym), domain)
+ && match (SYMBOL_SEARCH_NAME (*psym), name) == 0)
+ return *psym;
+ }
+ }
+
return NULL;
}
-static void
-pre_expand_symtabs_matching_psymtabs (struct objfile *objfile,
- int kind, const char *name,
- domain_enum domain)
+/* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
+ not contain any method/function instance information (since this would
+ force reading type information while reading psymtabs). Therefore,
+ if NAME contains overload information, it must be stripped before searching
+ psymtabs.
+
+ The caller is responsible for freeing the return result. */
+
+static char *
+psymtab_search_name (const char *name)
{
- /* Nothing. */
+ switch (current_language->la_language)
+ {
+ case language_cplus:
+ case language_java:
+ {
+ if (strchr (name, '('))
+ {
+ char *ret = cp_remove_params (name);
+
+ if (ret)
+ return ret;
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return xstrdup (name);
}
/* Look, in partial_symtab PST, for symbol whose natural name is NAME.
- Check the global symbols if GLOBAL, the static symbols if not. */
+ Check the global symbols if GLOBAL, the static symbols if not. */
static struct partial_symbol *
-lookup_partial_symbol (struct partial_symtab *pst, const char *name,
+lookup_partial_symbol (struct objfile *objfile,
+ struct partial_symtab *pst, const char *name,
int global, domain_enum domain)
{
struct partial_symbol **start, **psym;
struct partial_symbol **top, **real_top, **bottom, **center;
int length = (global ? pst->n_global_syms : pst->n_static_syms);
int do_linear_search = 1;
+ char *search_name;
+ struct cleanup *cleanup;
if (length == 0)
{
return (NULL);
}
+
+ search_name = psymtab_search_name (name);
+ cleanup = make_cleanup (xfree, search_name);
start = (global ?
- pst->objfile->global_psymbols.list + pst->globals_offset :
- pst->objfile->static_psymbols.list + pst->statics_offset);
+ objfile->global_psymbols.list + pst->globals_offset :
+ objfile->static_psymbols.list + pst->statics_offset);
- if (global) /* This means we can use a binary search. */
+ if (global) /* This means we can use a binary search. */
{
do_linear_search = 0;
{
center = bottom + (top - bottom) / 2;
if (!(center < top))
- internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
+ internal_error (__FILE__, __LINE__,
+ _("failed internal consistency check"));
if (!do_linear_search
- && (SYMBOL_LANGUAGE (*center) == language_java))
+ && SYMBOL_LANGUAGE (*center) == language_java)
{
do_linear_search = 1;
}
- if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center), name) >= 0)
+ if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
+ search_name) >= 0)
{
top = center;
}
}
}
if (!(top == bottom))
- internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
+ internal_error (__FILE__, __LINE__,
+ _("failed internal consistency check"));
- while (top <= real_top
- && SYMBOL_MATCHES_SEARCH_NAME (*top, name))
+ /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
+ search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
+ while (top >= start && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
+ top--;
+
+ /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
+ top++;
+
+ while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
{
if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
SYMBOL_DOMAIN (*top), domain))
- return (*top);
+ {
+ do_cleanups (cleanup);
+ return (*top);
+ }
top++;
}
}
/* Can't use a binary search or else we found during the binary search that
- we should also do a linear search. */
+ we should also do a linear search. */
if (do_linear_search)
{
{
if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
SYMBOL_DOMAIN (*psym), domain)
- && SYMBOL_MATCHES_SEARCH_NAME (*psym, name))
- return (*psym);
+ && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name))
+ {
+ do_cleanups (cleanup);
+ return (*psym);
+ }
}
}
+ do_cleanups (cleanup);
return (NULL);
}
/* Get the symbol table that corresponds to a partial_symtab.
- This is fast after the first time you do it. In fact, there
- is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
- case inline. */
+ This is fast after the first time you do it. */
static struct symtab *
-psymtab_to_symtab (struct partial_symtab *pst)
+psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
{
- /* If it's been looked up before, return it. */
+ /* If it is a shared psymtab, find an unshared psymtab that includes
+ it. Any such psymtab will do. */
+ while (pst->user != NULL)
+ pst = pst->user;
+
+ /* If it's been looked up before, return it. */
if (pst->symtab)
return pst->symtab;
{
struct cleanup *back_to = increment_reading_symtab ();
- (*pst->read_symtab) (pst);
+ (*pst->read_symtab) (pst, objfile);
do_cleanups (back_to);
}
static void
relocate_psymtabs (struct objfile *objfile,
- struct section_offsets *new_offsets,
- struct section_offsets *delta)
+ const struct section_offsets *new_offsets,
+ const struct section_offsets *delta)
{
struct partial_symbol **psym;
struct partial_symtab *p;
- ALL_OBJFILE_PSYMTABS (objfile, p)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
{
p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
struct partial_symtab *ps;
struct partial_symtab *cs_pst = 0;
- ALL_OBJFILE_PSYMTABS (ofp, ps)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)
{
const char *name = ps->filename;
int len = strlen (name);
"readin pst found and no symtabs."));
}
else
- return PSYMTAB_TO_SYMTAB (cs_pst);
+ return psymtab_to_symtab (ofp, cs_pst);
}
return NULL;
}
{
struct partial_symtab *pst;
- ALL_OBJFILE_PSYMTABS (objfile, pst)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
{
if (pst->fullname != NULL)
{
fprintf_filtered (outfile, " %s partial symbols:\n", what);
while (count-- > 0)
{
+ QUIT;
fprintf_filtered (outfile, " `%s'", SYMBOL_LINKAGE_NAME (*p));
if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
{
fputs_filtered ("undefined domain, ", outfile);
break;
case VAR_DOMAIN:
- /* This is the usual thing -- don't print it */
+ /* This is the usual thing -- don't print it. */
break;
case STRUCT_DOMAIN:
fputs_filtered ("struct domain, ", outfile);
fputs_filtered ("<invalid domain>, ", outfile);
break;
}
- switch (SYMBOL_CLASS (*p))
+ switch (PSYMBOL_CLASS (*p))
{
case LOC_UNDEF:
fputs_filtered ("undefined", outfile);
struct gdbarch *gdbarch = get_objfile_arch (objfile);
int i;
- fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
- psymtab->filename);
+ if (psymtab->anonymous)
+ {
+ fprintf_filtered (outfile, "\nAnonymous partial symtab (%s) ",
+ psymtab->filename);
+ }
+ else
+ {
+ fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
+ psymtab->filename);
+ }
fprintf_filtered (outfile, "(object ");
gdb_print_host_address (psymtab, outfile);
fprintf_filtered (outfile, ")\n\n");
fprintf_unfiltered (outfile, " Read from object file %s (",
- objfile->name);
+ objfile_name (objfile));
gdb_print_host_address (objfile, outfile);
fprintf_unfiltered (outfile, ")\n");
}
fprintf_filtered (outfile, " Relocate symbols by ");
- for (i = 0; i < psymtab->objfile->num_sections; ++i)
+ for (i = 0; i < objfile->num_sections; ++i)
{
if (i != 0)
fprintf_filtered (outfile, ", ");
fprintf_filtered (outfile, "-");
fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
fprintf_filtered (outfile, "\n");
+ fprintf_filtered (outfile, " Address map supported - %s.\n",
+ psymtab->psymtabs_addrmap_supported ? "yes" : "no");
fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
psymtab->number_of_dependencies);
for (i = 0; i < psymtab->number_of_dependencies; i++)
fprintf_filtered (outfile, " %s\n",
psymtab->dependencies[i]->filename);
}
+ if (psymtab->user != NULL)
+ {
+ fprintf_filtered (outfile, " Shared partial symtab with user ");
+ gdb_print_host_address (psymtab->user, outfile);
+ fprintf_filtered (outfile, "\n");
+ }
if (psymtab->n_global_syms > 0)
{
print_partial_symbols (gdbarch,
struct partial_symtab *ps;
i = 0;
- ALL_OBJFILE_PSYMTABS (objfile, ps)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
{
if (ps->readin == 0)
i++;
psymtab->filename);
gdb_print_host_address (psymtab, gdb_stdout);
printf_filtered (", ");
- if (psymtab->objfile != objfile)
- {
- printf_filtered ("NOT ON CHAIN! ");
- }
wrap_here (" ");
}
printf_filtered ("\n\n");
}
/* Look through the partial symtabs for all symbols which begin
- by matching FUNC_NAME. Make sure we read that symbol table in. */
+ by matching FUNC_NAME. Make sure we read that symbol table in. */
static void
read_symtabs_for_function (struct objfile *objfile, const char *func_name)
{
struct partial_symtab *ps;
- ALL_OBJFILE_PSYMTABS (objfile, ps)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
{
if (ps->readin)
continue;
- if ((lookup_partial_symbol (ps, func_name, 1, VAR_DOMAIN)
+ if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)
!= NULL)
- || (lookup_partial_symbol (ps, func_name, 0, VAR_DOMAIN)
+ || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)
!= NULL))
- psymtab_to_symtab (ps);
+ psymtab_to_symtab (objfile, ps);
}
}
{
struct partial_symtab *psymtab;
- for (psymtab = objfile->psymtabs;
- psymtab != NULL;
- psymtab = psymtab->next)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
{
- psymtab_to_symtab (psymtab);
+ psymtab_to_symtab (objfile, psymtab);
}
}
static void
-read_psymtabs_with_filename (struct objfile *objfile, const char *filename)
+read_psymtabs_with_fullname (struct objfile *objfile, const char *fullname)
{
struct partial_symtab *p;
- ALL_OBJFILE_PSYMTABS (objfile, p)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
{
- if (strcmp (filename, p->filename) == 0)
- PSYMTAB_TO_SYMTAB (p);
- }
-}
-
-static void
-map_symbol_names_psymtab (struct objfile *objfile,
- void (*fun) (const char *, void *), void *data)
-{
- struct partial_symtab *ps;
-
- ALL_OBJFILE_PSYMTABS (objfile, ps)
- {
- struct partial_symbol **psym;
-
- /* If the psymtab's been read in we'll get it when we search
- through the blockvector. */
- if (ps->readin)
+ /* Anonymous psymtabs don't have a name of a source file. */
+ if (p->anonymous)
continue;
- for (psym = objfile->global_psymbols.list + ps->globals_offset;
- psym < (objfile->global_psymbols.list + ps->globals_offset
- + ps->n_global_syms);
- psym++)
- {
- /* If interrupted, then quit. */
- QUIT;
- (*fun) (SYMBOL_NATURAL_NAME (*psym), data);
- }
-
- for (psym = objfile->static_psymbols.list + ps->statics_offset;
- psym < (objfile->static_psymbols.list + ps->statics_offset
- + ps->n_static_syms);
- psym++)
- {
- QUIT;
- (*fun) (SYMBOL_NATURAL_NAME (*psym), data);
- }
+ /* psymtab_to_fullname tries to open the file which is slow.
+ Don't call it if we know the basenames don't match. */
+ if ((basenames_may_differ
+ || filename_cmp (lbasename (fullname), lbasename (p->filename)) == 0)
+ && filename_cmp (fullname, psymtab_to_fullname (p)) == 0)
+ psymtab_to_symtab (objfile, p);
}
}
static void
map_symbol_filenames_psymtab (struct objfile *objfile,
- void (*fun) (const char *, const char *,
- void *),
- void *data)
+ symbol_filename_ftype *fun, void *data,
+ int need_fullname)
{
struct partial_symtab *ps;
- ALL_OBJFILE_PSYMTABS (objfile, ps)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
{
const char *fullname;
if (ps->readin)
continue;
- fullname = psymtab_to_fullname (ps);
+ /* We can skip shared psymtabs here, because any file name will be
+ attached to the unshared psymtab. */
+ if (ps->user != NULL)
+ continue;
+
+ /* Anonymous psymtabs don't have a file name. */
+ if (ps->anonymous)
+ continue;
+
+ QUIT;
+ if (need_fullname)
+ fullname = psymtab_to_fullname (ps);
+ else
+ fullname = NULL;
(*fun) (ps->filename, fullname, data);
}
}
-int find_and_open_source (const char *filename,
- const char *dirname,
- char **fullname);
-
/* Finds the fullname that a partial_symtab represents.
If this functions finds the fullname, it will save it in ps->fullname
If this function fails to find the file that this partial_symtab represents,
NULL will be returned and ps->fullname will be set to NULL. */
-static char *
+
+static const char *
psymtab_to_fullname (struct partial_symtab *ps)
{
- int r;
+ gdb_assert (!ps->anonymous);
- if (!ps)
- return NULL;
+ /* Use cached copy if we have it.
+ We rely on forget_cached_source_info being called appropriately
+ to handle cases like the file being moved. */
+ if (ps->fullname == NULL)
+ {
+ int fd = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
- /* Don't check ps->fullname here, the file could have been
- deleted/moved/..., look for it again */
- r = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
+ if (fd >= 0)
+ close (fd);
+ else
+ {
+ char *fullname;
+ struct cleanup *back_to;
- if (r >= 0)
- {
- close (r);
- return ps->fullname;
- }
+ /* rewrite_source_path would be applied by find_and_open_source, we
+ should report the pathname where GDB tried to find the file. */
- return NULL;
-}
+ if (ps->dirname == NULL || IS_ABSOLUTE_PATH (ps->filename))
+ fullname = xstrdup (ps->filename);
+ else
+ fullname = concat (ps->dirname, SLASH_STRING, ps->filename, NULL);
-static const char *
-find_symbol_file_from_partial (struct objfile *objfile, const char *name)
-{
- struct partial_symtab *pst;
+ back_to = make_cleanup (xfree, fullname);
+ ps->fullname = rewrite_source_path (fullname);
+ if (ps->fullname == NULL)
+ ps->fullname = xstrdup (fullname);
+ do_cleanups (back_to);
+ }
+ }
- ALL_OBJFILE_PSYMTABS (objfile, pst)
- {
- if (lookup_partial_symbol (pst, name, 1, VAR_DOMAIN))
- return pst->filename;
- }
- return NULL;
+ return ps->fullname;
}
-/* Look, in partial_symtab PST, for symbol NAME in given namespace.
- Check the global symbols if GLOBAL, the static symbols if not.
- Do wild-card match if WILD. */
+/* For all symbols, s, in BLOCK that are in NAMESPACE and match NAME
+ according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
+ BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
+ ever returns non-zero, and otherwise returns 0. */
-static struct partial_symbol *
-ada_lookup_partial_symbol (struct partial_symtab *pst, const char *name,
- int global, domain_enum namespace, int wild,
- int (*wild_match) (const char *, int, const char *),
- int (*is_name_suffix) (const char *))
+static int
+map_block (const char *name, domain_enum namespace, struct objfile *objfile,
+ struct block *block,
+ int (*callback) (struct block *, struct symbol *, void *),
+ void *data, symbol_compare_ftype *match)
{
- struct partial_symbol **start;
- int name_len = strlen (name);
- int length = (global ? pst->n_global_syms : pst->n_static_syms);
- int i;
+ struct block_iterator iter;
+ struct symbol *sym;
- if (length == 0)
+ for (sym = block_iter_match_first (block, name, match, &iter);
+ sym != NULL; sym = block_iter_match_next (name, match, &iter))
{
- return (NULL);
+ if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
+ SYMBOL_DOMAIN (sym), namespace))
+ {
+ if (callback (block, sym, data))
+ return 1;
+ }
}
- start = (global ?
- pst->objfile->global_psymbols.list + pst->globals_offset :
- pst->objfile->static_psymbols.list + pst->statics_offset);
-
- if (wild)
- {
- for (i = 0; i < length; i += 1)
- {
- struct partial_symbol *psym = start[i];
-
- if (symbol_matches_domain (SYMBOL_LANGUAGE (psym),
- SYMBOL_DOMAIN (psym), namespace)
- && (*wild_match) (name, name_len, SYMBOL_LINKAGE_NAME (psym)))
- return psym;
- }
- return NULL;
- }
- else
- {
- if (global)
- {
- int U;
-
- i = 0;
- U = length - 1;
- while (U - i > 4)
- {
- int M = (U + i) >> 1;
- struct partial_symbol *psym = start[M];
-
- if (SYMBOL_LINKAGE_NAME (psym)[0] < name[0])
- i = M + 1;
- else if (SYMBOL_LINKAGE_NAME (psym)[0] > name[0])
- U = M - 1;
- else if (strcmp (SYMBOL_LINKAGE_NAME (psym), name) < 0)
- i = M + 1;
- else
- U = M;
- }
- }
- else
- i = 0;
-
- while (i < length)
- {
- struct partial_symbol *psym = start[i];
-
- if (symbol_matches_domain (SYMBOL_LANGUAGE (psym),
- SYMBOL_DOMAIN (psym), namespace))
- {
- int cmp = strncmp (name, SYMBOL_LINKAGE_NAME (psym), name_len);
-
- if (cmp < 0)
- {
- if (global)
- break;
- }
- else if (cmp == 0
- && (*is_name_suffix) (SYMBOL_LINKAGE_NAME (psym)
- + name_len))
- return psym;
- }
- i += 1;
- }
-
- if (global)
- {
- int U;
-
- i = 0;
- U = length - 1;
- while (U - i > 4)
- {
- int M = (U + i) >> 1;
- struct partial_symbol *psym = start[M];
-
- if (SYMBOL_LINKAGE_NAME (psym)[0] < '_')
- i = M + 1;
- else if (SYMBOL_LINKAGE_NAME (psym)[0] > '_')
- U = M - 1;
- else if (strcmp (SYMBOL_LINKAGE_NAME (psym), "_ada_") < 0)
- i = M + 1;
- else
- U = M;
- }
- }
- else
- i = 0;
-
- while (i < length)
- {
- struct partial_symbol *psym = start[i];
-
- if (symbol_matches_domain (SYMBOL_LANGUAGE (psym),
- SYMBOL_DOMAIN (psym), namespace))
- {
- int cmp;
-
- cmp = (int) '_' - (int) SYMBOL_LINKAGE_NAME (psym)[0];
- if (cmp == 0)
- {
- cmp = strncmp ("_ada_", SYMBOL_LINKAGE_NAME (psym), 5);
- if (cmp == 0)
- cmp = strncmp (name, SYMBOL_LINKAGE_NAME (psym) + 5,
- name_len);
- }
-
- if (cmp < 0)
- {
- if (global)
- break;
- }
- else if (cmp == 0
- && (*is_name_suffix) (SYMBOL_LINKAGE_NAME (psym)
- + name_len + 5))
- return psym;
- }
- i += 1;
- }
- }
- return NULL;
+ return 0;
}
+/* Psymtab version of map_matching_symbols. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
static void
-map_ada_symtabs (struct objfile *objfile,
- int (*wild_match) (const char *, int, const char *),
- int (*is_name_suffix) (const char *),
- void (*callback) (struct objfile *, struct symtab *, void *),
- const char *name, int global, domain_enum namespace, int wild,
- void *data)
+map_matching_symbols_psymtab (struct objfile *objfile,
+ const char *name, domain_enum namespace,
+ int global,
+ int (*callback) (struct block *,
+ struct symbol *, void *),
+ void *data,
+ symbol_compare_ftype *match,
+ symbol_compare_ftype *ordered_compare)
{
+ const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
struct partial_symtab *ps;
- ALL_OBJFILE_PSYMTABS (objfile, ps)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
{
QUIT;
if (ps->readin
- || ada_lookup_partial_symbol (ps, name, global, namespace, wild,
- wild_match, is_name_suffix))
+ || match_partial_symbol (objfile, ps, global, name, namespace, match,
+ ordered_compare))
{
- struct symtab *s = PSYMTAB_TO_SYMTAB (ps);
+ struct symtab *s = psymtab_to_symtab (objfile, ps);
+ struct block *block;
if (s == NULL || !s->primary)
continue;
- (*callback) (objfile, s, data);
+ block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind);
+ if (map_block (name, namespace, objfile, block,
+ callback, data, match))
+ return;
+ if (callback (block, NULL, data))
+ return;
+ }
+ }
+}
+
+/* A helper for expand_symtabs_matching_via_partial that handles
+ searching included psymtabs. This returns 1 if a symbol is found,
+ and zero otherwise. It also updates the 'searched_flag' on the
+ various psymtabs that it searches. */
+
+static int
+recursively_search_psymtabs (struct partial_symtab *ps,
+ struct objfile *objfile,
+ enum search_domain kind,
+ expand_symtabs_symbol_matcher_ftype *sym_matcher,
+ void *data)
+{
+ struct partial_symbol **psym;
+ struct partial_symbol **bound, **gbound, **sbound;
+ int keep_going = 1;
+ int result = PST_SEARCHED_AND_NOT_FOUND;
+ int i;
+
+ if (ps->searched_flag != PST_NOT_SEARCHED)
+ return ps->searched_flag == PST_SEARCHED_AND_FOUND;
+
+ /* Recurse into shared psymtabs first, because they may have already
+ been searched, and this could save some time. */
+ for (i = 0; i < ps->number_of_dependencies; ++i)
+ {
+ int r;
+
+ /* Skip non-shared dependencies, these are handled elsewhere. */
+ if (ps->dependencies[i]->user == NULL)
+ continue;
+
+ r = recursively_search_psymtabs (ps->dependencies[i],
+ objfile, kind, sym_matcher, data);
+ if (r != 0)
+ {
+ ps->searched_flag = PST_SEARCHED_AND_FOUND;
+ return 1;
+ }
+ }
+
+ gbound = (objfile->global_psymbols.list
+ + ps->globals_offset + ps->n_global_syms);
+ sbound = (objfile->static_psymbols.list
+ + ps->statics_offset + ps->n_static_syms);
+ bound = gbound;
+
+ /* Go through all of the symbols stored in a partial
+ symtab in one loop. */
+ psym = objfile->global_psymbols.list + ps->globals_offset;
+ while (keep_going)
+ {
+ if (psym >= bound)
+ {
+ if (bound == gbound && ps->n_static_syms != 0)
+ {
+ psym = objfile->static_psymbols.list + ps->statics_offset;
+ bound = sbound;
+ }
+ else
+ keep_going = 0;
+ continue;
+ }
+ else
+ {
+ QUIT;
+
+ if ((kind == ALL_DOMAIN
+ || (kind == VARIABLES_DOMAIN
+ && PSYMBOL_CLASS (*psym) != LOC_TYPEDEF
+ && PSYMBOL_CLASS (*psym) != LOC_BLOCK)
+ || (kind == FUNCTIONS_DOMAIN
+ && PSYMBOL_CLASS (*psym) == LOC_BLOCK)
+ || (kind == TYPES_DOMAIN
+ && PSYMBOL_CLASS (*psym) == LOC_TYPEDEF))
+ && (*sym_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
+ {
+ /* Found a match, so notify our caller. */
+ result = PST_SEARCHED_AND_FOUND;
+ keep_going = 0;
+ }
}
+ psym++;
}
+
+ ps->searched_flag = result;
+ return result == PST_SEARCHED_AND_FOUND;
}
static void
-expand_symtabs_matching_via_partial (struct objfile *objfile,
- int (*file_matcher) (const char *, void *),
- int (*name_matcher) (const char *, void *),
- domain_enum kind,
- void *data)
+expand_symtabs_matching_via_partial
+ (struct objfile *objfile,
+ expand_symtabs_file_matcher_ftype *file_matcher,
+ expand_symtabs_symbol_matcher_ftype *symbol_matcher,
+ enum search_domain kind,
+ void *data)
{
struct partial_symtab *ps;
- ALL_OBJFILE_PSYMTABS (objfile, ps)
+ /* Clear the search flags. */
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
{
- struct partial_symbol **psym;
- struct partial_symbol **bound, **gbound, **sbound;
- int keep_going = 1;
+ ps->searched_flag = PST_NOT_SEARCHED;
+ }
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
+ {
if (ps->readin)
continue;
- if (! (*file_matcher) (ps->filename, data))
+ /* We skip shared psymtabs because file-matching doesn't apply
+ to them; but we search them later in the loop. */
+ if (ps->user != NULL)
continue;
- gbound = objfile->global_psymbols.list + ps->globals_offset + ps->n_global_syms;
- sbound = objfile->static_psymbols.list + ps->statics_offset + ps->n_static_syms;
- bound = gbound;
-
- /* Go through all of the symbols stored in a partial
- symtab in one loop. */
- psym = objfile->global_psymbols.list + ps->globals_offset;
- while (keep_going)
+ if (file_matcher)
{
- if (psym >= bound)
- {
- if (bound == gbound && ps->n_static_syms != 0)
- {
- psym = objfile->static_psymbols.list + ps->statics_offset;
- bound = sbound;
- }
- else
- keep_going = 0;
- continue;
- }
- else
+ int match;
+
+ if (ps->anonymous)
+ continue;
+
+ match = (*file_matcher) (ps->filename, data, 0);
+ if (!match)
{
- QUIT;
-
- if ((*name_matcher) (SYMBOL_NATURAL_NAME (*psym), data)
- && ((kind == VARIABLES_DOMAIN
- && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
- && SYMBOL_CLASS (*psym) != LOC_BLOCK)
- || (kind == FUNCTIONS_DOMAIN
- && SYMBOL_CLASS (*psym) == LOC_BLOCK)
- || (kind == TYPES_DOMAIN
- && SYMBOL_CLASS (*psym) == LOC_TYPEDEF)))
- {
- PSYMTAB_TO_SYMTAB (ps);
- keep_going = 0;
- }
+ /* Before we invoke realpath, which can get expensive when many
+ files are involved, do a quick comparison of the basenames. */
+ if (basenames_may_differ
+ || (*file_matcher) (lbasename (ps->filename), data, 1))
+ match = (*file_matcher) (psymtab_to_fullname (ps), data, 0);
}
- psym++;
+ if (!match)
+ continue;
}
+
+ if (recursively_search_psymtabs (ps, objfile, kind, symbol_matcher, data))
+ psymtab_to_symtab (objfile, ps);
}
}
objfile_has_psyms,
find_last_source_symtab_from_partial,
forget_cached_source_info_partial,
- lookup_symtab_via_partial_symtab,
+ partial_map_symtabs_matching_filename,
lookup_symbol_aux_psymtabs,
- pre_expand_symtabs_matching_psymtabs,
print_psymtab_stats_for_objfile,
dump_psymtabs_for_objfile,
relocate_psymtabs,
read_symtabs_for_function,
expand_partial_symbol_tables,
- read_psymtabs_with_filename,
- find_symbol_file_from_partial,
- map_ada_symtabs,
+ read_psymtabs_with_fullname,
+ map_matching_symbols_psymtab,
expand_symtabs_matching_via_partial,
find_pc_sect_symtab_from_partial,
- map_symbol_names_psymtab,
map_symbol_filenames_psymtab
};
}
void
-sort_pst_symbols (struct partial_symtab *pst)
+sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
{
- /* Sort the global list; don't sort the static list */
+ /* Sort the global list; don't sort the static list. */
- qsort (pst->objfile->global_psymbols.list + pst->globals_offset,
+ qsort (objfile->global_psymbols.list + pst->globals_offset,
pst->n_global_syms, sizeof (struct partial_symbol *),
compare_psymbols);
}
/* Allocate and partially fill a partial symtab. It will be
completely filled at the end of the symbol list.
- FILENAME is the name of the symbol-file we are reading from. */
+ FILENAME is the name of the symbol-file we are reading from. */
struct partial_symtab *
start_psymtab_common (struct objfile *objfile,
/* Calculate a hash code for the given partial symbol. The hash is
calculated using the symbol's value, language, domain, class
- and name. These are the values which are set by
+ and name. These are the values which are set by
add_psymbol_to_bcache. */
-unsigned long
+static unsigned long
psymbol_hash (const void *addr, int length)
{
unsigned long h = 0;
For the comparison this function uses a symbols value,
language, domain, class and name. */
-int
+static int
psymbol_compare (const void *addr1, const void *addr2, int length)
{
struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
&& sym1->ginfo.name == sym2->ginfo.name);
}
+/* Initialize a partial symbol bcache. */
+
+struct psymbol_bcache *
+psymbol_bcache_init (void)
+{
+ struct psymbol_bcache *bcache = XCNEW (struct psymbol_bcache);
+ bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
+ return bcache;
+}
+
+/* Free a partial symbol bcache. */
+void
+psymbol_bcache_free (struct psymbol_bcache *bcache)
+{
+ if (bcache == NULL)
+ return;
+
+ bcache_xfree (bcache->bcache);
+ xfree (bcache);
+}
+
+/* Return the internal bcache of the psymbol_bcache BCACHE. */
+
+struct bcache *
+psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
+{
+ return bcache->bcache;
+}
+
+/* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
+ symbol before, add a copy to BCACHE. In either case, return a pointer
+ to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
+ 1 in case of new entry or 0 if returning an old entry. */
+
+static const struct partial_symbol *
+psymbol_bcache_full (struct partial_symbol *sym,
+ struct psymbol_bcache *bcache,
+ int *added)
+{
+ return bcache_full (sym,
+ sizeof (struct partial_symbol),
+ bcache->bcache,
+ added);
+}
+
/* Helper function, initialises partial symbol structure and stashes
it into objfile's bcache. Note that our caching mechanism will
use all fields of struct partial_symbol to determine hash value of the
different domain (or address) is possible and correct. */
static const struct partial_symbol *
-add_psymbol_to_bcache (char *name, int namelength, int copy_name,
+add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
domain_enum domain,
enum address_class class,
long val, /* Value as a long */
{
struct partial_symbol psymbol;
- /* val and coreaddr are mutually exclusive, one of them *will* be zero */
+ /* We must ensure that the entire struct has been zeroed before
+ assigning to it, because an assignment may not touch some of the
+ holes. */
+ memset (&psymbol, 0, sizeof (psymbol));
+
+ /* val and coreaddr are mutually exclusive, one of them *will* be zero. */
if (val != 0)
{
SYMBOL_VALUE (&psymbol) = val;
{
SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
}
- SYMBOL_SECTION (&psymbol) = 0;
- SYMBOL_SET_LANGUAGE (&psymbol, language);
+ SYMBOL_SECTION (&psymbol) = -1;
+ SYMBOL_SET_LANGUAGE (&psymbol, language, &objfile->objfile_obstack);
PSYMBOL_DOMAIN (&psymbol) = domain;
PSYMBOL_CLASS (&psymbol) = class;
SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
- /* Stash the partial symbol away in the cache */
- return bcache_full (&psymbol, sizeof (struct partial_symbol),
- objfile->psymbol_cache, added);
+ /* Stash the partial symbol away in the cache. */
+ return psymbol_bcache_full (&psymbol,
+ objfile->psymbol_cache,
+ added);
+}
+
+/* Increase the space allocated for LISTP, which is probably
+ global_psymbols or static_psymbols. This space will eventually
+ be freed in free_objfile(). */
+
+static void
+extend_psymbol_list (struct psymbol_allocation_list *listp,
+ struct objfile *objfile)
+{
+ int new_size;
+
+ if (listp->size == 0)
+ {
+ new_size = 255;
+ listp->list = (struct partial_symbol **)
+ xmalloc (new_size * sizeof (struct partial_symbol *));
+ }
+ else
+ {
+ new_size = listp->size * 2;
+ listp->list = (struct partial_symbol **)
+ xrealloc ((char *) listp->list,
+ new_size * sizeof (struct partial_symbol *));
+ }
+ /* Next assumes we only went one over. Should be good if
+ program works correctly. */
+ listp->next = listp->list + listp->size;
+ listp->size = new_size;
}
/* Helper function, adds partial symbol to the given partial symbol
Since one arg is a struct, we pass in a ptr and deref it (sigh).
Return the partial symbol that has been added. */
-/* NOTE: carlton/2003-09-11: The reason why we return the partial
- symbol is so that callers can get access to the symbol's demangled
- name, which they don't have any cheap way to determine otherwise.
- (Currenly, dwarf2read.c is the only file who uses that information,
- though it's possible that other readers might in the future.)
- Elena wasn't thrilled about that, and I don't blame her, but we
- couldn't come up with a better way to get that information. If
- it's needed in other situations, we could consider breaking up
- SYMBOL_SET_NAMES to provide access to the demangled name lookup
- cache. */
-
-const struct partial_symbol *
-add_psymbol_to_list (char *name, int namelength, int copy_name,
+void
+add_psymbol_to_list (const char *name, int namelength, int copy_name,
domain_enum domain,
enum address_class class,
struct psymbol_allocation_list *list,
int added;
- /* Stash the partial symbol away in the cache */
+ /* Stash the partial symbol away in the cache. */
psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, class,
val, coreaddr, language, objfile, &added);
/* Do not duplicate global partial symbols. */
if (list == &objfile->global_psymbols
&& !added)
- return psym;
+ return;
- /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
+ /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
append_psymbol_to_list (list, psym, objfile);
- return psym;
}
/* Initialize storage for partial symbols. */
/* Current best guess is that approximately a twentieth
of the total symbols (in a debugging file) are global or static
- oriented symbols */
+ oriented symbols, then multiply that by slop factor of two. */
objfile->global_psymbols.size = total_symbols / 10;
objfile->static_psymbols.size = total_symbols / 10;
sizeof (struct partial_symtab));
memset (psymtab, 0, sizeof (struct partial_symtab));
- psymtab->filename = obsavestring (filename, strlen (filename),
- &objfile->objfile_obstack);
+ psymtab->filename = bcache (filename, strlen (filename) + 1,
+ objfile->per_bfd->filename_cache);
psymtab->symtab = NULL;
/* Prepend it to the psymtab list for the objfile it belongs to.
Psymtabs are searched in most recent inserted -> least recent
- inserted order. */
+ inserted order. */
- psymtab->objfile = objfile;
psymtab->next = objfile->psymtabs;
objfile->psymtabs = psymtab;
+ if (symtab_create_debug)
+ {
+ /* Be a bit clever with debugging messages, and don't print objfile
+ every time, only when it changes. */
+ static char *last_objfile_name = NULL;
+
+ if (last_objfile_name == NULL
+ || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
+ {
+ xfree (last_objfile_name);
+ last_objfile_name = xstrdup (objfile_name (objfile));
+ fprintf_unfiltered (gdb_stdlog,
+ "Creating one or more psymtabs for objfile %s ...\n",
+ last_objfile_name);
+ }
+ fprintf_unfiltered (gdb_stdlog,
+ "Created psymtab %s for module %s.\n",
+ host_address_to_string (psymtab), filename);
+ }
+
return (psymtab);
}
void
-discard_psymtab (struct partial_symtab *pst)
+discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
{
struct partial_symtab **prev_pst;
nothing else is not empty, but we don't realize that. Fixing
that without slowing things down might be tricky. */
- /* First, snip it out of the psymtab chain */
+ /* First, snip it out of the psymtab chain. */
- prev_pst = &(pst->objfile->psymtabs);
+ prev_pst = &(objfile->psymtabs);
while ((*prev_pst) != pst)
prev_pst = &((*prev_pst)->next);
(*prev_pst) = pst->next;
- /* Next, put it on a free list for recycling */
+ /* Next, put it on a free list for recycling. */
- pst->next = pst->objfile->free_psymtabs;
- pst->objfile->free_psymtabs = pst;
+ pst->next = objfile->free_psymtabs;
+ objfile->free_psymtabs = pst;
}
-/* Increase the space allocated for LISTP, which is probably
- global_psymbols or static_psymbols. This space will eventually
- be freed in free_objfile(). */
+/* An object of this type is passed to discard_psymtabs_upto. */
-void
-extend_psymbol_list (struct psymbol_allocation_list *listp,
- struct objfile *objfile)
+struct psymtab_state
{
- int new_size;
+ /* The objfile where psymtabs are discarded. */
- if (listp->size == 0)
- {
- new_size = 255;
- listp->list = (struct partial_symbol **)
- xmalloc (new_size * sizeof (struct partial_symbol *));
- }
- else
- {
- new_size = listp->size * 2;
- listp->list = (struct partial_symbol **)
- xrealloc ((char *) listp->list,
- new_size * sizeof (struct partial_symbol *));
- }
- /* Next assumes we only went one over. Should be good if
- program works correctly */
- listp->next = listp->list + listp->size;
- listp->size = new_size;
+ struct objfile *objfile;
+
+ /* The first psymtab to save. */
+
+ struct partial_symtab *save;
+};
+
+/* A cleanup function used by make_cleanup_discard_psymtabs. */
+
+static void
+discard_psymtabs_upto (void *arg)
+{
+ struct psymtab_state *state = arg;
+
+ while (state->objfile->psymtabs != state->save)
+ discard_psymtab (state->objfile, state->objfile->psymtabs);
+}
+
+/* Return a new cleanup that discards all psymtabs created in OBJFILE
+ after this function is called. */
+
+struct cleanup *
+make_cleanup_discard_psymtabs (struct objfile *objfile)
+{
+ struct psymtab_state *state = XNEW (struct psymtab_state);
+
+ state->objfile = objfile;
+ state->save = objfile->psymtabs;
+
+ return make_cleanup_dtor (discard_psymtabs_upto, state, xfree);
}
\f
-void
+static void
maintenance_print_psymbols (char *args, int from_tty)
{
char **argv;
if (args == NULL)
{
- error (_("print-psymbols takes an output file name and optional symbol file name"));
+ error (_("\
+print-psymbols takes an output file name and optional symbol file name"));
}
argv = gdb_buildargv (args);
cleanups = make_cleanup_freeargv (argv);
if (argv[0] != NULL)
{
filename = argv[0];
- /* If a second arg is supplied, it is a source file name to match on */
+ /* If a second arg is supplied, it is a source file name to match on. */
if (argv[1] != NULL)
{
symname = argv[1];
perror_with_name (filename);
make_cleanup_ui_file_delete (outfile);
- immediate_quit++;
ALL_PSYMTABS (objfile, ps)
- if (symname == NULL || strcmp (symname, ps->filename) == 0)
- dump_psymtab (objfile, ps, outfile);
- immediate_quit--;
+ {
+ QUIT;
+ if (symname == NULL || filename_cmp (symname, ps->filename) == 0)
+ dump_psymtab (objfile, ps, outfile);
+ }
do_cleanups (cleanups);
}
/* List all the partial symbol tables whose names match REGEXP (optional). */
-void
+static void
maintenance_info_psymtabs (char *regexp, int from_tty)
{
struct program_space *pspace;
actually find a symtab whose name matches. */
int printed_objfile_start = 0;
- ALL_OBJFILE_PSYMTABS (objfile, psymtab)
+ ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
{
QUIT;
{
if (! printed_objfile_start)
{
- printf_filtered ("{ objfile %s ", objfile->name);
+ printf_filtered ("{ objfile %s ", objfile_name (objfile));
wrap_here (" ");
printf_filtered ("((struct objfile *) %s)\n",
host_address_to_string (objfile));
printf_filtered (" readin %s\n",
psymtab->readin ? "yes" : "no");
printf_filtered (" fullname %s\n",
- psymtab->fullname ? psymtab->fullname : "(null)");
+ psymtab->fullname
+ ? psymtab->fullname : "(null)");
printf_filtered (" text addresses ");
fputs_filtered (paddress (gdbarch, psymtab->textlow),
gdb_stdout);
fputs_filtered (paddress (gdbarch, psymtab->texthigh),
gdb_stdout);
printf_filtered ("\n");
+ printf_filtered (" psymtabs_addrmap_supported %s\n",
+ (psymtab->psymtabs_addrmap_supported
+ ? "yes" : "no"));
printf_filtered (" globals ");
if (psymtab->n_global_syms)
{
printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
- host_address_to_string (psymtab->objfile->global_psymbols.list
+ host_address_to_string (objfile->global_psymbols.list
+ psymtab->globals_offset),
psymtab->n_global_syms);
}
if (psymtab->n_static_syms)
{
printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
- host_address_to_string (psymtab->objfile->static_psymbols.list
+ host_address_to_string (objfile->static_psymbols.list
+ psymtab->statics_offset),
psymtab->n_static_syms);
}
}
}
-/* Check consistency of psymtabs and symtabs. */
+/* Check consistency of currently expanded psymtabs vs symtabs. */
-void
-maintenance_check_symtabs (char *ignore, int from_tty)
+static void
+maintenance_check_psymtabs (char *ignore, int from_tty)
{
struct symbol *sym;
struct partial_symbol **psym;
struct symtab *s = NULL;
struct partial_symtab *ps;
- struct blockvector *bv;
+ const struct blockvector *bv;
struct objfile *objfile;
struct block *b;
int length;
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
- s = PSYMTAB_TO_SYMTAB (ps);
+ /* We don't call psymtab_to_symtab here because that may cause symtab
+ expansion. When debugging a problem it helps if checkers leave
+ things unchanged. */
+ s = ps->symtab;
+
+ /* First do some checks that don't require the associated symtab. */
+ if (ps->texthigh < ps->textlow)
+ {
+ printf_filtered ("Psymtab ");
+ puts_filtered (ps->filename);
+ printf_filtered (" covers bad range ");
+ fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
+ printf_filtered (" - ");
+ fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
+ printf_filtered ("\n");
+ continue;
+ }
+
+ /* Now do checks requiring the associated symtab. */
if (s == NULL)
continue;
bv = BLOCKVECTOR (s);
b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
- psym = ps->objfile->static_psymbols.list + ps->statics_offset;
+ psym = objfile->static_psymbols.list + ps->statics_offset;
length = ps->n_static_syms;
while (length--)
{
psym++;
}
b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- psym = ps->objfile->global_psymbols.list + ps->globals_offset;
+ psym = objfile->global_psymbols.list + ps->globals_offset;
length = ps->n_global_syms;
while (length--)
{
}
psym++;
}
- if (ps->texthigh < ps->textlow)
- {
- printf_filtered ("Psymtab ");
- puts_filtered (ps->filename);
- printf_filtered (" covers bad range ");
- fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
- printf_filtered (" - ");
- fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
- printf_filtered ("\n");
- continue;
- }
- if (ps->texthigh == 0)
- continue;
- if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
+ if (ps->texthigh != 0
+ && (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b)))
{
printf_filtered ("Psymtab ");
puts_filtered (ps->filename);
\f
-void
-map_partial_symbol_names (void (*fun) (const char *, void *), void *data)
-{
- struct objfile *objfile;
-
- ALL_OBJFILES (objfile)
- {
- if (objfile->sf)
- objfile->sf->qf->map_symbol_names (objfile, fun, data);
- }
-}
+extern initialize_file_ftype _initialize_psymtab;
void
-map_partial_symbol_filenames (void (*fun) (const char *, const char *,
- void *),
- void *data)
+_initialize_psymtab (void)
{
- struct objfile *objfile;
-
- ALL_OBJFILES (objfile)
- {
- if (objfile->sf)
- objfile->sf->qf->map_symbol_filenames (objfile, fun, data);
- }
+ add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
+Print dump of current partial symbol definitions.\n\
+Entries in the partial symbol table are dumped to file OUTFILE.\n\
+If a SOURCE file is specified, dump only that file's partial symbols."),
+ &maintenanceprintlist);
+
+ add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
+List the partial symbol tables for all object files.\n\
+This does not include information about individual partial symbols,\n\
+just the symbol table structures themselves."),
+ &maintenanceinfolist);
+
+ add_cmd ("check-psymtabs", class_maintenance, maintenance_check_psymtabs,
+ _("\
+Check consistency of currently expanded psymtabs versus symtabs."),
+ &maintenancelist);
}
projects / platform / upstream / binutils.git / blobdiff