/* Generic symbol file reading for the GNU debugger, GDB.
- Copyright (C) 1990-2021 Free Software Foundation, Inc.
+ Copyright (C) 1990-2022 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
#include "regcache.h"
#include "filenames.h" /* for DOSish file names */
#include "gdb-stabs.h"
-#include "gdb_obstack.h"
+#include "gdbsupport/gdb_obstack.h"
#include "completer.h"
#include "bcache.h"
#include "hashtab.h"
#include "gdbsupport/selftest.h"
#include "cli/cli-style.h"
#include "gdbsupport/forward-scope-exit.h"
+#include "gdbsupport/buildargv.h"
#include <sys/types.h>
#include <fcntl.h>
#include <chrono>
#include <algorithm>
-#include "psymtab.h"
-
int (*deprecated_ui_load_progress_hook) (const char *section,
unsigned long num);
void (*deprecated_show_load_progress) (const char *section,
osp = &addrs[i];
if (osp->sectindex == -1)
- continue;
+ continue;
/* Record all sections in offsets. */
/* The section_offsets in the objfile are here filled in using
/* find_separate_debug_file_in_section should be called only if there is
single binary with no existing separate debug info file. */
- if (!objfile_has_partial_symbols (objfile)
+ if (!objfile->has_partial_symbols ()
&& objfile->separate_debug_objfile == NULL
&& objfile->separate_debug_objfile_backlink == NULL)
{
}
}
if ((add_flags & SYMFILE_NO_READ) == 0)
- require_partial_symbols (objfile, false);
+ objfile->require_partial_symbols (false);
}
/* Initialize entry point information for this objfile. */
/* Make certain that the address points at real code, and not a
function descriptor. */
- entry_point
- = gdbarch_convert_from_func_ptr_addr (objfile->arch (),
- entry_point,
- current_top_target ());
+ entry_point = gdbarch_convert_from_func_ptr_addr
+ (objfile->arch (), entry_point, current_inferior ()->top_target ());
/* Remove any ISA markers, so that this matches entries in the
symbol table. */
const int mainline = add_flags & SYMFILE_MAINLINE;
objfile_set_sym_fns (objfile, find_sym_fns (objfile->obfd));
+ objfile->qf.clear ();
if (objfile->sf == NULL)
{
printf_filtered (_("Expanding full symbols from %ps...\n"),
styled_string (file_name_style.style (), name));
- if (objfile->sf)
- objfile->sf->qf->expand_all_symtabs (objfile);
+ objfile->expand_all_symtabs ();
}
/* Note that we only print a message if we have no symbols and have
if (separate_debug_file_debug)
{
- printf_filtered (_(" Trying %s..."), name.c_str ());
- gdb_flush (gdb_stdout);
+ fprintf_filtered (gdb_stdlog, _(" Trying %s..."), name.c_str ());
+ gdb_flush (gdb_stdlog);
}
gdb_bfd_ref_ptr abfd (gdb_bfd_open (name.c_str (), gnutarget));
if (abfd == NULL)
{
if (separate_debug_file_debug)
- printf_filtered (_(" no, unable to open.\n"));
+ fprintf_filtered (gdb_stdlog, _(" no, unable to open.\n"));
return 0;
}
&& abfd_stat.st_ino == parent_stat.st_ino)
{
if (separate_debug_file_debug)
- printf_filtered (_(" no, same file as the objfile.\n"));
+ fprintf_filtered (gdb_stdlog,
+ _(" no, same file as the objfile.\n"));
return 0;
}
if (!file_crc_p)
{
if (separate_debug_file_debug)
- printf_filtered (_(" no, error computing CRC.\n"));
+ fprintf_filtered (gdb_stdlog, _(" no, error computing CRC.\n"));
return 0;
}
if (!gdb_bfd_crc (parent_objfile->obfd, &parent_crc))
{
if (separate_debug_file_debug)
- printf_filtered (_(" no, error computing CRC.\n"));
+ fprintf_filtered (gdb_stdlog,
+ _(" no, error computing CRC.\n"));
return 0;
}
name.c_str (), objfile_name (parent_objfile));
if (separate_debug_file_debug)
- printf_filtered (_(" no, CRC doesn't match.\n"));
+ fprintf_filtered (gdb_stdlog, _(" no, CRC doesn't match.\n"));
return 0;
}
if (separate_debug_file_debug)
- printf_filtered (_(" yes!\n"));
+ fprintf_filtered (gdb_stdlog, _(" yes!\n"));
return 1;
}
-char *debug_file_directory = NULL;
+std::string debug_file_directory;
static void
show_debug_file_directory (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
unsigned long crc32, struct objfile *objfile)
{
if (separate_debug_file_debug)
- printf_filtered (_("\nLooking for separate debug info (debug link) for "
- "%s\n"), objfile_name (objfile));
+ fprintf_filtered (gdb_stdlog,
+ _("\nLooking for separate debug info (debug link) for "
+ "%s\n"), objfile_name (objfile));
/* First try in the same directory as the original file. */
std::string debugfile = dir;
bool target_prefix = startswith (dir, "target:");
const char *dir_notarget = target_prefix ? dir + strlen ("target:") : dir;
std::vector<gdb::unique_xmalloc_ptr<char>> debugdir_vec
- = dirnames_to_char_ptr_vec (debug_file_directory);
- gdb::unique_xmalloc_ptr<char> canon_sysroot = gdb_realpath (gdb_sysroot);
+ = dirnames_to_char_ptr_vec (debug_file_directory.c_str ());
+ gdb::unique_xmalloc_ptr<char> canon_sysroot
+ = gdb_realpath (gdb_sysroot.c_str ());
/* MS-Windows/MS-DOS don't allow colons in file names; we must
convert the drive letter into a one-letter directory, so that the
if (canon_sysroot.get () != NULL)
base_path = child_path (canon_sysroot.get (), canon_dir);
else
- base_path = child_path (gdb_sysroot, canon_dir);
+ base_path = child_path (gdb_sysroot.c_str (), canon_dir);
}
if (base_path != NULL)
{
/* The user might be reloading because the binary has changed. Take
this opportunity to check. */
reopen_exec_file ();
- reread_symbols ();
+ reread_symbols (from_tty);
std::string temp;
if (arg == NULL)
statements because hex_string returns a local static
string. */
- printf_unfiltered (_("add symbol table from file \"%s\""),
- filename.get ());
+ printf_filtered (_("add symbol table from file \"%s\""),
+ filename.get ());
section_addr_info section_addrs;
std::vector<sect_opt>::const_iterator it = sect_opts.begin ();
if (!seen_addr)
const char *sec = it->name;
if (section_addrs.empty ())
- printf_unfiltered (_(" at\n"));
+ printf_filtered (_(" at\n"));
addr = parse_and_eval_address (val);
/* Here we store the section offsets in the order they were
so we can't determine what section names are valid. */
}
if (seen_offset)
- printf_unfiltered (_("%s offset by %s\n"),
- (section_addrs.empty ()
- ? _(" with all sections")
- : _("with other sections")),
- paddress (gdbarch, offset));
+ printf_filtered (_("%s offset by %s\n"),
+ (section_addrs.empty ()
+ ? _(" with all sections")
+ : _("with other sections")),
+ paddress (gdbarch, offset));
else if (section_addrs.empty ())
- printf_unfiltered ("\n");
+ printf_filtered ("\n");
if (from_tty && (!query ("%s", "")))
error (_("Not confirmed."));
/* Re-read symbols if a symbol-file has changed. */
void
-reread_symbols (void)
+reread_symbols (int from_tty)
{
long new_modtime;
struct stat new_statbuf;
error (_("Can't read symbols from %s: %s."), objfile_name (objfile),
bfd_errmsg (bfd_get_error ()));
- objfile->reset_psymtabs ();
-
/* NB: after this call to obstack_free, objfiles_changed
will need to be called (see discussion below). */
obstack_free (&objfile->objfile_obstack, 0);
based on whether .gdb_index is present, and we need it to
start over. PR symtab/15885 */
objfile_set_sym_fns (objfile, find_sym_fns (objfile->obfd));
+ objfile->qf.clear ();
build_objfile_section_table (objfile);
read_symbols (objfile, 0);
+ if ((objfile->flags & OBJF_READNOW))
+ {
+ const int mainline = objfile->flags & OBJF_MAINLINE;
+ const int should_print = (print_symbol_loading_p (from_tty, mainline, 1)
+ && readnow_symbol_files);
+ if (should_print)
+ printf_filtered (_("Expanding full symbols from %ps...\n"),
+ styled_string (file_name_style.style (),
+ objfile_name (objfile)));
+
+ objfile->expand_all_symtabs ();
+ }
+
if (!objfile_has_symbols (objfile))
{
wrap_here ("");
filename_language_table.emplace_back (ext, lang);
}
-static char *ext_args;
+static std::string ext_args;
static void
show_ext_args (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
set_ext_lang_command (const char *args,
int from_tty, struct cmd_list_element *e)
{
- char *cp = ext_args;
- enum language lang;
+ const char *begin = ext_args.c_str ();
+ const char *end = ext_args.c_str ();
/* First arg is filename extension, starting with '.' */
- if (*cp != '.')
- error (_("'%s': Filename extension must begin with '.'"), ext_args);
+ if (*end != '.')
+ error (_("'%s': Filename extension must begin with '.'"), ext_args.c_str ());
/* Find end of first arg. */
- while (*cp && !isspace (*cp))
- cp++;
+ while (*end != '\0' && !isspace (*end))
+ end++;
- if (*cp == '\0')
+ if (*end == '\0')
error (_("'%s': two arguments required -- "
"filename extension and language"),
- ext_args);
+ ext_args.c_str ());
- /* Null-terminate first arg. */
- *cp++ = '\0';
+ /* Extract first arg, the extension. */
+ std::string extension = ext_args.substr (0, end - begin);
/* Find beginning of second arg, which should be a source language. */
- cp = skip_spaces (cp);
+ begin = skip_spaces (end);
- if (*cp == '\0')
+ if (*begin == '\0')
error (_("'%s': two arguments required -- "
"filename extension and language"),
- ext_args);
+ ext_args.c_str ());
/* Lookup the language from among those we know. */
- lang = language_enum (cp);
+ language lang = language_enum (begin);
auto it = filename_language_table.begin ();
/* Now lookup the filename extension: do we already know it? */
for (; it != filename_language_table.end (); it++)
{
- if (it->ext == ext_args)
+ if (it->ext == extension)
break;
}
if (it == filename_language_table.end ())
{
/* New file extension. */
- add_filename_language (ext_args, lang);
+ add_filename_language (extension.data (), lang);
}
else
{
{
/* Be a bit clever with debugging messages, and don't print objfile
every time, only when it changes. */
- static char *last_objfile_name = NULL;
+ static std::string last_objfile_name;
+ const char *this_objfile_name = objfile_name (objfile);
- if (last_objfile_name == NULL
- || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
+ if (last_objfile_name.empty () || last_objfile_name != this_objfile_name)
{
- xfree (last_objfile_name);
- last_objfile_name = xstrdup (objfile_name (objfile));
+ last_objfile_name = this_objfile_name;
fprintf_filtered (gdb_stdlog,
"Creating one or more symtabs for objfile %s ...\n",
- last_objfile_name);
+ this_objfile_name);
}
fprintf_filtered (gdb_stdlog,
"Created symtab %s for module %s.\n",
/* We assume the LMA is relocated by the same offset as the VMA. */
bfd_vma size = bfd_section_size (bfd_section);
- CORE_ADDR offset = obj_section_offset (section);
+ CORE_ADDR offset = section->offset ();
if (bfd_section_lma (bfd_section) + offset <= pc
&& pc < bfd_section_lma (bfd_section) + offset + size)
{
if (section_is_overlay (section))
{
- if (obj_section_addr (section) <= pc
- && pc < obj_section_endaddr (section))
+ if (section->addr () <= pc
+ && pc < section->endaddr ())
return 1;
}
static int
sections_overlap (struct obj_section *a, struct obj_section *b)
{
- CORE_ADDR a_start = obj_section_addr (a);
- CORE_ADDR a_end = obj_section_endaddr (a);
- CORE_ADDR b_start = obj_section_addr (b);
- CORE_ADDR b_end = obj_section_endaddr (b);
+ CORE_ADDR a_start = a->addr ();
+ CORE_ADDR a_end = a->endaddr ();
+ CORE_ADDR b_start = b->addr ();
+ CORE_ADDR b_end = b->endaddr ();
return (a_start < b_end && b_start < a_end);
}
sec2))
{
if (info_verbose)
- printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
- bfd_section_name (sec2->the_bfd_section));
+ printf_filtered (_("Note: section %s unmapped by overlap\n"),
+ bfd_section_name (sec2->the_bfd_section));
sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2. */
}
return;
overlay_debugging = ovly_auto;
enable_overlay_breakpoints ();
if (info_verbose)
- printf_unfiltered (_("Automatic overlay debugging enabled."));
+ printf_filtered (_("Automatic overlay debugging enabled."));
}
/* Function: overlay_manual_command
overlay_debugging = ovly_on;
disable_overlay_breakpoints ();
if (info_verbose)
- printf_unfiltered (_("Overlay debugging enabled."));
+ printf_filtered (_("Overlay debugging enabled."));
}
/* Function: overlay_off_command
overlay_debugging = ovly_off;
disable_overlay_breakpoints ();
if (info_verbose)
- printf_unfiltered (_("Overlay debugging disabled."));
+ printf_filtered (_("Overlay debugging disabled."));
}
static void
Expand all symtabs that match the specified criteria.
See quick_symbol_functions.expand_symtabs_matching for details. */
-void
+bool
expand_symtabs_matching
(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,
enum search_domain kind)
{
for (objfile *objfile : current_program_space->objfiles ())
- {
- if (objfile->sf)
- objfile->sf->qf->expand_symtabs_matching (objfile, file_matcher,
- &lookup_name,
- symbol_matcher,
- expansion_notify, kind);
- }
+ if (!objfile->expand_symtabs_matching (file_matcher,
+ &lookup_name,
+ symbol_matcher,
+ expansion_notify,
+ search_flags,
+ UNDEF_DOMAIN,
+ kind))
+ return false;
+ return true;
}
/* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
See quick_symbol_functions.map_symbol_filenames for details. */
void
-map_symbol_filenames (symbol_filename_ftype *fun, void *data,
- int need_fullname)
+map_symbol_filenames (gdb::function_view<symbol_filename_ftype> fun,
+ bool need_fullname)
{
for (objfile *objfile : current_program_space->objfiles ())
- {
- if (objfile->sf)
- objfile->sf->qf->map_symbol_filenames (objfile, fun, data,
- need_fullname);
- }
+ objfile->map_symbol_filenames (fun, need_fullname);
}
#if GDB_SELF_TEST
SELF_CHECK (lang == language_unknown);
/* Test adding a new extension using the CLI command. */
- auto args_holder = make_unique_xstrdup (".hello rust");
- ext_args = args_holder.get ();
+ ext_args = ".hello rust";
set_ext_lang_command (NULL, 1, NULL);
lang = deduce_language_from_filename ("cake.hello");
/* Test overriding an existing extension using the CLI command. */
int size_before = filename_language_table.size ();
- args_holder.reset (xstrdup (".hello pascal"));
- ext_args = args_holder.get ();
+ ext_args = ".hello pascal";
set_ext_lang_command (NULL, 1, NULL);
int size_after = filename_language_table.size ();
{
struct cmd_list_element *c;
- gdb::observers::free_objfile.attach (symfile_free_objfile);
+ gdb::observers::free_objfile.attach (symfile_free_objfile, "symfile");
#define READNOW_READNEVER_HELP \
"The '-readnow' option will cause GDB to read the entire symbol file\n\
on its own."), &cmdlist);
set_cmd_completer (c, filename_completer);
- add_basic_prefix_cmd ("overlay", class_support,
- _("Commands for debugging overlays."), &overlaylist,
- "overlay ", 0, &cmdlist);
+ cmd_list_element *overlay_cmd
+ = add_basic_prefix_cmd ("overlay", class_support,
+ _("Commands for debugging overlays."), &overlaylist,
+ 0, &cmdlist);
- add_com_alias ("ovly", "overlay", class_support, 1);
- add_com_alias ("ov", "overlay", class_support, 1);
+ add_com_alias ("ovly", overlay_cmd, class_support, 1);
+ add_com_alias ("ov", overlay_cmd, class_support, 1);
add_cmd ("map-overlay", class_support, map_overlay_command,
_("Assert that an overlay section is mapped."), &overlaylist);