/* 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>
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
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
for (const gdb::unique_xmalloc_ptr<char> &debugdir : debugdir_vec)
{
debugfile = target_prefix ? "target:" : "";
- debugfile += debugdir.get ();
+ debugfile += debugdir;
debugfile += "/";
debugfile += drive;
debugfile += dir_notarget;
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)
{
/* If the file is in the sysroot, try using its base path in
the global debugfile directory. */
debugfile = target_prefix ? "target:" : "";
- debugfile += debugdir.get ();
+ debugfile += debugdir;
debugfile += "/";
debugfile += base_path;
debugfile += "/";
the sysroot's global debugfile directory. */
debugfile = target_prefix ? "target:" : "";
debugfile += gdb_sysroot;
- debugfile += debugdir.get ();
+ debugfile += debugdir;
debugfile += "/";
debugfile += base_path;
debugfile += "/";
/* 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;
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 ("");
+ gdb_stdout->wrap_here (0);
printf_filtered (_("(no debugging symbols found)\n"));
- wrap_here ("");
+ gdb_stdout->wrap_here (0);
}
/* We're done reading the symbol file; finish off complaints. */
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
{
struct symtab *
allocate_symtab (struct compunit_symtab *cust, const char *filename)
{
- struct objfile *objfile = cust->objfile;
+ struct objfile *objfile = cust->objfile ();
struct symtab *symtab
= OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symtab);
symtab->filename = objfile->intern (filename);
symtab->fullname = NULL;
- symtab->language = deduce_language_from_filename (filename);
+ symtab->set_language (deduce_language_from_filename (filename));
/* This can be very verbose with lots of headers.
Only print at higher debug levels. */
}
/* Add it to CUST's list of symtabs. */
- if (cust->filetabs == NULL)
- {
- cust->filetabs = symtab;
- cust->last_filetab = symtab;
- }
- else
- {
- cust->last_filetab->next = symtab;
- cust->last_filetab = symtab;
- }
+ cust->add_filetab (symtab);
/* Backlink to the containing compunit symtab. */
- symtab->compunit_symtab = cust;
+ symtab->set_compunit (cust);
return symtab;
}
struct compunit_symtab);
const char *saved_name;
- cu->objfile = objfile;
+ cu->set_objfile (objfile);
/* The name we record here is only for display/debugging purposes.
Just save the basename to avoid path issues (too long for display,
saved_name = lbasename (name);
cu->name = obstack_strdup (&objfile->objfile_obstack, saved_name);
- COMPUNIT_DEBUGFORMAT (cu) = "unknown";
+ cu->set_debugformat ("unknown");
if (symtab_create_debug)
{
void
add_compunit_symtab_to_objfile (struct compunit_symtab *cu)
{
- cu->next = cu->objfile->compunit_symtabs;
- cu->objfile->compunit_symtabs = cu;
+ cu->next = cu->objfile ()->compunit_symtabs;
+ cu->objfile ()->compunit_symtabs = cu;
}
\f
/* 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);
}
name = bfd_section_name (osect->the_bfd_section);
printf_filtered ("Section %s, loaded at ", name);
- fputs_filtered (paddress (gdbarch, lma), gdb_stdout);
+ puts_filtered (paddress (gdbarch, lma));
puts_filtered (" - ");
- fputs_filtered (paddress (gdbarch, lma + size), gdb_stdout);
+ puts_filtered (paddress (gdbarch, lma + size));
printf_filtered (", mapped at ");
- fputs_filtered (paddress (gdbarch, vma), gdb_stdout);
+ puts_filtered (paddress (gdbarch, vma));
puts_filtered (" - ");
- fputs_filtered (paddress (gdbarch, vma + size), gdb_stdout);
+ puts_filtered (paddress (gdbarch, vma + size));
puts_filtered ("\n");
nmapped++;
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
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);