/* 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 "readline/readline.h"
+#include "readline/tilde.h"
#include "block.h"
#include "observable.h"
#include "exec.h"
#include "stack.h"
#include "gdb_bfd.h"
#include "cli/cli-utils.h"
-#include "common/byte-vector.h"
-#include "common/pathstuff.h"
-#include "common/selftest.h"
+#include "gdbsupport/byte-vector.h"
+#include "gdbsupport/pathstuff.h"
+#include "gdbsupport/selftest.h"
#include "cli/cli-style.h"
-#include "common/forward-scope-exit.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. */
};
static const char *print_symbol_loading = print_symbol_loading_full;
-/* If non-zero, shared library symbols will be added automatically
- when the inferior is created, new libraries are loaded, or when
- attaching to the inferior. This is almost always what users will
- want to have happen; but for very large programs, the startup time
- will be excessive, and so if this is a problem, the user can clear
- this flag and then add the shared library symbols as needed. Note
- that there is a potential for confusion, since if the shared
- library symbols are not loaded, commands like "info fun" will *not*
- report all the functions that are actually present. */
-
-int auto_solib_add = 1;
+/* See symfile.h. */
+
+bool auto_solib_add = true;
\f
/* Return non-zero if symbol-loading messages should be printed.
}
/* 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_get_section_flags (abfd, sect) & (SEC_ALLOC | SEC_LOAD)))
+ if (0 == (bfd_section_flags (sect) & (SEC_ALLOC | SEC_LOAD)))
return;
if (!*lowest)
*lowest = sect; /* First loadable section */
- else if (bfd_section_vma (abfd, *lowest) > bfd_section_vma (abfd, sect))
+ else if (bfd_section_vma (*lowest) > bfd_section_vma (sect))
*lowest = sect; /* A lower loadable section */
- else if (bfd_section_vma (abfd, *lowest) == bfd_section_vma (abfd, sect)
- && (bfd_section_size (abfd, (*lowest))
- <= bfd_section_size (abfd, sect)))
+ else if (bfd_section_vma (*lowest) == bfd_section_vma (sect)
+ && (bfd_section_size (*lowest) <= bfd_section_size (sect)))
*lowest = sect;
}
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_get_section_flags (abfd, asect) & (SEC_ALLOC | SEC_LOAD)
- && sap.size () < end - start)
- sap.emplace_back (stp->addr,
- bfd_section_name (abfd, asect),
+ if (bfd_section_flags (asect) & (SEC_ALLOC | SEC_LOAD)
+ && sap.size () < table.size ())
+ sap.emplace_back (stp.addr,
+ bfd_section_name (asect),
gdb_bfd_section_index (abfd, asect));
}
section_addr_info sap;
for (sec = abfd->sections; sec != NULL; sec = sec->next)
- if (bfd_get_section_flags (abfd, sec) & (SEC_ALLOC | SEC_LOAD))
- sap.emplace_back (bfd_get_section_vma (abfd, sec),
- bfd_get_section_name (abfd, sec),
+ if (bfd_section_flags (sec) & (SEC_ALLOC | SEC_LOAD))
+ sap.emplace_back (bfd_section_vma (sec),
+ bfd_section_name (sec),
gdb_bfd_section_index (abfd, sec));
return sap;
{
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_get_section_alignment (abfd, sect);
+ ULONGEST align = ((ULONGEST) 1) << bfd_section_alignment (sect);
/* We are only interested in allocated sections. */
- if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
+ if ((bfd_section_flags (sect) & SEC_ALLOC) == 0)
return;
/* If the user specified an offset, honor it. */
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;
continue;
/* We can only conflict with allocated sections. */
- if ((bfd_get_section_flags (abfd, cur_sec) & SEC_ALLOC) == 0)
+ if ((bfd_section_flags (cur_sec) & SEC_ALLOC) == 0)
continue;
/* If the section offset is 0, either the section has not been placed
continue;
/* If this section would overlap us, then we must move up. */
- if (start_addr + bfd_get_section_size (sect) > offsets[indx]
- && start_addr < offsets[indx] + bfd_get_section_size (cur_sec))
+ if (start_addr + bfd_section_size (sect) > offsets[indx]
+ && start_addr < offsets[indx] + bfd_section_size (cur_sec))
{
- start_addr = offsets[indx] + bfd_get_section_size (cur_sec);
+ start_addr = offsets[indx] + bfd_section_size (cur_sec);
start_addr = (start_addr + align - 1) & -align;
done = 0;
break;
while (!done);
offsets[gdb_bfd_section_index (abfd, sect)] = start_addr;
- arg->lowest = start_addr + bfd_get_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;
}
}
int i;
/* Find lowest loadable section to be used as starting point for
- continguous sections. */
+ 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"),
lower_offset = 0;
}
else
- lower_offset = bfd_section_vma (bfd_get_filename (abfd), lower_sect);
+ lower_offset = bfd_section_vma (lower_sect);
/* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
in ABFD. Section names are not unique - there can be multiple sections of
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;
for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
/* We do not expect this to happen; just skip this step if the
relocatable file has a section with an assigned VMA. */
- if (bfd_section_vma (abfd, cur_sec) != 0)
+ if (bfd_section_vma (cur_sec) != 0)
break;
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
for (cur_sec = abfd->sections; cur_sec != NULL;
cur_sec = cur_sec->next)
{
- if ((bfd_get_section_flags (abfd, cur_sec) & SEC_ALLOC) == 0)
+ if ((bfd_section_flags (cur_sec) & SEC_ALLOC) == 0)
continue;
- bfd_set_section_vma (abfd, cur_sec, offsets[cur_sec->index]);
+ bfd_set_section_vma (cur_sec, offsets[cur_sec->index]);
exec_set_section_address (bfd_get_filename (abfd),
cur_sec->index,
offsets[cur_sec->index]);
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
/* Make sure there is at least one loadable section in the file. */
for (sect = abfd->sections; sect != NULL; sect = sect->next)
{
- if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
+ if ((bfd_section_flags (sect) & SEC_ALLOC) == 0)
continue;
break;
if (sect == NULL)
return NULL;
- low = bfd_get_section_vma (abfd, sect);
- high = low + bfd_get_section_size (sect);
+ 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)
{
CORE_ADDR vma;
- if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
+ if ((bfd_section_flags (sect) & SEC_ALLOC) == 0)
continue;
- vma = bfd_get_section_vma (abfd, sect);
+ vma = bfd_section_vma (sect);
if (vma < low)
low = vma;
- if (vma + bfd_get_section_size (sect) > high)
- high = vma + bfd_get_section_size (sect);
+ if (vma + bfd_section_size (sect) > high)
+ high = vma + bfd_section_size (sect);
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, 0);
+ 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)
{
struct bfd_section *sect = osect->the_bfd_section;
- if (entry_point >= bfd_get_section_vma (objfile->obfd, sect)
- && entry_point < (bfd_get_section_vma (objfile->obfd, sect)
- + bfd_get_section_size (sect)))
+ if (entry_point >= bfd_section_vma (sect)
+ && entry_point < (bfd_section_vma (sect)
+ + bfd_section_size (sect)))
{
ei->the_bfd_section_index
= gdb_bfd_section_index (objfile->obfd, sect);
(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
- correspondig BFD section index, or -1 if the section was not found.
+ corresponding BFD section index, or -1 if the section was not found.
ADD_FLAGS encodes verbosity level, whether this is main symbol or
- an extra symbol file such as dynamically loaded code, and wether
+ an extra symbol file such as dynamically loaded code, and whether
breakpoint reset should be deferred. */
static void
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);
}
For NAME description see the objfile constructor.
ADD_FLAGS encodes verbosity, whether this is main symbol file or
- extra, such as dynamically loaded code, and what to do with breakpoins.
+ extra, such as dynamically loaded code, and what to do with breakpoints.
ADDRS is as described for syms_from_objfile_1, above.
ADDRS is ignored when SYMFILE_MAINLINE bit is set in 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."));
if (mainline)
flags |= OBJF_MAINLINE;
- objfile = new struct objfile (abfd, name, flags);
-
- if (parent)
- add_separate_debug_objfile (objfile, parent);
+ objfile = objfile::make (abfd, name, flags, parent);
/* We either created a new mapped symbol table, mapped an existing
symbol table file which has not had initial symbol reading
if (deprecated_pre_add_symbol_hook)
deprecated_pre_add_symbol_hook (name);
else
- {
- puts_filtered (_("Reading symbols from "));
- fputs_styled (name, file_name_style.style (), gdb_stdout);
- puts_filtered ("...\n");
- }
+ printf_filtered (_("Reading symbols from %ps...\n"),
+ styled_string (file_name_style.style (), name));
}
syms_from_objfile (objfile, addrs, add_flags);
if ((flags & OBJF_READNOW))
{
if (should_print)
- printf_filtered (_("Expanding full symbols from %s...\n"), name);
+ 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
file, and so printing it twice is just redundant. */
if (should_print && !objfile_has_symbols (objfile)
&& objfile->separate_debug_objfile == nullptr)
- printf_filtered (_("(No debugging symbols found in %s)\n"), name);
+ printf_filtered (_("(No debugging symbols found in %ps)\n"),
+ styled_string (file_name_style.style (), name));
if (should_print)
{
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"));
}
/* See symfile.h. */
-int separate_debug_file_debug = 0;
+bool separate_debug_file_debug = false;
static int
separate_debug_file_exists (const std::string &name, unsigned long crc,
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
https://sourceware.org/ml/gdb-patches/2019-04/msg00605.html
- If some of those scenarions need to be supported, we will need to
+ If some of those scenarios need to be supported, we will need to
use a different condition for HAS_DRIVE_SPEC and a different macro
instead of STRIP_DRIVE_SPEC, which work on Posix systems as well. */
std::string drive;
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)
{
validate_readnow_readnever (flags);
+ /* Set SYMFILE_DEFER_BP_RESET because the proper displacement for a PIE
+ (Position Independent Executable) main symbol file will only be
+ computed by the solib_create_inferior_hook below. Without it,
+ breakpoint_re_set would fail to insert the breakpoints with the zero
+ displacement. */
+ add_flags |= SYMFILE_DEFER_BP_RESET;
+
symbol_file_add_main_1 (name, add_flags, flags, offset);
+
+ solib_create_inferior_hook (from_tty);
+
+ /* Now it's safe to re-add the breakpoints. */
+ breakpoint_re_set ();
}
}
-/* 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)
{
- char *name = main_name ();
- struct symbol *sym = lookup_symbol (name, NULL, VAR_DOMAIN, NULL).symbol;
+ const char *name = main_name ();
+ 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_get_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_get_section_size (asec);
- const char *sect_name = bfd_get_section_name (abfd, asec);
+ bfd_size_type size = bfd_section_size (asec);
+ const char *sect_name = bfd_section_name (asec);
- if ((bfd_get_section_flags (abfd, asec) & SEC_LOAD) == 0)
+ if ((bfd_section_flags (asec) & SEC_LOAD) == 0)
return;
if (size == 0)
return;
- ULONGEST begin = bfd_section_lma (abfd, asec) + args->load_offset;
+ ULONGEST begin = bfd_section_lma (asec) + args->load_offset;
ULONGEST end = begin + size;
gdb_byte *buffer = (gdb_byte *) xmalloc (size);
bfd_get_section_contents (abfd, asec, buffer, 0, size);
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. */
void
generic_load (const char *args, int from_tty)
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 entry = bfd_get_start_address (loadfile_bfd.get ());
entry = gdbarch_addr_bits_remove (target_gdbarch (), entry);
uiout->text ("Start address ");
- uiout->field_fmt ("address", "%s", paddress (target_gdbarch (), entry));
+ uiout->field_core_addr ("address", target_gdbarch (), entry);
uiout->text (", load size ");
- uiout->field_fmt ("load-size", "%lu", total_progress.data_count);
+ uiout->field_unsigned ("load-size", total_progress.data_count);
uiout->text ("\n");
regcache_write_pc (get_current_regcache (), entry);
if (uiout->is_mi_like_p ())
{
- uiout->field_fmt ("transfer-rate", "%lu", rate * 8);
+ uiout->field_unsigned ("transfer-rate", rate * 8);
uiout->text (" bits/sec");
}
else if (rate < 1024)
{
- uiout->field_fmt ("transfer-rate", "%lu", rate);
+ uiout->field_unsigned ("transfer-rate", rate);
uiout->text (" bytes/sec");
}
else
{
- uiout->field_fmt ("transfer-rate", "%lu", rate / 1024);
+ uiout->field_unsigned ("transfer-rate", rate / 1024);
uiout->text (" KB/sec");
}
}
else
{
- uiout->field_fmt ("transferred-bits", "%lu", (data_count * 8));
+ uiout->field_unsigned ("transferred-bits", (data_count * 8));
uiout->text (" bits in <1 sec");
}
if (write_count > 0)
{
uiout->text (", ");
- uiout->field_fmt ("write-rate", "%lu", data_count / write_count);
+ uiout->field_unsigned ("write-rate", data_count / write_count);
uiout->text (" bytes/write");
}
uiout->text (".\n");
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. */
automatically recreated by sym_read. */
free_objfile_separate_debug (objfile);
+ /* Clear the stale source cache. */
+ forget_cached_source_info ();
+
/* Remove any references to this objfile in the global
value lists. */
preserve_values (objfile);
/* Clean up any state BFD has sitting around. */
{
gdb_bfd_ref_ptr obfd (objfile->obfd);
- char *obfd_filename;
+ const char *obfd_filename;
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);
set_objfile_per_bfd (objfile);
objfile->original_name
- = (char *) obstack_copy0 (&objfile->objfile_obstack,
- original_name.c_str (),
- original_name.size ());
+ = obstack_strdup (&objfile->objfile_obstack, original_name);
/* Reset the sym_fns pointer. The ELF reader can change it
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::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 *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);
{
/* 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",
Just save the basename to avoid path issues (too long for display,
relative vs absolute, etc.). */
saved_name = lbasename (name);
- cu->name
- = (const char *) obstack_copy0 (&objfile->objfile_obstack, saved_name,
- strlen (saved_name));
+ cu->name = obstack_strdup (&objfile->objfile_obstack, saved_name);
COMPUNIT_DEBUGFORMAT (cu) = "unknown";
{
asection *bfd_section = section->the_bfd_section;
- if (bfd_section_lma (abfd, bfd_section) != 0
- && bfd_section_lma (abfd, bfd_section)
- != bfd_section_vma (abfd, bfd_section))
+ if (bfd_section_lma (bfd_section) != 0
+ && bfd_section_lma (bfd_section) != bfd_section_vma (bfd_section))
return 1;
}
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)
{
if (section_is_overlay (section))
{
- bfd *abfd = section->objfile->obfd;
asection *bfd_section = section->the_bfd_section;
/* We assume the LMA is relocated by the same offset as the VMA. */
- bfd_vma size = bfd_get_section_size (bfd_section);
- CORE_ADDR offset = obj_section_offset (section);
+ bfd_vma size = bfd_section_size (bfd_section);
+ CORE_ADDR offset = section->offset ();
- if (bfd_get_section_lma (abfd, bfd_section) + offset <= pc
- && pc < bfd_get_section_lma (abfd, bfd_section) + offset + size)
+ if (bfd_section_lma (bfd_section) + offset <= pc
+ && pc < bfd_section_lma (bfd_section) + offset + size)
return 1;
}
{
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);
}
{
asection *bfd_section = section->the_bfd_section;
- return pc + bfd_section_lma (abfd, bfd_section)
- - bfd_section_vma (abfd, bfd_section);
+ return (pc + bfd_section_lma (bfd_section)
+ - bfd_section_vma (bfd_section));
}
return pc;
{
asection *bfd_section = section->the_bfd_section;
- return pc + bfd_section_vma (abfd, bfd_section)
- - bfd_section_lma (abfd, bfd_section);
+ return (pc + bfd_section_vma (bfd_section)
+ - bfd_section_lma (bfd_section));
}
return pc;
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;
- vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section);
- lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section);
- size = bfd_get_section_size (osect->the_bfd_section);
- name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
+ vma = bfd_section_vma (osect->the_bfd_section);
+ lma = bfd_section_lma (osect->the_bfd_section);
+ size = bfd_section_size (osect->the_bfd_section);
+ name = bfd_section_name (osect->the_bfd_section);
printf_filtered ("Section %s, loaded at ", name);
fputs_filtered (paddress (gdbarch, lma), gdb_stdout);
/* First, find a section matching the user supplied argument. */
for (objfile *obj_file : current_program_space->objfiles ())
ALL_OBJFILE_OSECTIONS (obj_file, sec)
- if (!strcmp (bfd_section_name (obj_file->obfd, sec->the_bfd_section),
- args))
+ if (!strcmp (bfd_section_name (sec->the_bfd_section), args))
{
/* Now, check to see if the section is an overlay. */
if (!section_is_overlay (sec))
sec2))
{
if (info_verbose)
- printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
- bfd_section_name (obj_file->obfd,
- 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;
/* First, find a section matching the user supplied argument. */
for (objfile *objfile : current_program_space->objfiles ())
ALL_OBJFILE_OSECTIONS (objfile, sec)
- if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
+ if (!strcmp (bfd_section_name (sec->the_bfd_section), args))
{
if (!sec->ovly_mapped)
error (_("Section %s is not mapped"), args);
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);
for (i = 0; i < cache_novlys; i++)
- if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
- && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect))
+ if (cache_ovly_table[i][VMA] == bfd_section_vma (bsect)
+ && cache_ovly_table[i][LMA] == bfd_section_lma (bsect))
{
read_target_long_array (cache_ovly_table_base + i * word_size,
(unsigned int *) cache_ovly_table[i],
4, word_size, byte_order);
- if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
- && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect))
+ if (cache_ovly_table[i][VMA] == bfd_section_vma (bsect)
+ && cache_ovly_table[i][LMA] == bfd_section_lma (bsect))
{
osect->ovly_mapped = cache_ovly_table[i][MAPPED];
return 1;
asection *bsect = osect->the_bfd_section;
for (i = 0; i < cache_novlys; i++)
- if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
- && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect))
+ if (cache_ovly_table[i][VMA] == bfd_section_vma (bsect)
+ && cache_ovly_table[i][LMA] == bfd_section_lma (bsect))
{ /* obj_section matches i'th entry in ovly_table. */
osect->ovly_mapped = cache_ovly_table[i][MAPPED];
break; /* finished with inner for loop: break out. */
}
}
-/* 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\
&cmdlist);
c = add_cmd ("load", class_files, load_command, _("\
-Dynamically load FILE into the running program, and record its symbols\n\
-for access from GDB.\n\
+Dynamically load FILE into the running program.\n\
+FILE symbols are recorded for access from GDB.\n\
Usage: load [FILE] [OFFSET]\n\
An optional load OFFSET may also be given as a literal address.\n\
When OFFSET is provided, FILE must also be provided. FILE can be provided\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);