\f
+inf_ptrace_target::~inf_ptrace_target ()
+{}
+
#ifdef PT_GET_PROCESS_STATE
/* Target hook for follow_fork. On entry and at return inferior_ptid is
the ptid of the followed inferior. */
-static int
-inf_ptrace_follow_fork (struct target_ops *ops, int follow_child,
- int detach_fork)
+int
+inf_ptrace_target::follow_fork (int follow_child, int detach_fork)
{
if (!follow_child)
{
return 0;
}
-static int
-inf_ptrace_insert_fork_catchpoint (struct target_ops *self, int pid)
+int
+inf_ptrace_target::insert_fork_catchpoint (int pid)
{
return 0;
}
-static int
-inf_ptrace_remove_fork_catchpoint (struct target_ops *self, int pid)
+int
+inf_ptrace_target::remove_fork_catchpoint (int pid)
{
return 0;
}
ENV is the environment vector to pass. If FROM_TTY is non-zero, be
chatty about it. */
-static void
-inf_ptrace_create_inferior (struct target_ops *ops,
- const char *exec_file, const std::string &allargs,
- char **env, int from_tty)
+void
+inf_ptrace_target::create_inferior (const char *exec_file,
+ const std::string &allargs,
+ char **env, int from_tty)
{
pid_t pid;
ptid_t ptid;
/* Do not change either targets above or the same target if already present.
The reason is the target stack is shared across multiple inferiors. */
- int ops_already_pushed = target_is_pushed (ops);
+ int ops_already_pushed = target_is_pushed (this);
target_unpush_up unpusher;
if (! ops_already_pushed)
{
/* Clear possible core file with its process_stratum. */
- push_target (ops);
- unpusher.reset (ops);
+ push_target (this);
+ unpusher.reset (this);
}
pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
#ifdef PT_GET_PROCESS_STATE
-static void
-inf_ptrace_post_startup_inferior (struct target_ops *self, ptid_t pid)
+void
+inf_ptrace_target::post_startup_inferior (ptid_t pid)
{
ptrace_event_t pe;
/* Clean up a rotting corpse of an inferior after it died. */
-static void
-inf_ptrace_mourn_inferior (struct target_ops *ops)
+void
+inf_ptrace_target::mourn_inferior ()
{
int status;
only report its exit status to its original parent. */
waitpid (ptid_get_pid (inferior_ptid), &status, 0);
- inf_child_mourn_inferior (ops);
+ inf_child_target::mourn_inferior ();
}
/* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
be chatty about it. */
-static void
-inf_ptrace_attach (struct target_ops *ops, const char *args, int from_tty)
+void
+inf_ptrace_target::attach (const char *args, int from_tty)
{
char *exec_file;
pid_t pid;
/* Do not change either targets above or the same target if already present.
The reason is the target stack is shared across multiple inferiors. */
- int ops_already_pushed = target_is_pushed (ops);
+ int ops_already_pushed = target_is_pushed (this);
pid = parse_pid_to_attach (args);
{
/* target_pid_to_str already uses the target. Also clear possible core
file with its process_stratum. */
- push_target (ops);
- unpusher.reset (ops);
+ push_target (this);
+ unpusher.reset (this);
}
if (from_tty)
#ifdef PT_GET_PROCESS_STATE
-static void
-inf_ptrace_post_attach (struct target_ops *self, int pid)
+void
+inf_ptrace_target::post_attach (int pid)
{
ptrace_event_t pe;
/* Detach from the inferior. If FROM_TTY is non-zero, be chatty about it. */
-static void
-inf_ptrace_detach (struct target_ops *ops, inferior *inf, int from_tty)
+void
+inf_ptrace_target::detach (inferior *inf, int from_tty)
{
pid_t pid = ptid_get_pid (inferior_ptid);
error (_("This system does not support detaching from a process"));
#endif
- inf_ptrace_detach_success (ops, inf);
+ detach_success (inf);
}
/* See inf-ptrace.h. */
void
-inf_ptrace_detach_success (struct target_ops *ops, inferior *inf)
+inf_ptrace_target::detach_success (inferior *inf)
{
inferior_ptid = null_ptid;
detach_inferior (inf);
- inf_child_maybe_unpush_target (ops);
+ maybe_unpush_target ();
}
/* Kill the inferior. */
-static void
-inf_ptrace_kill (struct target_ops *ops)
+void
+inf_ptrace_target::kill ()
{
pid_t pid = ptid_get_pid (inferior_ptid);
int status;
STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
that signal. */
-static void
-inf_ptrace_resume (struct target_ops *ops,
- ptid_t ptid, int step, enum gdb_signal signal)
+void
+inf_ptrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
{
pid_t pid;
int request;
process ID of the child, or MINUS_ONE_PTID in case of error; store
the status in *OURSTATUS. */
-static ptid_t
-inf_ptrace_wait (struct target_ops *ops,
- ptid_t ptid, struct target_waitstatus *ourstatus, int options)
+ptid_t
+inf_ptrace_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
+ int options)
{
pid_t pid;
int status, save_errno;
/* Implement the to_xfer_partial target_ops method. */
-static enum target_xfer_status
-inf_ptrace_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
+inf_ptrace_target::xfer_partial (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
{
pid_t pid = get_ptrace_pid (inferior_ptid);
/* Return non-zero if the thread specified by PTID is alive. */
-static int
-inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid)
+bool
+inf_ptrace_target::thread_alive (ptid_t ptid)
{
/* ??? Is kill the right way to do this? */
- return (kill (ptid_get_pid (ptid), 0) != -1);
+ return (::kill (ptid_get_pid (ptid), 0) != -1);
}
/* Print status information about what we're accessing. */
-static void
-inf_ptrace_files_info (struct target_ops *ignore)
+void
+inf_ptrace_target::files_info ()
{
struct inferior *inf = current_inferior ();
target_pid_to_str (inferior_ptid));
}
-static const char *
-inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
+const char *
+inf_ptrace_target::pid_to_str (ptid_t ptid)
{
return normal_pid_to_str (ptid);
}
Return -1 if there is insufficient buffer for a whole entry.
Return 1 if an entry was read into *TYPEP and *VALP. */
-static int
-inf_ptrace_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
- gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
+int
+inf_ptrace_target::auxv_parse (gdb_byte **readptr, gdb_byte *endptr,
+ CORE_ADDR *typep, CORE_ADDR *valp)
{
struct type *int_type = builtin_type (target_gdbarch ())->builtin_int;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
}
#endif
-
-/* Create a prototype ptrace target. The client can override it with
- local methods. */
-
-struct target_ops *
-inf_ptrace_target (void)
-{
- struct target_ops *t = inf_child_target ();
-
- t->to_attach = inf_ptrace_attach;
- t->to_detach = inf_ptrace_detach;
- t->to_resume = inf_ptrace_resume;
- t->to_wait = inf_ptrace_wait;
- t->to_files_info = inf_ptrace_files_info;
- t->to_kill = inf_ptrace_kill;
- t->to_create_inferior = inf_ptrace_create_inferior;
-#ifdef PT_GET_PROCESS_STATE
- t->to_follow_fork = inf_ptrace_follow_fork;
- t->to_insert_fork_catchpoint = inf_ptrace_insert_fork_catchpoint;
- t->to_remove_fork_catchpoint = inf_ptrace_remove_fork_catchpoint;
- t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
- t->to_post_attach = inf_ptrace_post_attach;
-#endif
- t->to_mourn_inferior = inf_ptrace_mourn_inferior;
- t->to_thread_alive = inf_ptrace_thread_alive;
- t->to_pid_to_str = inf_ptrace_pid_to_str;
- t->to_xfer_partial = inf_ptrace_xfer_partial;
-#if defined (PT_IO) && defined (PIOD_READ_AUXV)
- t->to_auxv_parse = inf_ptrace_auxv_parse;
-#endif
-
- return t;
-}
\f
projects / deliverable / binutils-gdb.git / blobdiff