/* Partial symbol tables.
- Copyright (C) 2009-2014 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. */
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);
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;
}
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)
{
psymtab_index, domain))
{
struct symbol *sym = NULL;
- struct symtab *stab = psymtab_to_symtab (objfile, ps);
+ 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);
/* 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)
- {
- struct blockvector *bv = BLOCKVECTOR (stab);
- struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
-
- sym = lookup_block_symbol (block, name, domain);
- }
+ sym = block_lookup_symbol (block, name, domain);
if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
{
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,
- const struct section_offsets *new_offsets,
- const 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;
{
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, "\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;
}
}
+/* 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;
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 (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)
+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;
&& PSYMBOL_CLASS (*psym) == LOC_BLOCK)
|| (kind == TYPES_DOMAIN
&& PSYMBOL_CLASS (*psym) == LOC_TYPEDEF))
- && (*name_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
+ && (*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 basenames),
- 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;
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,
- 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_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;
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,
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. */
memset (psymtab, 0, sizeof (struct partial_symtab));
psymtab->filename = bcache (filename, strlen (filename) + 1,
objfile->per_bfd->filename_cache);
- psymtab->symtab = NULL;
+ 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
{
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;
/* 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;
+ cust = ps->compunit_symtab;
/* First do some checks that don't require the associated symtab. */
if (ps->texthigh < ps->textlow)
}
/* Now do checks requiring the associated symtab. */
- if (s == NULL)
+ 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)
{
projects / deliverable / binutils-gdb.git / blobdiff