/* Partial symbol tables.
- Copyright (C) 2009-2018 Free Software Foundation, Inc.
+ Copyright (C) 2009-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "symtab.h"
-#include "psympriv.h"
#include "objfiles.h"
+#include "psympriv.h"
#include "block.h"
#include "filenames.h"
#include "source.h"
CORE_ADDR,
struct obj_section *);
-static void fixup_psymbol_section (struct partial_symbol *psym,
- struct objfile *objfile);
-
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. */
+\f
+
+psymtab_storage::psymtab_storage ()
+ : psymbol_cache (psymbol_bcache_init ())
+{
+}
+
+psymtab_storage::~psymtab_storage ()
+{
+ psymbol_bcache_free (psymbol_cache);
+}
+
+/* See psymtab.h. */
+
+struct partial_symtab *
+psymtab_storage::allocate_psymtab ()
+{
+ struct partial_symtab *psymtab;
+
+ if (free_psymtabs != nullptr)
+ {
+ psymtab = free_psymtabs;
+ free_psymtabs = psymtab->next;
+ }
+ else
+ psymtab = XOBNEW (obstack (), struct partial_symtab);
+
+ memset (psymtab, 0, sizeof (struct partial_symtab));
+
+ psymtab->next = psymtabs;
+ psymtabs = psymtab;
+
+ return psymtab;
+}
+
+\f
+
+/* See psymtab.h. */
-struct objfile *
+psymtab_storage::partial_symtab_range
require_partial_symbols (struct objfile *objfile, int verbose)
{
if ((objfile->flags & OBJF_PSYMTABS_READ) == 0)
if (objfile->sf->sym_read_psymbols)
{
if (verbose)
- {
- printf_unfiltered (_("Reading symbols from %s..."),
- objfile_name (objfile));
- gdb_flush (gdb_stdout);
- }
+ printf_filtered (_("Reading symbols from %s...\n"),
+ objfile_name (objfile));
(*objfile->sf->sym_read_psymbols) (objfile);
/* Partial symbols list are not expected to changed after this
point. */
- objfile->global_psymbols.shrink_to_fit ();
- objfile->static_psymbols.shrink_to_fit ();
+ objfile->partial_symtabs->global_psymbols.shrink_to_fit ();
+ objfile->partial_symtabs->static_psymbols.shrink_to_fit ();
- if (verbose)
- {
- if (!objfile_has_symbols (objfile))
- {
- wrap_here ("");
- printf_unfiltered (_("(no debugging symbols found)..."));
- wrap_here ("");
- }
-
- printf_unfiltered (_("done.\n"));
- }
+ if (verbose && !objfile_has_symbols (objfile))
+ printf_filtered (_("(No debugging symbols found in %s)\n"),
+ objfile_name (objfile));
}
}
- return objfile;
+ return objfile->psymtabs ();
}
-/* 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 psym_map_symtabs_matching_filename that
expands the symtabs and calls the iterator. */
const char *real_path,
gdb::function_view<bool (symtab *)> callback)
{
- struct partial_symtab *pst;
const char *name_basename = lbasename (name);
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
- {
- /* 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;
+ for (partial_symtab *pst : require_partial_symbols (objfile, 1))
+ {
+ /* We can skip shared psymtabs here, because any file name will be
+ attached to the unshared psymtab. */
+ if (pst->user != NULL)
+ continue;
- if (compare_filenames_for_search (pst->filename, name))
- {
- if (partial_map_expand_apply (objfile, name, real_path,
- pst, callback))
- return true;
+ /* Anonymous psymtabs don't have a file name. */
+ if (pst->anonymous)
continue;
- }
- /* 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 (pst->filename, name))
+ {
+ if (partial_map_expand_apply (objfile, name, real_path,
+ pst, callback))
+ return true;
+ continue;
+ }
- if (compare_filenames_for_search (psymtab_to_fullname (pst), name))
- {
- if (partial_map_expand_apply (objfile, name, real_path,
- pst, callback))
- return true;
+ /* 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 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));
- if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0)
- {
- if (partial_map_expand_apply (objfile, name, real_path,
- pst, callback))
- return true;
- continue;
- }
- }
- }
+ if (compare_filenames_for_search (psymtab_to_fullname (pst), name))
+ {
+ if (partial_map_expand_apply (objfile, name, real_path,
+ pst, callback))
+ return true;
+ 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));
+ if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0)
+ {
+ if (partial_map_expand_apply (objfile, name, real_path,
+ pst, callback))
+ return true;
+ continue;
+ }
+ }
+ }
return false;
}
{
struct partial_symtab *tpst;
struct partial_symtab *best_pst = pst;
- CORE_ADDR best_addr = pst->textlow;
+ CORE_ADDR best_addr = pst->text_low (objfile);
gdb_assert (!pst->psymtabs_addrmap_supported);
that is closest and still less than the given PC. */
for (tpst = pst; tpst != NULL; tpst = tpst->next)
{
- if (pc >= tpst->textlow && pc < tpst->texthigh)
+ if (pc >= tpst->text_low (objfile) && pc < tpst->text_high (objfile))
{
struct partial_symbol *p;
CORE_ADDR this_addr;
object's symbol table. */
p = find_pc_sect_psymbol (objfile, tpst, pc, section);
if (p != NULL
- && (SYMBOL_VALUE_ADDRESS (p)
- == BMSYMBOL_VALUE_ADDRESS (msymbol)))
+ && (p->address (objfile) == BMSYMBOL_VALUE_ADDRESS (msymbol)))
return tpst;
/* Also accept the textlow value of a psymtab as a
symbol tables with line information but no debug
symbols (e.g. those produced by an assembler). */
if (p != NULL)
- this_addr = SYMBOL_VALUE_ADDRESS (p);
+ this_addr = p->address (objfile);
else
- this_addr = tpst->textlow;
+ this_addr = tpst->text_low (objfile);
/* Check whether it is closer than our current
BEST_ADDR. Since this symbol address is
struct obj_section *section,
struct bound_minimal_symbol msymbol)
{
- struct partial_symtab *pst;
+ CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
+ SECT_OFF_TEXT (objfile));
/* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
than the later used TEXTLOW/TEXTHIGH one. */
- if (objfile->psymtabs_addrmap != NULL)
+ if (objfile->partial_symtabs->psymtabs_addrmap != NULL)
{
- pst = ((struct partial_symtab *)
- addrmap_find (objfile->psymtabs_addrmap, pc));
+ struct partial_symtab *pst
+ = ((struct partial_symtab *)
+ addrmap_find (objfile->partial_symtabs->psymtabs_addrmap,
+ pc - baseaddr));
if (pst != NULL)
{
/* FIXME: addrmaps currently do not handle overlayed sections,
object's symbol table. */
p = find_pc_sect_psymbol (objfile, pst, pc, section);
if (p == NULL
- || (SYMBOL_VALUE_ADDRESS (p)
+ || (p->address (objfile)
!= 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_REQUIRED (objfile, pst)
+ for (partial_symtab *pst : require_partial_symbols (objfile, 1))
if (!pst->psymtabs_addrmap_supported
- && pc >= pst->textlow && pc < pst->texthigh)
+ && pc >= pst->text_low (objfile) && pc < pst->text_high (objfile))
{
struct partial_symtab *best_pst;
{
struct partial_symbol *best = NULL;
CORE_ADDR best_pc;
+ const CORE_ADDR textlow = psymtab->text_low (objfile);
gdb_assert (psymtab != NULL);
/* Cope with programs that start at address 0. */
- best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
+ best_pc = (textlow != 0) ? 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 (int i = 0; i < psymtab->n_global_syms; i++)
{
- partial_symbol *p = objfile->global_psymbols[psymtab->globals_offset + i];
-
- if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
- && 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)))
+ partial_symbol *p
+ = objfile->partial_symtabs->global_psymbols[psymtab->globals_offset
+ + i];
+
+ if (p->domain == VAR_DOMAIN
+ && p->aclass == LOC_BLOCK
+ && pc >= p->address (objfile)
+ && (p->address (objfile) > best_pc
+ || (psymtab->text_low (objfile) == 0
+ && best_pc == 0 && p->address (objfile) == 0)))
{
if (section != NULL) /* Match on a specific section. */
{
- fixup_psymbol_section (p, objfile);
- if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
+ if (!matching_obj_sections (p->obj_section (objfile),
section))
continue;
}
- best_pc = SYMBOL_VALUE_ADDRESS (p);
+ best_pc = p->address (objfile);
best = p;
}
}
for (int i = 0; i < psymtab->n_static_syms; i++)
{
- partial_symbol *p = objfile->static_psymbols[psymtab->statics_offset + i];
-
- if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
- && 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)))
+ partial_symbol *p
+ = objfile->partial_symtabs->static_psymbols[psymtab->statics_offset
+ + i];
+
+ if (p->domain == VAR_DOMAIN
+ && p->aclass == LOC_BLOCK
+ && pc >= p->address (objfile)
+ && (p->address (objfile) > best_pc
+ || (psymtab->text_low (objfile) == 0
+ && best_pc == 0 && p->address (objfile) == 0)))
{
if (section != NULL) /* Match on a specific section. */
{
- fixup_psymbol_section (p, objfile);
- if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
+ if (!matching_obj_sections (p->obj_section (objfile),
section))
continue;
}
- best_pc = SYMBOL_VALUE_ADDRESS (p);
+ best_pc = p->address (objfile);
best = p;
}
}
return best;
}
-static void
-fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
-{
- CORE_ADDR addr;
-
- if (psym == NULL)
- return;
-
- if (SYMBOL_SECTION (psym) >= 0)
- return;
-
- gdb_assert (objfile);
-
- switch (PSYMBOL_CLASS (psym))
- {
- case LOC_STATIC:
- case LOC_LABEL:
- case LOC_BLOCK:
- addr = SYMBOL_VALUE_ADDRESS (psym);
- break;
- default:
- /* Nothing else will be listed in the minsyms -- no use looking
- it up. */
- return;
- }
-
- fixup_section (&psym->ginfo, addr, objfile);
-}
-
/* Psymtab version of lookup_symbol. See its definition in
the definition of quick_symbol_functions in symfile.h. */
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 compunit_symtab *stab_best = NULL;
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
- {
- if (!ps->readin && lookup_partial_symbol (objfile, ps, name,
- psymtab_index, domain))
- {
- 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 index will not contain any overload
- information (but NAME might contain it). */
-
- if (sym != NULL
- && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
- return stab;
- if (with_opaque != NULL
- && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
- stab_best = stab;
-
- /* Keep looking through other psymtabs. */
- }
- }
+ for (partial_symtab *ps : require_partial_symbols (objfile, 1))
+ {
+ if (!ps->readin && lookup_partial_symbol (objfile, ps, name,
+ psymtab_index, domain))
+ {
+ 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 index will not contain any overload
+ information (but NAME might contain it). */
+
+ if (sym != NULL
+ && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
+ return stab;
+ if (with_opaque != NULL
+ && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
+ stab_best = stab;
+
+ /* Keep looking through other psymtabs. */
+ }
+ }
return stab_best;
}
psymbol_name_matches (partial_symbol *psym,
const lookup_name_info &lookup_name)
{
- const language_defn *lang = language_def (SYMBOL_LANGUAGE (psym));
+ const language_defn *lang = language_def (psym->ginfo.language);
symbol_name_matcher_ftype *name_match
= get_symbol_name_matcher (lang, lookup_name);
- return name_match (SYMBOL_SEARCH_NAME (psym), lookup_name, NULL);
+ return name_match (symbol_search_name (&psym->ginfo), lookup_name, NULL);
}
/* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
lookup_name_info lookup_name (name, match_type);
start = (global ?
- &objfile->global_psymbols[pst->globals_offset] :
- &objfile->static_psymbols[pst->statics_offset]);
+ &objfile->partial_symtabs->global_psymbols[pst->globals_offset] :
+ &objfile->partial_symtabs->static_psymbols[pst->statics_offset]);
if (global && ordered_compare) /* Can use a binary search. */
{
center = bottom + (top - bottom) / 2;
gdb_assert (center < top);
- enum language lang = SYMBOL_LANGUAGE (*center);
+ enum language lang = (*center)->ginfo.language;
const char *lang_ln
= lookup_name.language_lookup_name (lang).c_str ();
- if (ordered_compare (SYMBOL_SEARCH_NAME (*center), lang_ln) >= 0)
+ if (ordered_compare (symbol_search_name (&(*center)->ginfo),
+ lang_ln) >= 0)
top = center;
else
bottom = center + 1;
while (top <= real_top
&& psymbol_name_matches (*top, lookup_name))
{
- if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
- SYMBOL_DOMAIN (*top), domain))
+ if (symbol_matches_domain ((*top)->ginfo.language,
+ (*top)->domain, domain))
return *top;
top++;
}
{
for (psym = start; psym < start + length; psym++)
{
- if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
- SYMBOL_DOMAIN (*psym), domain)
+ if (symbol_matches_domain ((*psym)->ginfo.language,
+ (*psym)->domain, domain)
&& psymbol_name_matches (*psym, lookup_name))
return *psym;
}
lookup_name_info lookup_name (search_name.get (), symbol_name_match_type::FULL);
start = (global ?
- &objfile->global_psymbols[pst->globals_offset] :
- &objfile->static_psymbols[pst->statics_offset]);
+ &objfile->partial_symtabs->global_psymbols[pst->globals_offset] :
+ &objfile->partial_symtabs->static_psymbols[pst->statics_offset]);
if (global) /* This means we can use a binary search. */
{
if (!(center < top))
internal_error (__FILE__, __LINE__,
_("failed internal consistency check"));
- if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
+ if (strcmp_iw_ordered (symbol_search_name (&(*center)->ginfo),
search_name.get ()) >= 0)
{
top = center;
/* 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, lookup_name))
+ while (top >= start && symbol_matches_search_name (&(*top)->ginfo,
+ lookup_name))
top--;
/* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
top++;
- while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, lookup_name))
+ while (top <= real_top && symbol_matches_search_name (&(*top)->ginfo,
+ lookup_name))
{
- if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
- SYMBOL_DOMAIN (*top), domain))
+ if (symbol_matches_domain ((*top)->ginfo.language,
+ (*top)->domain, domain))
return *top;
top++;
}
{
for (psym = start; psym < start + length; psym++)
{
- if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
- SYMBOL_DOMAIN (*psym), domain)
- && SYMBOL_MATCHES_SEARCH_NAME (*psym, lookup_name))
+ if (symbol_matches_domain ((*psym)->ginfo.language,
+ (*psym)->domain, domain)
+ && symbol_matches_search_name (&(*psym)->ginfo, lookup_name))
return *psym;
}
}
return pst->compunit_symtab;
}
-/* Psymtab version of relocate. See its definition in
- the definition of quick_symbol_functions in symfile.h. */
-
-static void
-psym_relocate (struct objfile *objfile,
- const struct section_offsets *new_offsets,
- const struct section_offsets *delta)
-{
- struct partial_symtab *p;
-
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
- {
- p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
- p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
- }
-
- for (partial_symbol *psym : objfile->global_psymbols)
- {
- fixup_psymbol_section (psym, objfile);
- if (SYMBOL_SECTION (psym) >= 0)
- SYMBOL_VALUE_ADDRESS (psym) += ANOFFSET (delta, SYMBOL_SECTION (psym));
- }
- for (partial_symbol *psym : objfile->static_psymbols)
- {
- fixup_psymbol_section (psym, objfile);
- if (SYMBOL_SECTION (psym) >= 0)
- SYMBOL_VALUE_ADDRESS (psym) += ANOFFSET (delta, SYMBOL_SECTION (psym));
- }
-
- objfile->psymbol_map.clear ();
-}
-
/* Psymtab version of find_last_source_symtab. See its definition in
the definition of quick_symbol_functions in symfile.h. */
static struct symtab *
psym_find_last_source_symtab (struct objfile *ofp)
{
- struct partial_symtab *ps;
struct partial_symtab *cs_pst = NULL;
- ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)
+ for (partial_symtab *ps : require_partial_symbols (ofp, 1))
{
const char *name = ps->filename;
int len = strlen (name);
static void
psym_forget_cached_source_info (struct objfile *objfile)
{
- struct partial_symtab *pst;
-
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
+ for (partial_symtab *pst : require_partial_symbols (objfile, 1))
{
if (pst->fullname != NULL)
{
}
static void
-print_partial_symbols (struct gdbarch *gdbarch,
+print_partial_symbols (struct gdbarch *gdbarch, struct objfile *objfile,
struct partial_symbol **p, int count, const char *what,
struct ui_file *outfile)
{
while (count-- > 0)
{
QUIT;
- fprintf_filtered (outfile, " `%s'", SYMBOL_LINKAGE_NAME (*p));
- if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
+ fprintf_filtered (outfile, " `%s'", (*p)->ginfo.name);
+ if (symbol_demangled_name (&(*p)->ginfo) != NULL)
{
- fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
+ fprintf_filtered (outfile, " `%s'",
+ symbol_demangled_name (&(*p)->ginfo));
}
fputs_filtered (", ", outfile);
- switch (SYMBOL_DOMAIN (*p))
+ switch ((*p)->domain)
{
case UNDEF_DOMAIN:
fputs_filtered ("undefined domain, ", outfile);
fputs_filtered ("<invalid domain>, ", outfile);
break;
}
- switch (PSYMBOL_CLASS (*p))
+ switch ((*p)->aclass)
{
case LOC_UNDEF:
fputs_filtered ("undefined", outfile);
break;
}
fputs_filtered (", ", outfile);
- fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile);
+ fputs_filtered (paddress (gdbarch, (*p)->unrelocated_address ()), outfile);
fprintf_filtered (outfile, "\n");
p++;
}
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));
+ fprintf_filtered (outfile, " Read from object file %s (",
+ objfile_name (objfile));
gdb_print_host_address (objfile, outfile);
- fprintf_unfiltered (outfile, ")\n");
+ fprintf_filtered (outfile, ")\n");
if (psymtab->readin)
{
}
fprintf_filtered (outfile, " Symbols cover text addresses ");
- fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
+ fputs_filtered (paddress (gdbarch, psymtab->text_low (objfile)), outfile);
fprintf_filtered (outfile, "-");
- fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
+ fputs_filtered (paddress (gdbarch, psymtab->text_high (objfile)), outfile);
fprintf_filtered (outfile, "\n");
fprintf_filtered (outfile, " Address map supported - %s.\n",
psymtab->psymtabs_addrmap_supported ? "yes" : "no");
}
if (psymtab->n_global_syms > 0)
{
- print_partial_symbols (gdbarch,
- &objfile->global_psymbols[psymtab->globals_offset],
- psymtab->n_global_syms, "Global", outfile);
+ print_partial_symbols
+ (gdbarch, objfile,
+ &objfile->partial_symtabs->global_psymbols[psymtab->globals_offset],
+ psymtab->n_global_syms, "Global", outfile);
}
if (psymtab->n_static_syms > 0)
{
- print_partial_symbols (gdbarch,
- &objfile->static_psymbols[psymtab->statics_offset],
- psymtab->n_static_syms, "Static", outfile);
+ print_partial_symbols
+ (gdbarch, objfile,
+ &objfile->partial_symtabs->static_psymbols[psymtab->statics_offset],
+ psymtab->n_static_syms, "Static", outfile);
}
fprintf_filtered (outfile, "\n");
}
psym_print_stats (struct objfile *objfile)
{
int i;
- struct partial_symtab *ps;
i = 0;
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
+ for (partial_symtab *ps : require_partial_symbols (objfile, 1))
{
if (ps->readin == 0)
i++;
{
struct partial_symtab *psymtab;
- if (objfile->psymtabs)
+ if (objfile->partial_symtabs->psymtabs)
{
printf_filtered ("Psymtabs:\n");
- for (psymtab = objfile->psymtabs;
+ for (psymtab = objfile->partial_symtabs->psymtabs;
psymtab != NULL;
psymtab = psymtab->next)
{
psym_expand_symtabs_for_function (struct objfile *objfile,
const char *func_name)
{
- struct partial_symtab *ps;
-
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
- {
- if (ps->readin)
- continue;
+ for (partial_symtab *ps : require_partial_symbols (objfile, 1))
+ {
+ if (ps->readin)
+ continue;
- if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)
- != NULL)
- || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)
- != NULL))
- psymtab_to_symtab (objfile, ps);
- }
+ if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)
+ != NULL)
+ || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)
+ != NULL))
+ psymtab_to_symtab (objfile, ps);
+ }
}
/* Psymtab version of expand_all_symtabs. See its definition in
static void
psym_expand_all_symtabs (struct objfile *objfile)
{
- struct partial_symtab *psymtab;
-
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
- {
- psymtab_to_symtab (objfile, psymtab);
- }
+ for (partial_symtab *psymtab : require_partial_symbols (objfile, 1))
+ psymtab_to_symtab (objfile, psymtab);
}
/* Psymtab version of expand_symtabs_with_fullname. See its definition in
psym_expand_symtabs_with_fullname (struct objfile *objfile,
const char *fullname)
{
- struct partial_symtab *p;
-
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
+ for (partial_symtab *p : require_partial_symbols (objfile, 1))
{
/* Anonymous psymtabs don't have a name of a source file. */
if (p->anonymous)
symbol_filename_ftype *fun, void *data,
int need_fullname)
{
- struct partial_symtab *ps;
-
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
+ for (partial_symtab *ps : require_partial_symbols (objfile, 1))
{
const char *fullname;
if (ps->fullname == NULL)
{
gdb::unique_xmalloc_ptr<char> fullname;
- int fd = find_and_open_source (ps->filename, ps->dirname, &fullname);
+ scoped_fd fd = find_and_open_source (ps->filename, ps->dirname,
+ &fullname);
ps->fullname = fullname.release ();
- if (fd >= 0)
- close (fd);
- else
+ if (fd.get () < 0)
{
/* rewrite_source_path would be applied by find_and_open_source, we
should report the pathname where GDB tried to find the file. */
symbol_compare_ftype *ordered_compare)
{
const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
- struct partial_symtab *ps;
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
+ for (partial_symtab *ps : require_partial_symbols (objfile, 1))
{
QUIT;
if (ps->readin
static bool
recursively_search_psymtabs
- (struct partial_symtab *ps, struct objfile *objfile, enum search_domain domain,
+ (struct partial_symtab *ps,
+ struct objfile *objfile,
+ enum search_domain domain,
const lookup_name_info &lookup_name,
gdb::function_view<expand_symtabs_symbol_matcher_ftype> sym_matcher)
{
}
partial_symbol **gbound
- = objfile->global_psymbols.data () + ps->globals_offset + ps->n_global_syms;
+ = (objfile->partial_symtabs->global_psymbols.data ()
+ + ps->globals_offset + ps->n_global_syms);
partial_symbol **sbound
- = objfile->static_psymbols.data () + ps->statics_offset + ps->n_static_syms;
+ = (objfile->partial_symtabs->static_psymbols.data ()
+ + ps->statics_offset + ps->n_static_syms);
partial_symbol **bound = gbound;
/* Go through all of the symbols stored in a partial
symtab in one loop. */
- partial_symbol **psym = objfile->global_psymbols.data () + ps->globals_offset;
+ partial_symbol **psym = (objfile->partial_symtabs->global_psymbols.data ()
+ + ps->globals_offset);
while (keep_going)
{
if (psym >= bound)
{
if (bound == gbound && ps->n_static_syms != 0)
{
- psym = objfile->static_psymbols.data () + ps->statics_offset;
+ psym = (objfile->partial_symtabs->static_psymbols.data ()
+ + ps->statics_offset);
bound = sbound;
}
else
if ((domain == ALL_DOMAIN
|| (domain == VARIABLES_DOMAIN
- && PSYMBOL_CLASS (*psym) != LOC_TYPEDEF
- && PSYMBOL_CLASS (*psym) != LOC_BLOCK)
+ && (*psym)->aclass != LOC_TYPEDEF
+ && (*psym)->aclass != LOC_BLOCK)
|| (domain == FUNCTIONS_DOMAIN
- && PSYMBOL_CLASS (*psym) == LOC_BLOCK)
+ && (*psym)->aclass == LOC_BLOCK)
|| (domain == TYPES_DOMAIN
- && PSYMBOL_CLASS (*psym) == LOC_TYPEDEF))
+ && (*psym)->aclass == LOC_TYPEDEF))
&& psymbol_name_matches (*psym, lookup_name)
- && (sym_matcher == NULL || sym_matcher (SYMBOL_SEARCH_NAME (*psym))))
+ && (sym_matcher == NULL
+ || sym_matcher (symbol_search_name (&(*psym)->ginfo))))
{
/* Found a match, so notify our caller. */
result = PST_SEARCHED_AND_FOUND;
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
enum search_domain domain)
{
- struct partial_symtab *ps;
-
lookup_name_info lookup_name = lookup_name_in.make_ignore_params ();
/* Clear the search flags. */
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
- {
- ps->searched_flag = PST_NOT_SEARCHED;
- }
+ for (partial_symtab *ps : require_partial_symbols (objfile, 1))
+ ps->searched_flag = PST_NOT_SEARCHED;
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
+ for (partial_symtab *ps : objfile->psymtabs ())
{
QUIT;
static int
psym_has_symbols (struct objfile *objfile)
{
- return objfile->psymtabs != NULL;
+ return objfile->partial_symtabs->psymtabs != NULL;
}
/* Helper function for psym_find_compunit_symtab_by_address that fills
{
struct partial_symbol *psym = symbols[start + i];
- if (PSYMBOL_CLASS (psym) == LOC_STATIC)
+ if (psym->aclass == LOC_STATIC)
{
- CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (psym);
+ CORE_ADDR addr = psym->address (objfile);
if (seen_addrs->find (addr) == seen_addrs->end ())
{
seen_addrs->insert (addr);
{
if (objfile->psymbol_map.empty ())
{
- struct partial_symtab *pst;
-
std::set<CORE_ADDR> seen_addrs;
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
- {
- psym_fill_psymbol_map (objfile, pst,
- &seen_addrs,
- objfile->global_psymbols,
- pst->globals_offset,
- pst->n_global_syms);
- psym_fill_psymbol_map (objfile, pst,
- &seen_addrs,
- objfile->static_psymbols,
- pst->statics_offset,
- pst->n_static_syms);
- }
+ for (partial_symtab *pst : require_partial_symbols (objfile, 1))
+ {
+ psym_fill_psymbol_map (objfile, pst,
+ &seen_addrs,
+ objfile->partial_symtabs->global_psymbols,
+ pst->globals_offset,
+ pst->n_global_syms);
+ psym_fill_psymbol_map (objfile, pst,
+ &seen_addrs,
+ objfile->partial_symtabs->static_psymbols,
+ pst->statics_offset,
+ pst->n_static_syms);
+ }
objfile->psymbol_map.shrink_to_fit ();
psym_lookup_symbol,
psym_print_stats,
psym_dump,
- psym_relocate,
psym_expand_symtabs_for_function,
psym_expand_all_symtabs,
psym_expand_symtabs_with_fullname,
sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
{
/* Sort the global list; don't sort the static list. */
- auto begin = objfile->global_psymbols.begin ();
+ auto begin = objfile->partial_symtabs->global_psymbols.begin ();
std::advance (begin, pst->globals_offset);
/* The psymbols for this partial_symtab are currently at the end of the
vector. */
- auto end = objfile->global_psymbols.end ();
+ auto end = objfile->partial_symtabs->global_psymbols.end ();
std::sort (begin, end, [] (partial_symbol *s1, partial_symbol *s2)
{
- return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (s1),
- SYMBOL_SEARCH_NAME (s2)) < 0;
+ return strcmp_iw_ordered (symbol_search_name (&s1->ginfo),
+ symbol_search_name (&s2->ginfo)) < 0;
});
}
struct partial_symtab *
start_psymtab_common (struct objfile *objfile,
const char *filename,
- CORE_ADDR textlow,
- std::vector<partial_symbol *> &global_psymbols,
- std::vector<partial_symbol *> &static_psymbols)
+ CORE_ADDR textlow)
{
struct partial_symtab *psymtab;
psymtab = allocate_psymtab (filename, objfile);
- psymtab->textlow = textlow;
- psymtab->texthigh = psymtab->textlow; /* default */
- psymtab->globals_offset = global_psymbols.size ();
- psymtab->statics_offset = static_psymbols.size ();
+ psymtab->set_text_low (textlow);
+ psymtab->set_text_high (psymtab->raw_text_low ()); /* default */
+ psymtab->globals_offset = objfile->partial_symtabs->global_psymbols.size ();
+ psymtab->statics_offset = objfile->partial_symtabs->static_psymbols.size ();
return psymtab;
}
void
end_psymtab_common (struct objfile *objfile, struct partial_symtab *pst)
{
- pst->n_global_syms = objfile->global_psymbols.size () - pst->globals_offset;
- pst->n_static_syms = objfile->static_psymbols.size () - pst->statics_offset;
+ pst->n_global_syms = (objfile->partial_symtabs->global_psymbols.size ()
+ - pst->globals_offset);
+ pst->n_static_syms = (objfile->partial_symtabs->static_psymbols.size ()
+ - pst->statics_offset);
sort_pst_symbols (objfile, pst);
}
unsigned long h = 0;
struct partial_symbol *psymbol = (struct partial_symbol *) addr;
unsigned int lang = psymbol->ginfo.language;
- unsigned int domain = PSYMBOL_DOMAIN (psymbol);
- unsigned int theclass = PSYMBOL_CLASS (psymbol);
+ unsigned int domain = psymbol->domain;
+ unsigned int theclass = psymbol->aclass;
h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
h = hash_continue (&lang, sizeof (unsigned int), h);
h = hash_continue (&theclass, sizeof (unsigned int), h);
/* Note that psymbol names are interned via symbol_set_names, so
there's no need to hash the contents of the name here. */
- h = hash_continue (&psymbol->ginfo.name, sizeof (psymbol->ginfo.name), h);
+ h = hash_continue (&psymbol->ginfo.name,
+ sizeof (psymbol->ginfo.name), h);
return h;
}
return (memcmp (&sym1->ginfo.value, &sym2->ginfo.value,
sizeof (sym1->ginfo.value)) == 0
&& sym1->ginfo.language == sym2->ginfo.language
- && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2)
- && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2)
+ && sym1->domain == sym2->domain
+ && sym1->aclass == sym2->aclass
/* Note that psymbol names are interned via
symbol_set_names, so there's no need to compare the
contents of the name here. */
add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
domain_enum domain,
enum address_class theclass,
+ short section,
CORE_ADDR coreaddr,
enum language language, struct objfile *objfile,
int *added)
{
struct partial_symbol psymbol;
-
- /* 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));
- SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
- SYMBOL_SECTION (&psymbol) = -1;
- SYMBOL_SET_LANGUAGE (&psymbol, language, &objfile->objfile_obstack);
- PSYMBOL_DOMAIN (&psymbol) = domain;
- PSYMBOL_CLASS (&psymbol) = theclass;
-
- SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
+ psymbol.set_unrelocated_address (coreaddr);
+ psymbol.ginfo.section = section;
+ psymbol.domain = domain;
+ psymbol.aclass = theclass;
+ symbol_set_language (&psymbol.ginfo, language,
+ objfile->partial_symtabs->obstack ());
+ symbol_set_names (&psymbol.ginfo, name, namelength, copy_name,
+ objfile->per_bfd);
/* Stash the partial symbol away in the cache. */
- return psymbol_bcache_full (&psymbol, objfile->psymbol_cache, added);
+ return psymbol_bcache_full (&psymbol,
+ objfile->partial_symtabs->psymbol_cache,
+ added);
}
/* Helper function, adds partial symbol to the given partial symbol list. */
add_psymbol_to_list (const char *name, int namelength, int copy_name,
domain_enum domain,
enum address_class theclass,
- std::vector<partial_symbol *> *list,
+ short section,
+ psymbol_placement where,
CORE_ADDR coreaddr,
enum language language, struct objfile *objfile)
{
/* Stash the partial symbol away in the cache. */
psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, theclass,
- coreaddr, language, objfile, &added);
+ section, coreaddr, language, objfile, &added);
/* Do not duplicate global partial symbols. */
- if (list == &objfile->global_psymbols
- && !added)
+ if (where == psymbol_placement::GLOBAL && !added)
return;
/* Save pointer to partial symbol in psymtab, growing symtab if needed. */
+ std::vector<partial_symbol *> *list
+ = (where == psymbol_placement::STATIC
+ ? &objfile->partial_symtabs->static_psymbols
+ : &objfile->partial_symtabs->global_psymbols);
append_psymbol_to_list (list, psym, objfile);
}
-/* Initialize storage for partial symbols. */
+/* See psympriv.h. */
void
init_psymbol_list (struct objfile *objfile, int total_symbols)
{
- /* Free any previously allocated psymbol lists. */
- objfile->global_psymbols.clear ();
- objfile->static_psymbols.clear ();
-
- /* Current best guess is that approximately a twentieth
- of the total symbols (in a debugging file) are global or static
- oriented symbols, then multiply that by slop factor of two. */
- objfile->global_psymbols.reserve (total_symbols / 10);
- objfile->static_psymbols.reserve (total_symbols / 10);
+ if (objfile->partial_symtabs->global_psymbols.capacity () == 0
+ && objfile->partial_symtabs->static_psymbols.capacity () == 0)
+ {
+ /* Current best guess is that approximately a twentieth of the
+ total symbols (in a debugging file) are global or static
+ oriented symbols, then multiply that by slop factor of
+ two. */
+ objfile->partial_symtabs->global_psymbols.reserve (total_symbols / 10);
+ objfile->partial_symtabs->static_psymbols.reserve (total_symbols / 10);
+ }
}
+/* See psympriv.h. */
+
struct partial_symtab *
allocate_psymtab (const char *filename, struct objfile *objfile)
{
- struct partial_symtab *psymtab;
+ struct partial_symtab *psymtab
+ = objfile->partial_symtabs->allocate_psymtab ();
- if (objfile->free_psymtabs)
- {
- psymtab = objfile->free_psymtabs;
- objfile->free_psymtabs = psymtab->next;
- }
- else
- psymtab = (struct partial_symtab *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct partial_symtab));
-
- memset (psymtab, 0, sizeof (struct partial_symtab));
psymtab->filename
= (const char *) 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
- inserted order. */
-
- psymtab->next = objfile->psymtabs;
- objfile->psymtabs = psymtab;
-
if (symtab_create_debug)
{
/* Be a bit clever with debugging messages, and don't print objfile
{
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_filtered (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);
+ fprintf_filtered (gdb_stdlog,
+ "Created psymtab %s for module %s.\n",
+ host_address_to_string (psymtab), filename);
}
return psymtab;
}
void
-discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
+psymtab_storage::discard_psymtab (struct partial_symtab *pst)
{
struct partial_symtab **prev_pst;
/* First, snip it out of the psymtab chain. */
- prev_pst = &(objfile->psymtabs);
+ prev_pst = &psymtabs;
while ((*prev_pst) != pst)
prev_pst = &((*prev_pst)->next);
(*prev_pst) = pst->next;
/* Next, put it on a free list for recycling. */
- pst->next = objfile->free_psymtabs;
- objfile->free_psymtabs = pst;
+ pst->next = free_psymtabs;
+ free_psymtabs = pst;
}
\f
if ((psymtab == NULL
|| psymtab->psymtabs_addrmap_supported)
- && objfile->psymtabs_addrmap != NULL)
+ && objfile->partial_symtabs->psymtabs_addrmap != NULL)
{
addrmap_dump_data.objfile = objfile;
addrmap_dump_data.psymtab = psymtab;
addrmap_dump_data.previous_matched = 0;
fprintf_filtered (outfile, "%sddress map:\n",
psymtab == NULL ? "Entire a" : " A");
- addrmap_foreach (objfile->psymtabs_addrmap, dump_psymtab_addrmap_1,
- &addrmap_dump_data);
+ addrmap_foreach (objfile->partial_symtabs->psymtabs_addrmap,
+ dump_psymtab_addrmap_1, &addrmap_dump_data);
}
}
{
struct ui_file *outfile = gdb_stdout;
char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
- struct objfile *objfile;
- struct partial_symtab *ps;
int i, outfile_idx, found;
CORE_ADDR pc = 0;
struct obj_section *section = NULL;
}
found = 0;
- ALL_OBJFILES (objfile)
+ for (objfile *objfile : current_program_space->objfiles ())
{
int printed_objfile_header = 0;
int print_for_objfile = 1;
/* We don't assume each pc has a unique objfile (this is for
debugging). */
- ps = find_pc_sect_psymtab (objfile, pc, section, msymbol);
+ struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc,
+ section, msymbol);
if (ps != NULL)
{
if (!printed_objfile_header)
}
else
{
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
+ for (partial_symtab *ps : require_partial_symbols (objfile, 1))
{
int print_for_source = 0;
if (address_arg == NULL
&& source_arg == NULL
- && objfile->psymtabs_addrmap != NULL)
+ && objfile->partial_symtabs->psymtabs_addrmap != NULL)
{
outfile->puts ("\n");
dump_psymtab_addrmap (objfile, NULL, outfile);
maintenance_info_psymtabs (const char *regexp, int from_tty)
{
struct program_space *pspace;
- struct objfile *objfile;
if (regexp)
re_comp (regexp);
ALL_PSPACES (pspace)
- ALL_PSPACE_OBJFILES (pspace, objfile)
- {
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
- struct partial_symtab *psymtab;
-
- /* We don't want to print anything for this objfile until we
- actually find a symtab whose name matches. */
- int printed_objfile_start = 0;
-
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
- {
- QUIT;
-
- if (! regexp
- || re_exec (psymtab->filename))
- {
- if (! printed_objfile_start)
- {
- printf_filtered ("{ objfile %s ", objfile_name (objfile));
- wrap_here (" ");
- printf_filtered ("((struct objfile *) %s)\n",
- host_address_to_string (objfile));
- printed_objfile_start = 1;
- }
-
- printf_filtered (" { psymtab %s ", psymtab->filename);
- wrap_here (" ");
- printf_filtered ("((struct partial_symtab *) %s)\n",
- host_address_to_string (psymtab));
-
- printf_filtered (" readin %s\n",
- psymtab->readin ? "yes" : "no");
- printf_filtered (" fullname %s\n",
- psymtab->fullname
- ? psymtab->fullname : "(null)");
- printf_filtered (" text addresses ");
- fputs_filtered (paddress (gdbarch, psymtab->textlow),
- gdb_stdout);
- printf_filtered (" -- ");
- 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)
- {
- auto p = &objfile->global_psymbols[psymtab->globals_offset];
-
- printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
- host_address_to_string (p),
- psymtab->n_global_syms);
- }
- else
- printf_filtered ("(none)\n");
- printf_filtered (" statics ");
- if (psymtab->n_static_syms)
- {
- auto p = &objfile->static_psymbols[psymtab->statics_offset];
-
- printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
- host_address_to_string (p),
- psymtab->n_static_syms);
- }
- else
- printf_filtered ("(none)\n");
- printf_filtered (" dependencies ");
- if (psymtab->number_of_dependencies)
- {
- int i;
+ for (objfile *objfile : pspace->objfiles ())
+ {
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
- printf_filtered ("{\n");
- for (i = 0; i < psymtab->number_of_dependencies; i++)
- {
- struct partial_symtab *dep = psymtab->dependencies[i];
+ /* We don't want to print anything for this objfile until we
+ actually find a symtab whose name matches. */
+ int printed_objfile_start = 0;
- /* Note the string concatenation there --- no comma. */
- printf_filtered (" psymtab %s "
- "((struct partial_symtab *) %s)\n",
- dep->filename,
- host_address_to_string (dep));
- }
- printf_filtered (" }\n");
- }
- else
- printf_filtered ("(none)\n");
- printf_filtered (" }\n");
- }
- }
+ for (partial_symtab *psymtab : require_partial_symbols (objfile, 1))
+ {
+ QUIT;
+
+ if (! regexp
+ || re_exec (psymtab->filename))
+ {
+ if (! printed_objfile_start)
+ {
+ printf_filtered ("{ objfile %s ", objfile_name (objfile));
+ wrap_here (" ");
+ printf_filtered ("((struct objfile *) %s)\n",
+ host_address_to_string (objfile));
+ printed_objfile_start = 1;
+ }
+
+ printf_filtered (" { psymtab %s ", psymtab->filename);
+ wrap_here (" ");
+ printf_filtered ("((struct partial_symtab *) %s)\n",
+ host_address_to_string (psymtab));
+
+ printf_filtered (" readin %s\n",
+ psymtab->readin ? "yes" : "no");
+ printf_filtered (" fullname %s\n",
+ psymtab->fullname
+ ? psymtab->fullname : "(null)");
+ printf_filtered (" text addresses ");
+ fputs_filtered (paddress (gdbarch,
+ psymtab->text_low (objfile)),
+ gdb_stdout);
+ printf_filtered (" -- ");
+ fputs_filtered (paddress (gdbarch,
+ psymtab->text_high (objfile)),
+ 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)
+ {
+ auto p = &(objfile->partial_symtabs
+ ->global_psymbols[psymtab->globals_offset]);
+
+ printf_filtered
+ ("(* (struct partial_symbol **) %s @ %d)\n",
+ host_address_to_string (p),
+ psymtab->n_global_syms);
+ }
+ else
+ printf_filtered ("(none)\n");
+ printf_filtered (" statics ");
+ if (psymtab->n_static_syms)
+ {
+ auto p = &(objfile->partial_symtabs
+ ->static_psymbols[psymtab->statics_offset]);
+
+ printf_filtered
+ ("(* (struct partial_symbol **) %s @ %d)\n",
+ host_address_to_string (p),
+ psymtab->n_static_syms);
+ }
+ else
+ printf_filtered ("(none)\n");
+ printf_filtered (" dependencies ");
+ if (psymtab->number_of_dependencies)
+ {
+ int i;
+
+ printf_filtered ("{\n");
+ for (i = 0; i < psymtab->number_of_dependencies; i++)
+ {
+ struct partial_symtab *dep = psymtab->dependencies[i];
+
+ /* Note the string concatenation there --- no
+ comma. */
+ printf_filtered (" psymtab %s "
+ "((struct partial_symtab *) %s)\n",
+ dep->filename,
+ host_address_to_string (dep));
+ }
+ printf_filtered (" }\n");
+ }
+ else
+ printf_filtered ("(none)\n");
+ printf_filtered (" }\n");
+ }
+ }
- if (printed_objfile_start)
- printf_filtered ("}\n");
- }
+ if (printed_objfile_start)
+ printf_filtered ("}\n");
+ }
}
/* Check consistency of currently expanded psymtabs vs symtabs. */
{
struct symbol *sym;
struct compunit_symtab *cust = NULL;
- struct partial_symtab *ps;
const struct blockvector *bv;
- struct objfile *objfile;
struct block *b;
int length;
- ALL_PSYMTABS (objfile, ps)
- {
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
-
- /* 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)
+ for (objfile *objfile : current_program_space->objfiles ())
+ for (partial_symtab *ps : require_partial_symbols (objfile, 1))
{
- 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;
- }
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
- /* Now do checks requiring the associated symtab. */
- if (cust == NULL)
- continue;
- bv = COMPUNIT_BLOCKVECTOR (cust);
- b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
- partial_symbol **psym = &objfile->static_psymbols[ps->statics_offset];
- length = ps->n_static_syms;
- while (length--)
- {
- sym = block_lookup_symbol (b, SYMBOL_SEARCH_NAME (*psym),
- symbol_name_match_type::SEARCH_NAME,
- SYMBOL_DOMAIN (*psym));
- if (!sym)
+ /* 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->text_high (objfile) < ps->text_low (objfile))
{
- printf_filtered ("Static symbol `");
- puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
- printf_filtered ("' only found in ");
+ printf_filtered ("Psymtab ");
puts_filtered (ps->filename);
- printf_filtered (" psymtab\n");
+ printf_filtered (" covers bad range ");
+ fputs_filtered (paddress (gdbarch, ps->text_low (objfile)),
+ gdb_stdout);
+ printf_filtered (" - ");
+ fputs_filtered (paddress (gdbarch, ps->text_high (objfile)),
+ gdb_stdout);
+ printf_filtered ("\n");
+ continue;
}
- psym++;
- }
- b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- psym = &objfile->global_psymbols[ps->globals_offset];
- length = ps->n_global_syms;
- while (length--)
- {
- sym = block_lookup_symbol (b, SYMBOL_SEARCH_NAME (*psym),
- symbol_name_match_type::SEARCH_NAME,
- SYMBOL_DOMAIN (*psym));
- if (!sym)
+
+ /* Now do checks requiring the associated symtab. */
+ if (cust == NULL)
+ continue;
+ bv = COMPUNIT_BLOCKVECTOR (cust);
+ b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+ partial_symbol **psym
+ = &objfile->partial_symtabs->static_psymbols[ps->statics_offset];
+ length = ps->n_static_syms;
+ while (length--)
{
- printf_filtered ("Global symbol `");
- puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
- printf_filtered ("' only found in ");
+ sym = block_lookup_symbol (b, symbol_search_name (&(*psym)->ginfo),
+ symbol_name_match_type::SEARCH_NAME,
+ (*psym)->domain);
+ if (!sym)
+ {
+ printf_filtered ("Static symbol `");
+ puts_filtered ((*psym)->ginfo.name);
+ printf_filtered ("' only found in ");
+ puts_filtered (ps->filename);
+ printf_filtered (" psymtab\n");
+ }
+ psym++;
+ }
+ b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+ psym = &objfile->partial_symtabs->global_psymbols[ps->globals_offset];
+ length = ps->n_global_syms;
+ while (length--)
+ {
+ sym = block_lookup_symbol (b, symbol_search_name (&(*psym)->ginfo),
+ symbol_name_match_type::SEARCH_NAME,
+ (*psym)->domain);
+ if (!sym)
+ {
+ printf_filtered ("Global symbol `");
+ puts_filtered ((*psym)->ginfo.name);
+ printf_filtered ("' only found in ");
+ puts_filtered (ps->filename);
+ printf_filtered (" psymtab\n");
+ }
+ psym++;
+ }
+ if (ps->raw_text_high () != 0
+ && (ps->text_low (objfile) < BLOCK_START (b)
+ || ps->text_high (objfile) > BLOCK_END (b)))
+ {
+ printf_filtered ("Psymtab ");
puts_filtered (ps->filename);
- printf_filtered (" psymtab\n");
+ printf_filtered (" covers ");
+ fputs_filtered (paddress (gdbarch, ps->text_low (objfile)),
+ gdb_stdout);
+ printf_filtered (" - ");
+ fputs_filtered (paddress (gdbarch, ps->text_high (objfile)),
+ gdb_stdout);
+ printf_filtered (" but symtab covers only ");
+ fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
+ printf_filtered (" - ");
+ fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
+ printf_filtered ("\n");
}
- psym++;
- }
- if (ps->texthigh != 0
- && (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b)))
- {
- printf_filtered ("Psymtab ");
- puts_filtered (ps->filename);
- printf_filtered (" covers ");
- fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
- printf_filtered (" - ");
- fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
- printf_filtered (" but symtab covers only ");
- fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
- printf_filtered (" - ");
- fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
- printf_filtered ("\n");
}
- }
}
void
{
add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
Print dump of current partial symbol definitions.\n\
-Usage: mt print psymbols [-objfile objfile] [-pc address] [--] [outfile]\n\
- mt print psymbols [-objfile objfile] [-source source] [--] [outfile]\n\
+Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\
+ mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
Entries in the partial symbol table are dumped to file OUTFILE,\n\
or the terminal if OUTFILE is unspecified.\n\
If ADDRESS is provided, dump only the file for that address.\n\