/* Partial symbol tables.
- Copyright (C) 2009-2021 Free Software Foundation, Inc.
+ Copyright (C) 2009-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "ui-out.h"
#include "command.h"
#include "readline/tilde.h"
-#include "gdb_regex.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 *,
\f
-/* Ensure that the partial symbols for OBJFILE have been loaded. This
- will print a message when symbols are loaded. This function
- returns a range adapter suitable for iterating over the psymtabs of
- OBJFILE. */
+/* See psympriv.h. */
psymtab_storage::partial_symtab_range
-psymbol_functions::require_partial_symbols (struct objfile *objfile)
+psymbol_functions::partial_symbols (struct objfile *objfile)
{
- objfile->require_partial_symbols (true);
+ gdb_assert ((objfile->flags & OBJF_PSYMTABS_READ) != 0);
return m_partial_symtabs->range ();
}
-/* Helper function for psym_map_symtabs_matching_filename that
- expands the symtabs and calls the iterator. */
-
-static bool
-partial_map_expand_apply (struct objfile *objfile,
- const char *name,
- const char *real_path,
- struct partial_symtab *pst,
- gdb::function_view<bool (symtab *)> callback)
-{
- struct compunit_symtab *last_made = objfile->compunit_symtabs;
-
- /* Shared psymtabs should never be seen here. Instead they should
- be handled properly by the caller. */
- gdb_assert (pst->user == NULL);
-
- /* Don't visit already-expanded psymtabs. */
- if (pst->readin_p (objfile))
- return 0;
-
- /* This may expand more than one symtab, and we want to iterate over
- all of them. */
- psymtab_to_symtab (objfile, pst);
-
- return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
- last_made, callback);
-}
-
-/* Psymtab version of map_symtabs_matching_filename. See its definition in
- the definition of quick_symbol_functions in symfile.h. */
-
-bool
-psymbol_functions::map_symtabs_matching_filename
- (struct objfile *objfile,
- const char *name,
- const char *real_path,
- gdb::function_view<bool (symtab *)> callback)
-{
- const char *name_basename = lbasename (name);
-
- for (partial_symtab *pst : require_partial_symbols (objfile))
- {
- /* Anonymous psymtabs don't have a file name. */
- if (pst->anonymous)
- continue;
-
- if (compare_filenames_for_search (pst->filename, name))
- {
- while (pst->user)
- pst = pst->user;
-
- if (partial_map_expand_apply (objfile, name, real_path,
- pst, callback))
- return true;
- 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 (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;
-}
-
/* 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. */
object's symbol table. */
p = find_pc_sect_psymbol (objfile, tpst, pc, section);
if (p != NULL
- && (p->address (objfile) == BMSYMBOL_VALUE_ADDRESS (msymbol)))
+ && (p->address (objfile) == msymbol.value_address ()))
return tpst;
/* Also accept the textlow value of a psymtab as a
p = find_pc_sect_psymbol (objfile, pst, pc, section);
if (p == NULL
|| (p->address (objfile)
- != BMSYMBOL_VALUE_ADDRESS (msymbol)))
+ != msymbol.value_address ()))
goto next;
}
its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
debug info type in single OBJFILE. */
- for (partial_symtab *pst : require_partial_symbols (objfile))
+ for (partial_symtab *pst : partial_symbols (objfile))
if (!pst->psymtabs_addrmap_supported
&& pc >= pst->text_low (objfile) && pc < pst->text_high (objfile))
{
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
- for (partial_symtab *ps : require_partial_symbols (objfile))
+ for (partial_symtab *ps : partial_symbols (objfile))
{
struct partial_symbol *psym;
if (ps->readin_p (objfile))
if (info_verbose)
{
- printf_filtered (_("Reading in symbols for %s...\n"),
- pst->filename);
+ gdb_printf (_("Reading in symbols for %s...\n"),
+ pst->filename);
gdb_flush (gdb_stdout);
}
{
struct partial_symtab *cs_pst = NULL;
- for (partial_symtab *ps : require_partial_symbols (ofp))
+ for (partial_symtab *ps : partial_symbols (ofp))
{
const char *name = ps->filename;
int len = strlen (name);
if (cust == NULL)
return NULL;
- return compunit_primary_filetab (cust);
+ return cust->primary_filetab ();
}
}
return NULL;
void
psymbol_functions::forget_cached_source_info (struct objfile *objfile)
{
- for (partial_symtab *pst : require_partial_symbols (objfile))
+ for (partial_symtab *pst : partial_symbols (objfile))
{
if (pst->fullname != NULL)
{
const std::vector<partial_symbol *> &symbols,
const char *what, struct ui_file *outfile)
{
- fprintf_filtered (outfile, " %s partial symbols:\n", what);
+ gdb_printf (outfile, " %s partial symbols:\n", what);
for (partial_symbol *p : symbols)
{
QUIT;
- fprintf_filtered (outfile, " `%s'", p->ginfo.linkage_name ());
+ gdb_printf (outfile, " `%s'", p->ginfo.linkage_name ());
if (p->ginfo.demangled_name () != NULL)
{
- fprintf_filtered (outfile, " `%s'",
- p->ginfo.demangled_name ());
+ gdb_printf (outfile, " `%s'",
+ p->ginfo.demangled_name ());
}
- fputs_filtered (", ", outfile);
+ gdb_puts (", ", outfile);
switch (p->domain)
{
case UNDEF_DOMAIN:
- fputs_filtered ("undefined domain, ", outfile);
+ gdb_puts ("undefined domain, ", outfile);
break;
case VAR_DOMAIN:
/* This is the usual thing -- don't print it. */
break;
case STRUCT_DOMAIN:
- fputs_filtered ("struct domain, ", outfile);
+ gdb_puts ("struct domain, ", outfile);
break;
case MODULE_DOMAIN:
- fputs_filtered ("module domain, ", outfile);
+ gdb_puts ("module domain, ", outfile);
break;
case LABEL_DOMAIN:
- fputs_filtered ("label domain, ", outfile);
+ gdb_puts ("label domain, ", outfile);
break;
case COMMON_BLOCK_DOMAIN:
- fputs_filtered ("common block domain, ", outfile);
+ gdb_puts ("common block domain, ", outfile);
break;
default:
- fputs_filtered ("<invalid domain>, ", outfile);
+ gdb_puts ("<invalid domain>, ", outfile);
break;
}
switch (p->aclass)
{
case LOC_UNDEF:
- fputs_filtered ("undefined", outfile);
+ gdb_puts ("undefined", outfile);
break;
case LOC_CONST:
- fputs_filtered ("constant int", outfile);
+ gdb_puts ("constant int", outfile);
break;
case LOC_STATIC:
- fputs_filtered ("static", outfile);
+ gdb_puts ("static", outfile);
break;
case LOC_REGISTER:
- fputs_filtered ("register", outfile);
+ gdb_puts ("register", outfile);
break;
case LOC_ARG:
- fputs_filtered ("pass by value", outfile);
+ gdb_puts ("pass by value", outfile);
break;
case LOC_REF_ARG:
- fputs_filtered ("pass by reference", outfile);
+ gdb_puts ("pass by reference", outfile);
break;
case LOC_REGPARM_ADDR:
- fputs_filtered ("register address parameter", outfile);
+ gdb_puts ("register address parameter", outfile);
break;
case LOC_LOCAL:
- fputs_filtered ("stack parameter", outfile);
+ gdb_puts ("stack parameter", outfile);
break;
case LOC_TYPEDEF:
- fputs_filtered ("type", outfile);
+ gdb_puts ("type", outfile);
break;
case LOC_LABEL:
- fputs_filtered ("label", outfile);
+ gdb_puts ("label", outfile);
break;
case LOC_BLOCK:
- fputs_filtered ("function", outfile);
+ gdb_puts ("function", outfile);
break;
case LOC_CONST_BYTES:
- fputs_filtered ("constant bytes", outfile);
+ gdb_puts ("constant bytes", outfile);
break;
case LOC_UNRESOLVED:
- fputs_filtered ("unresolved", outfile);
+ gdb_puts ("unresolved", outfile);
break;
case LOC_OPTIMIZED_OUT:
- fputs_filtered ("optimized out", outfile);
+ gdb_puts ("optimized out", outfile);
break;
case LOC_COMPUTED:
- fputs_filtered ("computed at runtime", outfile);
+ gdb_puts ("computed at runtime", outfile);
break;
default:
- fputs_filtered ("<invalid location>", outfile);
+ gdb_puts ("<invalid location>", outfile);
break;
}
- fputs_filtered (", ", outfile);
- fputs_filtered (paddress (gdbarch, p->unrelocated_address ()), outfile);
- fprintf_filtered (outfile, "\n");
+ gdb_puts (", ", outfile);
+ gdb_puts (paddress (gdbarch, p->unrelocated_address ()), outfile);
+ gdb_printf (outfile, "\n");
}
}
if (psymtab->anonymous)
{
- fprintf_filtered (outfile, "\nAnonymous partial symtab (%s) ",
- psymtab->filename);
+ gdb_printf (outfile, "\nAnonymous partial symtab (%s) ",
+ psymtab->filename);
}
else
{
- fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
- psymtab->filename);
+ gdb_printf (outfile, "\nPartial symtab for source file %s ",
+ psymtab->filename);
}
- fprintf_filtered (outfile, "(object ");
- gdb_print_host_address (psymtab, outfile);
- fprintf_filtered (outfile, ")\n\n");
- fprintf_filtered (outfile, " Read from object file %s (",
- objfile_name (objfile));
- gdb_print_host_address (objfile, outfile);
- fprintf_filtered (outfile, ")\n");
+ 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))
- {
- fprintf_filtered (outfile,
- " Full symtab was read (at ");
- gdb_print_host_address (psymtab->get_compunit_symtab (objfile), outfile);
- fprintf_filtered (outfile, ")\n");
- }
-
- fprintf_filtered (outfile, " Symbols cover text addresses ");
- fputs_filtered (paddress (gdbarch, psymtab->text_low (objfile)), outfile);
- fprintf_filtered (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");
- fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
- psymtab->number_of_dependencies);
+ 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, " Address map supported - %s.\n",
+ psymtab->psymtabs_addrmap_supported ? "yes" : "no");
+ gdb_printf (outfile, " Depends on %d other partial symtabs.\n",
+ psymtab->number_of_dependencies);
for (i = 0; i < psymtab->number_of_dependencies; i++)
- {
- fprintf_filtered (outfile, " %d ", i);
- gdb_print_host_address (psymtab->dependencies[i], outfile);
- fprintf_filtered (outfile, " %s\n",
- psymtab->dependencies[i]->filename);
- }
+ gdb_printf (outfile, " %d %s\n", i,
+ host_address_to_string (psymtab->dependencies[i]));
if (psymtab->user != NULL)
- {
- fprintf_filtered (outfile, " Shared partial symtab with user ");
- gdb_print_host_address (psymtab->user, outfile);
- fprintf_filtered (outfile, "\n");
- }
+ 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->static_psymbols,
"Static", outfile);
}
- fprintf_filtered (outfile, "\n");
+ gdb_printf (outfile, "\n");
}
/* Count the number of partial symbols in OBJFILE. */
{
int n_psyms = count_psyms ();
if (n_psyms > 0)
- printf_filtered (_(" Number of \"partial\" symbols read: %d\n"),
- n_psyms);
+ gdb_printf (_(" Number of \"partial\" symbols read: %d\n"),
+ n_psyms);
i = 0;
- for (partial_symtab *ps : require_partial_symbols (objfile))
+ for (partial_symtab *ps : partial_symbols (objfile))
{
if (!ps->readin_p (objfile))
i++;
}
- printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"),
- i);
- printf_filtered (_(" Total memory used for psymbol cache: %d\n"),
- m_partial_symtabs->psymbol_cache.memory_used ());
+ 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
{
- printf_filtered (_("Psymbol byte cache statistics:\n"));
+ gdb_printf (_("Psymbol byte cache statistics:\n"));
m_partial_symtabs->psymbol_cache.print_statistics
("partial symbol cache");
}
if (m_partial_symtabs->psymtabs)
{
- printf_filtered ("Psymtabs:\n");
+ gdb_printf ("Psymtabs:\n");
for (psymtab = m_partial_symtabs->psymtabs;
psymtab != NULL;
psymtab = psymtab->next)
- {
- printf_filtered ("%s at ",
- psymtab->filename);
- gdb_print_host_address (psymtab, gdb_stdout);
- printf_filtered (", ");
- wrap_here (" ");
- }
- printf_filtered ("\n\n");
- }
-}
-
-/* Psymtab version of expand_symtabs_for_function. See its definition in
- the definition of quick_symbol_functions in symfile.h. */
-
-void
-psymbol_functions::expand_symtabs_for_function (struct objfile *objfile,
- const char *func_name)
-{
- lookup_name_info base_lookup (func_name, symbol_name_match_type::FULL);
- lookup_name_info lookup_name = base_lookup.make_ignore_params ();
-
- for (partial_symtab *ps : require_partial_symbols (objfile))
- {
- if (ps->readin_p (objfile))
- continue;
-
- if ((lookup_partial_symbol (objfile, ps, lookup_name, 1, VAR_DOMAIN)
- != NULL)
- || (lookup_partial_symbol (objfile, ps, lookup_name, 0, VAR_DOMAIN)
- != NULL))
- psymtab_to_symtab (objfile, ps);
+ gdb_printf ("%s at %s\n",
+ psymtab->filename,
+ host_address_to_string (psymtab));
+ gdb_printf ("\n\n");
}
}
void
psymbol_functions::expand_all_symtabs (struct objfile *objfile)
{
- for (partial_symtab *psymtab : require_partial_symbols (objfile))
+ for (partial_symtab *psymtab : partial_symbols (objfile))
psymtab_to_symtab (objfile, psymtab);
}
-/* Psymtab version of expand_symtabs_with_fullname. See its definition in
- the definition of quick_symbol_functions in symfile.h. */
-
-void
-psymbol_functions::expand_symtabs_with_fullname (struct objfile *objfile,
- const char *fullname)
-{
- for (partial_symtab *p : require_partial_symbols (objfile))
- {
- /* Anonymous psymtabs don't have a name of a source file. */
- if (p->anonymous)
- continue;
-
- /* psymtab_to_fullname tries to open the file which is slow.
- Don't call it if we know the basenames don't match. */
- if ((basenames_may_differ
- || filename_cmp (lbasename (fullname), lbasename (p->filename)) == 0)
- && filename_cmp (fullname, psymtab_to_fullname (p)) == 0)
- psymtab_to_symtab (objfile, p);
- }
-}
-
/* Psymtab version of map_symbol_filenames. See its definition in
the definition of quick_symbol_functions in symfile.h. */
gdb::function_view<symbol_filename_ftype> fun,
bool need_fullname)
{
- for (partial_symtab *ps : require_partial_symbols (objfile))
+ for (partial_symtab *ps : partial_symbols (objfile))
{
const char *fullname;
to handle cases like the file being moved. */
if (ps->fullname == NULL)
{
- gdb::unique_xmalloc_ptr<char> fullname;
- scoped_fd fd = find_and_open_source (ps->filename, ps->dirname,
- &fullname);
+ gdb::unique_xmalloc_ptr<char> fullname
+ = find_source_or_rewrite (ps->filename, ps->dirname);
ps->fullname = fullname.release ();
-
- 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. */
-
- if (ps->dirname == NULL || IS_ABSOLUTE_PATH (ps->filename))
- fullname.reset (xstrdup (ps->filename));
- else
- fullname.reset (concat (ps->dirname, SLASH_STRING,
- ps->filename, (char *) NULL));
-
- ps->fullname = rewrite_source_path (fullname.get ()).release ();
- if (ps->fullname == NULL)
- ps->fullname = fullname.release ();
- }
}
return ps->fullname;
}
-/* Psymtab version of map_matching_symbols. See its definition in
+/* Psymtab version of expand_matching_symbols. See its definition in
the definition of quick_symbol_functions in symfile.h. */
void
-psymbol_functions::map_matching_symbols
+psymbol_functions::expand_matching_symbols
(struct objfile *objfile,
const lookup_name_info &name, domain_enum domain,
int global,
- gdb::function_view<symbol_found_callback_ftype> callback,
symbol_compare_ftype *ordered_compare)
{
- const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
-
- for (partial_symtab *ps : require_partial_symbols (objfile))
+ for (partial_symtab *ps : partial_symbols (objfile))
{
QUIT;
- if (ps->readin_p (objfile)
- || match_partial_symbol (objfile, ps, global, name, domain,
+ if (!ps->readin_p (objfile)
+ && match_partial_symbol (objfile, ps, global, name, domain,
ordered_compare))
- {
- struct compunit_symtab *cust = psymtab_to_symtab (objfile, ps);
- const struct block *block;
-
- if (cust == NULL)
- continue;
- block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), block_kind);
- if (!iterate_over_symbols_terminated (block, name,
- domain, callback))
- return;
- }
+ psymtab_to_symtab (objfile, ps);
}
}
enum search_domain search)
{
/* Clear the search flags. */
- for (partial_symtab *ps : require_partial_symbols (objfile))
+ 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;
continue;
}
- if ((symbol_matcher == NULL && lookup_name == NULL)
+ if (lookup_name == nullptr
|| recursively_search_psymtabs (ps, objfile, search_flags,
domain, search,
*psym_lookup_name,
symbol_matcher))
{
- struct compunit_symtab *symtab =
- psymtab_to_symtab (objfile, ps);
+ compunit_symtab *cust = psymtab_to_symtab (objfile, ps);
- if (expansion_notify != NULL)
- if (!expansion_notify (symtab))
+ if (cust != nullptr && expansion_notify != nullptr)
+ if (!expansion_notify (cust))
return false;
}
}
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. */
{
std::set<CORE_ADDR> seen_addrs;
- for (partial_symtab *pst : require_partial_symbols (objfile))
+ for (partial_symtab *pst : partial_symbols (objfile))
{
fill_psymbol_map (objfile, pst,
&seen_addrs,
unsigned int domain = psymbol->domain;
unsigned int theclass = psymbol->aclass;
- h = fast_hash (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
+ 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);
struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
- return (memcmp (&sym1->ginfo.value, &sym2->ginfo.value,
- sizeof (sym1->ginfo.value)) == 0
+ 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
if (last_bfd_name.empty () || last_bfd_name != this_bfd_name)
{
last_bfd_name = this_bfd_name;
- fprintf_filtered (gdb_stdlog,
- "Creating one or more psymtabs for %s ...\n",
- this_bfd_name);
+ gdb_printf (gdb_stdlog,
+ "Creating one or more psymtabs for %s ...\n",
+ this_bfd_name);
}
- fprintf_filtered (gdb_stdlog,
- "Created psymtab %s for module %s.\n",
- host_address_to_string (this), filename);
+ gdb_printf (gdb_stdlog,
+ "Created psymtab %s for module %s.\n",
+ host_address_to_string (this), filename);
}
}
/* Inform about additional files to be read in. */
if (info_verbose)
{
- fputs_filtered (" ", gdb_stdout);
- wrap_here ("");
- fputs_filtered ("and ", gdb_stdout);
- wrap_here ("");
- printf_filtered ("%s...", dependencies[i]->filename);
- wrap_here (""); /* Flush output */
+ 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);
\f
-/* We need to pass a couple of items to the addrmap_foreach function,
- so use a struct. */
-
-struct dump_psymtab_addrmap_data
-{
- struct objfile *objfile;
- struct partial_symtab *psymtab;
- struct ui_file *outfile;
-
- /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
- If so, we want to print the next one as well (since the next addrmap
- entry defines the end of the range). */
- int previous_matched;
-};
-
-/* Helper function for dump_psymtab_addrmap to print an addrmap entry. */
-
-static int
-dump_psymtab_addrmap_1 (void *datap, CORE_ADDR start_addr, void *obj)
-{
- struct dump_psymtab_addrmap_data *data
- = (struct dump_psymtab_addrmap_data *) datap;
- struct gdbarch *gdbarch = data->objfile->arch ();
- struct partial_symtab *addrmap_psymtab = (struct partial_symtab *) obj;
- const char *psymtab_address_or_end = NULL;
-
- QUIT;
-
- if (data->psymtab == NULL
- || data->psymtab == addrmap_psymtab)
- psymtab_address_or_end = host_address_to_string (addrmap_psymtab);
- else if (data->previous_matched)
- psymtab_address_or_end = "<ends here>";
-
- if (data->psymtab == NULL
- || data->psymtab == addrmap_psymtab
- || data->previous_matched)
- {
- fprintf_filtered (data->outfile, " %s%s %s\n",
- data->psymtab != NULL ? " " : "",
- paddress (gdbarch, start_addr),
- psymtab_address_or_end);
- }
-
- data->previous_matched = (data->psymtab == NULL
- || data->psymtab == addrmap_psymtab);
-
- return 0;
-}
-
/* Helper function for maintenance_print_psymbols to print the addrmap
of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
struct partial_symtab *psymtab,
struct ui_file *outfile)
{
- struct dump_psymtab_addrmap_data addrmap_dump_data;
-
if ((psymtab == NULL
|| psymtab->psymtabs_addrmap_supported)
&& partial_symtabs->psymtabs_addrmap != NULL)
{
- addrmap_dump_data.objfile = objfile;
- addrmap_dump_data.psymtab = psymtab;
- addrmap_dump_data.outfile = outfile;
- addrmap_dump_data.previous_matched = 0;
- fprintf_filtered (outfile, "%sddress map:\n",
- psymtab == NULL ? "Entire a" : " A");
- addrmap_foreach (partial_symtabs->psymtabs_addrmap,
- dump_psymtab_addrmap_1, &addrmap_dump_data);
+ if (psymtab == nullptr)
+ gdb_printf (outfile, _("Entire address map:\n"));
+ else
+ gdb_printf (outfile, _("Address map:\n"));
+ addrmap_dump (partial_symtabs->psymtabs_addrmap, outfile, psymtab);
}
}
if (address_arg != NULL)
{
- struct bound_minimal_symbol msymbol = { NULL, NULL };
+ struct bound_minimal_symbol msymbol;
/* We don't assume each pc has a unique objfile (this is for
debugging). */
}
else
{
- for (partial_symtab *ps : psf->require_partial_symbols (objfile))
+ for (partial_symtab *ps : psf->partial_symbols (objfile))
{
int print_for_source = 0;
= dynamic_cast<psymbol_functions *> (iter.get ());
if (psf == nullptr)
continue;
- for (partial_symtab *psymtab : psf->require_partial_symbols (objfile))
+ for (partial_symtab *psymtab : psf->partial_symbols (objfile))
{
QUIT;
{
if (! printed_objfile_start)
{
- printf_filtered ("{ objfile %s ", objfile_name (objfile));
- wrap_here (" ");
- printf_filtered ("((struct objfile *) %s)\n",
- host_address_to_string (objfile));
+ 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;
}
- 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_p (objfile) ? "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 ");
+ 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 (" psymtabs_addrmap_supported %s\n",
+ (psymtab->psymtabs_addrmap_supported
+ ? "yes" : "no"));
+ gdb_printf (" globals ");
if (!psymtab->global_psymbols.empty ())
- printf_filtered
+ gdb_printf
("(* (struct partial_symbol **) %s @ %d)\n",
host_address_to_string (psymtab->global_psymbols.data ()),
(int) psymtab->global_psymbols.size ());
else
- printf_filtered ("(none)\n");
- printf_filtered (" statics ");
+ gdb_printf ("(none)\n");
+ gdb_printf (" statics ");
if (!psymtab->static_psymbols.empty ())
- printf_filtered
+ gdb_printf
("(* (struct partial_symbol **) %s @ %d)\n",
host_address_to_string (psymtab->static_psymbols.data ()),
(int) psymtab->static_psymbols.size ());
else
- printf_filtered ("(none)\n");
+ gdb_printf ("(none)\n");
if (psymtab->user)
- printf_filtered (" user %s "
- "((struct partial_symtab *) %s)\n",
- psymtab->user->filename,
- host_address_to_string (psymtab->user));
- printf_filtered (" dependencies ");
+ 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;
- printf_filtered ("{\n");
+ 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. */
- printf_filtered (" psymtab %s "
- "((struct partial_symtab *) %s)\n",
- dep->filename,
- host_address_to_string (dep));
+ gdb_printf (" psymtab %s "
+ "((struct partial_symtab *) %s)\n",
+ dep->filename,
+ host_address_to_string (dep));
}
- printf_filtered (" }\n");
+ gdb_printf (" }\n");
}
else
- printf_filtered ("(none)\n");
- printf_filtered (" }\n");
+ gdb_printf ("(none)\n");
+ gdb_printf (" }\n");
}
}
}
if (printed_objfile_start)
- printf_filtered ("}\n");
+ gdb_printf ("}\n");
}
}
if (psf == nullptr)
continue;
- for (partial_symtab *ps : psf->require_partial_symbols (objfile))
+ for (partial_symtab *ps : psf->partial_symbols (objfile))
{
struct gdbarch *gdbarch = objfile->arch ();
/* First do some checks that don't require the associated symtab. */
if (ps->text_high (objfile) < ps->text_low (objfile))
{
- printf_filtered ("Psymtab ");
- puts_filtered (ps->filename);
- 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");
+ 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 = COMPUNIT_BLOCKVECTOR (cust);
- b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+ 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)
+ && psym->ginfo.value_address () == 0)
continue;
sym = block_lookup_symbol (b, psym->ginfo.search_name (),
psym->domain);
if (!sym)
{
- printf_filtered ("Static symbol `");
- puts_filtered (psym->ginfo.linkage_name ());
- printf_filtered ("' only found in ");
- puts_filtered (ps->filename);
- printf_filtered (" psymtab\n");
+ gdb_printf ("Static symbol `");
+ gdb_puts (psym->ginfo.linkage_name ());
+ gdb_printf ("' only found in ");
+ gdb_puts (ps->filename);
+ gdb_printf (" psymtab\n");
}
}
- b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+ b = bv->global_block ();
for (partial_symbol *psym : ps->global_psymbols)
{
sym = block_lookup_symbol (b, psym->ginfo.search_name (),
psym->domain);
if (!sym)
{
- printf_filtered ("Global symbol `");
- puts_filtered (psym->ginfo.linkage_name ());
- printf_filtered ("' only found in ");
- puts_filtered (ps->filename);
- printf_filtered (" psymtab\n");
+ 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) < BLOCK_START (b)
- || ps->text_high (objfile) > BLOCK_END (b)))
+ && (ps->text_low (objfile) < b->start ()
+ || ps->text_high (objfile) > b->end ()))
{
- printf_filtered ("Psymtab ");
- puts_filtered (ps->filename);
- 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");
+ 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");
}
}
}
projects / binutils-gdb.git / blobdiff