/* Work with executable files, for GDB.
- Copyright (C) 1988-2018 Free Software Foundation, Inc.
+ Copyright (C) 1988-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "completer.h"
#include "value.h"
#include "exec.h"
-#include "observer.h"
+#include "observable.h"
#include "arch-utils.h"
#include "gdbthread.h"
#include "progspace.h"
+#include "progspace-and-thread.h"
#include "gdb_bfd.h"
#include "gcore.h"
#include "source.h"
#include <fcntl.h>
-#include "readline/readline.h"
+#include "readline/tilde.h"
#include "gdbcore.h"
#include <ctype.h>
#include <sys/stat.h>
#include "solist.h"
#include <algorithm>
-#include "common/pathstuff.h"
+#include "gdbsupport/pathstuff.h"
+#include "cli/cli-style.h"
void (*deprecated_file_changed_hook) (const char *);
-/* Prototypes for local functions */
-
-static void exec_files_info (struct target_ops *);
-
-static void init_exec_ops (void);
+static const target_info exec_target_info = {
+ "exec",
+ N_("Local exec file"),
+ N_("Use an executable file as a target.\n\
+Specify the filename of the executable file.")
+};
/* The target vector for executable files. */
-static struct target_ops exec_ops;
+struct exec_target final : public target_ops
+{
+ const target_info &info () const override
+ { return exec_target_info; }
+
+ strata stratum () const override { return file_stratum; }
+
+ void close () override;
+ enum target_xfer_status xfer_partial (enum target_object object,
+ const char *annex,
+ gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len) override;
+ struct target_section_table *get_section_table () override;
+ void files_info () override;
+
+ bool has_memory () override;
+ char *make_corefile_notes (bfd *, int *) override;
+ int find_memory_regions (find_memory_region_ftype func, void *data) override;
+};
+
+static exec_target exec_ops;
+
+/* How to handle a mismatch between the current exec file and the exec
+ file determined from target. */
+
+static const char *const exec_file_mismatch_names[]
+ = {"ask", "warn", "off", NULL };
+enum exec_file_mismatch_mode
+ {
+ exec_file_mismatch_ask, exec_file_mismatch_warn, exec_file_mismatch_off
+ };
+static const char *exec_file_mismatch = exec_file_mismatch_names[0];
+static enum exec_file_mismatch_mode exec_file_mismatch_mode
+ = exec_file_mismatch_ask;
+
+/* Show command. */
+static void
+show_exec_file_mismatch_command (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (gdb_stdout,
+ _("exec-file-mismatch handling is currently \"%s\".\n"),
+ exec_file_mismatch_names[exec_file_mismatch_mode]);
+}
+
+/* Set command. Change the setting for range checking. */
+static void
+set_exec_file_mismatch_command (const char *ignore,
+ int from_tty, struct cmd_list_element *c)
+{
+ for (enum exec_file_mismatch_mode mode = exec_file_mismatch_ask;
+ ;
+ mode = static_cast<enum exec_file_mismatch_mode>(1 + (int) mode))
+ {
+ if (strcmp (exec_file_mismatch, exec_file_mismatch_names[mode]) == 0)
+ {
+ exec_file_mismatch_mode = mode;
+ return;
+ }
+ if (mode == exec_file_mismatch_off)
+ internal_error (__FILE__, __LINE__,
+ _("Unrecognized exec-file-mismatch setting: \"%s\""),
+ exec_file_mismatch);
+ }
+}
/* Whether to open exec and core files read-only or read-write. */
-int write_files = 0;
+bool write_files = false;
static void
show_write_files (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
static void
-exec_open (const char *args, int from_tty)
+exec_target_open (const char *args, int from_tty)
{
target_preopen (from_tty);
exec_file_attach (args, from_tty);
/* This is the target_close implementation. Clears all target
sections and closes all executable bfds from all program spaces. */
-static void
-exec_close_1 (struct target_ops *self)
+void
+exec_target::close ()
{
struct program_space *ss;
scoped_restore_current_program_space restore_pspace;
}
}
-void
-exec_file_clear (int from_tty)
-{
- /* Remove exec file. */
- exec_close ();
-
- if (from_tty)
- printf_unfiltered (_("No executable file now.\n"));
-}
-
-/* See exec.h. */
+/* See gdbcore.h. */
void
try_open_exec_file (const char *exec_file_host, struct inferior *inf,
symfile_add_flags add_flags)
{
- struct cleanup *old_chain;
- struct gdb_exception prev_err = exception_none;
-
- old_chain = make_cleanup (free_current_contents, &prev_err.message);
+ struct gdb_exception prev_err;
/* exec_file_attach and symbol_file_add_main may throw an error if the file
cannot be opened either locally or remotely.
Even without a symbol file, the remote-based debugging session should
continue normally instead of ending abruptly. Hence we catch thrown
errors/exceptions in the following code. */
- TRY
+ try
{
/* We must do this step even if exec_file_host is NULL, so that
exec_file_attach will clear state. */
exec_file_attach (exec_file_host, add_flags & SYMFILE_VERBOSE);
}
- CATCH (err, RETURN_MASK_ERROR)
+ catch (gdb_exception_error &err)
{
if (err.message != NULL)
- warning ("%s", err.message);
-
- prev_err = err;
+ warning ("%s", err.what ());
- /* Save message so it doesn't get trashed by the catch below. */
- if (err.message != NULL)
- prev_err.message = xstrdup (err.message);
+ prev_err = std::move (err);
}
- END_CATCH
if (exec_file_host != NULL)
{
- TRY
+ try
{
symbol_file_add_main (exec_file_host, add_flags);
}
- CATCH (err, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &err)
{
if (!exception_print_same (prev_err, err))
- warning ("%s", err.message);
+ warning ("%s", err.what ());
}
- END_CATCH
}
+}
+
+/* See gdbcore.h. */
+
+void
+validate_exec_file (int from_tty)
+{
+ /* If user asked to ignore the mismatch, do nothing. */
+ if (exec_file_mismatch_mode == exec_file_mismatch_off)
+ return;
+
+ const char *current_exec_file = get_exec_file (0);
+ struct inferior *inf = current_inferior ();
+ /* Try to determine a filename from the process itself. */
+ const char *pid_exec_file = target_pid_to_exec_file (inf->pid);
+
+ /* If wee cannot validate the exec file, return. */
+ if (current_exec_file == NULL || pid_exec_file == NULL)
+ return;
- do_cleanups (old_chain);
+ std::string exec_file_target (pid_exec_file);
+
+ /* In case the exec file is not local, exec_file_target has to point at
+ the target file system. */
+ if (is_target_filename (current_exec_file) && !target_filesystem_is_local ())
+ exec_file_target = TARGET_SYSROOT_PREFIX + exec_file_target;
+
+ if (exec_file_target != current_exec_file)
+ {
+ warning
+ (_("Mismatch between current exec-file %ps\n"
+ "and automatically determined exec-file %ps\n"
+ "exec-file-mismatch handling is currently \"%s\""),
+ styled_string (file_name_style.style (), current_exec_file),
+ styled_string (file_name_style.style (), exec_file_target.c_str ()),
+ exec_file_mismatch_names[exec_file_mismatch_mode]);
+ if (exec_file_mismatch_mode == exec_file_mismatch_ask)
+ {
+ symfile_add_flags add_flags = SYMFILE_MAINLINE;
+ if (from_tty)
+ add_flags |= SYMFILE_VERBOSE;
+ try
+ {
+ symbol_file_add_main (exec_file_target.c_str (), add_flags);
+ exec_file_attach (exec_file_target.c_str (), from_tty);
+ }
+ catch (gdb_exception_error &err)
+ {
+ warning (_("loading %ps %s"),
+ styled_string (file_name_style.style (),
+ exec_file_target.c_str ()),
+ err.message != NULL ? err.what () : "error");
+ }
+ }
+ }
}
/* See gdbcore.h. */
/* First, acquire a reference to the current exec_bfd. We release
this at the end of the function; but acquiring it now lets the
BFD cache return it if this call refers to the same file. */
- gdb_bfd_ref_ptr exec_bfd_holder = new_bfd_ref (exec_bfd);
+ gdb_bfd_ref_ptr exec_bfd_holder = gdb_bfd_ref_ptr::new_reference (exec_bfd);
/* Remove any previous exec file. */
exec_close ();
if (!exec_bfd)
{
- error (_("\"%s\": could not open as an executable file: %s."),
- scratch_pathname, bfd_errmsg (bfd_get_error ()));
+ error (_("\"%ps\": could not open as an executable file: %s."),
+ styled_string (file_name_style.style (), scratch_pathname),
+ bfd_errmsg (bfd_get_error ()));
}
/* gdb_realpath_keepfile resolves symlinks on the local
/* Make sure to close exec_bfd, or else "run" might try to use
it. */
exec_close ();
- error (_("\"%s\": not in executable format: %s"),
- scratch_pathname,
- gdb_bfd_errmsg (bfd_get_error (), matching));
+ error (_("\"%ps\": not in executable format: %s"),
+ styled_string (file_name_style.style (), scratch_pathname),
+ gdb_bfd_errmsg (bfd_get_error (), matching).c_str ());
}
if (build_section_table (exec_bfd, §ions, §ions_end))
/* Make sure to close exec_bfd, or else "run" might try to use
it. */
exec_close ();
- error (_("\"%s\": can't find the file sections: %s"),
- scratch_pathname, bfd_errmsg (bfd_get_error ()));
+ error (_("\"%ps\": can't find the file sections: %s"),
+ styled_string (file_name_style.style (), scratch_pathname),
+ bfd_errmsg (bfd_get_error ()));
}
exec_bfd_mtime = bfd_get_mtime (exec_bfd);
}
bfd_cache_close_all ();
- observer_notify_executable_changed ();
+ gdb::observers::executable_changed.notify ();
}
/* Process the first arg in ARGS as the new exec file.
encountered on sparc-solaris 2.10 a shared library with an empty .bss
section to which a symbol named "_end" was attached. The address
of this symbol still needs to be relocated. */
- aflag = bfd_get_section_flags (abfd, asect);
+ aflag = bfd_section_flags (asect);
if (!(aflag & SEC_ALLOC))
return;
(*table_pp)->owner = NULL;
(*table_pp)->the_bfd_section = asect;
- (*table_pp)->addr = bfd_section_vma (abfd, asect);
- (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
+ (*table_pp)->addr = bfd_section_vma (asect);
+ (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (asect);
(*table_pp)++;
}
*start = XNEWVEC (struct target_section, count);
*end = *start;
bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
- if (*end > *start + count)
- internal_error (__FILE__, __LINE__,
- _("failed internal consistency check"));
+
+ gdb_assert (*end <= *start + count);
+
/* We could realloc the table, but it probably loses for most files. */
return 0;
}
table->sections[space + i].owner = owner;
}
+ scoped_restore_current_pspace_and_thread restore_pspace_thread;
+ program_space *curr_pspace = current_program_space;
+
/* If these are the first file sections we can provide memory
- from, push the file_stratum target. */
- if (!target_is_pushed (&exec_ops))
- push_target (&exec_ops);
+ from, push the file_stratum target. Must do this in all
+ inferiors sharing the program space. */
+ for (inferior *inf : all_inferiors ())
+ {
+ if (inf->pspace != curr_pspace)
+ continue;
+
+ if (inf->target_is_pushed (&exec_ops))
+ continue;
+
+ switch_to_inferior_no_thread (inf);
+ push_target (&exec_ops);
+ }
}
}
/* Compute the number of sections to add. */
ALL_OBJFILE_OSECTIONS (objfile, osect)
{
- if (bfd_get_section_size (osect->the_bfd_section) == 0)
+ if (bfd_section_size (osect->the_bfd_section) == 0)
continue;
count++;
}
ALL_OBJFILE_OSECTIONS (objfile, osect)
{
- if (bfd_get_section_size (osect->the_bfd_section) == 0)
+ if (bfd_section_size (osect->the_bfd_section) == 0)
continue;
gdb_assert (ts < table->sections + space + count);
old_count = resize_section_table (table, dest - src);
/* If we don't have any more sections to read memory from,
- remove the file_stratum target from the stack. */
+ remove the file_stratum target from the stack of each
+ inferior sharing the program space. */
if (old_count + (dest - src) == 0)
{
- struct program_space *pspace;
+ scoped_restore_current_pspace_and_thread restore_pspace_thread;
+ program_space *curr_pspace = current_program_space;
+
+ for (inferior *inf : all_inferiors ())
+ {
+ if (inf->pspace != curr_pspace)
+ continue;
- ALL_PSPACES (pspace)
- if (pspace->target_sections.sections
- != pspace->target_sections.sections_end)
- return;
+ if (inf->pspace->target_sections.sections
+ != inf->pspace->target_sections.sections_end)
+ continue;
- unpush_target (&exec_ops);
+ switch_to_inferior_no_thread (inf);
+ unpush_target (&exec_ops);
+ }
}
}
}
+/* See exec.h. */
+
+void
+exec_on_vfork ()
+{
+ if (current_program_space->target_sections.sections
+ != current_program_space->target_sections.sections_end)
+ push_target (&exec_ops);
+}
+
\f
enum target_xfer_status
continue;
vma = s->vma;
- size = bfd_get_section_size (s);
+ size = bfd_section_size (s);
if (vma <= offset && offset < (vma + size))
{
ULONGEST amt;
for (target_section *p = sections; p < sections_end; p++)
{
- if ((bfd_get_section_flags (p->the_bfd_section->owner,
- p->the_bfd_section)
- & SEC_READONLY) == 0)
+ if ((bfd_section_flags (p->the_bfd_section) & SEC_READONLY) == 0)
continue;
/* Copy the meta-data, adjusted. */
ULONGEST memaddr = offset;
ULONGEST memend = memaddr + len;
- if (len == 0)
- internal_error (__FILE__, __LINE__,
- _("failed internal consistency check"));
+ gdb_assert (len != 0);
for (p = sections; p < sections_end; p++)
{
return TARGET_XFER_EOF; /* We can't help. */
}
-static struct target_section_table *
-exec_get_section_table (struct target_ops *ops)
+struct target_section_table *
+exec_target::get_section_table ()
{
return current_target_sections;
}
-static enum target_xfer_status
-exec_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf,
- ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
+enum target_xfer_status
+exec_target::xfer_partial (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
{
- struct target_section_table *table = target_get_section_table (ops);
+ struct target_section_table *table = get_section_table ();
if (object == TARGET_OBJECT_MEMORY)
return section_table_xfer_memory_partial (readbuf, writebuf,
/* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
- printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
+ printf_filtered ("\t`%ps', ",
+ styled_string (file_name_style.style (),
+ bfd_get_filename (abfd)));
wrap_here (" ");
printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
if (abfd == exec_bfd)
for (p = t->sections; p < t->sections_end; p++)
{
struct bfd_section *psect = p->the_bfd_section;
- bfd *pbfd = psect->owner;
- if ((bfd_get_section_flags (pbfd, psect) & (SEC_ALLOC | SEC_LOAD))
+ if ((bfd_section_flags (psect) & (SEC_ALLOC | SEC_LOAD))
!= (SEC_ALLOC | SEC_LOAD))
continue;
- if (bfd_get_section_vma (pbfd, psect) <= abfd->start_address
- && abfd->start_address < (bfd_get_section_vma (pbfd, psect)
- + bfd_get_section_size (psect)))
+ if (bfd_section_vma (psect) <= abfd->start_address
+ && abfd->start_address < (bfd_section_vma (psect)
+ + bfd_section_size (psect)))
{
- displacement = p->addr - bfd_get_section_vma (pbfd, psect);
+ displacement = p->addr - bfd_section_vma (psect);
break;
}
}
if (p == t->sections_end)
- warning (_("Cannot find section for the entry point of %s."),
- bfd_get_filename (abfd));
+ warning (_("Cannot find section for the entry point of %ps."),
+ styled_string (file_name_style.style (),
+ bfd_get_filename (abfd)));
entry_point = gdbarch_addr_bits_remove (gdbarch,
bfd_get_start_address (abfd)
if (info_verbose)
printf_filtered (" @ %s",
hex_string_custom (psect->filepos, 8));
- printf_filtered (" is %s", bfd_section_name (pbfd, psect));
+ printf_filtered (" is %s", bfd_section_name (psect));
if (pbfd != abfd)
- printf_filtered (" in %s", bfd_get_filename (pbfd));
+ printf_filtered (" in %ps",
+ styled_string (file_name_style.style (),
+ bfd_get_filename (pbfd)));
printf_filtered ("\n");
}
}
-static void
-exec_files_info (struct target_ops *t)
+void
+exec_target::files_info ()
{
if (exec_bfd)
print_section_info (current_target_sections, exec_bfd);
table = current_target_sections;
for (p = table->sections; p < table->sections_end; p++)
{
- if (!strncmp (secname, bfd_section_name (p->bfd,
- p->the_bfd_section), seclen)
- && bfd_section_name (p->bfd, p->the_bfd_section)[seclen] == '\0')
+ if (!strncmp (secname, bfd_section_name (p->the_bfd_section), seclen)
+ && bfd_section_name (p->the_bfd_section)[seclen] == '\0')
{
offset = secaddr - p->addr;
p->addr += offset;
p->endaddr += offset;
if (from_tty)
- exec_files_info (&exec_ops);
+ exec_ops.files_info ();
return;
}
}
}
}
-/* If mourn is being called in all the right places, this could be say
- `gdb internal error' (since generic_mourn calls
- breakpoint_init_inferior). */
-
-static int
-ignore (struct target_ops *ops, struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- return 0;
-}
-
-/* Implement the to_remove_breakpoint method. */
-
-static int
-exec_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt,
- enum remove_bp_reason reason)
-{
- return 0;
-}
-
-static int
-exec_has_memory (struct target_ops *ops)
+bool
+exec_target::has_memory ()
{
/* We can provide memory if we have any file/target sections to read
from. */
!= current_target_sections->sections_end);
}
-static char *
-exec_make_note_section (struct target_ops *self, bfd *obfd, int *note_size)
+char *
+exec_target::make_corefile_notes (bfd *obfd, int *note_size)
{
error (_("Can't create a corefile"));
}
-/* Fill in the exec file target vector. Very few entries need to be
- defined. */
-
-static void
-init_exec_ops (void)
+int
+exec_target::find_memory_regions (find_memory_region_ftype func, void *data)
{
- exec_ops.to_shortname = "exec";
- exec_ops.to_longname = "Local exec file";
- exec_ops.to_doc = "Use an executable file as a target.\n\
-Specify the filename of the executable file.";
- exec_ops.to_open = exec_open;
- exec_ops.to_close = exec_close_1;
- exec_ops.to_xfer_partial = exec_xfer_partial;
- exec_ops.to_get_section_table = exec_get_section_table;
- exec_ops.to_files_info = exec_files_info;
- exec_ops.to_insert_breakpoint = ignore;
- exec_ops.to_remove_breakpoint = exec_remove_breakpoint;
- exec_ops.to_stratum = file_stratum;
- exec_ops.to_has_memory = exec_has_memory;
- exec_ops.to_make_corefile_notes = exec_make_note_section;
- exec_ops.to_find_memory_regions = objfile_find_memory_regions;
- exec_ops.to_magic = OPS_MAGIC;
+ return objfile_find_memory_regions (this, func, data);
}
+void _initialize_exec ();
void
-_initialize_exec (void)
+_initialize_exec ()
{
struct cmd_list_element *c;
- init_exec_ops ();
-
if (!dbx_commands)
{
c = add_cmd ("file", class_files, file_command, _("\
show_write_files,
&setlist, &showlist);
- add_target_with_completer (&exec_ops, filename_completer);
+ add_setshow_enum_cmd ("exec-file-mismatch", class_support,
+ exec_file_mismatch_names,
+ &exec_file_mismatch,
+ _("\
+Set exec-file-mismatch handling (ask|warn|off)."),
+ _("\
+Show exec-file-mismatch handling (ask|warn|off)."),
+ _("\
+Specifies how to handle a mismatch between the current exec-file name\n\
+loaded by GDB and the exec-file name automatically determined when attaching\n\
+to a process:\n\n\
+ ask - warn the user and ask whether to load the determined exec-file.\n\
+ warn - warn the user, but do not change the exec-file.\n\
+ off - do not check for mismatch."),
+ set_exec_file_mismatch_command,
+ show_exec_file_mismatch_command,
+ &setlist, &showlist);
+
+ add_target (exec_target_info, exec_target_open, filename_completer);
}