/* Generic symbol file reading for the GNU debugger, GDB.
- Copyright (C) 1990-2019 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,
= FORWARD_SCOPE_EXIT (clear_symtab_users);
/* Global variables owned by this file. */
-int readnow_symbol_files; /* Read full symbols immediately. */
-int readnever_symbol_files; /* Never read full symbols. */
+
+/* See symfile.h. */
+
+int readnow_symbol_files;
+
+/* See symfile.h. */
+
+int readnever_symbol_files;
/* Functions this file defines. */
}
/* Remember the lowest-addressed loadable section we've seen.
- This function is called via bfd_map_over_sections.
In case of equal vmas, the section with the largest size becomes the
lowest-addressed loadable section.
If the vmas and sizes are equal, the last section is considered the
lowest-addressed loadable section. */
-void
-find_lowest_section (bfd *abfd, asection *sect, void *obj)
+static void
+find_lowest_section (asection *sect, asection **lowest)
{
- asection **lowest = (asection **) obj;
-
if (0 == (bfd_section_flags (sect) & (SEC_ALLOC | SEC_LOAD)))
return;
if (!*lowest)
an existing section table. */
section_addr_info
-build_section_addr_info_from_section_table (const struct target_section *start,
- const struct target_section *end)
+build_section_addr_info_from_section_table (const target_section_table &table)
{
- const struct target_section *stp;
-
section_addr_info sap;
- for (stp = start; stp != end; stp++)
+ for (const target_section &stp : table)
{
- struct bfd_section *asect = stp->the_bfd_section;
+ struct bfd_section *asect = stp.the_bfd_section;
bfd *abfd = asect->owner;
if (bfd_section_flags (asect) & (SEC_ALLOC | SEC_LOAD)
- && sap.size () < end - start)
- sap.emplace_back (stp->addr,
+ && sap.size () < table.size ())
+ sap.emplace_back (stp.addr,
bfd_section_name (asect),
gdb_bfd_section_index (abfd, asect));
}
{
int sectindex = sap[i].sectindex;
- sap[i].addr += objfile->section_offsets->offsets[sectindex];
+ sap[i].addr += objfile->section_offsets[sectindex];
}
return sap;
}
later, e.g. by the remote qOffsets packet, and then this will
be wrong! That's why we try segments first. */
- for (i = 0; i < objfile->num_sections; i++)
+ for (i = 0; i < objfile->section_offsets.size (); i++)
{
- if (ANOFFSET (objfile->section_offsets, i) != 0)
+ if (objfile->section_offsets[i] != 0)
{
break;
}
}
- if (i == objfile->num_sections)
+ if (i == objfile->section_offsets.size ())
{
if (objfile->sect_index_text == -1)
objfile->sect_index_text = 0;
}
}
-/* The arguments to place_section. */
-
-struct place_section_arg
-{
- struct section_offsets *offsets;
- CORE_ADDR lowest;
-};
-
/* Find a unique offset to use for loadable section SECT if
the user did not provide an offset. */
static void
-place_section (bfd *abfd, asection *sect, void *obj)
+place_section (bfd *abfd, asection *sect, section_offsets &offsets,
+ CORE_ADDR &lowest)
{
- struct place_section_arg *arg = (struct place_section_arg *) obj;
- CORE_ADDR *offsets = arg->offsets->offsets, start_addr;
+ CORE_ADDR start_addr;
int done;
ULONGEST align = ((ULONGEST) 1) << bfd_section_alignment (sect);
return;
/* Otherwise, let's try to find a place for the section. */
- start_addr = (arg->lowest + align - 1) & -align;
+ start_addr = (lowest + align - 1) & -align;
do {
asection *cur_sec;
while (!done);
offsets[gdb_bfd_section_index (abfd, sect)] = start_addr;
- arg->lowest = start_addr + bfd_section_size (sect);
+ lowest = start_addr + bfd_section_size (sect);
}
/* Store section_addr_info as prepared (made relative and with SECTINDEX
- filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
- entries. */
+ filled-in) by addr_info_make_relative into SECTION_OFFSETS. */
void
-relative_addr_info_to_section_offsets (struct section_offsets *section_offsets,
- int num_sections,
+relative_addr_info_to_section_offsets (section_offsets §ion_offsets,
const section_addr_info &addrs)
{
int i;
- memset (section_offsets, 0, SIZEOF_N_SECTION_OFFSETS (num_sections));
+ section_offsets.assign (section_offsets.size (), 0);
/* Now calculate offsets for section that were specified by the caller. */
for (i = 0; i < addrs.size (); i++)
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
- the BFD index. */
- section_offsets->offsets[osp->sectindex] = osp->addr;
+ the BFD index. */
+ section_offsets[osp->sectindex] = osp->addr;
}
}
/* Find lowest loadable section to be used as starting point for
contiguous sections. */
lower_sect = NULL;
- bfd_map_over_sections (abfd, find_lowest_section, &lower_sect);
+ for (asection *iter : gdb_bfd_sections (abfd))
+ find_lowest_section (iter, &lower_sect);
if (lower_sect == NULL)
{
warning (_("no loadable sections found in added symbol-file %s"),
default_symfile_offsets (struct objfile *objfile,
const section_addr_info &addrs)
{
- objfile->num_sections = gdb_bfd_count_sections (objfile->obfd);
- objfile->section_offsets = (struct section_offsets *)
- obstack_alloc (&objfile->objfile_obstack,
- SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
- relative_addr_info_to_section_offsets (objfile->section_offsets,
- objfile->num_sections, addrs);
+ objfile->section_offsets.resize (gdb_bfd_count_sections (objfile->obfd));
+ relative_addr_info_to_section_offsets (objfile->section_offsets, addrs);
/* For relocatable files, all loadable sections will start at zero.
The zero is meaningless, so try to pick arbitrary addresses such
small. */
if ((bfd_get_file_flags (objfile->obfd) & (EXEC_P | DYNAMIC)) == 0)
{
- struct place_section_arg arg;
bfd *abfd = objfile->obfd;
asection *cur_sec;
if (cur_sec == NULL)
{
- CORE_ADDR *offsets = objfile->section_offsets->offsets;
+ section_offsets &offsets = objfile->section_offsets;
/* Pick non-overlapping offsets for sections the user did not
place explicitly. */
- arg.offsets = objfile->section_offsets;
- arg.lowest = 0;
- bfd_map_over_sections (objfile->obfd, place_section, &arg);
+ CORE_ADDR lowest = 0;
+ for (asection *sect : gdb_bfd_sections (objfile->obfd))
+ place_section (objfile->obfd, sect, objfile->section_offsets,
+ lowest);
/* Correctly filling in the section offsets is not quite
enough. Relocatable files have two properties that
It assumes that object files do not have segments, and fully linked
files have a single segment. */
-struct symfile_segment_data *
+symfile_segment_data_up
default_symfile_segments (bfd *abfd)
{
int num_sections, i;
asection *sect;
- struct symfile_segment_data *data;
CORE_ADDR low, high;
/* Relocatable files contain enough information to position each
low = bfd_section_vma (sect);
high = low + bfd_section_size (sect);
- data = XCNEW (struct symfile_segment_data);
- data->num_segments = 1;
- data->segment_bases = XCNEW (CORE_ADDR);
- data->segment_sizes = XCNEW (CORE_ADDR);
+ symfile_segment_data_up data (new symfile_segment_data);
num_sections = bfd_count_sections (abfd);
- data->segment_info = XCNEWVEC (int, num_sections);
+
+ /* All elements are initialized to 0 (map to no segment). */
+ data->segment_info.resize (num_sections);
for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
{
data->segment_info[i] = 1;
}
- data->segment_bases[0] = low;
- data->segment_sizes[0] = high - low;
+ data->segments.emplace_back (low, high - low);
return data;
}
/* 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. */
if (bfd_get_file_flags (objfile->obfd) & EXEC_P)
{
/* Executable file -- record its entry point so we'll recognize
- the startup file because it contains the entry point. */
+ the startup file because it contains the entry point. */
ei->entry_point = bfd_get_start_address (objfile->obfd);
ei->entry_point_p = 1;
}
/* Make certain that the address points at real code, and not a
function descriptor. */
- entry_point
- = gdbarch_convert_from_func_ptr_addr (get_objfile_arch (objfile),
- 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. */
ei->entry_point
- = gdbarch_addr_bits_remove (get_objfile_arch (objfile), entry_point);
+ = gdbarch_addr_bits_remove (objfile->arch (), entry_point);
found = 0;
ALL_OBJFILE_OSECTIONS (objfile, osect)
(as gleaned by GDB's shared library code). We convert each address
into an offset from the section VMA's as it appears in the object
file, and then call the file's sym_offsets function to convert this
- into a format-specific offset table --- a `struct section_offsets'.
+ into a format-specific offset table --- a `section_offsets'.
The sectindex field is used to control the ordering of sections
with the same name. Upon return, it is updated to contain the
corresponding BFD section index, or -1 if the section was not found.
const int mainline = add_flags & SYMFILE_MAINLINE;
objfile_set_sym_fns (objfile, find_sym_fns (objfile->obfd));
+ objfile->qf.clear ();
if (objfile->sf == NULL)
{
/* No symbols to load, but we still need to make sure
that the section_offsets table is allocated. */
int num_sections = gdb_bfd_count_sections (objfile->obfd);
- size_t size = SIZEOF_N_SECTION_OFFSETS (num_sections);
- objfile->num_sections = num_sections;
- objfile->section_offsets
- = (struct section_offsets *) obstack_alloc (&objfile->objfile_obstack,
- size);
- memset (objfile->section_offsets, 0, size);
+ objfile->section_offsets.assign (num_sections, 0);
return;
}
if an error occurs during symbol reading. */
gdb::optional<clear_symtab_users_cleanup> defer_clear_users;
- std::unique_ptr<struct objfile> objfile_holder (objfile);
+ objfile_up objfile_holder (objfile);
/* If ADDRS is NULL, put together a dummy address list.
We now establish the convention that an addr of zero means
if (mainline)
{
/* We will modify the main symbol table, make sure that all its users
- will be cleaned up if an error occurs during symbol reading. */
+ will be cleaned up if an error occurs during symbol reading. */
defer_clear_users.emplace ((symfile_add_flag) 0);
/* Since no error yet, throw away the old symbol table. */
- if (symfile_objfile != NULL)
+ if (current_program_space->symfile_object_file != NULL)
{
- delete symfile_objfile;
- gdb_assert (symfile_objfile == NULL);
+ current_program_space->symfile_object_file->unlink ();
+ gdb_assert (current_program_space->symfile_object_file == NULL);
}
/* Currently we keep symbols from the add-symbol-file command.
- If the user wants to get rid of them, they should do "symbol-file"
- without arguments first. Not sure this is the best behavior
- (PR 2207). */
+ If the user wants to get rid of them, they should do "symbol-file"
+ without arguments first. Not sure this is the best behavior
+ (PR 2207). */
(*objfile->sf->sym_new_init) (objfile);
}
if (add_flags & SYMFILE_MAINLINE)
{
/* OK, make it the "real" symbol file. */
- symfile_objfile = objfile;
+ current_program_space->symfile_object_file = objfile;
clear_symtab_users (add_flags);
}
struct objfile *objfile;
const int from_tty = add_flags & SYMFILE_VERBOSE;
const int mainline = add_flags & SYMFILE_MAINLINE;
+ const int always_confirm = add_flags & SYMFILE_ALWAYS_CONFIRM;
const int should_print = (print_symbol_loading_p (from_tty, mainline, 1)
&& (readnow_symbol_files
|| (add_flags & SYMFILE_NO_READ) == 0));
if ((add_flags & SYMFILE_NOT_FILENAME) != 0)
flags |= OBJF_NOT_FILENAME;
- /* Give user a chance to burp if we'd be
+ /* Give user a chance to burp if ALWAYS_CONFIRM or we'd be
interactively wiping out any existing symbols. */
- if ((have_full_symbols () || have_partial_symbols ())
- && mainline
- && from_tty
+ if (from_tty
+ && (always_confirm
+ || ((have_full_symbols () || have_partial_symbols ())
+ && mainline))
&& !query (_("Load new symbol table from \"%s\"? "), name))
error (_("Not confirmed."));
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
symbol_file_add_with_addrs
(bfd, name, symfile_flags, &sap,
objfile->flags & (OBJF_REORDERED | OBJF_SHARED | OBJF_READNOW
- | OBJF_USERLOADED),
+ | OBJF_USERLOADED | OBJF_MAINLINE),
objfile);
}
symbol_file_add_from_bfd (bfd *abfd, const char *name,
symfile_add_flags add_flags,
section_addr_info *addrs,
- objfile_flags flags, struct objfile *parent)
+ objfile_flags flags, struct objfile *parent)
{
return symbol_file_add_with_addrs (abfd, name, add_flags, addrs, flags,
parent);
{
if ((have_full_symbols () || have_partial_symbols ())
&& from_tty
- && (symfile_objfile
+ && (current_program_space->symfile_object_file
? !query (_("Discard symbol table from `%s'? "),
- objfile_name (symfile_objfile))
+ objfile_name (current_program_space->symfile_object_file))
: !query (_("Discard symbol table? "))))
error (_("Not confirmed."));
objfiles get stale by free_all_objfiles. */
no_shared_libraries (NULL, from_tty);
- free_all_objfiles ();
+ current_program_space->free_all_objfiles ();
- gdb_assert (symfile_objfile == NULL);
+ clear_symtab_users (0);
+
+ gdb_assert (current_program_space->symfile_object_file == NULL);
if (from_tty)
printf_filtered (_("No symbol file now.\n"));
}
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, -1));
+ 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)
{
}
}
-/* Set the initial language.
-
- FIXME: A better solution would be to record the language in the
- psymtab when reading partial symbols, and then use it (if known) to
- set the language. This would be a win for formats that encode the
- language in an easily discoverable place, such as DWARF. For
- stabs, we can jump through hoops looking for specially named
- symbols or try to intuit the language from the specific type of
- stabs we find, but we can't do that until later when we read in
- full symbols. */
+/* Set the initial language. */
void
set_initial_language (void)
{
+ if (language_mode == language_mode_manual)
+ return;
enum language lang = main_language ();
+ /* Make C the default language. */
+ enum language default_lang = language_c;
if (lang == language_unknown)
{
const char *name = main_name ();
- struct symbol *sym = lookup_symbol (name, NULL, VAR_DOMAIN, NULL).symbol;
+ struct symbol *sym
+ = lookup_symbol_in_language (name, NULL, VAR_DOMAIN, default_lang,
+ NULL).symbol;
if (sym != NULL)
- lang = SYMBOL_LANGUAGE (sym);
+ lang = sym->language ();
}
if (lang == language_unknown)
{
- /* Make C the default language */
- lang = language_c;
+ lang = default_lang;
}
set_language (lang);
/* 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)
static int validate_download = 0;
-/* Callback service function for generic_load (bfd_map_over_sections). */
-
-static void
-add_section_size_callback (bfd *abfd, asection *asec, void *data)
-{
- bfd_size_type *sum = (bfd_size_type *) data;
-
- *sum += bfd_section_size (asec);
-}
-
/* Opaque data for load_progress. */
struct load_progress_data
{
totals->total_size);
}
-/* Callback service function for generic_load (bfd_map_over_sections). */
+/* Service function for generic_load. */
static void
-load_section_callback (bfd *abfd, asection *asec, void *data)
+load_one_section (bfd *abfd, asection *asec,
+ struct load_section_data *args)
{
- struct load_section_data *args = (struct load_section_data *) data;
bfd_size_type size = bfd_section_size (asec);
const char *sect_name = bfd_section_name (asec);
static void print_transfer_performance (struct ui_file *stream,
unsigned long data_count,
unsigned long write_count,
- std::chrono::steady_clock::duration d);
+ std::chrono::steady_clock::duration d);
/* See symfile.h. */
cbdata.load_offset = strtoulst (argv[1], &endptr, 0);
/* If the last word was not a valid number then
- treat it as a file name with spaces in. */
+ treat it as a file name with spaces in. */
if (argv[1] == endptr)
- error (_("Invalid download offset:%s."), argv[1]);
+ error (_("Invalid download offset:%s."), argv[1]);
if (argv[2] != NULL)
error (_("Too many parameters."));
}
/* Open the file for loading. */
- gdb_bfd_ref_ptr loadfile_bfd (gdb_bfd_open (filename.get (), gnutarget, -1));
+ gdb_bfd_ref_ptr loadfile_bfd (gdb_bfd_open (filename.get (), gnutarget));
if (loadfile_bfd == NULL)
perror_with_name (filename.get ());
bfd_errmsg (bfd_get_error ()));
}
- bfd_map_over_sections (loadfile_bfd.get (), add_section_size_callback,
- (void *) &total_progress.total_size);
+ for (asection *asec : gdb_bfd_sections (loadfile_bfd))
+ total_progress.total_size += bfd_section_size (asec);
- bfd_map_over_sections (loadfile_bfd.get (), load_section_callback, &cbdata);
+ for (asection *asec : gdb_bfd_sections (loadfile_bfd))
+ load_one_section (loadfile_bfd.get (), asec, &cbdata);
using namespace std::chrono;
CORE_ADDR offset)
{
/* Add OFFSET to all sections by default. */
- std::vector<struct section_offsets> offsets (objf->num_sections,
- { { offset } });
+ section_offsets offsets (objf->section_offsets.size (), offset);
/* Create sorted lists of all sections in ADDRS as well as all
sections in OBJF. */
}
if (cmp == 0)
- offsets[objf_sect->sectindex].offsets[0] = 0;
+ offsets[objf_sect->sectindex] = 0;
}
/* Apply the new section offsets. */
- objfile_relocate (objf, offsets.data ());
+ objfile_relocate (objf, offsets);
}
/* This function allows the addition of incrementally linked object files.
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
- entered on the command line. Every array element is
- assigned an ascending section index to preserve the above
- order over an unstable sorting algorithm. This dummy
- index is not used for any other purpose.
+ entered on the command line. Every array element is
+ assigned an ascending section index to preserve the above
+ order over an unstable sorting algorithm. This dummy
+ index is not used for any other purpose.
*/
section_addrs.emplace_back (addr, sec, section_addrs.size ());
printf_filtered ("\t%s_addr = %s\n", sec,
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."));
if (seen_offset)
set_objfile_default_section_offset (objf, section_addrs, offset);
- add_target_sections_of_objfile (objf);
+ current_program_space->add_target_sections (objf);
/* Getting new symbols may change our opinion about what is
frameless. */
objfile_name (objf)))
error (_("Not confirmed."));
- delete objf;
+ objf->unlink ();
clear_symtab_users (0);
}
/* 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;
a `shared library' on AIX is also an archive), then you should
stat on the archive name, not member name. */
if (objfile->obfd->my_archive)
- res = stat (objfile->obfd->my_archive->filename, &new_statbuf);
+ res = stat (bfd_get_filename (objfile->obfd->my_archive), &new_statbuf);
else
res = stat (objfile_name (objfile), &new_statbuf);
if (res != 0)
new_modtime = new_statbuf.st_mtime;
if (new_modtime != objfile->mtime)
{
- struct section_offsets *offsets;
- int num_offsets;
-
printf_filtered (_("`%s' has changed; re-reading symbols.\n"),
objfile_name (objfile));
/* If we get an error, blow away this objfile (not sure if
that is the correct response for things like shared
libraries). */
- std::unique_ptr<struct objfile> objfile_holder (objfile);
+ objfile_up objfile_holder (objfile);
/* We need to do this whenever any symbols go away. */
clear_symtab_users_cleanup defer_clear_users (0);
- if (exec_bfd != NULL
+ if (current_program_space->exec_bfd () != NULL
&& filename_cmp (bfd_get_filename (objfile->obfd),
- bfd_get_filename (exec_bfd)) == 0)
+ bfd_get_filename (current_program_space->exec_bfd ())) == 0)
{
/* Reload EXEC_BFD without asking anything. */
obfd_filename = bfd_get_filename (objfile->obfd);
/* Open the new BFD before freeing the old one, so that
the filename remains live. */
- gdb_bfd_ref_ptr temp (gdb_bfd_open (obfd_filename, gnutarget, -1));
+ gdb_bfd_ref_ptr temp (gdb_bfd_open (obfd_filename, gnutarget));
objfile->obfd = temp.release ();
if (objfile->obfd == NULL)
error (_("Can't open %s to read symbols."), obfd_filename);
error (_("Can't read symbols from %s: %s."), objfile_name (objfile),
bfd_errmsg (bfd_get_error ()));
- /* Save the offsets, we will nuke them with the rest of the
- objfile_obstack. */
- num_offsets = objfile->num_sections;
- offsets = ((struct section_offsets *)
- alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets)));
- memcpy (offsets, objfile->section_offsets,
- SIZEOF_N_SECTION_OFFSETS (num_offsets));
-
- 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);
objfile->sections = NULL;
+ objfile->section_offsets.clear ();
+ objfile->sect_index_bss = -1;
+ objfile->sect_index_data = -1;
+ objfile->sect_index_rodata = -1;
+ objfile->sect_index_text = -1;
objfile->compunit_symtabs = NULL;
objfile->template_symbols = NULL;
objfile->static_links.reset (nullptr);
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);
- /* We use the same section offsets as from last time. I'm not
- sure whether that is always correct for shared libraries. */
- objfile->section_offsets = (struct section_offsets *)
- obstack_alloc (&objfile->objfile_obstack,
- SIZEOF_N_SECTION_OFFSETS (num_offsets));
- memcpy (objfile->section_offsets, offsets,
- SIZEOF_N_SECTION_OFFSETS (num_offsets));
- objfile->num_sections = num_offsets;
-
/* What the hell is sym_new_init for, anyway? The concept of
distinguishing between the main file and additional files
in this way seems rather dubious. */
- if (objfile == symfile_objfile)
+ if (objfile == current_program_space->symfile_object_file)
{
(*objfile->sf->sym_new_init) (objfile);
}
objfiles_changed ();
+ /* Recompute section offsets and section indices. */
+ objfile->sf->sym_offsets (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 ("");
+ 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. */
gdb::observers::new_objfile.notify (iter);
/* At least one objfile has changed, so we can consider that
- the executable we're debugging has changed too. */
+ the executable we're debugging has changed too. */
gdb::observers::executable_changed.notify ();
}
}
void
add_filename_language (const char *ext, enum language lang)
{
+ gdb_assert (ext != nullptr);
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
- = ((const char *) objfile->per_bfd->filename_cache.insert
- (filename, strlen (filename) + 1));
+ 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. */
{
/* 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",
}
/* 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
return 0; /* overlay debugging off */
case ovly_auto: /* overlay debugging automatic */
/* Unles there is a gdbarch_overlay_update function,
- there's really nothing useful to do here (can't really go auto). */
- gdbarch = get_objfile_arch (osect->objfile);
+ there's really nothing useful to do here (can't really go auto). */
+ gdbarch = osect->objfile->arch ();
if (gdbarch_overlay_update_p (gdbarch))
{
if (overlay_cache_invalid)
/* 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);
}
ALL_OBJFILE_OSECTIONS (objfile, osect)
if (section_is_mapped (osect))
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
const char *name;
bfd_vma lma, vma;
int size;
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
error (_("This target does not know how to read its overlay state."));
}
-/* Function: overlay_command
- A place-holder for a mis-typed command. */
-
/* Command list chain containing all defined "overlay" subcommands. */
static struct cmd_list_element *overlaylist;
-static void
-overlay_command (const char *args, int from_tty)
-{
- printf_unfiltered
- ("\"overlay\" must be followed by the name of an overlay command.\n");
- help_list (overlaylist, "overlay ", all_commands, gdb_stdout);
-}
-
/* Target Overlays for the "Simplest" overlay manager:
This is GDB's default target overlay layer. It works with the
static void
simple_free_overlay_table (void)
{
- if (cache_ovly_table)
- xfree (cache_ovly_table);
+ xfree (cache_ovly_table);
cache_novlys = 0;
cache_ovly_table = NULL;
cache_ovly_table_base = 0;
if (! novlys_msym.minsym)
{
error (_("Error reading inferior's overlay table: "
- "couldn't find `_novlys' variable\n"
- "in inferior. Use `overlay manual' mode."));
+ "couldn't find `_novlys' variable\n"
+ "in inferior. Use `overlay manual' mode."));
return 0;
}
if (! ovly_table_msym.minsym)
{
error (_("Error reading inferior's overlay table: couldn't find "
- "`_ovly_table' array\n"
- "in inferior. Use `overlay manual' mode."));
+ "`_ovly_table' array\n"
+ "in inferior. Use `overlay manual' mode."));
return 0;
}
- gdbarch = get_objfile_arch (ovly_table_msym.objfile);
+ gdbarch = ovly_table_msym.objfile->arch ();
word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
byte_order = gdbarch_byte_order (gdbarch);
= (unsigned int (*)[4]) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
cache_ovly_table_base = BMSYMBOL_VALUE_ADDRESS (ovly_table_msym);
read_target_long_array (cache_ovly_table_base,
- (unsigned int *) cache_ovly_table,
- cache_novlys * 4, word_size, byte_order);
+ (unsigned int *) cache_ovly_table,
+ cache_novlys * 4, word_size, byte_order);
return 1; /* SUCCESS */
}
{
int i;
asection *bsect = osect->the_bfd_section;
- struct gdbarch *gdbarch = get_objfile_arch (osect->objfile);
+ struct gdbarch *gdbarch = osect->objfile->arch ();
int word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
}
-/* Set the output sections and output offsets for section SECTP in
- ABFD. The relocation code in BFD will read these offsets, so we
- need to be sure they're initialized. We map each section to itself,
- with no offset; this means that SECTP->vma will be honored. */
-
-static void
-symfile_dummy_outputs (bfd *abfd, asection *sectp, void *dummy)
-{
- sectp->output_section = sectp;
- sectp->output_offset = 0;
-}
-
/* Default implementation for sym_relocate. */
bfd_byte *
default_symfile_relocate (struct objfile *objfile, asection *sectp,
- bfd_byte *buf)
+ bfd_byte *buf)
{
/* Use sectp->owner instead of objfile->obfd. sectp may point to a
DWO file. */
/* We will handle section offsets properly elsewhere, so relocate as if
all sections begin at 0. */
- bfd_map_over_sections (abfd, symfile_dummy_outputs, NULL);
+ for (asection *sect : gdb_bfd_sections (abfd))
+ {
+ sect->output_section = sect;
+ sect->output_offset = 0;
+ }
return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
}
bfd_byte *
symfile_relocate_debug_section (struct objfile *objfile,
- asection *sectp, bfd_byte *buf)
+ asection *sectp, bfd_byte *buf)
{
gdb_assert (objfile->sf->sym_relocate);
return (*objfile->sf->sym_relocate) (objfile, sectp, buf);
}
-struct symfile_segment_data *
+symfile_segment_data_up
get_symfile_segment_data (bfd *abfd)
{
const struct sym_fns *sf = find_sym_fns (abfd);
return sf->sym_segments (abfd);
}
-void
-free_symfile_segment_data (struct symfile_segment_data *data)
-{
- xfree (data->segment_bases);
- xfree (data->segment_sizes);
- xfree (data->segment_info);
- xfree (data);
-}
-
/* Given:
- DATA, containing segment addresses from the object file ABFD, and
the mapping from ABFD's sections onto the segments that own them,
int
symfile_map_offsets_to_segments (bfd *abfd,
const struct symfile_segment_data *data,
- struct section_offsets *offsets,
+ section_offsets &offsets,
int num_segment_bases,
const CORE_ADDR *segment_bases)
{
/* If we do not have segment mappings for the object file, we
can not relocate it by segments. */
gdb_assert (data != NULL);
- gdb_assert (data->num_segments > 0);
+ gdb_assert (data->segments.size () > 0);
for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
{
int which = data->segment_info[i];
- gdb_assert (0 <= which && which <= data->num_segments);
+ gdb_assert (0 <= which && which <= data->segments.size ());
/* Don't bother computing offsets for sections that aren't
- loaded as part of any segment. */
+ loaded as part of any segment. */
if (! which)
- continue;
+ continue;
/* Use the last SEGMENT_BASES entry as the address of any extra
- segments mentioned in DATA->segment_info. */
+ segments mentioned in DATA->segment_info. */
if (which > num_segment_bases)
- which = num_segment_bases;
+ which = num_segment_bases;
- offsets->offsets[i] = (segment_bases[which - 1]
- - data->segment_bases[which - 1]);
+ offsets[i] = segment_bases[which - 1] - data->segments[which - 1].base;
}
return 1;
bfd *abfd = objfile->obfd;
int i;
asection *sect;
- struct symfile_segment_data *data;
- data = get_symfile_segment_data (objfile->obfd);
+ symfile_segment_data_up data
+ = get_symfile_segment_data (objfile->obfd);
if (data == NULL)
return;
- if (data->num_segments != 1 && data->num_segments != 2)
- {
- free_symfile_segment_data (data);
- return;
- }
+ if (data->segments.size () != 1 && data->segments.size () != 2)
+ return;
for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
{
objfile->sect_index_bss = sect->index;
}
}
-
- free_symfile_segment_data (data);
}
/* Listen for free_objfile events. */
{
/* Remove the target sections owned by this objfile. */
if (objfile != NULL)
- remove_target_sections ((void *) objfile);
+ current_program_space->remove_target_sections ((void *) objfile);
}
/* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
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 ();
#endif /* GDB_SELF_TEST */
+void _initialize_symfile ();
void
-_initialize_symfile (void)
+_initialize_symfile ()
{
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_prefix_cmd ("overlay", class_support, overlay_command,
- _("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_alias, 1);
- add_com_alias ("ov", "overlay", class_alias, 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);
Show printing of symbol loading messages."), _("\
off == turn all messages off\n\
brief == print messages for the executable,\n\
- and brief messages for shared libraries\n\
+ and brief messages for shared libraries\n\
full == print messages for the executable,\n\
- and messages for each shared library."),
+ and messages for each shared library."),
NULL,
NULL,
&setprintlist, &showprintlist);
projects / binutils-gdb.git / blobdiff