-/* Default child (native) target interface, for GDB when running under
- Unix.
+/* Base/prototype target for default child (native) targets.
- Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
- 1998, 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc.
+ Copyright (C) 1988-2018 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+/* This file provides a common base class/target that all native
+ target implementations extend, by calling inf_child_target to get a
+ new prototype target and then overriding target methods as
+ necessary. */
#include "defs.h"
#include "regcache.h"
#include "symtab.h"
#include "target.h"
#include "inferior.h"
-#include "gdb_string.h"
+#include <sys/stat.h>
+#include "inf-child.h"
+#include "fileio.h"
+#include "agent.h"
+#include "gdb_wait.h"
+#include "filestuff.h"
-/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
- for all registers. */
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
-static void
-inf_child_fetch_inferior_registers (int regnum)
+/* Helper function for child_wait and the derivatives of child_wait.
+ HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
+ translation of that in OURSTATUS. */
+void
+store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
{
- if (regnum == -1)
+ if (WIFEXITED (hoststatus))
+ {
+ ourstatus->kind = TARGET_WAITKIND_EXITED;
+ ourstatus->value.integer = WEXITSTATUS (hoststatus);
+ }
+ else if (!WIFSTOPPED (hoststatus))
{
- for (regnum = 0; regnum < NUM_REGS; regnum++)
- regcache_raw_supply (current_regcache, regnum, NULL);
+ ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
+ ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (hoststatus));
}
else
- regcache_raw_supply (current_regcache, regnum, NULL);
+ {
+ ourstatus->kind = TARGET_WAITKIND_STOPPED;
+ ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (hoststatus));
+ }
}
-/* Store register REGNUM back into the inferior. If REGNUM is -1, do
- this for all registers (including the floating point registers). */
-
-static void
-inf_child_store_inferior_registers (int regnum)
-{
-}
+inf_child_target::~inf_child_target ()
+{}
-static void
-inf_child_post_attach (int pid)
+void
+inf_child_target::post_attach (int pid)
{
- /* This version of Unix doesn't require a meaningful "post attach"
- operation by a debugger. */
+ /* This target doesn't require a meaningful "post attach" operation
+ by a debugger. */
}
/* Get ready to modify the registers array. On machines which store
makes sure that registers contains all the registers from the
program being debugged. */
-static void
-inf_child_prepare_to_store (void)
+void
+inf_child_target::prepare_to_store (struct regcache *regcache)
{
}
-static void
-inf_child_open (char *arg, int from_tty)
+bool
+inf_child_target::supports_terminal_ours ()
{
- error ("Use the \"run\" command to start a Unix child process.");
+ return true;
}
-static void
-inf_child_post_startup_inferior (ptid_t ptid)
+void
+inf_child_target::terminal_init ()
{
- /* This version of Unix doesn't require a meaningful "post startup
- inferior" operation by a debugger. */
+ child_terminal_init (this);
}
-static void
-inf_child_acknowledge_created_inferior (int pid)
+void
+inf_child_target::terminal_inferior ()
{
- /* This version of Unix doesn't require a meaningful "acknowledge
- created inferior" operation by a debugger. */
+ child_terminal_inferior (this);
}
-static int
-inf_child_insert_fork_catchpoint (int pid)
+void
+inf_child_target::terminal_ours_for_output ()
{
- /* This version of Unix doesn't support notification of fork
- events. */
- return 0;
+ child_terminal_ours_for_output (this);
}
-static int
-inf_child_remove_fork_catchpoint (int pid)
+void
+inf_child_target::terminal_ours ()
{
- /* This version of Unix doesn't support notification of fork
- events. */
- return 0;
+ child_terminal_ours (this);
}
-static int
-inf_child_insert_vfork_catchpoint (int pid)
+void
+inf_child_target::interrupt ()
{
- /* This version of Unix doesn't support notification of vfork
- events. */
- return 0;
+ child_interrupt (this);
}
-static int
-inf_child_remove_vfork_catchpoint (int pid)
+void
+inf_child_target::pass_ctrlc ()
{
- /* This version of Unix doesn't support notification of vfork
- events. */
- return 0;
+ child_pass_ctrlc (this);
}
-static int
-inf_child_follow_fork (int follow_child)
+void
+inf_child_target::terminal_info (const char *args, int from_tty)
{
- /* This version of Unix doesn't support following fork or vfork
- events. */
- return 0;
+ child_terminal_info (this, args, from_tty);
}
-static int
-inf_child_insert_exec_catchpoint (int pid)
+/* True if the user did "target native". In that case, we won't
+ unpush the child target automatically when the last inferior is
+ gone. */
+static int inf_child_explicitly_opened;
+
+/* See inf-child.h. */
+
+void
+inf_child_open_target (struct target_ops *target, const char *arg,
+ int from_tty)
{
- /* This version of Unix doesn't support notification of exec
- events. */
- return 0;
+ target_preopen (from_tty);
+ push_target (target);
+ inf_child_explicitly_opened = 1;
+ if (from_tty)
+ printf_filtered ("Done. Use the \"run\" command to start a process.\n");
}
-static int
-inf_child_remove_exec_catchpoint (int pid)
+void
+inf_child_target::open (const char *arg, int from_tty)
{
- /* This version of Unix doesn't support notification of exec
- events. */
- return 0;
+ inf_child_open_target (this, arg, from_tty);
}
-static int
-inf_child_reported_exec_events_per_exec_call (void)
+/* Implement the to_disconnect target_ops method. */
+
+void
+inf_child_target::disconnect (const char *args, int from_tty)
{
- /* This version of Unix doesn't support notification of exec
- events. */
- return 1;
+ if (args != NULL)
+ error (_("Argument given to \"disconnect\"."));
+
+ /* This offers to detach/kill current inferiors, and then pops all
+ targets. */
+ target_preopen (from_tty);
+}
+
+/* Implement the to_close target_ops method. */
+
+void
+inf_child_target::close ()
+{
+ /* In case we were forcibly closed. */
+ inf_child_explicitly_opened = 0;
+}
+
+void
+inf_child_target::mourn_inferior ()
+{
+ generic_mourn_inferior ();
+ maybe_unpush_target ();
+}
+
+/* See inf-child.h. */
+
+void
+inf_child_target::maybe_unpush_target ()
+{
+ if (!inf_child_explicitly_opened && !have_inferiors ())
+ unpush_target (this);
+}
+
+void
+inf_child_target::post_startup_inferior (ptid_t ptid)
+{
+ /* This target doesn't require a meaningful "post startup inferior"
+ operation by a debugger. */
}
-static int
-inf_child_can_run (void)
+int
+inf_child_target::can_run ()
{
return 1;
}
-static struct symtab_and_line *
-inf_child_enable_exception_callback (enum exception_event_kind kind,
- int enable)
+bool
+inf_child_target::can_create_inferior ()
{
- return (struct symtab_and_line *) NULL;
+ return true;
}
-static struct exception_event_record *
-inf_child_get_current_exception_event (void)
+bool
+inf_child_target::can_attach ()
{
- return (struct exception_event_record *) NULL;
+ return true;
}
-static char *
-inf_child_pid_to_exec_file (int pid)
+char *
+inf_child_target::pid_to_exec_file (int pid)
{
- /* This version of Unix doesn't support translation of a process ID
- to the filename of the executable file. */
+ /* This target doesn't support translation of a process ID to the
+ filename of the executable file. */
return NULL;
}
-struct target_ops *
-inf_child_target (void)
-{
- struct target_ops *t = XZALLOC (struct target_ops);
- t->to_shortname = "child";
- t->to_longname = "Unix child process";
- t->to_doc = "Unix child process (started by the \"run\" command).";
- t->to_open = inf_child_open;
- t->to_post_attach = inf_child_post_attach;
- t->to_fetch_registers = inf_child_fetch_inferior_registers;
- t->to_store_registers = inf_child_store_inferior_registers;
- t->to_prepare_to_store = inf_child_prepare_to_store;
- t->to_insert_breakpoint = memory_insert_breakpoint;
- t->to_remove_breakpoint = memory_remove_breakpoint;
- t->to_terminal_init = terminal_init_inferior;
- t->to_terminal_inferior = terminal_inferior;
- t->to_terminal_ours_for_output = terminal_ours_for_output;
- t->to_terminal_save_ours = terminal_save_ours;
- t->to_terminal_ours = terminal_ours;
- t->to_terminal_info = child_terminal_info;
- t->to_post_startup_inferior = inf_child_post_startup_inferior;
- t->to_acknowledge_created_inferior = inf_child_acknowledge_created_inferior;
- t->to_insert_fork_catchpoint = inf_child_insert_fork_catchpoint;
- t->to_remove_fork_catchpoint = inf_child_remove_fork_catchpoint;
- t->to_insert_vfork_catchpoint = inf_child_insert_vfork_catchpoint;
- t->to_remove_vfork_catchpoint = inf_child_remove_vfork_catchpoint;
- t->to_follow_fork = inf_child_follow_fork;
- t->to_insert_exec_catchpoint = inf_child_insert_exec_catchpoint;
- t->to_remove_exec_catchpoint = inf_child_remove_exec_catchpoint;
- t->to_reported_exec_events_per_exec_call =
- inf_child_reported_exec_events_per_exec_call;
- t->to_can_run = inf_child_can_run;
- t->to_enable_exception_callback = inf_child_enable_exception_callback;
- t->to_get_current_exception_event = inf_child_get_current_exception_event;
- t->to_pid_to_exec_file = inf_child_pid_to_exec_file;
- t->to_stratum = process_stratum;
- t->to_has_all_memory = 1;
- t->to_has_memory = 1;
- t->to_has_stack = 1;
- t->to_has_registers = 1;
- t->to_has_execution = 1;
- t->to_magic = OPS_MAGIC;
- return t;
+int
+inf_child_target::has_all_memory ()
+{
+ return default_child_has_all_memory ();
+}
+
+int
+inf_child_target::has_memory ()
+{
+ return default_child_has_memory ();
+}
+
+int
+inf_child_target::has_stack ()
+{
+ return default_child_has_stack ();
+}
+
+int
+inf_child_target::has_registers ()
+{
+ return default_child_has_registers ();
+}
+
+int
+inf_child_target::has_execution (ptid_t ptid)
+{
+ return default_child_has_execution (ptid);
+}
+
+/* Implementation of to_fileio_open. */
+
+int
+inf_child_target::fileio_open (struct inferior *inf, const char *filename,
+ int flags, int mode, int warn_if_slow,
+ int *target_errno)
+{
+ int nat_flags;
+ mode_t nat_mode;
+ int fd;
+
+ if (fileio_to_host_openflags (flags, &nat_flags) == -1
+ || fileio_to_host_mode (mode, &nat_mode) == -1)
+ {
+ *target_errno = FILEIO_EINVAL;
+ return -1;
+ }
+
+ fd = gdb_open_cloexec (filename, nat_flags, nat_mode);
+ if (fd == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return fd;
+}
+
+/* Implementation of to_fileio_pwrite. */
+
+int
+inf_child_target::fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
+ ULONGEST offset, int *target_errno)
+{
+ int ret;
+
+#ifdef HAVE_PWRITE
+ ret = pwrite (fd, write_buf, len, (long) offset);
+#else
+ ret = -1;
+#endif
+ /* If we have no pwrite or it failed for this file, use lseek/write. */
+ if (ret == -1)
+ {
+ ret = lseek (fd, (long) offset, SEEK_SET);
+ if (ret != -1)
+ ret = write (fd, write_buf, len);
+ }
+
+ if (ret == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return ret;
+}
+
+/* Implementation of to_fileio_pread. */
+
+int
+inf_child_target::fileio_pread (int fd, gdb_byte *read_buf, int len,
+ ULONGEST offset, int *target_errno)
+{
+ int ret;
+
+#ifdef HAVE_PREAD
+ ret = pread (fd, read_buf, len, (long) offset);
+#else
+ ret = -1;
+#endif
+ /* If we have no pread or it failed for this file, use lseek/read. */
+ if (ret == -1)
+ {
+ ret = lseek (fd, (long) offset, SEEK_SET);
+ if (ret != -1)
+ ret = read (fd, read_buf, len);
+ }
+
+ if (ret == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return ret;
+}
+
+/* Implementation of to_fileio_fstat. */
+
+int
+inf_child_target::fileio_fstat (int fd, struct stat *sb, int *target_errno)
+{
+ int ret;
+
+ ret = fstat (fd, sb);
+ if (ret == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return ret;
+}
+
+/* Implementation of to_fileio_close. */
+
+int
+inf_child_target::fileio_close (int fd, int *target_errno)
+{
+ int ret;
+
+ ret = ::close (fd);
+ if (ret == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return ret;
+}
+
+/* Implementation of to_fileio_unlink. */
+
+int
+inf_child_target::fileio_unlink (struct inferior *inf, const char *filename,
+ int *target_errno)
+{
+ int ret;
+
+ ret = unlink (filename);
+ if (ret == -1)
+ *target_errno = host_to_fileio_error (errno);
+
+ return ret;
+}
+
+/* Implementation of to_fileio_readlink. */
+
+gdb::optional<std::string>
+inf_child_target::fileio_readlink (struct inferior *inf, const char *filename,
+ int *target_errno)
+{
+ /* We support readlink only on systems that also provide a compile-time
+ maximum path length (PATH_MAX), at least for now. */
+#if defined (PATH_MAX)
+ char buf[PATH_MAX];
+ int len;
+
+ len = readlink (filename, buf, sizeof buf);
+ if (len < 0)
+ {
+ *target_errno = host_to_fileio_error (errno);
+ return {};
+ }
+
+ return std::string (buf, len);
+#else
+ *target_errno = FILEIO_ENOSYS;
+ return {};
+#endif
+}
+
+int
+inf_child_target::use_agent (int use)
+{
+ if (agent_loaded_p ())
+ {
+ ::use_agent = use;
+ return 1;
+ }
+ else
+ return 0;
+}
+
+int
+inf_child_target::can_use_agent ()
+{
+ return agent_loaded_p ();
+}
+
+inf_child_target::inf_child_target ()
+{
+ this->to_stratum = process_stratum;
}
projects / thirdparty / binutils-gdb.git / blobdiff