|
|
/* Partial symbol tables.
|
|
|
|
|
|
Copyright (C) 2009-2022 Free Software Foundation, Inc.
|
|
|
|
|
|
This file is part of GDB.
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
|
(at your option) any later version.
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
#include "defs.h"
|
|
|
#include "symtab.h"
|
|
|
#include "objfiles.h"
|
|
|
#include "psympriv.h"
|
|
|
#include "block.h"
|
|
|
#include "filenames.h"
|
|
|
#include "source.h"
|
|
|
#include "addrmap.h"
|
|
|
#include "gdbtypes.h"
|
|
|
#include "ui-out.h"
|
|
|
#include "command.h"
|
|
|
#include "readline/tilde.h"
|
|
|
#include "gdbsupport/gdb_regex.h"
|
|
|
#include "dictionary.h"
|
|
|
#include "language.h"
|
|
|
#include "cp-support.h"
|
|
|
#include "gdbcmd.h"
|
|
|
#include <algorithm>
|
|
|
#include <set>
|
|
|
#include "gdbsupport/buildargv.h"
|
|
|
|
|
|
static struct partial_symbol *lookup_partial_symbol (struct objfile *,
|
|
|
struct partial_symtab *,
|
|
|
const lookup_name_info &,
|
|
|
int,
|
|
|
domain_enum);
|
|
|
|
|
|
static const char *psymtab_to_fullname (struct partial_symtab *ps);
|
|
|
|
|
|
static struct partial_symbol *find_pc_sect_psymbol (struct objfile *,
|
|
|
struct partial_symtab *,
|
|
|
CORE_ADDR,
|
|
|
struct obj_section *);
|
|
|
|
|
|
static struct compunit_symtab *psymtab_to_symtab (struct objfile *objfile,
|
|
|
struct partial_symtab *pst);
|
|
|
|
|
|
psymtab_storage::~psymtab_storage ()
|
|
|
{
|
|
|
partial_symtab *iter = psymtabs;
|
|
|
while (iter != nullptr)
|
|
|
{
|
|
|
partial_symtab *next = iter->next;
|
|
|
delete iter;
|
|
|
iter = next;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* See psymtab.h. */
|
|
|
|
|
|
void
|
|
|
psymtab_storage::install_psymtab (partial_symtab *pst)
|
|
|
{
|
|
|
pst->next = psymtabs;
|
|
|
psymtabs = pst;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* See psympriv.h. */
|
|
|
|
|
|
psymtab_storage::partial_symtab_range
|
|
|
psymbol_functions::partial_symbols (struct objfile *objfile)
|
|
|
{
|
|
|
gdb_assert ((objfile->flags & OBJF_PSYMTABS_READ) != 0);
|
|
|
return m_partial_symtabs->range ();
|
|
|
}
|
|
|
|
|
|
/* Find which partial symtab contains PC and SECTION starting at psymtab PST.
|
|
|
We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
|
|
|
|
|
|
static struct partial_symtab *
|
|
|
find_pc_sect_psymtab_closer (struct objfile *objfile,
|
|
|
CORE_ADDR pc, struct obj_section *section,
|
|
|
struct partial_symtab *pst,
|
|
|
struct bound_minimal_symbol msymbol)
|
|
|
{
|
|
|
struct partial_symtab *tpst;
|
|
|
struct partial_symtab *best_pst = pst;
|
|
|
CORE_ADDR best_addr = pst->text_low (objfile);
|
|
|
|
|
|
/* An objfile that has its functions reordered might have
|
|
|
many partial symbol tables containing the PC, but
|
|
|
we want the partial symbol table that contains the
|
|
|
function containing the PC. */
|
|
|
if (!(objfile->flags & OBJF_REORDERED)
|
|
|
&& section == NULL) /* Can't validate section this way. */
|
|
|
return pst;
|
|
|
|
|
|
if (msymbol.minsym == NULL)
|
|
|
return pst;
|
|
|
|
|
|
/* The code range of partial symtabs sometimes overlap, so, in
|
|
|
the loop below, we need to check all partial symtabs and
|
|
|
find the one that fits better for the given PC address. We
|
|
|
select the partial symtab that contains a symbol whose
|
|
|
address is closest to the PC address. By closest we mean
|
|
|
that find_pc_sect_symbol returns the symbol with address
|
|
|
that is closest and still less than the given PC. */
|
|
|
for (tpst = pst; tpst != NULL; tpst = tpst->next)
|
|
|
{
|
|
|
if (pc >= tpst->text_low (objfile) && pc < tpst->text_high (objfile))
|
|
|
{
|
|
|
struct partial_symbol *p;
|
|
|
CORE_ADDR this_addr;
|
|
|
|
|
|
/* NOTE: This assumes that every psymbol has a
|
|
|
corresponding msymbol, which is not necessarily
|
|
|
true; the debug info might be much richer than the
|
|
|
object's symbol table. */
|
|
|
p = find_pc_sect_psymbol (objfile, tpst, pc, section);
|
|
|
if (p != NULL
|
|
|
&& (p->address (objfile) == msymbol.value_address ()))
|
|
|
return tpst;
|
|
|
|
|
|
/* Also accept the textlow value of a psymtab as a
|
|
|
"symbol", to provide some support for partial
|
|
|
symbol tables with line information but no debug
|
|
|
symbols (e.g. those produced by an assembler). */
|
|
|
if (p != NULL)
|
|
|
this_addr = p->address (objfile);
|
|
|
else
|
|
|
this_addr = tpst->text_low (objfile);
|
|
|
|
|
|
/* Check whether it is closer than our current
|
|
|
BEST_ADDR. Since this symbol address is
|
|
|
necessarily lower or equal to PC, the symbol closer
|
|
|
to PC is the symbol which address is the highest.
|
|
|
This way we return the psymtab which contains such
|
|
|
best match symbol. This can help in cases where the
|
|
|
symbol information/debuginfo is not complete, like
|
|
|
for instance on IRIX6 with gcc, where no debug info
|
|
|
is emitted for statics. (See also the nodebug.exp
|
|
|
testcase.) */
|
|
|
if (this_addr > best_addr)
|
|
|
{
|
|
|
best_addr = this_addr;
|
|
|
best_pst = tpst;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return best_pst;
|
|
|
}
|
|
|
|
|
|
/* See psympriv.h. */
|
|
|
|
|
|
struct partial_symtab *
|
|
|
psymbol_functions::find_pc_sect_psymtab (struct objfile *objfile,
|
|
|
CORE_ADDR pc,
|
|
|
struct obj_section *section,
|
|
|
struct bound_minimal_symbol msymbol)
|
|
|
{
|
|
|
for (partial_symtab *pst : partial_symbols (objfile))
|
|
|
if (pc >= pst->text_low (objfile) && pc < pst->text_high (objfile))
|
|
|
{
|
|
|
struct partial_symtab *best_pst;
|
|
|
|
|
|
best_pst = find_pc_sect_psymtab_closer (objfile, pc, section, pst,
|
|
|
msymbol);
|
|
|
if (best_pst != NULL)
|
|
|
return best_pst;
|
|
|
}
|
|
|
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
/* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
|
|
|
the definition of quick_symbol_functions in symfile.h. */
|
|
|
|
|
|
struct compunit_symtab *
|
|
|
psymbol_functions::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);
|
|
|
if (ps != NULL)
|
|
|
{
|
|
|
if (warn_if_readin && ps->readin_p (objfile))
|
|
|
/* Might want to error() here (in case symtab is corrupt and
|
|
|
will cause a core dump), but maybe we can successfully
|
|
|
continue, so let's not. */
|
|
|
warning (_("\
|
|
|
(Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
|
|
|
paddress (objfile->arch (), pc));
|
|
|
psymtab_to_symtab (objfile, ps);
|
|
|
return ps->get_compunit_symtab (objfile);
|
|
|
}
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
/* Find which partial symbol within a psymtab matches PC and SECTION.
|
|
|
Return NULL if none. */
|
|
|
|
|
|
static struct partial_symbol *
|
|
|
find_pc_sect_psymbol (struct objfile *objfile,
|
|
|
struct partial_symtab *psymtab, CORE_ADDR pc,
|
|
|
struct obj_section *section)
|
|
|
{
|
|
|
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 = (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 (partial_symbol *p : psymtab->global_psymbols)
|
|
|
{
|
|
|
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. */
|
|
|
{
|
|
|
if (!matching_obj_sections (p->obj_section (objfile),
|
|
|
section))
|
|
|
continue;
|
|
|
}
|
|
|
best_pc = p->address (objfile);
|
|
|
best = p;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for (partial_symbol *p : psymtab->static_psymbols)
|
|
|
{
|
|
|
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. */
|
|
|
{
|
|
|
if (!matching_obj_sections (p->obj_section (objfile),
|
|
|
section))
|
|
|
continue;
|
|
|
}
|
|
|
best_pc = p->address (objfile);
|
|
|
best = p;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return best;
|
|
|
}
|
|
|
|
|
|
/* Psymtab version of lookup_global_symbol_language. See its definition in
|
|
|
the definition of quick_symbol_functions in symfile.h. */
|
|
|
|
|
|
enum language
|
|
|
psymbol_functions::lookup_global_symbol_language (struct objfile *objfile,
|
|
|
const char *name,
|
|
|
domain_enum domain,
|
|
|
bool *symbol_found_p)
|
|
|
{
|
|
|
*symbol_found_p = false;
|
|
|
if (objfile->sf == NULL)
|
|
|
return language_unknown;
|
|
|
|
|
|
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
|
|
|
|
|
|
for (partial_symtab *ps : partial_symbols (objfile))
|
|
|
{
|
|
|
struct partial_symbol *psym;
|
|
|
if (ps->readin_p (objfile))
|
|
|
continue;
|
|
|
|
|
|
psym = lookup_partial_symbol (objfile, ps, lookup_name, 1, domain);
|
|
|
if (psym)
|
|
|
{
|
|
|
*symbol_found_p = true;
|
|
|
return psym->ginfo.language ();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return language_unknown;
|
|
|
}
|
|
|
|
|
|
/* Returns true if PSYM matches LOOKUP_NAME. */
|
|
|
|
|
|
static bool
|
|
|
psymbol_name_matches (partial_symbol *psym,
|
|
|
const lookup_name_info &lookup_name)
|
|
|
{
|
|
|
const language_defn *lang = language_def (psym->ginfo.language ());
|
|
|
symbol_name_matcher_ftype *name_match
|
|
|
= lang->get_symbol_name_matcher (lookup_name);
|
|
|
return name_match (psym->ginfo.search_name (), lookup_name, NULL);
|
|
|
}
|
|
|
|
|
|
/* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
|
|
|
the global block of PST if GLOBAL, and otherwise the static block.
|
|
|
MATCH is the comparison operation that returns true iff MATCH (s,
|
|
|
NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
|
|
|
non-null, the symbols in the block are assumed to be ordered
|
|
|
according to it (allowing binary search). It must be compatible
|
|
|
with MATCH. Returns the symbol, if found, and otherwise NULL. */
|
|
|
|
|
|
static struct partial_symbol *
|
|
|
match_partial_symbol (struct objfile *objfile,
|
|
|
struct partial_symtab *pst, int global,
|
|
|
const lookup_name_info &name, domain_enum domain,
|
|
|
symbol_compare_ftype *ordered_compare)
|
|
|
{
|
|
|
struct partial_symbol **start, **psym;
|
|
|
struct partial_symbol **top, **real_top, **bottom, **center;
|
|
|
int length = (global
|
|
|
? pst->global_psymbols.size ()
|
|
|
: pst->static_psymbols.size ());
|
|
|
int do_linear_search = 1;
|
|
|
|
|
|
if (length == 0)
|
|
|
return NULL;
|
|
|
|
|
|
start = (global ?
|
|
|
&pst->global_psymbols[0] :
|
|
|
&pst->static_psymbols[0]);
|
|
|
|
|
|
if (global && ordered_compare) /* Can use a binary search. */
|
|
|
{
|
|
|
do_linear_search = 0;
|
|
|
|
|
|
/* Binary search. This search is guaranteed to end with center
|
|
|
pointing at the earliest partial symbol whose name might be
|
|
|
correct. At that point *all* partial symbols with an
|
|
|
appropriate name will be checked against the correct
|
|
|
domain. */
|
|
|
|
|
|
bottom = start;
|
|
|
top = start + length - 1;
|
|
|
real_top = top;
|
|
|
while (top > bottom)
|
|
|
{
|
|
|
center = bottom + (top - bottom) / 2;
|
|
|
gdb_assert (center < top);
|
|
|
|
|
|
enum language lang = (*center)->ginfo.language ();
|
|
|
const char *lang_ln = name.language_lookup_name (lang);
|
|
|
|
|
|
if (ordered_compare ((*center)->ginfo.search_name (),
|
|
|
lang_ln) >= 0)
|
|
|
top = center;
|
|
|
else
|
|
|
bottom = center + 1;
|
|
|
}
|
|
|
gdb_assert (top == bottom);
|
|
|
|
|
|
while (top <= real_top
|
|
|
&& psymbol_name_matches (*top, name))
|
|
|
{
|
|
|
if (symbol_matches_domain ((*top)->ginfo.language (),
|
|
|
(*top)->domain, domain))
|
|
|
return *top;
|
|
|
top++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Can't use a binary search or else we found during the binary search that
|
|
|
we should also do a linear search. */
|
|
|
|
|
|
if (do_linear_search)
|
|
|
{
|
|
|
for (psym = start; psym < start + length; psym++)
|
|
|
{
|
|
|
if (symbol_matches_domain ((*psym)->ginfo.language (),
|
|
|
(*psym)->domain, domain)
|
|
|
&& psymbol_name_matches (*psym, name))
|
|
|
return *psym;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
/* Look, in partial_symtab PST, for symbol whose natural name is
|
|
|
LOOKUP_NAME. Check the global symbols if GLOBAL, the static
|
|
|
symbols if not. */
|
|
|
|
|
|
static struct partial_symbol *
|
|
|
lookup_partial_symbol (struct objfile *objfile,
|
|
|
struct partial_symtab *pst,
|
|
|
const lookup_name_info &lookup_name,
|
|
|
int global, domain_enum domain)
|
|
|
{
|
|
|
struct partial_symbol **start, **psym;
|
|
|
struct partial_symbol **top, **real_top, **bottom, **center;
|
|
|
int length = (global
|
|
|
? pst->global_psymbols.size ()
|
|
|
: pst->static_psymbols.size ());
|
|
|
int do_linear_search = 1;
|
|
|
|
|
|
if (length == 0)
|
|
|
return NULL;
|
|
|
|
|
|
start = (global ?
|
|
|
&pst->global_psymbols[0] :
|
|
|
&pst->static_psymbols[0]);
|
|
|
|
|
|
if (global) /* This means we can use a binary search. */
|
|
|
{
|
|
|
do_linear_search = 0;
|
|
|
|
|
|
/* Binary search. This search is guaranteed to end with center
|
|
|
pointing at the earliest partial symbol whose name might be
|
|
|
correct. At that point *all* partial symbols with an
|
|
|
appropriate name will be checked against the correct
|
|
|
domain. */
|
|
|
|
|
|
bottom = start;
|
|
|
top = start + length - 1;
|
|
|
real_top = top;
|
|
|
while (top > bottom)
|
|
|
{
|
|
|
center = bottom + (top - bottom) / 2;
|
|
|
|
|
|
gdb_assert (center < top);
|
|
|
|
|
|
if (strcmp_iw_ordered ((*center)->ginfo.search_name (),
|
|
|
lookup_name.c_str ()) >= 0)
|
|
|
{
|
|
|
top = center;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
bottom = center + 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
gdb_assert (top == bottom);
|
|
|
|
|
|
/* 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)->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)->ginfo,
|
|
|
lookup_name))
|
|
|
{
|
|
|
if (symbol_matches_domain ((*top)->ginfo.language (),
|
|
|
(*top)->domain, domain))
|
|
|
return *top;
|
|
|
top++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Can't use a binary search or else we found during the binary search that
|
|
|
we should also do a linear search. */
|
|
|
|
|
|
if (do_linear_search)
|
|
|
{
|
|
|
for (psym = start; psym < start + length; psym++)
|
|
|
{
|
|
|
if (symbol_matches_domain ((*psym)->ginfo.language (),
|
|
|
(*psym)->domain, domain)
|
|
|
&& symbol_matches_search_name (&(*psym)->ginfo, lookup_name))
|
|
|
return *psym;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
/* Get the symbol table that corresponds to a partial_symtab.
|
|
|
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 compunit_symtab *
|
|
|
psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
|
|
|
{
|
|
|
/* If it is a shared psymtab, find an unshared psymtab that includes
|
|
|
it. Any such psymtab will do. */
|
|
|
while (pst->user != NULL)
|
|
|
pst = pst->user;
|
|
|
|
|
|
/* If it's been looked up before, return it. */
|
|
|
if (pst->get_compunit_symtab (objfile))
|
|
|
return pst->get_compunit_symtab (objfile);
|
|
|
|
|
|
/* If it has not yet been read in, read it. */
|
|
|
if (!pst->readin_p (objfile))
|
|
|
{
|
|
|
scoped_restore decrementer = increment_reading_symtab ();
|
|
|
|
|
|
if (info_verbose)
|
|
|
{
|
|
|
gdb_printf (_("Reading in symbols for %s...\n"),
|
|
|
pst->filename);
|
|
|
gdb_flush (gdb_stdout);
|
|
|
}
|
|
|
|
|
|
pst->read_symtab (objfile);
|
|
|
}
|
|
|
|
|
|
return pst->get_compunit_symtab (objfile);
|
|
|
}
|
|
|
|
|
|
/* Psymtab version of find_last_source_symtab. See its definition in
|
|
|
the definition of quick_symbol_functions in symfile.h. */
|
|
|
|
|
|
struct symtab *
|
|
|
psymbol_functions::find_last_source_symtab (struct objfile *ofp)
|
|
|
{
|
|
|
struct partial_symtab *cs_pst = NULL;
|
|
|
|
|
|
for (partial_symtab *ps : partial_symbols (ofp))
|
|
|
{
|
|
|
const char *name = ps->filename;
|
|
|
int len = strlen (name);
|
|
|
|
|
|
if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
|
|
|
|| strcmp (name, "<<C++-namespaces>>") == 0)))
|
|
|
cs_pst = ps;
|
|
|
}
|
|
|
|
|
|
if (cs_pst)
|
|
|
{
|
|
|
if (cs_pst->readin_p (ofp))
|
|
|
{
|
|
|
internal_error (__FILE__, __LINE__,
|
|
|
_("select_source_symtab: "
|
|
|
"readin pst found and no symtabs."));
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
struct compunit_symtab *cust = psymtab_to_symtab (ofp, cs_pst);
|
|
|
|
|
|
if (cust == NULL)
|
|
|
return NULL;
|
|
|
return cust->primary_filetab ();
|
|
|
}
|
|
|
}
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
/* Psymtab version of forget_cached_source_info. See its definition in
|
|
|
the definition of quick_symbol_functions in symfile.h. */
|
|
|
|
|
|
void
|
|
|
psymbol_functions::forget_cached_source_info (struct objfile *objfile)
|
|
|
{
|
|
|
for (partial_symtab *pst : partial_symbols (objfile))
|
|
|
{
|
|
|
if (pst->fullname != NULL)
|
|
|
{
|
|
|
xfree (pst->fullname);
|
|
|
pst->fullname = NULL;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
static void
|
|
|
print_partial_symbols (struct gdbarch *gdbarch, struct objfile *objfile,
|
|
|
const std::vector<partial_symbol *> &symbols,
|
|
|
const char *what, struct ui_file *outfile)
|
|
|
{
|
|
|
gdb_printf (outfile, " %s partial symbols:\n", what);
|
|
|
for (partial_symbol *p : symbols)
|
|
|
{
|
|
|
QUIT;
|
|
|
gdb_printf (outfile, " `%s'", p->ginfo.linkage_name ());
|
|
|
if (p->ginfo.demangled_name () != NULL)
|
|
|
{
|
|
|
gdb_printf (outfile, " `%s'",
|
|
|
p->ginfo.demangled_name ());
|
|
|
}
|
|
|
gdb_puts (", ", outfile);
|
|
|
switch (p->domain)
|
|
|
{
|
|
|
case UNDEF_DOMAIN:
|
|
|
gdb_puts ("undefined domain, ", outfile);
|
|
|
break;
|
|
|
case VAR_DOMAIN:
|
|
|
/* This is the usual thing -- don't print it. */
|
|
|
break;
|
|
|
case STRUCT_DOMAIN:
|
|
|
gdb_puts ("struct domain, ", outfile);
|
|
|
break;
|
|
|
case MODULE_DOMAIN:
|
|
|
gdb_puts ("module domain, ", outfile);
|
|
|
break;
|
|
|
case LABEL_DOMAIN:
|
|
|
gdb_puts ("label domain, ", outfile);
|
|
|
break;
|
|
|
case COMMON_BLOCK_DOMAIN:
|
|
|
gdb_puts ("common block domain, ", outfile);
|
|
|
break;
|
|
|
default:
|
|
|
gdb_puts ("<invalid domain>, ", outfile);
|
|
|
break;
|
|
|
}
|
|
|
switch (p->aclass)
|
|
|
{
|
|
|
case LOC_UNDEF:
|
|
|
gdb_puts ("undefined", outfile);
|
|
|
break;
|
|
|
case LOC_CONST:
|
|
|
gdb_puts ("constant int", outfile);
|
|
|
break;
|
|
|
case LOC_STATIC:
|
|
|
gdb_puts ("static", outfile);
|
|
|
break;
|
|
|
case LOC_REGISTER:
|
|
|
gdb_puts ("register", outfile);
|
|
|
break;
|
|
|
case LOC_ARG:
|
|
|
gdb_puts ("pass by value", outfile);
|
|
|
break;
|
|
|
case LOC_REF_ARG:
|
|
|
gdb_puts ("pass by reference", outfile);
|
|
|
break;
|
|
|
case LOC_REGPARM_ADDR:
|
|
|
gdb_puts ("register address parameter", outfile);
|
|
|
break;
|
|
|
case LOC_LOCAL:
|
|
|
gdb_puts ("stack parameter", outfile);
|
|
|
break;
|
|
|
case LOC_TYPEDEF:
|
|
|
gdb_puts ("type", outfile);
|
|
|
break;
|
|
|
case LOC_LABEL:
|
|
|
gdb_puts ("label", outfile);
|
|
|
break;
|
|
|
case LOC_BLOCK:
|
|
|
gdb_puts ("function", outfile);
|
|
|
break;
|
|
|
case LOC_CONST_BYTES:
|
|
|
gdb_puts ("constant bytes", outfile);
|
|
|
break;
|
|
|
case LOC_UNRESOLVED:
|
|
|
gdb_puts ("unresolved", outfile);
|
|
|
break;
|
|
|
case LOC_OPTIMIZED_OUT:
|
|
|
gdb_puts ("optimized out", outfile);
|
|
|
break;
|
|
|
case LOC_COMPUTED:
|
|
|
gdb_puts ("computed at runtime", outfile);
|
|
|
break;
|
|
|
default:
|
|
|
gdb_puts ("<invalid location>", outfile);
|
|
|
break;
|
|
|
}
|
|
|
gdb_puts (", ", outfile);
|
|
|
gdb_puts (paddress (gdbarch, p->unrelocated_address ()), outfile);
|
|
|
gdb_printf (outfile, "\n");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
static void
|
|
|
dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
|
|
|
struct ui_file *outfile)
|
|
|
{
|
|
|
struct gdbarch *gdbarch = objfile->arch ();
|
|
|
int i;
|
|
|
|
|
|
if (psymtab->anonymous)
|
|
|
{
|
|
|
gdb_printf (outfile, "\nAnonymous partial symtab (%s) ",
|
|
|
psymtab->filename);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
gdb_printf (outfile, "\nPartial symtab for source file %s ",
|
|
|
psymtab->filename);
|
|
|
}
|
|
|
gdb_printf (outfile, "(object %s)\n\n",
|
|
|
host_address_to_string (psymtab));
|
|
|
gdb_printf (outfile, " Read from object file %s (%s)\n",
|
|
|
objfile_name (objfile),
|
|
|
host_address_to_string (objfile));
|
|
|
|
|
|
if (psymtab->readin_p (objfile))
|
|
|
gdb_printf
|
|
|
(outfile,
|
|
|
" Full symtab was read (at %s)\n",
|
|
|
host_address_to_string (psymtab->get_compunit_symtab (objfile)));
|
|
|
|
|
|
gdb_printf (outfile, " Symbols cover text addresses ");
|
|
|
gdb_puts (paddress (gdbarch, psymtab->text_low (objfile)), outfile);
|
|
|
gdb_printf (outfile, "-");
|
|
|
gdb_puts (paddress (gdbarch, psymtab->text_high (objfile)), outfile);
|
|
|
gdb_printf (outfile, "\n");
|
|
|
gdb_printf (outfile, " Depends on %d other partial symtabs.\n",
|
|
|
psymtab->number_of_dependencies);
|
|
|
for (i = 0; i < psymtab->number_of_dependencies; i++)
|
|
|
gdb_printf (outfile, " %d %s\n", i,
|
|
|
host_address_to_string (psymtab->dependencies[i]));
|
|
|
if (psymtab->user != NULL)
|
|
|
gdb_printf (outfile, " Shared partial symtab with user %s\n",
|
|
|
host_address_to_string (psymtab->user));
|
|
|
if (!psymtab->global_psymbols.empty ())
|
|
|
{
|
|
|
print_partial_symbols
|
|
|
(gdbarch, objfile, psymtab->global_psymbols,
|
|
|
"Global", outfile);
|
|
|
}
|
|
|
if (!psymtab->static_psymbols.empty ())
|
|
|
{
|
|
|
print_partial_symbols
|
|
|
(gdbarch, objfile, psymtab->static_psymbols,
|
|
|
"Static", outfile);
|
|
|
}
|
|
|
gdb_printf (outfile, "\n");
|
|
|
}
|
|
|
|
|
|
/* Count the number of partial symbols in OBJFILE. */
|
|
|
|
|
|
int
|
|
|
psymbol_functions::count_psyms ()
|
|
|
{
|
|
|
int count = 0;
|
|
|
for (partial_symtab *pst : m_partial_symtabs->range ())
|
|
|
{
|
|
|
count += pst->global_psymbols.size ();
|
|
|
count += pst->static_psymbols.size ();
|
|
|
}
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
/* Psymtab version of print_stats. See its definition in
|
|
|
the definition of quick_symbol_functions in symfile.h. */
|
|
|
|
|
|
void
|
|
|
psymbol_functions::print_stats (struct objfile *objfile, bool print_bcache)
|
|
|
{
|
|
|
int i;
|
|
|
|
|
|
if (!print_bcache)
|
|
|
{
|
|
|
int n_psyms = count_psyms ();
|
|
|
if (n_psyms > 0)
|
|
|
gdb_printf (_(" Number of \"partial\" symbols read: %d\n"),
|
|
|
n_psyms);
|
|
|
|
|
|
i = 0;
|
|
|
for (partial_symtab *ps : partial_symbols (objfile))
|
|
|
{
|
|
|
if (!ps->readin_p (objfile))
|
|
|
i++;
|
|
|
}
|
|
|
gdb_printf (_(" Number of psym tables (not yet expanded): %d\n"),
|
|
|
i);
|
|
|
gdb_printf (_(" Total memory used for psymbol cache: %d\n"),
|
|
|
m_partial_symtabs->psymbol_cache.memory_used ());
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
gdb_printf (_("Psymbol byte cache statistics:\n"));
|
|
|
m_partial_symtabs->psymbol_cache.print_statistics
|
|
|
("partial symbol cache");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Psymtab version of dump. See its definition in
|
|
|
the definition of quick_symbol_functions in symfile.h. */
|
|
|
|
|
|
void
|
|
|
psymbol_functions::dump (struct objfile *objfile)
|
|
|
{
|
|
|
struct partial_symtab *psymtab;
|
|
|
|
|
|
if (m_partial_symtabs->psymtabs)
|
|
|
{
|
|
|
gdb_printf ("Psymtabs:\n");
|
|
|
for (psymtab = m_partial_symtabs->psymtabs;
|
|
|
psymtab != NULL;
|
|
|
psymtab = psymtab->next)
|
|
|
gdb_printf ("%s at %s\n",
|
|
|
psymtab->filename,
|
|
|
host_address_to_string (psymtab));
|
|
|
gdb_printf ("\n\n");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Psymtab version of expand_all_symtabs. See its definition in
|
|
|
the definition of quick_symbol_functions in symfile.h. */
|
|
|
|
|
|
void
|
|
|
psymbol_functions::expand_all_symtabs (struct objfile *objfile)
|
|
|
{
|
|
|
for (partial_symtab *psymtab : partial_symbols (objfile))
|
|
|
psymtab_to_symtab (objfile, psymtab);
|
|
|
}
|
|
|
|
|
|
/* Psymtab version of map_symbol_filenames. See its definition in
|
|
|
the definition of quick_symbol_functions in symfile.h. */
|
|
|
|
|
|
void
|
|
|
psymbol_functions::map_symbol_filenames
|
|
|
(struct objfile *objfile,
|
|
|
gdb::function_view<symbol_filename_ftype> fun,
|
|
|
bool need_fullname)
|
|
|
{
|
|
|
for (partial_symtab *ps : partial_symbols (objfile))
|
|
|
{
|
|
|
const char *fullname;
|
|
|
|
|
|
if (ps->readin_p (objfile))
|
|
|
continue;
|
|
|
|
|
|
/* We can skip shared psymtabs here, because any file name will be
|
|
|
attached to the unshared psymtab. */
|
|
|
if (ps->user != NULL)
|
|
|
continue;
|
|
|
|
|
|
/* Anonymous psymtabs don't have a file name. */
|
|
|
if (ps->anonymous)
|
|
|
continue;
|
|
|
|
|
|
QUIT;
|
|
|
if (need_fullname)
|
|
|
fullname = psymtab_to_fullname (ps);
|
|
|
else
|
|
|
fullname = NULL;
|
|
|
fun (ps->filename, fullname);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Finds the fullname that a partial_symtab represents.
|
|
|
|
|
|
If this functions finds the fullname, it will save it in ps->fullname
|
|
|
and it will also return the value.
|
|
|
|
|
|
If this function fails to find the file that this partial_symtab represents,
|
|
|
NULL will be returned and ps->fullname will be set to NULL. */
|
|
|
|
|
|
static const char *
|
|
|
psymtab_to_fullname (struct partial_symtab *ps)
|
|
|
{
|
|
|
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 == NULL)
|
|
|
{
|
|
|
gdb::unique_xmalloc_ptr<char> fullname
|
|
|
= find_source_or_rewrite (ps->filename, ps->dirname);
|
|
|
ps->fullname = fullname.release ();
|
|
|
}
|
|
|
|
|
|
return ps->fullname;
|
|
|
}
|
|
|
|
|
|
/* Psymtab version of expand_matching_symbols. See its definition in
|
|
|
the definition of quick_symbol_functions in symfile.h. */
|
|
|
|
|
|
void
|
|
|
psymbol_functions::expand_matching_symbols
|
|
|
(struct objfile *objfile,
|
|
|
const lookup_name_info &name, domain_enum domain,
|
|
|
int global,
|
|
|
symbol_compare_ftype *ordered_compare)
|
|
|
{
|
|
|
for (partial_symtab *ps : partial_symbols (objfile))
|
|
|
{
|
|
|
QUIT;
|
|
|
if (!ps->readin_p (objfile)
|
|
|
&& match_partial_symbol (objfile, ps, global, name, domain,
|
|
|
ordered_compare))
|
|
|
psymtab_to_symtab (objfile, ps);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* A helper for psym_expand_symtabs_matching that handles searching
|
|
|
included psymtabs. This returns true if a symbol is found, and
|
|
|
false otherwise. It also updates the 'searched_flag' on the
|
|
|
various psymtabs that it searches. */
|
|
|
|
|
|
static bool
|
|
|
recursively_search_psymtabs
|
|
|
(struct partial_symtab *ps,
|
|
|
struct objfile *objfile,
|
|
|
block_search_flags search_flags,
|
|
|
domain_enum domain,
|
|
|
enum search_domain search,
|
|
|
const lookup_name_info &lookup_name,
|
|
|
gdb::function_view<expand_symtabs_symbol_matcher_ftype> sym_matcher)
|
|
|
{
|
|
|
int keep_going = 1;
|
|
|
enum psymtab_search_status result = PST_SEARCHED_AND_NOT_FOUND;
|
|
|
int i;
|
|
|
|
|
|
if (ps->searched_flag != PST_NOT_SEARCHED)
|
|
|
return ps->searched_flag == PST_SEARCHED_AND_FOUND;
|
|
|
|
|
|
/* Recurse into shared psymtabs first, because they may have already
|
|
|
been searched, and this could save some time. */
|
|
|
for (i = 0; i < ps->number_of_dependencies; ++i)
|
|
|
{
|
|
|
int r;
|
|
|
|
|
|
/* Skip non-shared dependencies, these are handled elsewhere. */
|
|
|
if (ps->dependencies[i]->user == NULL)
|
|
|
continue;
|
|
|
|
|
|
r = recursively_search_psymtabs (ps->dependencies[i],
|
|
|
objfile, search_flags, domain, search,
|
|
|
lookup_name, sym_matcher);
|
|
|
if (r != 0)
|
|
|
{
|
|
|
ps->searched_flag = PST_SEARCHED_AND_FOUND;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
partial_symbol **gbound = (ps->global_psymbols.data ()
|
|
|
+ ps->global_psymbols.size ());
|
|
|
partial_symbol **sbound = (ps->static_psymbols.data ()
|
|
|
+ ps->static_psymbols.size ());
|
|
|
partial_symbol **bound = gbound;
|
|
|
|
|
|
/* Go through all of the symbols stored in a partial
|
|
|
symtab in one loop. */
|
|
|
partial_symbol **psym = ps->global_psymbols.data ();
|
|
|
|
|
|
if ((search_flags & SEARCH_GLOBAL_BLOCK) == 0)
|
|
|
{
|
|
|
if (ps->static_psymbols.empty ())
|
|
|
keep_going = 0;
|
|
|
else
|
|
|
{
|
|
|
psym = ps->static_psymbols.data ();
|
|
|
bound = sbound;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
while (keep_going)
|
|
|
{
|
|
|
if (psym >= bound)
|
|
|
{
|
|
|
if (bound == gbound && !ps->static_psymbols.empty ()
|
|
|
&& (search_flags & SEARCH_STATIC_BLOCK) != 0)
|
|
|
{
|
|
|
psym = ps->static_psymbols.data ();
|
|
|
bound = sbound;
|
|
|
}
|
|
|
else
|
|
|
keep_going = 0;
|
|
|
continue;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
QUIT;
|
|
|
|
|
|
if ((domain == UNDEF_DOMAIN
|
|
|
|| symbol_matches_domain ((*psym)->ginfo.language (),
|
|
|
(*psym)->domain, domain))
|
|
|
&& (search == ALL_DOMAIN
|
|
|
|| (search == MODULES_DOMAIN
|
|
|
&& (*psym)->domain == MODULE_DOMAIN)
|
|
|
|| (search == VARIABLES_DOMAIN
|
|
|
&& (*psym)->aclass != LOC_TYPEDEF
|
|
|
&& (*psym)->aclass != LOC_BLOCK)
|
|
|
|| (search == FUNCTIONS_DOMAIN
|
|
|
&& (*psym)->aclass == LOC_BLOCK)
|
|
|
|| (search == TYPES_DOMAIN
|
|
|
&& (*psym)->aclass == LOC_TYPEDEF))
|
|
|
&& psymbol_name_matches (*psym, lookup_name)
|
|
|
&& (sym_matcher == NULL
|
|
|
|| sym_matcher ((*psym)->ginfo.search_name ())))
|
|
|
{
|
|
|
/* Found a match, so notify our caller. */
|
|
|
result = PST_SEARCHED_AND_FOUND;
|
|
|
keep_going = 0;
|
|
|
}
|
|
|
}
|
|
|
psym++;
|
|
|
}
|
|
|
|
|
|
ps->searched_flag = result;
|
|
|
return result == PST_SEARCHED_AND_FOUND;
|
|
|
}
|
|
|
|
|
|
/* Psymtab version of expand_symtabs_matching. See its definition in
|
|
|
the definition of quick_symbol_functions in symfile.h. */
|
|
|
|
|
|
bool
|
|
|
psymbol_functions::expand_symtabs_matching
|
|
|
(struct objfile *objfile,
|
|
|
gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
|
|
|
const lookup_name_info *lookup_name,
|
|
|
gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
|
|
|
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
|
|
|
block_search_flags search_flags,
|
|
|
domain_enum domain,
|
|
|
enum search_domain search)
|
|
|
{
|
|
|
/* Clear the search flags. */
|
|
|
for (partial_symtab *ps : partial_symbols (objfile))
|
|
|
ps->searched_flag = PST_NOT_SEARCHED;
|
|
|
|
|
|
gdb::optional<lookup_name_info> psym_lookup_name;
|
|
|
if (lookup_name != nullptr)
|
|
|
psym_lookup_name = lookup_name->make_ignore_params ();
|
|
|
|
|
|
/* This invariant is documented in quick-functions.h. */
|
|
|
gdb_assert (lookup_name != nullptr || symbol_matcher == nullptr);
|
|
|
|
|
|
for (partial_symtab *ps : m_partial_symtabs->range ())
|
|
|
{
|
|
|
QUIT;
|
|
|
|
|
|
if (ps->readin_p (objfile))
|
|
|
continue;
|
|
|
|
|
|
if (file_matcher)
|
|
|
{
|
|
|
bool match;
|
|
|
|
|
|
if (ps->anonymous)
|
|
|
continue;
|
|
|
|
|
|
match = file_matcher (ps->filename, false);
|
|
|
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), true))
|
|
|
match = file_matcher (psymtab_to_fullname (ps), false);
|
|
|
}
|
|
|
if (!match)
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
if (lookup_name == nullptr
|
|
|
|| recursively_search_psymtabs (ps, objfile, search_flags,
|
|
|
domain, search,
|
|
|
*psym_lookup_name,
|
|
|
symbol_matcher))
|
|
|
{
|
|
|
compunit_symtab *cust = psymtab_to_symtab (objfile, ps);
|
|
|
|
|
|
if (cust != nullptr && expansion_notify != nullptr)
|
|
|
if (!expansion_notify (cust))
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/* Psymtab version of has_symbols. See its definition in
|
|
|
the definition of quick_symbol_functions in symfile.h. */
|
|
|
|
|
|
bool
|
|
|
psymbol_functions::has_symbols (struct objfile *objfile)
|
|
|
{
|
|
|
return m_partial_symtabs->psymtabs != NULL;
|
|
|
}
|
|
|
|
|
|
/* See quick_symbol_functions::has_unexpanded_symtabs in quick-symbol.h. */
|
|
|
|
|
|
bool
|
|
|
psymbol_functions::has_unexpanded_symtabs (struct objfile *objfile)
|
|
|
{
|
|
|
for (partial_symtab *psymtab : partial_symbols (objfile))
|
|
|
{
|
|
|
/* Is this already expanded? */
|
|
|
if (psymtab->readin_p (objfile))
|
|
|
continue;
|
|
|
|
|
|
/* It has not yet been expanded. */
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
/* Helper function for psym_find_compunit_symtab_by_address that fills
|
|
|
in m_psymbol_map for a given range of psymbols. */
|
|
|
|
|
|
void
|
|
|
psymbol_functions::fill_psymbol_map
|
|
|
(struct objfile *objfile,
|
|
|
struct partial_symtab *psymtab,
|
|
|
std::set<CORE_ADDR> *seen_addrs,
|
|
|
const std::vector<partial_symbol *> &symbols)
|
|
|
{
|
|
|
for (partial_symbol *psym : symbols)
|
|
|
{
|
|
|
if (psym->aclass == LOC_STATIC)
|
|
|
{
|
|
|
CORE_ADDR addr = psym->address (objfile);
|
|
|
if (seen_addrs->find (addr) == seen_addrs->end ())
|
|
|
{
|
|
|
seen_addrs->insert (addr);
|
|
|
m_psymbol_map.emplace_back (addr, psymtab);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* See find_compunit_symtab_by_address in quick_symbol_functions, in
|
|
|
symfile.h. */
|
|
|
|
|
|
compunit_symtab *
|
|
|
psymbol_functions::find_compunit_symtab_by_address (struct objfile *objfile,
|
|
|
CORE_ADDR address)
|
|
|
{
|
|
|
if (m_psymbol_map.empty ())
|
|
|
{
|
|
|
std::set<CORE_ADDR> seen_addrs;
|
|
|
|
|
|
for (partial_symtab *pst : partial_symbols (objfile))
|
|
|
{
|
|
|
fill_psymbol_map (objfile, pst,
|
|
|
&seen_addrs,
|
|
|
pst->global_psymbols);
|
|
|
fill_psymbol_map (objfile, pst,
|
|
|
&seen_addrs,
|
|
|
pst->static_psymbols);
|
|
|
}
|
|
|
|
|
|
m_psymbol_map.shrink_to_fit ();
|
|
|
|
|
|
std::sort (m_psymbol_map.begin (), m_psymbol_map.end (),
|
|
|
[] (const std::pair<CORE_ADDR, partial_symtab *> &a,
|
|
|
const std::pair<CORE_ADDR, partial_symtab *> &b)
|
|
|
{
|
|
|
return a.first < b.first;
|
|
|
});
|
|
|
}
|
|
|
|
|
|
auto iter = std::lower_bound
|
|
|
(m_psymbol_map.begin (), m_psymbol_map.end (), address,
|
|
|
[] (const std::pair<CORE_ADDR, partial_symtab *> &a,
|
|
|
CORE_ADDR b)
|
|
|
{
|
|
|
return a.first < b;
|
|
|
});
|
|
|
|
|
|
if (iter == m_psymbol_map.end () || iter->first != address)
|
|
|
return NULL;
|
|
|
|
|
|
return psymtab_to_symtab (objfile, iter->second);
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Partially fill a partial symtab. It will be completely filled at
|
|
|
the end of the symbol list. */
|
|
|
|
|
|
partial_symtab::partial_symtab (const char *filename,
|
|
|
psymtab_storage *partial_symtabs,
|
|
|
objfile_per_bfd_storage *objfile_per_bfd,
|
|
|
CORE_ADDR textlow)
|
|
|
: partial_symtab (filename, partial_symtabs, objfile_per_bfd)
|
|
|
{
|
|
|
set_text_low (textlow);
|
|
|
set_text_high (raw_text_low ()); /* default */
|
|
|
}
|
|
|
|
|
|
/* Perform "finishing up" operations of a partial symtab. */
|
|
|
|
|
|
void
|
|
|
partial_symtab::end ()
|
|
|
{
|
|
|
global_psymbols.shrink_to_fit ();
|
|
|
static_psymbols.shrink_to_fit ();
|
|
|
|
|
|
/* Sort the global list; don't sort the static list. */
|
|
|
std::sort (global_psymbols.begin (),
|
|
|
global_psymbols.end (),
|
|
|
[] (partial_symbol *s1, partial_symbol *s2)
|
|
|
{
|
|
|
return strcmp_iw_ordered (s1->ginfo.search_name (),
|
|
|
s2->ginfo.search_name ()) < 0;
|
|
|
});
|
|
|
}
|
|
|
|
|
|
/* See psymtab.h. */
|
|
|
|
|
|
unsigned long
|
|
|
psymbol_bcache::hash (const void *addr, int length)
|
|
|
{
|
|
|
unsigned long h = 0;
|
|
|
struct partial_symbol *psymbol = (struct partial_symbol *) addr;
|
|
|
unsigned int lang = psymbol->ginfo.language ();
|
|
|
unsigned int domain = psymbol->domain;
|
|
|
unsigned int theclass = psymbol->aclass;
|
|
|
|
|
|
h = fast_hash (&psymbol->ginfo.m_value, sizeof (psymbol->ginfo.m_value), h);
|
|
|
h = fast_hash (&lang, sizeof (unsigned int), h);
|
|
|
h = fast_hash (&domain, sizeof (unsigned int), h);
|
|
|
h = fast_hash (&theclass, sizeof (unsigned int), h);
|
|
|
/* Note that psymbol names are interned via compute_and_set_names, so
|
|
|
there's no need to hash the contents of the name here. */
|
|
|
h = fast_hash (&psymbol->ginfo.m_name, sizeof (psymbol->ginfo.m_name), h);
|
|
|
|
|
|
return h;
|
|
|
}
|
|
|
|
|
|
/* See psymtab.h. */
|
|
|
|
|
|
int
|
|
|
psymbol_bcache::compare (const void *addr1, const void *addr2, int length)
|
|
|
{
|
|
|
struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
|
|
|
struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
|
|
|
|
|
|
return (memcmp (&sym1->ginfo.m_value, &sym2->ginfo.m_value,
|
|
|
sizeof (sym1->ginfo.m_value)) == 0
|
|
|
&& sym1->ginfo.language () == sym2->ginfo.language ()
|
|
|
&& sym1->domain == sym2->domain
|
|
|
&& sym1->aclass == sym2->aclass
|
|
|
/* Note that psymbol names are interned via
|
|
|
compute_and_set_names, so there's no need to compare the
|
|
|
contents of the name here. */
|
|
|
&& sym1->ginfo.linkage_name () == sym2->ginfo.linkage_name ());
|
|
|
}
|
|
|
|
|
|
/* See psympriv.h. */
|
|
|
|
|
|
void
|
|
|
partial_symtab::add_psymbol (const partial_symbol &psymbol,
|
|
|
psymbol_placement where,
|
|
|
psymtab_storage *partial_symtabs,
|
|
|
struct objfile *objfile)
|
|
|
{
|
|
|
bool added;
|
|
|
|
|
|
/* Stash the partial symbol away in the cache. */
|
|
|
partial_symbol *psym
|
|
|
= ((struct partial_symbol *)
|
|
|
partial_symtabs->psymbol_cache.insert
|
|
|
(&psymbol, sizeof (struct partial_symbol), &added));
|
|
|
|
|
|
/* Do not duplicate global partial symbols. */
|
|
|
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
|
|
|
? static_psymbols
|
|
|
: global_psymbols);
|
|
|
list.push_back (psym);
|
|
|
}
|
|
|
|
|
|
/* See psympriv.h. */
|
|
|
|
|
|
void
|
|
|
partial_symtab::add_psymbol (gdb::string_view name, bool copy_name,
|
|
|
domain_enum domain,
|
|
|
enum address_class theclass,
|
|
|
short section,
|
|
|
psymbol_placement where,
|
|
|
CORE_ADDR coreaddr,
|
|
|
enum language language,
|
|
|
psymtab_storage *partial_symtabs,
|
|
|
struct objfile *objfile)
|
|
|
{
|
|
|
struct partial_symbol psymbol;
|
|
|
memset (&psymbol, 0, sizeof (psymbol));
|
|
|
|
|
|
psymbol.set_unrelocated_address (coreaddr);
|
|
|
psymbol.ginfo.set_section_index (section);
|
|
|
psymbol.domain = domain;
|
|
|
psymbol.aclass = theclass;
|
|
|
psymbol.ginfo.set_language (language, partial_symtabs->obstack ());
|
|
|
psymbol.ginfo.compute_and_set_names (name, copy_name, objfile->per_bfd);
|
|
|
|
|
|
add_psymbol (psymbol, where, partial_symtabs, objfile);
|
|
|
}
|
|
|
|
|
|
/* See psympriv.h. */
|
|
|
|
|
|
partial_symtab::partial_symtab (const char *filename_,
|
|
|
psymtab_storage *partial_symtabs,
|
|
|
objfile_per_bfd_storage *objfile_per_bfd)
|
|
|
: searched_flag (PST_NOT_SEARCHED),
|
|
|
text_low_valid (0),
|
|
|
text_high_valid (0)
|
|
|
{
|
|
|
partial_symtabs->install_psymtab (this);
|
|
|
|
|
|
filename = objfile_per_bfd->intern (filename_);
|
|
|
|
|
|
if (symtab_create_debug)
|
|
|
{
|
|
|
/* Be a bit clever with debugging messages, and don't print objfile
|
|
|
every time, only when it changes. */
|
|
|
static std::string last_bfd_name;
|
|
|
const char *this_bfd_name
|
|
|
= bfd_get_filename (objfile_per_bfd->get_bfd ());
|
|
|
|
|
|
if (last_bfd_name.empty () || last_bfd_name != this_bfd_name)
|
|
|
{
|
|
|
last_bfd_name = this_bfd_name;
|
|
|
gdb_printf (gdb_stdlog,
|
|
|
"Creating one or more psymtabs for %s ...\n",
|
|
|
this_bfd_name);
|
|
|
}
|
|
|
gdb_printf (gdb_stdlog,
|
|
|
"Created psymtab %s for module %s.\n",
|
|
|
host_address_to_string (this), filename);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* See psympriv.h. */
|
|
|
|
|
|
void
|
|
|
partial_symtab::expand_dependencies (struct objfile *objfile)
|
|
|
{
|
|
|
for (int i = 0; i < number_of_dependencies; ++i)
|
|
|
{
|
|
|
if (!dependencies[i]->readin_p (objfile)
|
|
|
&& dependencies[i]->user == NULL)
|
|
|
{
|
|
|
/* Inform about additional files to be read in. */
|
|
|
if (info_verbose)
|
|
|
{
|
|
|
gdb_puts (" ");
|
|
|
gdb_stdout->wrap_here (0);
|
|
|
gdb_puts ("and ");
|
|
|
gdb_stdout->wrap_here (0);
|
|
|
gdb_printf ("%s...", dependencies[i]->filename);
|
|
|
gdb_flush (gdb_stdout);
|
|
|
}
|
|
|
dependencies[i]->expand_psymtab (objfile);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
void
|
|
|
psymtab_storage::discard_psymtab (struct partial_symtab *pst)
|
|
|
{
|
|
|
struct partial_symtab **prev_pst;
|
|
|
|
|
|
/* From dbxread.c:
|
|
|
Empty psymtabs happen as a result of header files which don't
|
|
|
have any symbols in them. There can be a lot of them. But this
|
|
|
check is wrong, in that a psymtab with N_SLINE entries but
|
|
|
nothing else is not empty, but we don't realize that. Fixing
|
|
|
that without slowing things down might be tricky. */
|
|
|
|
|
|
/* First, snip it out of the psymtab chain. */
|
|
|
|
|
|
prev_pst = &psymtabs;
|
|
|
while ((*prev_pst) != pst)
|
|
|
prev_pst = &((*prev_pst)->next);
|
|
|
(*prev_pst) = pst->next;
|
|
|
delete pst;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
maintenance_print_psymbols (const char *args, int from_tty)
|
|
|
{
|
|
|
struct ui_file *outfile = gdb_stdout;
|
|
|
char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
|
|
|
int i, outfile_idx, found;
|
|
|
CORE_ADDR pc = 0;
|
|
|
struct obj_section *section = NULL;
|
|
|
|
|
|
dont_repeat ();
|
|
|
|
|
|
gdb_argv argv (args);
|
|
|
|
|
|
for (i = 0; argv != NULL && argv[i] != NULL; ++i)
|
|
|
{
|
|
|
if (strcmp (argv[i], "-pc") == 0)
|
|
|
{
|
|
|
if (argv[i + 1] == NULL)
|
|
|
error (_("Missing pc value"));
|
|
|
address_arg = argv[++i];
|
|
|
}
|
|
|
else if (strcmp (argv[i], "-source") == 0)
|
|
|
{
|
|
|
if (argv[i + 1] == NULL)
|
|
|
error (_("Missing source file"));
|
|
|
source_arg = argv[++i];
|
|
|
}
|
|
|
else if (strcmp (argv[i], "-objfile") == 0)
|
|
|
{
|
|
|
if (argv[i + 1] == NULL)
|
|
|
error (_("Missing objfile name"));
|
|
|
objfile_arg = argv[++i];
|
|
|
}
|
|
|
else if (strcmp (argv[i], "--") == 0)
|
|
|
{
|
|
|
/* End of options. */
|
|
|
++i;
|
|
|
break;
|
|
|
}
|
|
|
else if (argv[i][0] == '-')
|
|
|
{
|
|
|
/* Future proofing: Don't allow OUTFILE to begin with "-". */
|
|
|
error (_("Unknown option: %s"), argv[i]);
|
|
|
}
|
|
|
else
|
|
|
break;
|
|
|
}
|
|
|
outfile_idx = i;
|
|
|
|
|
|
if (address_arg != NULL && source_arg != NULL)
|
|
|
error (_("Must specify at most one of -pc and -source"));
|
|
|
|
|
|
stdio_file arg_outfile;
|
|
|
|
|
|
if (argv != NULL && argv[outfile_idx] != NULL)
|
|
|
{
|
|
|
if (argv[outfile_idx + 1] != NULL)
|
|
|
error (_("Junk at end of command"));
|
|
|
gdb::unique_xmalloc_ptr<char> outfile_name
|
|
|
(tilde_expand (argv[outfile_idx]));
|
|
|
if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
|
|
|
perror_with_name (outfile_name.get ());
|
|
|
outfile = &arg_outfile;
|
|
|
}
|
|
|
|
|
|
if (address_arg != NULL)
|
|
|
{
|
|
|
pc = parse_and_eval_address (address_arg);
|
|
|
/* If we fail to find a section, that's ok, try the lookup anyway. */
|
|
|
section = find_pc_section (pc);
|
|
|
}
|
|
|
|
|
|
found = 0;
|
|
|
for (objfile *objfile : current_program_space->objfiles ())
|
|
|
{
|
|
|
int printed_objfile_header = 0;
|
|
|
int print_for_objfile = 1;
|
|
|
|
|
|
QUIT;
|
|
|
if (objfile_arg != NULL)
|
|
|
print_for_objfile
|
|
|
= compare_filenames_for_search (objfile_name (objfile),
|
|
|
objfile_arg);
|
|
|
if (!print_for_objfile)
|
|
|
continue;
|
|
|
|
|
|
for (const auto &iter : objfile->qf)
|
|
|
{
|
|
|
psymbol_functions *psf
|
|
|
= dynamic_cast<psymbol_functions *> (iter.get ());
|
|
|
if (psf == nullptr)
|
|
|
continue;
|
|
|
|
|
|
if (address_arg != NULL)
|
|
|
{
|
|
|
struct bound_minimal_symbol msymbol;
|
|
|
|
|
|
/* We don't assume each pc has a unique objfile (this is for
|
|
|
debugging). */
|
|
|
struct partial_symtab *ps
|
|
|
= psf->find_pc_sect_psymtab (objfile, pc, section, msymbol);
|
|
|
if (ps != NULL)
|
|
|
{
|
|
|
if (!printed_objfile_header)
|
|
|
{
|
|
|
outfile->printf ("\nPartial symtabs for objfile %s\n",
|
|
|
objfile_name (objfile));
|
|
|
printed_objfile_header = 1;
|
|
|
}
|
|
|
dump_psymtab (objfile, ps, outfile);
|
|
|
found = 1;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
for (partial_symtab *ps : psf->partial_symbols (objfile))
|
|
|
{
|
|
|
int print_for_source = 0;
|
|
|
|
|
|
QUIT;
|
|
|
if (source_arg != NULL)
|
|
|
{
|
|
|
print_for_source
|
|
|
= compare_filenames_for_search (ps->filename, source_arg);
|
|
|
found = 1;
|
|
|
}
|
|
|
if (source_arg == NULL
|
|
|
|| print_for_source)
|
|
|
{
|
|
|
if (!printed_objfile_header)
|
|
|
{
|
|
|
outfile->printf ("\nPartial symtabs for objfile %s\n",
|
|
|
objfile_name (objfile));
|
|
|
printed_objfile_header = 1;
|
|
|
}
|
|
|
dump_psymtab (objfile, ps, outfile);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (!found)
|
|
|
{
|
|
|
if (address_arg != NULL)
|
|
|
error (_("No partial symtab for address: %s"), address_arg);
|
|
|
if (source_arg != NULL)
|
|
|
error (_("No partial symtab for source file: %s"), source_arg);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* List all the partial symbol tables whose names match REGEXP (optional). */
|
|
|
|
|
|
static void
|
|
|
maintenance_info_psymtabs (const char *regexp, int from_tty)
|
|
|
{
|
|
|
if (regexp)
|
|
|
re_comp (regexp);
|
|
|
|
|
|
for (struct program_space *pspace : program_spaces)
|
|
|
for (objfile *objfile : pspace->objfiles ())
|
|
|
{
|
|
|
struct gdbarch *gdbarch = objfile->arch ();
|
|
|
|
|
|
/* We don't want to print anything for this objfile until we
|
|
|
actually find a symtab whose name matches. */
|
|
|
int printed_objfile_start = 0;
|
|
|
|
|
|
for (const auto &iter : objfile->qf)
|
|
|
{
|
|
|
psymbol_functions *psf
|
|
|
= dynamic_cast<psymbol_functions *> (iter.get ());
|
|
|
if (psf == nullptr)
|
|
|
continue;
|
|
|
for (partial_symtab *psymtab : psf->partial_symbols (objfile))
|
|
|
{
|
|
|
QUIT;
|
|
|
|
|
|
if (! regexp
|
|
|
|| re_exec (psymtab->filename))
|
|
|
{
|
|
|
if (! printed_objfile_start)
|
|
|
{
|
|
|
gdb_printf ("{ objfile %s ", objfile_name (objfile));
|
|
|
gdb_stdout->wrap_here (2);
|
|
|
gdb_printf ("((struct objfile *) %s)\n",
|
|
|
host_address_to_string (objfile));
|
|
|
printed_objfile_start = 1;
|
|
|
}
|
|
|
|
|
|
gdb_printf (" { psymtab %s ", psymtab->filename);
|
|
|
gdb_stdout->wrap_here (4);
|
|
|
gdb_printf ("((struct partial_symtab *) %s)\n",
|
|
|
host_address_to_string (psymtab));
|
|
|
|
|
|
gdb_printf (" readin %s\n",
|
|
|
psymtab->readin_p (objfile) ? "yes" : "no");
|
|
|
gdb_printf (" fullname %s\n",
|
|
|
psymtab->fullname
|
|
|
? psymtab->fullname : "(null)");
|
|
|
gdb_printf (" text addresses ");
|
|
|
gdb_puts (paddress (gdbarch,
|
|
|
psymtab->text_low (objfile)));
|
|
|
gdb_printf (" -- ");
|
|
|
gdb_puts (paddress (gdbarch,
|
|
|
psymtab->text_high (objfile)));
|
|
|
gdb_printf ("\n");
|
|
|
gdb_printf (" globals ");
|
|
|
if (!psymtab->global_psymbols.empty ())
|
|
|
gdb_printf
|
|
|
("(* (struct partial_symbol **) %s @ %d)\n",
|
|
|
host_address_to_string (psymtab->global_psymbols.data ()),
|
|
|
(int) psymtab->global_psymbols.size ());
|
|
|
else
|
|
|
gdb_printf ("(none)\n");
|
|
|
gdb_printf (" statics ");
|
|
|
if (!psymtab->static_psymbols.empty ())
|
|
|
gdb_printf
|
|
|
("(* (struct partial_symbol **) %s @ %d)\n",
|
|
|
host_address_to_string (psymtab->static_psymbols.data ()),
|
|
|
(int) psymtab->static_psymbols.size ());
|
|
|
else
|
|
|
gdb_printf ("(none)\n");
|
|
|
if (psymtab->user)
|
|
|
gdb_printf (" user %s "
|
|
|
"((struct partial_symtab *) %s)\n",
|
|
|
psymtab->user->filename,
|
|
|
host_address_to_string (psymtab->user));
|
|
|
gdb_printf (" dependencies ");
|
|
|
if (psymtab->number_of_dependencies)
|
|
|
{
|
|
|
int i;
|
|
|
|
|
|
gdb_printf ("{\n");
|
|
|
for (i = 0; i < psymtab->number_of_dependencies; i++)
|
|
|
{
|
|
|
struct partial_symtab *dep = psymtab->dependencies[i];
|
|
|
|
|
|
/* Note the string concatenation there --- no
|
|
|
comma. */
|
|
|
gdb_printf (" psymtab %s "
|
|
|
"((struct partial_symtab *) %s)\n",
|
|
|
dep->filename,
|
|
|
host_address_to_string (dep));
|
|
|
}
|
|
|
gdb_printf (" }\n");
|
|
|
}
|
|
|
else
|
|
|
gdb_printf ("(none)\n");
|
|
|
gdb_printf (" }\n");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (printed_objfile_start)
|
|
|
gdb_printf ("}\n");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Check consistency of currently expanded psymtabs vs symtabs. */
|
|
|
|
|
|
static void
|
|
|
maintenance_check_psymtabs (const char *ignore, int from_tty)
|
|
|
{
|
|
|
struct symbol *sym;
|
|
|
struct compunit_symtab *cust = NULL;
|
|
|
const struct blockvector *bv;
|
|
|
const struct block *b;
|
|
|
|
|
|
for (objfile *objfile : current_program_space->objfiles ())
|
|
|
{
|
|
|
for (const auto &iter : objfile->qf)
|
|
|
{
|
|
|
psymbol_functions *psf
|
|
|
= dynamic_cast<psymbol_functions *> (iter.get ());
|
|
|
if (psf == nullptr)
|
|
|
continue;
|
|
|
|
|
|
for (partial_symtab *ps : psf->partial_symbols (objfile))
|
|
|
{
|
|
|
struct gdbarch *gdbarch = objfile->arch ();
|
|
|
|
|
|
/* 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->get_compunit_symtab (objfile);
|
|
|
|
|
|
/* First do some checks that don't require the associated symtab. */
|
|
|
if (ps->text_high (objfile) < ps->text_low (objfile))
|
|
|
{
|
|
|
gdb_printf ("Psymtab ");
|
|
|
gdb_puts (ps->filename);
|
|
|
gdb_printf (" covers bad range ");
|
|
|
gdb_puts (paddress (gdbarch, ps->text_low (objfile)));
|
|
|
gdb_printf (" - ");
|
|
|
gdb_puts (paddress (gdbarch, ps->text_high (objfile)));
|
|
|
gdb_printf ("\n");
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
/* Now do checks requiring the associated symtab. */
|
|
|
if (cust == NULL)
|
|
|
continue;
|
|
|
bv = cust->blockvector ();
|
|
|
b = bv->static_block ();
|
|
|
for (partial_symbol *psym : ps->static_psymbols)
|
|
|
{
|
|
|
/* Skip symbols for inlined functions without address. These may
|
|
|
or may not have a match in the full symtab. */
|
|
|
if (psym->aclass == LOC_BLOCK
|
|
|
&& psym->ginfo.value_address () == 0)
|
|
|
continue;
|
|
|
|
|
|
sym = block_lookup_symbol (b, psym->ginfo.search_name (),
|
|
|
symbol_name_match_type::SEARCH_NAME,
|
|
|
psym->domain);
|
|
|
if (!sym)
|
|
|
{
|
|
|
gdb_printf ("Static symbol `");
|
|
|
gdb_puts (psym->ginfo.linkage_name ());
|
|
|
gdb_printf ("' only found in ");
|
|
|
gdb_puts (ps->filename);
|
|
|
gdb_printf (" psymtab\n");
|
|
|
}
|
|
|
}
|
|
|
b = bv->global_block ();
|
|
|
for (partial_symbol *psym : ps->global_psymbols)
|
|
|
{
|
|
|
sym = block_lookup_symbol (b, psym->ginfo.search_name (),
|
|
|
symbol_name_match_type::SEARCH_NAME,
|
|
|
psym->domain);
|
|
|
if (!sym)
|
|
|
{
|
|
|
gdb_printf ("Global symbol `");
|
|
|
gdb_puts (psym->ginfo.linkage_name ());
|
|
|
gdb_printf ("' only found in ");
|
|
|
gdb_puts (ps->filename);
|
|
|
gdb_printf (" psymtab\n");
|
|
|
}
|
|
|
}
|
|
|
if (ps->raw_text_high () != 0
|
|
|
&& (ps->text_low (objfile) < b->start ()
|
|
|
|| ps->text_high (objfile) > b->end ()))
|
|
|
{
|
|
|
gdb_printf ("Psymtab ");
|
|
|
gdb_puts (ps->filename);
|
|
|
gdb_printf (" covers ");
|
|
|
gdb_puts (paddress (gdbarch, ps->text_low (objfile)));
|
|
|
gdb_printf (" - ");
|
|
|
gdb_puts (paddress (gdbarch, ps->text_high (objfile)));
|
|
|
gdb_printf (" but symtab covers only ");
|
|
|
gdb_puts (paddress (gdbarch, b->start ()));
|
|
|
gdb_printf (" - ");
|
|
|
gdb_puts (paddress (gdbarch, b->end ()));
|
|
|
gdb_printf ("\n");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void _initialize_psymtab ();
|
|
|
void
|
|
|
_initialize_psymtab ()
|
|
|
{
|
|
|
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\
|
|
|
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\
|
|
|
If SOURCE is provided, dump only that file's symbols.\n\
|
|
|
If OBJFILE is provided, dump only that file's minimal symbols."),
|
|
|
&maintenanceprintlist);
|
|
|
|
|
|
add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
|
|
|
List the partial symbol tables for all object files.\n\
|
|
|
This does not include information about individual partial symbols,\n\
|
|
|
just the symbol table structures themselves."),
|
|
|
&maintenanceinfolist);
|
|
|
|
|
|
add_cmd ("check-psymtabs", class_maintenance, maintenance_check_psymtabs,
|
|
|
_("\
|
|
|
Check consistency of currently expanded psymtabs versus symtabs."),
|
|
|
&maintenancelist);
|
|
|
}
|