/* Work with executable files, for GDB.
- Copyright (C) 1988-2019 Free Software Foundation, Inc.
+ Copyright (C) 1988-2020 Free Software Foundation, Inc.
This file is part of GDB.
#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 "build-id.h"
#include <fcntl.h>
-#include "readline/readline.h"
+#include "readline/tilde.h"
#include "gdbcore.h"
#include <ctype.h>
#include "solist.h"
#include <algorithm>
#include "gdbsupport/pathstuff.h"
+#include "cli/cli-style.h"
void (*deprecated_file_changed_hook) (const char *);
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. */
bool write_files = false;
void
exec_target::close ()
{
- struct program_space *ss;
scoped_restore_current_program_space restore_pspace;
- ALL_PSPACES (ss)
+ for (struct program_space *ss : program_spaces)
{
set_current_program_space (ss);
clear_section_table (current_target_sections);
/* 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);
+ bool build_id_mismatch = false;
+
+ /* If we cannot validate the exec file, return. */
+ if (current_exec_file == NULL || pid_exec_file == NULL)
+ return;
+
+ /* Try validating via build-id, if available. This is the most
+ reliable check. */
+ const bfd_build_id *exec_file_build_id = build_id_bfd_get (exec_bfd);
+ if (exec_file_build_id != nullptr)
+ {
+ /* Prepend the target prefix, to force gdb_bfd_open to open the
+ file on the remote file system (if indeed remote). */
+ std::string target_pid_exec_file
+ = std::string (TARGET_SYSROOT_PREFIX) + pid_exec_file;
+
+ gdb_bfd_ref_ptr abfd (gdb_bfd_open (target_pid_exec_file.c_str (),
+ gnutarget, -1, false));
+ if (abfd != nullptr)
+ {
+ const bfd_build_id *target_exec_file_build_id
+ = build_id_bfd_get (abfd.get ());
+
+ if (target_exec_file_build_id != nullptr)
+ {
+ if (exec_file_build_id->size == target_exec_file_build_id->size
+ && memcmp (exec_file_build_id->data,
+ target_exec_file_build_id->data,
+ exec_file_build_id->size) == 0)
+ {
+ /* Match. */
+ return;
+ }
+ else
+ build_id_mismatch = true;
+ }
+ }
+ }
+
+ if (build_id_mismatch)
+ {
+ 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;
+
+ 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. */
+
void
exec_file_locate_attach (int pid, int defer_bp_reset, int from_tty)
{
#if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
if (scratch_chan < 0)
{
+ int first_errno = errno;
char *exename = (char *) alloca (strlen (filename) + 5);
strcat (strcpy (exename, filename), ".exe");
O_RDWR | O_BINARY
: O_RDONLY | O_BINARY,
&scratch_storage);
+ if (scratch_chan < 0)
+ errno = first_errno;
}
#endif
if (scratch_chan < 0)
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,
+ error (_("\"%ps\": not in executable format: %s"),
+ styled_string (file_name_style.style (), scratch_pathname),
gdb_bfd_errmsg (bfd_get_error (), matching).c_str ());
}
/* 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);
unsigned count;
count = bfd_count_sections (some_bfd);
- if (*start)
- xfree (* start);
+ xfree (*start);
*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);
+ }
}
}
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
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++)
{
/* 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)
}
}
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)
hex_string_custom (psect->filepos, 8));
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");
}
}
table = current_target_sections;
for (p = table->sections; p < table->sections_end; p++)
{
- if (filename_cmp (filename, p->the_bfd_section->owner->filename) == 0
+ if (filename_cmp (filename,
+ bfd_get_filename (p->the_bfd_section->owner)) == 0
&& index == p->the_bfd_section->index)
{
p->endaddr += address - p->addr;
return objfile_find_memory_regions (this, func, data);
}
+void _initialize_exec ();
void
-_initialize_exec (void)
+_initialize_exec ()
{
struct cmd_list_element *c;
show_write_files,
&setlist, &showlist);
+ 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\n\
+loaded by GDB and the exec-file 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);
}
projects / deliverable / binutils-gdb.git / blobdiff