/* Partial symbol tables.
- Copyright (C) 2009-2013 Free Software Foundation, Inc.
+ Copyright (C) 2009-2015 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"
static void fixup_psymbol_section (struct partial_symbol *psym,
struct objfile *objfile);
-static struct symtab *psymtab_to_symtab (struct objfile *objfile,
- struct partial_symtab *pst);
+static struct compunit_symtab *psymtab_to_symtab (struct objfile *objfile,
+ struct partial_symtab *pst);
/* Ensure that the partial symbols for OBJFILE have been loaded. This
function always returns its argument, as a convenience. */
if (verbose)
{
printf_unfiltered (_("Reading symbols from %s..."),
- objfile->name);
+ objfile_name (objfile));
gdb_flush (gdb_stdout);
}
(*objfile->sf->sym_read_psymbols) (objfile);
ALL_OBJFILES (objfile) \
ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
-/* Helper function for partial_map_symtabs_matching_filename that
+/* Helper function for psym_map_symtabs_matching_filename that
expands the symtabs and calls the iterator. */
static int
int (*callback) (struct symtab *, void *),
void *data)
{
- struct symtab *last_made = objfile->symtabs;
+ struct compunit_symtab *last_made = objfile->compunit_symtabs;
/* Shared psymtabs should never be seen here. Instead they should
be handled properly by the caller. */
psymtab_to_symtab (objfile, pst);
return iterate_over_some_symtabs (name, real_path, callback, data,
- objfile->symtabs, last_made);
+ objfile->compunit_symtabs, last_made);
}
-/* Implementation of the map_symtabs_matching_filename method. */
+/* Psymtab version of map_symtabs_matching_filename. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
static int
-partial_map_symtabs_matching_filename (struct objfile *objfile,
- const char *name,
- const char *real_path,
- int (*callback) (struct symtab *,
- void *),
- void *data)
+psym_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);
if (partial_map_expand_apply (objfile, name, real_path,
pst, callback, data))
return 1;
+ continue;
}
/* Before we invoke realpath, which can get expensive when many
&& FILENAME_CMP (name_basename, lbasename (pst->filename)) != 0)
continue;
+ if (compare_filenames_for_search (psymtab_to_fullname (pst), name))
+ {
+ 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)
{
gdb_assert (IS_ABSOLUTE_PATH (real_path));
gdb_assert (IS_ABSOLUTE_PATH (name));
- psymtab_to_fullname (pst);
- if (pst->fullname != NULL
- && FILENAME_CMP (real_path, pst->fullname) == 0)
+ if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0)
{
if (partial_map_expand_apply (objfile, name, real_path,
pst, callback, data))
return 1;
+ continue;
}
}
}
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 partial_symtab *tpst;
struct partial_symtab *best_pst = pst;
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
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
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;
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;
}
return NULL;
}
-static struct symtab *
-find_pc_sect_symtab_from_partial (struct objfile *objfile,
- struct minimal_symbol *msymbol,
- CORE_ADDR pc, struct obj_section *section,
- int warn_if_readin)
+/* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
+static struct compunit_symtab *
+psym_find_pc_sect_compunit_symtab (struct objfile *objfile,
+ struct bound_minimal_symbol msymbol,
+ CORE_ADDR pc,
+ struct obj_section *section,
+ int warn_if_readin)
{
struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section,
msymbol);
(Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
paddress (get_objfile_arch (objfile), pc));
psymtab_to_symtab (objfile, ps);
- return ps->symtab;
+ return ps->compunit_symtab;
}
return NULL;
}
{
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
if (section) /* Match on a specific section. */
{
fixup_psymbol_section (p, objfile);
- if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
+ if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
+ section))
continue;
}
best_pc = SYMBOL_VALUE_ADDRESS (p);
{
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
if (section) /* Match on a specific section. */
{
fixup_psymbol_section (p, objfile);
- if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
+ if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
+ section))
continue;
}
best_pc = SYMBOL_VALUE_ADDRESS (p);
{
CORE_ADDR addr;
- if (psym == NULL || SYMBOL_OBJ_SECTION (psym) != NULL)
+ if (!psym)
+ return;
+
+ if (SYMBOL_SECTION (psym) >= 0)
return;
gdb_assert (objfile);
- switch (SYMBOL_CLASS (psym))
+ switch (PSYMBOL_CLASS (psym))
{
case LOC_STATIC:
case LOC_LABEL:
fixup_section (&psym->ginfo, addr, objfile);
}
-static struct symtab *
-lookup_symbol_aux_psymtabs (struct objfile *objfile,
- int block_index, const char *name,
- const domain_enum domain)
+/* Psymtab version of lookup_symbol. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
+static struct compunit_symtab *
+psym_lookup_symbol (struct objfile *objfile,
+ int block_index, const char *name,
+ const domain_enum domain)
{
struct partial_symtab *ps;
const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
- struct symtab *stab_best = NULL;
+ struct compunit_symtab *stab_best = NULL;
ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, 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);
+ struct symbol *sym, *with_opaque = NULL;
+ struct compunit_symtab *stab = psymtab_to_symtab (objfile, ps);
+ /* Note: While psymtab_to_symtab can return NULL if the partial symtab
+ is empty, we can assume it won't here because lookup_partial_symbol
+ succeeded. */
+ const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
+ struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
+
+ sym = block_find_symbol (block, name, domain,
+ block_find_non_opaque_type_preferred,
+ &with_opaque);
/* Some caution must be observed with overloaded functions
- and methods, since the psymtab will not contain any overload
+ and methods, since the index will not contain any overload
information (but NAME might contain it). */
- if (stab->primary)
- {
- 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;
- }
+ if (sym != NULL
+ && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
+ return stab;
+ if (with_opaque != NULL
+ && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
+ stab_best = stab;
/* Keep looking through other psymtabs. */
}
case language_cplus:
case language_java:
{
- if (strchr (name, '('))
- {
- char *ret = cp_remove_params (name);
+ if (strchr (name, '('))
+ {
+ char *ret = cp_remove_params (name);
- if (ret)
- return ret;
- }
+ if (ret)
+ return ret;
+ }
}
break;
}
/* Get the symbol table that corresponds to a partial_symtab.
- This is fast after the first time you do it. */
+ This is fast after the first time you do it.
+ The result will be NULL if the primary symtab has no symbols,
+ which can happen. Otherwise the result is the primary symtab
+ that contains PST. */
-static struct symtab *
+static struct compunit_symtab *
psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
{
/* If it is a shared psymtab, find an unshared psymtab that includes
pst = pst->user;
/* If it's been looked up before, return it. */
- if (pst->symtab)
- return pst->symtab;
+ if (pst->compunit_symtab)
+ return pst->compunit_symtab;
/* If it has not yet been read in, read it. */
if (!pst->readin)
do_cleanups (back_to);
}
- return pst->symtab;
+ return pst->compunit_symtab;
}
+/* Psymtab version of relocate. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
static void
-relocate_psymtabs (struct objfile *objfile,
- struct section_offsets *new_offsets,
- struct section_offsets *delta)
+psym_relocate (struct objfile *objfile,
+ const struct section_offsets *new_offsets,
+ const struct section_offsets *delta)
{
struct partial_symbol **psym;
struct partial_symtab *p;
}
}
+/* Psymtab version of find_last_source_symtab. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
static struct symtab *
-find_last_source_symtab_from_partial (struct objfile *ofp)
+psym_find_last_source_symtab (struct objfile *ofp)
{
struct partial_symtab *ps;
struct partial_symtab *cs_pst = 0;
"readin pst found and no symtabs."));
}
else
- return psymtab_to_symtab (ofp, cs_pst);
+ {
+ struct compunit_symtab *cust = psymtab_to_symtab (ofp, cs_pst);
+
+ if (cust == NULL)
+ return NULL;
+ return compunit_primary_filetab (cust);
+ }
}
return NULL;
}
+/* Psymtab version of forget_cached_source_info. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
static void
-forget_cached_source_info_partial (struct objfile *objfile)
+psym_forget_cached_source_info (struct objfile *objfile)
{
struct partial_symtab *pst;
fputs_filtered ("<invalid domain>, ", outfile);
break;
}
- switch (SYMBOL_CLASS (*p))
+ switch (PSYMBOL_CLASS (*p))
{
case LOC_UNDEF:
fputs_filtered ("undefined", outfile);
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,
" Full symtab was read (at ");
- gdb_print_host_address (psymtab->symtab, outfile);
+ gdb_print_host_address (psymtab->compunit_symtab, outfile);
fprintf_filtered (outfile, " by function at ");
gdb_print_host_address (psymtab->read_symtab, outfile);
fprintf_filtered (outfile, ")\n");
}
- fprintf_filtered (outfile, " Relocate symbols by ");
- for (i = 0; i < objfile->num_sections; ++i)
- {
- if (i != 0)
- fprintf_filtered (outfile, ", ");
- wrap_here (" ");
- fputs_filtered (paddress (gdbarch,
- ANOFFSET (psymtab->section_offsets, i)),
- outfile);
- }
- fprintf_filtered (outfile, "\n");
-
fprintf_filtered (outfile, " Symbols cover text addresses ");
fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
fprintf_filtered (outfile, "-");
fprintf_filtered (outfile, "\n");
}
+/* Psymtab version of print_stats. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
static void
-print_psymtab_stats_for_objfile (struct objfile *objfile)
+psym_print_stats (struct objfile *objfile)
{
int i;
struct partial_symtab *ps;
printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
}
+/* Psymtab version of dump. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
static void
-dump_psymtabs_for_objfile (struct objfile *objfile)
+psym_dump (struct objfile *objfile)
{
struct partial_symtab *psymtab;
}
}
-/* Look through the partial symtabs for all symbols which begin
- by matching FUNC_NAME. Make sure we read that symbol table in. */
+/* Psymtab version of expand_symtabs_for_function. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
static void
-read_symtabs_for_function (struct objfile *objfile, const char *func_name)
+psym_expand_symtabs_for_function (struct objfile *objfile,
+ const char *func_name)
{
struct partial_symtab *ps;
}
}
+/* Psymtab version of expand_all_symtabs. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
static void
-expand_partial_symbol_tables (struct objfile *objfile)
+psym_expand_all_symtabs (struct objfile *objfile)
{
struct partial_symtab *psymtab;
}
}
+/* Psymtab version of expand_symtabs_with_fullname. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
static void
-read_psymtabs_with_fullname (struct objfile *objfile, const char *fullname)
+psym_expand_symtabs_with_fullname (struct objfile *objfile,
+ const char *fullname)
{
struct partial_symtab *p;
if (p->anonymous)
continue;
- if (filename_cmp (fullname, p->filename) == 0)
+ /* 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);
}
}
+/* Psymtab version of map_symbol_filenames. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
static void
-map_symbol_filenames_psymtab (struct objfile *objfile,
- symbol_filename_ftype *fun, void *data,
- int need_fullname)
+psym_map_symbol_filenames (struct objfile *objfile,
+ symbol_filename_ftype *fun, void *data,
+ int need_fullname)
{
struct partial_symtab *ps;
static const char *
psymtab_to_fullname (struct partial_symtab *ps)
{
- int r;
-
- if (!ps)
- return NULL;
- if (ps->anonymous)
- return NULL;
+ gdb_assert (!ps->anonymous);
/* 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)
- return ps->fullname;
+ if (ps->fullname == NULL)
+ {
+ int fd = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
- 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_REQUIRED (objfile, pst)
- {
- if (lookup_partial_symbol (objfile, pst, name, 1, VAR_DOMAIN))
- return pst->filename;
- }
- return NULL;
+ return ps->fullname;
}
-/* For all symbols, s, in BLOCK that are in NAMESPACE and match NAME
+/* For all symbols, s, in BLOCK that are in DOMAIN 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 int
-map_block (const char *name, domain_enum namespace, struct objfile *objfile,
+map_block (const char *name, domain_enum domain, struct objfile *objfile,
struct block *block,
int (*callback) (struct block *, struct symbol *, void *),
void *data, symbol_compare_ftype *match)
sym != NULL; sym = block_iter_match_next (name, match, &iter))
{
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
- SYMBOL_DOMAIN (sym), namespace))
+ SYMBOL_DOMAIN (sym), domain))
{
if (callback (block, sym, data))
return 1;
the definition of quick_symbol_functions in symfile.h. */
static void
-map_matching_symbols_psymtab (const char *name, domain_enum namespace,
- struct objfile *objfile, int global,
- int (*callback) (struct block *,
- struct symbol *, void *),
- void *data,
- symbol_compare_ftype *match,
- symbol_compare_ftype *ordered_compare)
+psym_map_matching_symbols (struct objfile *objfile,
+ const char *name, domain_enum domain,
+ 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;
{
QUIT;
if (ps->readin
- || match_partial_symbol (objfile, ps, global, name, namespace, match,
+ || match_partial_symbol (objfile, ps, global, name, domain, match,
ordered_compare))
{
- struct symtab *s = psymtab_to_symtab (objfile, ps);
+ struct compunit_symtab *cust = psymtab_to_symtab (objfile, ps);
struct block *block;
- if (s == NULL || !s->primary)
+ if (cust == NULL)
continue;
- block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind);
- if (map_block (name, namespace, objfile, block,
+ block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), block_kind);
+ if (map_block (name, domain, objfile, block,
callback, data, match))
return;
if (callback (block, NULL, data))
}
}
-/* A helper for expand_symtabs_matching_via_partial that handles
+/* A helper for psym_expand_symtabs_matching 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. */
recursively_search_psymtabs (struct partial_symtab *ps,
struct objfile *objfile,
enum search_domain kind,
- int (*name_matcher) (const char *, void *),
+ expand_symtabs_symbol_matcher_ftype *sym_matcher,
void *data)
{
struct partial_symbol **psym;
continue;
r = recursively_search_psymtabs (ps->dependencies[i],
- objfile, kind, name_matcher, data);
+ objfile, kind, sym_matcher, data);
if (r != 0)
{
ps->searched_flag = PST_SEARCHED_AND_FOUND;
if ((kind == ALL_DOMAIN
|| (kind == VARIABLES_DOMAIN
- && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
- && SYMBOL_CLASS (*psym) != LOC_BLOCK)
+ && PSYMBOL_CLASS (*psym) != LOC_TYPEDEF
+ && PSYMBOL_CLASS (*psym) != LOC_BLOCK)
|| (kind == FUNCTIONS_DOMAIN
- && SYMBOL_CLASS (*psym) == LOC_BLOCK)
+ && PSYMBOL_CLASS (*psym) == LOC_BLOCK)
|| (kind == TYPES_DOMAIN
- && SYMBOL_CLASS (*psym) == LOC_TYPEDEF))
- && (*name_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
+ && PSYMBOL_CLASS (*psym) == LOC_TYPEDEF))
+ && (*sym_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
{
/* Found a match, so notify our caller. */
result = PST_SEARCHED_AND_FOUND;
return result == PST_SEARCHED_AND_FOUND;
}
+/* Psymtab version of expand_symtabs_matching. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
static void
-expand_symtabs_matching_via_partial
+psym_expand_symtabs_matching
(struct objfile *objfile,
- int (*file_matcher) (const char *, void *),
- int (*name_matcher) (const char *, void *),
+ expand_symtabs_file_matcher_ftype *file_matcher,
+ expand_symtabs_symbol_matcher_ftype *symbol_matcher,
+ expand_symtabs_exp_notify_ftype *expansion_notify,
enum search_domain kind,
void *data)
{
ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
{
+ QUIT;
+
if (ps->readin)
continue;
if (file_matcher)
{
+ int match;
+
if (ps->anonymous)
continue;
- if (! (*file_matcher) (ps->filename, data))
+
+ match = (*file_matcher) (ps->filename, data, 0);
+ if (!match)
+ {
+ /* 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);
+ }
+ if (!match)
continue;
}
- if (recursively_search_psymtabs (ps, objfile, kind, name_matcher, data))
- psymtab_to_symtab (objfile, ps);
+ if (recursively_search_psymtabs (ps, objfile, kind, symbol_matcher, data))
+ {
+ struct compunit_symtab *symtab =
+ psymtab_to_symtab (objfile, ps);
+
+ if (expansion_notify != NULL)
+ expansion_notify (symtab, data);
+ }
}
}
+/* Psymtab version of has_symbols. See its definition in
+ the definition of quick_symbol_functions in symfile.h. */
+
static int
-objfile_has_psyms (struct objfile *objfile)
+psym_has_symbols (struct objfile *objfile)
{
return objfile->psymtabs != NULL;
}
const struct quick_symbol_functions psym_functions =
{
- objfile_has_psyms,
- find_last_source_symtab_from_partial,
- forget_cached_source_info_partial,
- partial_map_symtabs_matching_filename,
- lookup_symbol_aux_psymtabs,
- print_psymtab_stats_for_objfile,
- dump_psymtabs_for_objfile,
- relocate_psymtabs,
- read_symtabs_for_function,
- expand_partial_symbol_tables,
- read_psymtabs_with_fullname,
- find_symbol_file_from_partial,
- map_matching_symbols_psymtab,
- expand_symtabs_matching_via_partial,
- find_pc_sect_symtab_from_partial,
- map_symbol_filenames_psymtab
+ psym_has_symbols,
+ psym_find_last_source_symtab,
+ psym_forget_cached_source_info,
+ psym_map_symtabs_matching_filename,
+ psym_lookup_symbol,
+ psym_print_stats,
+ psym_dump,
+ psym_relocate,
+ psym_expand_symtabs_for_function,
+ psym_expand_all_symtabs,
+ psym_expand_symtabs_with_fullname,
+ psym_map_matching_symbols,
+ psym_expand_symtabs_matching,
+ psym_find_pc_sect_compunit_symtab,
+ psym_map_symbol_filenames
};
\f
struct partial_symtab *
start_psymtab_common (struct objfile *objfile,
- struct section_offsets *section_offsets,
const char *filename,
CORE_ADDR textlow, struct partial_symbol **global_syms,
struct partial_symbol **static_syms)
struct partial_symtab *psymtab;
psymtab = allocate_psymtab (filename, objfile);
- psymtab->section_offsets = section_offsets;
psymtab->textlow = textlow;
psymtab->texthigh = psymtab->textlow; /* default */
psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
struct partial_symbol *psymbol = (struct partial_symbol *) addr;
unsigned int lang = psymbol->ginfo.language;
unsigned int domain = PSYMBOL_DOMAIN (psymbol);
- unsigned int class = PSYMBOL_CLASS (psymbol);
+ unsigned int theclass = PSYMBOL_CLASS (psymbol);
h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
h = hash_continue (&lang, sizeof (unsigned int), h);
h = hash_continue (&domain, sizeof (unsigned int), h);
- h = hash_continue (&class, sizeof (unsigned int), h);
+ h = hash_continue (&theclass, sizeof (unsigned int), h);
h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h);
return h;
struct psymbol_bcache *
psymbol_bcache_init (void)
{
- struct psymbol_bcache *bcache = XCALLOC (1, struct psymbol_bcache);
+ struct psymbol_bcache *bcache = XCNEW (struct psymbol_bcache);
bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
return bcache;
}
static const struct partial_symbol *
add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
domain_enum domain,
- enum address_class class,
+ enum address_class theclass,
long val, /* Value as a long */
CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
enum language language, struct objfile *objfile,
{
struct partial_symbol psymbol;
- /* We must ensure that the entire 'value' field has been zeroed
- before assigning to it, because an assignment may not write the
- entire field. */
- memset (&psymbol.ginfo.value, 0, sizeof (psymbol.ginfo.value));
+ /* 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_ADDRESS (&psymbol) = coreaddr;
}
- SYMBOL_SECTION (&psymbol) = 0;
- SYMBOL_OBJ_SECTION (&psymbol) = NULL;
- 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;
+ PSYMBOL_CLASS (&psymbol) = theclass;
SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
void
add_psymbol_to_list (const char *name, int namelength, int copy_name,
domain_enum domain,
- enum address_class class,
+ enum address_class theclass,
struct psymbol_allocation_list *list,
long val, /* Value as a long */
CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
int added;
/* Stash the partial symbol away in the cache. */
- psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, class,
+ psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, theclass,
val, coreaddr, language, objfile, &added);
/* Do not duplicate global partial symbols. */
sizeof (struct partial_symtab));
memset (psymtab, 0, sizeof (struct partial_symtab));
- psymtab->filename = obstack_copy0 (&objfile->objfile_obstack,
- filename, strlen (filename));
- psymtab->symtab = NULL;
+ psymtab->filename = bcache (filename, strlen (filename) + 1,
+ objfile->per_bfd->filename_cache);
+ psymtab->compunit_symtab = NULL;
/* Prepend it to the psymtab list for the objfile it belongs to.
Psymtabs are searched in most recent inserted -> least recent
static char *last_objfile_name = NULL;
if (last_objfile_name == NULL
- || strcmp (last_objfile_name, objfile->name) != 0)
+ || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
{
xfree (last_objfile_name);
- last_objfile_name = xstrdup (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);
{
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));
}
}
-/* Check consistency of psymtabs and symtabs. */
+/* Check consistency of currently expanded psymtabs vs symtabs. */
static void
-maintenance_check_symtabs (char *ignore, int from_tty)
+maintenance_check_psymtabs (char *ignore, int from_tty)
{
struct symbol *sym;
struct partial_symbol **psym;
- struct symtab *s = NULL;
+ struct compunit_symtab *cust = 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 (objfile, ps);
- if (s == NULL)
+ /* 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. */
+ cust = ps->compunit_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 (cust == NULL)
continue;
- bv = BLOCKVECTOR (s);
+ bv = COMPUNIT_BLOCKVECTOR (cust);
b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
psym = objfile->static_psymbols.list + ps->statics_offset;
length = ps->n_static_syms;
while (length--)
{
- sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
+ sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
SYMBOL_DOMAIN (*psym));
if (!sym)
{
length = ps->n_global_syms;
while (length--)
{
- sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
+ sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
SYMBOL_DOMAIN (*psym));
if (!sym)
{
}
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
-expand_partial_symbol_names (int (*fun) (const char *, void *),
- void *data)
-{
- struct objfile *objfile;
-
- ALL_OBJFILES (objfile)
- {
- if (objfile->sf)
- objfile->sf->qf->expand_symtabs_matching (objfile, NULL, fun,
- ALL_DOMAIN, data);
- }
-}
-
-void
-map_partial_symbol_filenames (symbol_filename_ftype *fun, void *data,
- int need_fullname)
-{
- struct objfile *objfile;
-
- ALL_OBJFILES (objfile)
- {
- if (objfile->sf)
- objfile->sf->qf->map_symbol_filenames (objfile, fun, data,
- need_fullname);
- }
-}
-
extern initialize_file_ftype _initialize_psymtab;
void
just the symbol table structures themselves."),
&maintenanceinfolist);
- add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
- _("Check consistency of psymtabs and symtabs."),
+ add_cmd ("check-psymtabs", class_maintenance, maintenance_check_psymtabs,
+ _("\
+Check consistency of currently expanded psymtabs versus symtabs."),
&maintenancelist);
}