/* Generic symbol file reading for the GNU debugger, GDB.
- Copyright (C) 1990-2018 Free Software Foundation, Inc.
+ Copyright (C) 1990-2019 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
#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 "selftest.h"
+#include "gdbsupport/byte-vector.h"
+#include "gdbsupport/pathstuff.h"
+#include "gdbsupport/selftest.h"
+#include "cli/cli-style.h"
+#include "gdbsupport/forward-scope-exit.h"
#include <sys/types.h>
#include <fcntl.h>
void (*deprecated_pre_add_symbol_hook) (const char *);
void (*deprecated_post_add_symbol_hook) (void);
-static void clear_symtab_users_cleanup (void *ignore);
+using clear_symtab_users_cleanup
+ = FORWARD_SCOPE_EXIT (clear_symtab_users);
/* Global variables owned by this file. */
int readnow_symbol_files; /* Read full symbols immediately. */
};
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.
{
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;
}
struct bfd_section *asect = stp->the_bfd_section;
bfd *abfd = asect->owner;
- if (bfd_get_section_flags (abfd, asect) & (SEC_ALLOC | SEC_LOAD)
+ if (bfd_section_flags (asect) & (SEC_ALLOC | SEC_LOAD)
&& sap.size () < end - start)
sap.emplace_back (stp->addr,
- bfd_section_name (abfd, asect),
+ 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;
struct place_section_arg *arg = (struct place_section_arg *) obj;
CORE_ADDR *offsets = arg->offsets->offsets, 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. */
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);
+ arg->lowest = start_addr + bfd_section_size (sect);
}
/* Store section_addr_info as prepared (made relative and with SECTINDEX
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);
if (lower_sect == NULL)
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
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)
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]);
/* 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;
{
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;
}
}
}
if ((add_flags & SYMFILE_NO_READ) == 0)
- require_partial_symbols (objfile, 0);
+ require_partial_symbols (objfile, false);
}
/* Initialize entry point information for this objfile. */
{
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);
into a format-specific offset table --- a `struct 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
symfile_add_flags add_flags)
{
section_addr_info local_addr;
- struct cleanup *old_chain;
const int mainline = add_flags & SYMFILE_MAINLINE;
objfile_set_sym_fns (objfile, find_sym_fns (objfile->obfd));
/* Make sure that partially constructed symbol tables will be cleaned up
if an error occurs during symbol reading. */
- old_chain = make_cleanup (null_cleanup, NULL);
+ gdb::optional<clear_symtab_users_cleanup> defer_clear_users;
+
std::unique_ptr<struct objfile> objfile_holder (objfile);
/* If ADDRS is NULL, put together a dummy address list.
{
/* We will modify the main symbol table, make sure that all its users
will be cleaned up if an error occurs during symbol reading. */
- make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
+ defer_clear_users.emplace ((symfile_add_flag) 0);
/* Since no error yet, throw away the old symbol table. */
initial symbol reading for this file. */
(*objfile->sf->sym_init) (objfile);
- clear_complaints (1);
+ clear_complaints ();
(*objfile->sf->sym_offsets) (objfile, *addrs);
/* Discard cleanups as symbol reading was successful. */
objfile_holder.release ();
- discard_cleanups (old_chain);
+ if (defer_clear_users)
+ defer_clear_users->release ();
}
/* Same as syms_from_objfile_1, but also initializes the objfile
}
/* We're done reading the symbol file; finish off complaints. */
- clear_complaints (0);
+ clear_complaints ();
}
/* Process a symbol file, as either the main file or as a dynamically
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.
if (mainline)
flags |= OBJF_MAINLINE;
- objfile = new struct objfile (abfd, name, flags);
+ objfile = objfile::make (abfd, name, flags);
if (parent)
add_separate_debug_objfile (objfile, parent);
if (deprecated_pre_add_symbol_hook)
deprecated_pre_add_symbol_hook (name);
else
- printf_filtered (_("Reading symbols from %s...\n"), name);
+ 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);
}
- if (should_print && !objfile_has_symbols (objfile))
- printf_filtered (_("(No debugging symbols found in %s)\n"), name);
+ /* Note that we only print a message if we have no symbols and have
+ no separate debug file. If there is a separate debug file which
+ does not have symbols, we'll have emitted this message for that
+ 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 %ps)\n"),
+ styled_string (file_name_style.style (), name));
if (should_print)
{
/* 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,
return 0;
if (separate_debug_file_debug)
- printf_filtered (_(" Trying %s\n"), name.c_str ());
+ {
+ printf_filtered (_(" Trying %s..."), name.c_str ());
+ gdb_flush (gdb_stdout);
+ }
gdb_bfd_ref_ptr abfd (gdb_bfd_open (name.c_str (), gnutarget, -1));
if (abfd == NULL)
- return 0;
+ {
+ if (separate_debug_file_debug)
+ printf_filtered (_(" no, unable to open.\n"));
+
+ return 0;
+ }
/* Verify symlinks were not the cause of filename_cmp name difference above.
{
if (abfd_stat.st_dev == parent_stat.st_dev
&& abfd_stat.st_ino == parent_stat.st_ino)
- return 0;
+ {
+ if (separate_debug_file_debug)
+ printf_filtered (_(" no, same file as the objfile.\n"));
+
+ return 0;
+ }
verified_as_different = 1;
}
else
file_crc_p = gdb_bfd_crc (abfd.get (), &file_crc);
if (!file_crc_p)
- return 0;
+ {
+ if (separate_debug_file_debug)
+ printf_filtered (_(" no, error computing CRC.\n"));
+
+ return 0;
+ }
if (crc != file_crc)
{
if (!verified_as_different)
{
if (!gdb_bfd_crc (parent_objfile->obfd, &parent_crc))
- return 0;
+ {
+ if (separate_debug_file_debug)
+ printf_filtered (_(" no, error computing CRC.\n"));
+
+ return 0;
+ }
}
if (verified_as_different || parent_crc != file_crc)
" does not match \"%s\" (CRC mismatch).\n"),
name.c_str (), objfile_name (parent_objfile));
+ if (separate_debug_file_debug)
+ printf_filtered (_(" no, CRC doesn't match.\n"));
+
return 0;
}
+ if (separate_debug_file_debug)
+ printf_filtered (_(" yes!\n"));
+
return 1;
}
Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
cause "/..." lookups. */
+ 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);
+
+ /* 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
+ file name resulting from splicing below will be valid.
+
+ FIXME: The below only works when GDB runs on MS-Windows/MS-DOS.
+ There are various remote-debugging scenarios where such a
+ transformation of the drive letter might be required when GDB runs
+ on a Posix host, see
+
+ https://sourceware.org/ml/gdb-patches/2019-04/msg00605.html
+
+ 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 (HAS_DRIVE_SPEC (dir_notarget))
+ {
+ drive = dir_notarget[0];
+ dir_notarget = STRIP_DRIVE_SPEC (dir_notarget);
+ }
for (const gdb::unique_xmalloc_ptr<char> &debugdir : debugdir_vec)
{
- debugfile = debugdir.get ();
+ debugfile = target_prefix ? "target:" : "";
+ debugfile += debugdir.get ();
debugfile += "/";
- debugfile += dir;
+ debugfile += drive;
+ debugfile += dir_notarget;
debugfile += debuglink;
if (separate_debug_file_exists (debugfile, crc32, objfile))
return debugfile;
- /* If the file is in the sysroot, try using its base path in the
- global debugfile directory. */
- if (canon_dir != NULL
- && filename_ncmp (canon_dir, gdb_sysroot,
- strlen (gdb_sysroot)) == 0
- && IS_DIR_SEPARATOR (canon_dir[strlen (gdb_sysroot)]))
+ const char *base_path = NULL;
+ if (canon_dir != NULL)
+ {
+ if (canon_sysroot.get () != NULL)
+ base_path = child_path (canon_sysroot.get (), canon_dir);
+ else
+ base_path = child_path (gdb_sysroot, canon_dir);
+ }
+ if (base_path != NULL)
{
- debugfile = debugdir.get ();
- debugfile += (canon_dir + strlen (gdb_sysroot));
+ /* If the file is in the sysroot, try using its base path in
+ the global debugfile directory. */
+ debugfile = target_prefix ? "target:" : "";
+ debugfile += debugdir.get ();
+ debugfile += "/";
+ debugfile += base_path;
+ debugfile += "/";
+ debugfile += debuglink;
+
+ if (separate_debug_file_exists (debugfile, crc32, objfile))
+ return debugfile;
+
+ /* If the file is in the sysroot, try using its base path in
+ the sysroot's global debugfile directory. */
+ debugfile = target_prefix ? "target:" : "";
+ debugfile += gdb_sysroot;
+ debugfile += debugdir.get ();
+ debugfile += "/";
+ debugfile += base_path;
debugfile += "/";
debugfile += debuglink;
if (separate_debug_file_exists (debugfile, crc32, objfile))
return debugfile;
}
+
}
return std::string ();
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 ();
}
}
if (lang == language_unknown)
{
- char *name = main_name ();
+ const char *name = main_name ();
struct symbol *sym = lookup_symbol (name, NULL, VAR_DOMAIN, NULL).symbol;
if (sym != NULL)
{
bfd_size_type *sum = (bfd_size_type *) data;
- *sum += bfd_get_section_size (asec);
+ *sum += bfd_section_size (asec);
}
/* Opaque data for load_progress. */
load_section_callback (bfd *abfd, asection *asec, void *data)
{
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);
unsigned long write_count,
std::chrono::steady_clock::duration d);
+/* See symfile.h. */
+
void
generic_load (const char *args, int from_tty)
{
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");
/* This function allows the addition of incrementally linked object files.
It does not modify any state in the target, only in the debugger. */
-/* Note: ezannoni 2000-04-13 This function/command used to have a
- special case syntax for the rombug target (Rombug is the boot
- monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
- rombug case, the user doesn't need to supply a text address,
- instead a call to target_link() (in target.c) would supply the
- value to use. We are now discontinuing this type of ad hoc syntax. */
static void
add_symbol_file_command (const char *args, int from_tty)
objf = symbol_file_add (filename.get (), add_flags, §ion_addrs,
flags);
+ if (!objfile_has_symbols (objf) && objf->per_bfd->minimal_symbol_count <= 0)
+ warning (_("newly-added symbol file \"%s\" does not provide any symbols"),
+ filename.get ());
if (seen_offset)
set_objfile_default_section_offset (objf, section_addrs, offset);
addr = parse_and_eval_address (argv[1]);
- ALL_OBJFILES (objf)
+ for (objfile *objfile : current_program_space->objfiles ())
{
- if ((objf->flags & OBJF_USERLOADED) != 0
- && (objf->flags & OBJF_SHARED) != 0
- && objf->pspace == pspace && is_addr_in_objfile (addr, objf))
- break;
+ if ((objfile->flags & OBJF_USERLOADED) != 0
+ && (objfile->flags & OBJF_SHARED) != 0
+ && objfile->pspace == pspace
+ && is_addr_in_objfile (addr, objfile))
+ {
+ objf = objfile;
+ break;
+ }
}
}
else if (argv[0] != NULL)
gdb::unique_xmalloc_ptr<char> filename (tilde_expand (argv[0]));
- ALL_OBJFILES (objf)
+ for (objfile *objfile : current_program_space->objfiles ())
{
- if ((objf->flags & OBJF_USERLOADED) != 0
- && (objf->flags & OBJF_SHARED) != 0
- && objf->pspace == pspace
- && filename_cmp (filename.get (), objfile_name (objf)) == 0)
- break;
+ if ((objfile->flags & OBJF_USERLOADED) != 0
+ && (objfile->flags & OBJF_SHARED) != 0
+ && objfile->pspace == pspace
+ && filename_cmp (filename.get (), objfile_name (objfile)) == 0)
+ {
+ objf = objfile;
+ break;
+ }
}
}
void
reread_symbols (void)
{
- struct objfile *objfile;
long new_modtime;
struct stat new_statbuf;
int res;
std::vector<struct objfile *> new_objfiles;
- /* With the addition of shared libraries, this should be modified,
- the load time should be saved in the partial symbol tables, since
- different tables may come from different source files. FIXME.
- This routine should then walk down each partial symbol table
- and see if the symbol table that it originates from has been changed. */
-
- for (objfile = object_files; objfile; objfile = objfile->next)
+ for (objfile *objfile : current_program_space->objfiles ())
{
if (objfile->obfd == NULL)
continue;
new_modtime = new_statbuf.st_mtime;
if (new_modtime != objfile->mtime)
{
- struct cleanup *old_cleanups;
struct section_offsets *offsets;
int num_offsets;
std::unique_ptr<struct objfile> objfile_holder (objfile);
/* We need to do this whenever any symbols go away. */
- old_cleanups = make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
+ clear_symtab_users_cleanup defer_clear_users (0);
if (exec_bfd != NULL
&& filename_cmp (bfd_get_filename (objfile->obfd),
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
memcpy (offsets, objfile->section_offsets,
SIZEOF_N_SECTION_OFFSETS (num_offsets));
- /* FIXME: Do we have to free a whole linked list, or is this
- enough? */
- objfile->global_psymbols.clear ();
- objfile->static_psymbols.clear ();
-
- /* Free the obstacks for non-reusable objfiles. */
- psymbol_bcache_free (objfile->psymbol_cache);
- objfile->psymbol_cache = psymbol_bcache_init ();
+ 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->compunit_symtabs = NULL;
- objfile->psymtabs = NULL;
- objfile->psymtabs_addrmap = NULL;
- objfile->free_psymtabs = NULL;
objfile->template_symbols = NULL;
+ objfile->static_links.reset (nullptr);
/* obstack_init also initializes the obstack so it is
empty. We could use obstack_specify_allocation but
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
objfile_set_sym_fns (objfile, find_sym_fns (objfile->obfd));
build_objfile_section_table (objfile);
- terminate_minimal_symbol_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->sf->sym_init) (objfile);
- clear_complaints (1);
+ clear_complaints ();
objfile->flags &= ~OBJF_PSYMTABS_READ;
}
/* We're done reading the symbol file; finish off complaints. */
- clear_complaints (0);
+ clear_complaints ();
/* Getting new symbols may change our opinion about what is
frameless. */
/* Discard cleanups as symbol reading was successful. */
objfile_holder.release ();
- discard_cleanups (old_cleanups);
+ defer_clear_users.release ();
/* If the mtime has changed between the time we set new_modtime
and now, we *want* this to be out of date, so don't call stat
= OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symtab);
symtab->filename
- = (const char *) bcache (filename, strlen (filename) + 1,
- objfile->per_bfd->filename_cache);
+ = ((const char *) objfile->per_bfd->filename_cache.insert
+ (filename, strlen (filename) + 1));
symtab->fullname = NULL;
symtab->language = deduce_language_from_filename (filename);
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";
clear_pc_function_cache ();
gdb::observers::new_objfile.notify (NULL);
- /* Clear globals which might have pointed into a removed objfile.
- FIXME: It's not clear which of these are supposed to persist
- between expressions and which ought to be reset each time. */
- expression_context_block = NULL;
- innermost_block.reset ();
-
/* Varobj may refer to old symbols, perform a cleanup. */
varobj_invalidate ();
if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
breakpoint_re_set ();
}
-
-static void
-clear_symtab_users_cleanup (void *ignore)
-{
- clear_symtab_users (0);
-}
\f
/* OVERLAYS:
The following code implements an abstraction for debugging overlay sections.
{
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;
}
static void
overlay_invalidate_all (void)
{
- struct objfile *objfile;
struct obj_section *sect;
- ALL_OBJSECTIONS (objfile, sect)
- if (section_is_overlay (sect))
- sect->ovly_mapped = -1;
+ for (objfile *objfile : current_program_space->objfiles ())
+ ALL_OBJFILE_OSECTIONS (objfile, sect)
+ if (section_is_overlay (sect))
+ sect->ovly_mapped = -1;
}
/* Function: section_is_mapped (SECTION)
{
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);
+ bfd_vma size = bfd_section_size (bfd_section);
CORE_ADDR offset = obj_section_offset (section);
- 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;
}
{
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;
struct obj_section *
find_pc_overlay (CORE_ADDR pc)
{
- struct objfile *objfile;
struct obj_section *osect, *best_match = NULL;
if (overlay_debugging)
{
- ALL_OBJSECTIONS (objfile, osect)
- if (section_is_overlay (osect))
- {
- if (pc_in_mapped_range (pc, osect))
- {
- if (section_is_mapped (osect))
- return osect;
- else
- best_match = osect;
- }
- else if (pc_in_unmapped_range (pc, osect))
- best_match = osect;
- }
+ for (objfile *objfile : current_program_space->objfiles ())
+ ALL_OBJFILE_OSECTIONS (objfile, osect)
+ if (section_is_overlay (osect))
+ {
+ if (pc_in_mapped_range (pc, osect))
+ {
+ if (section_is_mapped (osect))
+ return osect;
+ else
+ best_match = osect;
+ }
+ else if (pc_in_unmapped_range (pc, osect))
+ best_match = osect;
+ }
}
return best_match;
}
struct obj_section *
find_pc_mapped_section (CORE_ADDR pc)
{
- struct objfile *objfile;
struct obj_section *osect;
if (overlay_debugging)
{
- ALL_OBJSECTIONS (objfile, osect)
- if (pc_in_mapped_range (pc, osect) && section_is_mapped (osect))
- return osect;
+ for (objfile *objfile : current_program_space->objfiles ())
+ ALL_OBJFILE_OSECTIONS (objfile, osect)
+ if (pc_in_mapped_range (pc, osect) && section_is_mapped (osect))
+ return osect;
}
return NULL;
list_overlays_command (const char *args, int from_tty)
{
int nmapped = 0;
- struct objfile *objfile;
struct obj_section *osect;
if (overlay_debugging)
{
- ALL_OBJSECTIONS (objfile, osect)
- if (section_is_mapped (osect))
- {
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
- 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);
-
- printf_filtered ("Section %s, loaded at ", name);
- fputs_filtered (paddress (gdbarch, lma), gdb_stdout);
- puts_filtered (" - ");
- fputs_filtered (paddress (gdbarch, lma + size), gdb_stdout);
- printf_filtered (", mapped at ");
- fputs_filtered (paddress (gdbarch, vma), gdb_stdout);
- puts_filtered (" - ");
- fputs_filtered (paddress (gdbarch, vma + size), gdb_stdout);
- puts_filtered ("\n");
-
- nmapped++;
- }
+ for (objfile *objfile : current_program_space->objfiles ())
+ ALL_OBJFILE_OSECTIONS (objfile, osect)
+ if (section_is_mapped (osect))
+ {
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ const char *name;
+ bfd_vma lma, vma;
+ int size;
+
+ 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);
+ puts_filtered (" - ");
+ fputs_filtered (paddress (gdbarch, lma + size), gdb_stdout);
+ printf_filtered (", mapped at ");
+ fputs_filtered (paddress (gdbarch, vma), gdb_stdout);
+ puts_filtered (" - ");
+ fputs_filtered (paddress (gdbarch, vma + size), gdb_stdout);
+ puts_filtered ("\n");
+
+ nmapped++;
+ }
}
if (nmapped == 0)
printf_filtered (_("No sections are mapped.\n"));
static void
map_overlay_command (const char *args, int from_tty)
{
- struct objfile *objfile, *objfile2;
struct obj_section *sec, *sec2;
if (!overlay_debugging)
error (_("Argument required: name of an overlay section"));
/* First, find a section matching the user supplied argument. */
- ALL_OBJSECTIONS (objfile, sec)
- if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
- {
- /* Now, check to see if the section is an overlay. */
- if (!section_is_overlay (sec))
- continue; /* not an overlay section */
-
- /* Mark the overlay as "mapped". */
- sec->ovly_mapped = 1;
-
- /* Next, make a pass and unmap any sections that are
- overlapped by this new section: */
- ALL_OBJSECTIONS (objfile2, sec2)
- if (sec2->ovly_mapped && sec != sec2 && sections_overlap (sec, sec2))
+ for (objfile *obj_file : current_program_space->objfiles ())
+ ALL_OBJFILE_OSECTIONS (obj_file, sec)
+ if (!strcmp (bfd_section_name (sec->the_bfd_section), args))
{
- if (info_verbose)
- printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
- bfd_section_name (objfile->obfd,
- sec2->the_bfd_section));
- sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2. */
+ /* Now, check to see if the section is an overlay. */
+ if (!section_is_overlay (sec))
+ continue; /* not an overlay section */
+
+ /* Mark the overlay as "mapped". */
+ sec->ovly_mapped = 1;
+
+ /* Next, make a pass and unmap any sections that are
+ overlapped by this new section: */
+ for (objfile *objfile2 : current_program_space->objfiles ())
+ ALL_OBJFILE_OSECTIONS (objfile2, sec2)
+ if (sec2->ovly_mapped && sec != sec2 && sections_overlap (sec,
+ sec2))
+ {
+ if (info_verbose)
+ printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
+ bfd_section_name (sec2->the_bfd_section));
+ sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2. */
+ }
+ return;
}
- return;
- }
error (_("No overlay section called %s"), args);
}
static void
unmap_overlay_command (const char *args, int from_tty)
{
- struct objfile *objfile;
struct obj_section *sec = NULL;
if (!overlay_debugging)
error (_("Argument required: name of an overlay section"));
/* First, find a section matching the user supplied argument. */
- ALL_OBJSECTIONS (objfile, sec)
- if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
- {
- if (!sec->ovly_mapped)
- error (_("Section %s is not mapped"), args);
- sec->ovly_mapped = 0;
- return;
- }
+ for (objfile *objfile : current_program_space->objfiles ())
+ ALL_OBJFILE_OSECTIONS (objfile, sec)
+ if (!strcmp (bfd_section_name (sec->the_bfd_section), args))
+ {
+ if (!sec->ovly_mapped)
+ error (_("Section %s is not mapped"), args);
+ sec->ovly_mapped = 0;
+ return;
+ }
error (_("No overlay section called %s"), args);
}
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;
void
simple_overlay_update (struct obj_section *osect)
{
- struct objfile *objfile;
-
/* Were we given an osect to look up? NULL means do all of them. */
if (osect)
/* Have we got a cached copy of the target's overlay table? */
return;
/* Now may as well update all sections, even if only one was requested. */
- ALL_OBJSECTIONS (objfile, osect)
- if (section_is_overlay (osect))
- {
- int i;
- 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))
- { /* 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. */
- }
- }
+ for (objfile *objfile : current_program_space->objfiles ())
+ ALL_OBJFILE_OSECTIONS (objfile, osect)
+ if (section_is_overlay (osect))
+ {
+ int i;
+ asection *bsect = osect->the_bfd_section;
+
+ for (i = 0; i < cache_novlys; i++)
+ 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
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
enum search_domain kind)
{
- struct objfile *objfile;
-
- ALL_OBJFILES (objfile)
- {
- if (objfile->sf)
- objfile->sf->qf->expand_symtabs_matching (objfile, file_matcher,
- lookup_name,
- symbol_matcher,
- expansion_notify, 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);
+ }
}
/* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
map_symbol_filenames (symbol_filename_ftype *fun, void *data,
int need_fullname)
{
- struct objfile *objfile;
-
- ALL_OBJFILES (objfile)
- {
- if (objfile->sf)
- objfile->sf->qf->map_symbol_filenames (objfile, fun, data,
- need_fullname);
- }
+ for (objfile *objfile : current_program_space->objfiles ())
+ {
+ if (objfile->sf)
+ objfile->sf->qf->map_symbol_filenames (objfile, fun, data,
+ need_fullname);
+ }
}
#if GDB_SELF_TEST
SELF_CHECK (lang == language_unknown);
/* Test adding a new extension using the CLI command. */
- gdb::unique_xmalloc_ptr<char> args_holder (xstrdup (".hello rust"));
+ auto args_holder = make_unique_xstrdup (".hello rust");
ext_args = args_holder.get ();
set_ext_lang_command (NULL, 1, NULL);
&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\
projects / deliverable / binutils-gdb.git / blobdiff