static void target_info (char *, int);
-static void default_terminal_info (const char *, int);
+static void default_terminal_info (struct target_ops *, const char *, int);
static int default_watchpoint_addr_within_range (struct target_ops *,
CORE_ADDR, CORE_ADDR, int);
-static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
+static int default_region_ok_for_hw_watchpoint (struct target_ops *,
+ CORE_ADDR, int);
static void tcomplain (void) ATTRIBUTE_NORETURN;
static int debug_to_remove_breakpoint (struct target_ops *, struct gdbarch *,
struct bp_target_info *);
-static int debug_to_can_use_hw_breakpoint (int, int, int);
+static int debug_to_can_use_hw_breakpoint (struct target_ops *self,
+ int, int, int);
-static int debug_to_insert_hw_breakpoint (struct gdbarch *,
+static int debug_to_insert_hw_breakpoint (struct target_ops *self,
+ struct gdbarch *,
struct bp_target_info *);
-static int debug_to_remove_hw_breakpoint (struct gdbarch *,
+static int debug_to_remove_hw_breakpoint (struct target_ops *self,
+ struct gdbarch *,
struct bp_target_info *);
-static int debug_to_insert_watchpoint (CORE_ADDR, int, int,
+static int debug_to_insert_watchpoint (struct target_ops *self,
+ CORE_ADDR, int, int,
struct expression *);
-static int debug_to_remove_watchpoint (CORE_ADDR, int, int,
+static int debug_to_remove_watchpoint (struct target_ops *self,
+ CORE_ADDR, int, int,
struct expression *);
static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
static int debug_to_watchpoint_addr_within_range (struct target_ops *,
CORE_ADDR, CORE_ADDR, int);
-static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
+static int debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
+ CORE_ADDR, int);
-static int debug_to_can_accel_watchpoint_condition (CORE_ADDR, int, int,
+static int debug_to_can_accel_watchpoint_condition (struct target_ops *self,
+ CORE_ADDR, int, int,
struct expression *);
-static void debug_to_terminal_init (void);
+static void debug_to_terminal_init (struct target_ops *self);
-static void debug_to_terminal_inferior (void);
+static void debug_to_terminal_inferior (struct target_ops *self);
-static void debug_to_terminal_ours_for_output (void);
+static void debug_to_terminal_ours_for_output (struct target_ops *self);
-static void debug_to_terminal_save_ours (void);
+static void debug_to_terminal_save_ours (struct target_ops *self);
-static void debug_to_terminal_ours (void);
+static void debug_to_terminal_ours (struct target_ops *self);
-static void debug_to_load (char *, int);
+static void debug_to_load (struct target_ops *self, char *, int);
-static int debug_to_can_run (void);
+static int debug_to_can_run (struct target_ops *self);
-static void debug_to_stop (ptid_t);
+static void debug_to_stop (struct target_ops *self, ptid_t);
/* Pointer to array of target architecture structures; the size of the
array; the current index into the array; the allocated size of the
target_load (char *arg, int from_tty)
{
target_dcache_invalidate ();
- (*current_target.to_load) (arg, from_tty);
+ (*current_target.to_load) (¤t_target, arg, from_tty);
}
void
/* If GDB is resuming the inferior in the foreground, install
inferior's terminal modes. */
- (*current_target.to_terminal_inferior) ();
+ (*current_target.to_terminal_inferior) (¤t_target);
}
static int
}
static void
-default_terminal_info (const char *args, int from_tty)
+default_terminal_info (struct target_ops *self, const char *args, int from_tty)
{
printf_unfiltered (_("No saved terminal information.\n"));
}
inferior_ptid. */
static ptid_t
-default_get_ada_task_ptid (long lwp, long tid)
+default_get_ada_task_ptid (struct target_ops *self, long lwp, long tid)
{
return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
}
static enum exec_direction_kind
-default_execution_direction (void)
+default_execution_direction (struct target_ops *self)
{
if (!target_can_execute_reverse)
return EXEC_FORWARD;
(void (*) (char *, int))
tcomplain);
de_fault (to_close,
- (void (*) (void))
+ (void (*) (struct target_ops *))
target_ignore);
de_fault (to_post_attach,
- (void (*) (int))
+ (void (*) (struct target_ops *, int))
target_ignore);
de_fault (to_prepare_to_store,
(void (*) (struct target_ops *, struct regcache *))
(void (*) (struct target_ops *))
target_ignore);
de_fault (to_can_use_hw_breakpoint,
- (int (*) (int, int, int))
+ (int (*) (struct target_ops *, int, int, int))
return_zero);
de_fault (to_insert_hw_breakpoint,
- (int (*) (struct gdbarch *, struct bp_target_info *))
+ (int (*) (struct target_ops *, struct gdbarch *,
+ struct bp_target_info *))
return_minus_one);
de_fault (to_remove_hw_breakpoint,
- (int (*) (struct gdbarch *, struct bp_target_info *))
+ (int (*) (struct target_ops *, struct gdbarch *,
+ struct bp_target_info *))
return_minus_one);
de_fault (to_insert_watchpoint,
- (int (*) (CORE_ADDR, int, int, struct expression *))
+ (int (*) (struct target_ops *, CORE_ADDR, int, int,
+ struct expression *))
return_minus_one);
de_fault (to_remove_watchpoint,
- (int (*) (CORE_ADDR, int, int, struct expression *))
+ (int (*) (struct target_ops *, CORE_ADDR, int, int,
+ struct expression *))
return_minus_one);
de_fault (to_watchpoint_addr_within_range,
default_watchpoint_addr_within_range);
de_fault (to_region_ok_for_hw_watchpoint,
default_region_ok_for_hw_watchpoint);
de_fault (to_can_accel_watchpoint_condition,
- (int (*) (CORE_ADDR, int, int, struct expression *))
+ (int (*) (struct target_ops *, CORE_ADDR, int, int,
+ struct expression *))
return_zero);
de_fault (to_terminal_init,
- (void (*) (void))
+ (void (*) (struct target_ops *))
target_ignore);
de_fault (to_terminal_inferior,
- (void (*) (void))
+ (void (*) (struct target_ops *))
target_ignore);
de_fault (to_terminal_ours_for_output,
- (void (*) (void))
+ (void (*) (struct target_ops *))
target_ignore);
de_fault (to_terminal_ours,
- (void (*) (void))
+ (void (*) (struct target_ops *))
target_ignore);
de_fault (to_terminal_save_ours,
- (void (*) (void))
+ (void (*) (struct target_ops *))
target_ignore);
de_fault (to_terminal_info,
default_terminal_info);
de_fault (to_load,
- (void (*) (char *, int))
+ (void (*) (struct target_ops *, char *, int))
tcomplain);
de_fault (to_post_startup_inferior,
- (void (*) (ptid_t))
+ (void (*) (struct target_ops *, ptid_t))
target_ignore);
de_fault (to_insert_fork_catchpoint,
- (int (*) (int))
+ (int (*) (struct target_ops *, int))
return_one);
de_fault (to_remove_fork_catchpoint,
- (int (*) (int))
+ (int (*) (struct target_ops *, int))
return_one);
de_fault (to_insert_vfork_catchpoint,
- (int (*) (int))
+ (int (*) (struct target_ops *, int))
return_one);
de_fault (to_remove_vfork_catchpoint,
- (int (*) (int))
+ (int (*) (struct target_ops *, int))
return_one);
de_fault (to_insert_exec_catchpoint,
- (int (*) (int))
+ (int (*) (struct target_ops *, int))
return_one);
de_fault (to_remove_exec_catchpoint,
- (int (*) (int))
+ (int (*) (struct target_ops *, int))
return_one);
de_fault (to_set_syscall_catchpoint,
- (int (*) (int, int, int, int, int *))
+ (int (*) (struct target_ops *, int, int, int, int, int *))
return_one);
de_fault (to_has_exited,
- (int (*) (int, int, int *))
+ (int (*) (struct target_ops *, int, int, int *))
return_zero);
de_fault (to_can_run,
+ (int (*) (struct target_ops *))
return_zero);
de_fault (to_extra_thread_info,
- (char *(*) (struct thread_info *))
+ (char *(*) (struct target_ops *, struct thread_info *))
return_null);
de_fault (to_thread_name,
- (char *(*) (struct thread_info *))
+ (char *(*) (struct target_ops *, struct thread_info *))
return_null);
de_fault (to_stop,
- (void (*) (ptid_t))
+ (void (*) (struct target_ops *, ptid_t))
target_ignore);
de_fault (to_rcmd,
- (void (*) (char *, struct ui_file *))
+ (void (*) (struct target_ops *, char *, struct ui_file *))
tcomplain);
de_fault (to_pid_to_exec_file,
- (char *(*) (int))
+ (char *(*) (struct target_ops *, int))
return_null);
de_fault (to_thread_architecture,
default_thread_architecture);
current_target.to_read_description = NULL;
de_fault (to_get_ada_task_ptid,
- (ptid_t (*) (long, long))
+ (ptid_t (*) (struct target_ops *, long, long))
default_get_ada_task_ptid);
de_fault (to_supports_multi_process,
- (int (*) (void))
+ (int (*) (struct target_ops *))
return_zero);
de_fault (to_supports_enable_disable_tracepoint,
- (int (*) (void))
+ (int (*) (struct target_ops *))
return_zero);
de_fault (to_supports_string_tracing,
- (int (*) (void))
+ (int (*) (struct target_ops *))
return_zero);
de_fault (to_trace_init,
- (void (*) (void))
+ (void (*) (struct target_ops *))
tcomplain);
de_fault (to_download_tracepoint,
- (void (*) (struct bp_location *))
+ (void (*) (struct target_ops *, struct bp_location *))
tcomplain);
de_fault (to_can_download_tracepoint,
- (int (*) (void))
+ (int (*) (struct target_ops *))
return_zero);
de_fault (to_download_trace_state_variable,
- (void (*) (struct trace_state_variable *))
+ (void (*) (struct target_ops *, struct trace_state_variable *))
tcomplain);
de_fault (to_enable_tracepoint,
- (void (*) (struct bp_location *))
+ (void (*) (struct target_ops *, struct bp_location *))
tcomplain);
de_fault (to_disable_tracepoint,
- (void (*) (struct bp_location *))
+ (void (*) (struct target_ops *, struct bp_location *))
tcomplain);
de_fault (to_trace_set_readonly_regions,
- (void (*) (void))
+ (void (*) (struct target_ops *))
tcomplain);
de_fault (to_trace_start,
(void (*) (void))
(struct traceframe_info * (*) (void))
return_null);
de_fault (to_supports_evaluation_of_breakpoint_conditions,
- (int (*) (void))
+ (int (*) (struct target_ops *))
return_zero);
de_fault (to_can_run_breakpoint_commands,
- (int (*) (void))
+ (int (*) (struct target_ops *))
return_zero);
de_fault (to_use_agent,
(int (*) (int))
for (t = current_target.beneath; t != NULL; t = t->beneath)
{
if (t->to_thread_name != NULL)
- return (*t->to_thread_name) (info);
+ return (*t->to_thread_name) (t, info);
}
return NULL;
fprintf_unfiltered (gdb_stdlog, " })\n");
}
- (*t->to_pass_signals) (numsigs, pass_signals);
+ (*t->to_pass_signals) (t, numsigs, pass_signals);
return;
}
}
fprintf_unfiltered (gdb_stdlog, " })\n");
}
- (*t->to_program_signals) (numsigs, program_signals);
+ (*t->to_program_signals) (t, numsigs, program_signals);
return;
}
}
}
static int
-find_default_supports_non_stop (void)
+find_default_supports_non_stop (struct target_ops *self)
{
struct target_ops *t;
t = find_default_run_target (NULL);
if (t && t->to_supports_non_stop)
- return (t->to_supports_non_stop) ();
+ return (t->to_supports_non_stop) (t);
return 0;
}
for (t = ¤t_target; t != NULL; t = t->beneath)
if (t->to_supports_non_stop)
- return t->to_supports_non_stop ();
+ return t->to_supports_non_stop (t);
return 0;
}
}
static int
-find_default_supports_disable_randomization (void)
+find_default_supports_disable_randomization (struct target_ops *self)
{
struct target_ops *t;
t = find_default_run_target (NULL);
if (t && t->to_supports_disable_randomization)
- return (t->to_supports_disable_randomization) ();
+ return (t->to_supports_disable_randomization) (t);
return 0;
}
for (t = ¤t_target; t != NULL; t = t->beneath)
if (t->to_supports_disable_randomization)
- return t->to_supports_disable_randomization ();
+ return t->to_supports_disable_randomization (t);
return 0;
}
{
if (t->to_fileio_open != NULL)
{
- int fd = t->to_fileio_open (filename, flags, mode, target_errno);
+ int fd = t->to_fileio_open (t, filename, flags, mode, target_errno);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog,
{
if (t->to_fileio_pwrite != NULL)
{
- int ret = t->to_fileio_pwrite (fd, write_buf, len, offset,
+ int ret = t->to_fileio_pwrite (t, fd, write_buf, len, offset,
target_errno);
if (targetdebug)
{
if (t->to_fileio_pread != NULL)
{
- int ret = t->to_fileio_pread (fd, read_buf, len, offset,
+ int ret = t->to_fileio_pread (t, fd, read_buf, len, offset,
target_errno);
if (targetdebug)
{
if (t->to_fileio_close != NULL)
{
- int ret = t->to_fileio_close (fd, target_errno);
+ int ret = t->to_fileio_close (t, fd, target_errno);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog,
{
if (t->to_fileio_unlink != NULL)
{
- int ret = t->to_fileio_unlink (filename, target_errno);
+ int ret = t->to_fileio_unlink (t, filename, target_errno);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog,
{
if (t->to_fileio_readlink != NULL)
{
- char *ret = t->to_fileio_readlink (filename, target_errno);
+ char *ret = t->to_fileio_readlink (t, filename, target_errno);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog,
static int
-default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
+default_region_ok_for_hw_watchpoint (struct target_ops *self,
+ CORE_ADDR addr, int len)
{
return (len <= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT);
}
/* Error-catcher for target_find_memory_regions. */
static int
-dummy_find_memory_regions (find_memory_region_ftype ignore1, void *ignore2)
+dummy_find_memory_regions (struct target_ops *self,
+ find_memory_region_ftype ignore1, void *ignore2)
{
error (_("Command not implemented for this target."));
return 0;
/* Error-catcher for target_make_corefile_notes. */
static char *
-dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
+dummy_make_corefile_notes (struct target_ops *self,
+ bfd *ignore1, int *ignore2)
{
error (_("Command not implemented for this target."));
return NULL;
/* Error-catcher for target_get_bookmark. */
static gdb_byte *
-dummy_get_bookmark (char *ignore1, int ignore2)
+dummy_get_bookmark (struct target_ops *self, char *ignore1, int ignore2)
{
tcomplain ();
return NULL;
/* Error-catcher for target_goto_bookmark. */
static void
-dummy_goto_bookmark (gdb_byte *ignore, int from_tty)
+dummy_goto_bookmark (struct target_ops *self, gdb_byte *ignore, int from_tty)
{
tcomplain ();
}
if (targ->to_xclose != NULL)
targ->to_xclose (targ);
else if (targ->to_close != NULL)
- targ->to_close ();
+ targ->to_close (targ);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "target_close ()\n");
return;
}
- (*current_target.to_stop) (ptid);
+ (*current_target.to_stop) (¤t_target, ptid);
}
static void
-debug_to_post_attach (int pid)
+debug_to_post_attach (struct target_ops *self, int pid)
{
- debug_target.to_post_attach (pid);
+ debug_target.to_post_attach (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
}
/* See target.h. */
-int
-target_supports_btrace (void)
-{
- struct target_ops *t;
-
- for (t = current_target.beneath; t != NULL; t = t->beneath)
- if (t->to_supports_btrace != NULL)
- return t->to_supports_btrace ();
-
- return 0;
-}
-
-/* See target.h. */
-
struct btrace_target_info *
target_enable_btrace (ptid_t ptid)
{
}
static int
-debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
+debug_to_can_use_hw_breakpoint (struct target_ops *self,
+ int type, int cnt, int from_tty)
{
int retval;
- retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
+ retval = debug_target.to_can_use_hw_breakpoint (&debug_target,
+ type, cnt, from_tty);
fprintf_unfiltered (gdb_stdlog,
"target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
}
static int
-debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
+debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
+ CORE_ADDR addr, int len)
{
CORE_ADDR retval;
- retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
+ retval = debug_target.to_region_ok_for_hw_watchpoint (&debug_target,
+ addr, len);
fprintf_unfiltered (gdb_stdlog,
"target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
}
static int
-debug_to_can_accel_watchpoint_condition (CORE_ADDR addr, int len, int rw,
+debug_to_can_accel_watchpoint_condition (struct target_ops *self,
+ CORE_ADDR addr, int len, int rw,
struct expression *cond)
{
int retval;
- retval = debug_target.to_can_accel_watchpoint_condition (addr, len,
+ retval = debug_target.to_can_accel_watchpoint_condition (&debug_target,
+ addr, len,
rw, cond);
fprintf_unfiltered (gdb_stdlog,
}
static int
-debug_to_insert_hw_breakpoint (struct gdbarch *gdbarch,
+debug_to_insert_hw_breakpoint (struct target_ops *self,
+ struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{
int retval;
- retval = debug_target.to_insert_hw_breakpoint (gdbarch, bp_tgt);
+ retval = debug_target.to_insert_hw_breakpoint (&debug_target,
+ gdbarch, bp_tgt);
fprintf_unfiltered (gdb_stdlog,
"target_insert_hw_breakpoint (%s, xxx) = %ld\n",
}
static int
-debug_to_remove_hw_breakpoint (struct gdbarch *gdbarch,
+debug_to_remove_hw_breakpoint (struct target_ops *self,
+ struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{
int retval;
- retval = debug_target.to_remove_hw_breakpoint (gdbarch, bp_tgt);
+ retval = debug_target.to_remove_hw_breakpoint (&debug_target,
+ gdbarch, bp_tgt);
fprintf_unfiltered (gdb_stdlog,
"target_remove_hw_breakpoint (%s, xxx) = %ld\n",
}
static int
-debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type,
+debug_to_insert_watchpoint (struct target_ops *self,
+ CORE_ADDR addr, int len, int type,
struct expression *cond)
{
int retval;
- retval = debug_target.to_insert_watchpoint (addr, len, type, cond);
+ retval = debug_target.to_insert_watchpoint (&debug_target,
+ addr, len, type, cond);
fprintf_unfiltered (gdb_stdlog,
"target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
}
static int
-debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type,
+debug_to_remove_watchpoint (struct target_ops *self,
+ CORE_ADDR addr, int len, int type,
struct expression *cond)
{
int retval;
- retval = debug_target.to_remove_watchpoint (addr, len, type, cond);
+ retval = debug_target.to_remove_watchpoint (&debug_target,
+ addr, len, type, cond);
fprintf_unfiltered (gdb_stdlog,
"target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
}
static void
-debug_to_terminal_init (void)
+debug_to_terminal_init (struct target_ops *self)
{
- debug_target.to_terminal_init ();
+ debug_target.to_terminal_init (&debug_target);
fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
}
static void
-debug_to_terminal_inferior (void)
+debug_to_terminal_inferior (struct target_ops *self)
{
- debug_target.to_terminal_inferior ();
+ debug_target.to_terminal_inferior (&debug_target);
fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
}
static void
-debug_to_terminal_ours_for_output (void)
+debug_to_terminal_ours_for_output (struct target_ops *self)
{
- debug_target.to_terminal_ours_for_output ();
+ debug_target.to_terminal_ours_for_output (&debug_target);
fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
}
static void
-debug_to_terminal_ours (void)
+debug_to_terminal_ours (struct target_ops *self)
{
- debug_target.to_terminal_ours ();
+ debug_target.to_terminal_ours (&debug_target);
fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
}
static void
-debug_to_terminal_save_ours (void)
+debug_to_terminal_save_ours (struct target_ops *self)
{
- debug_target.to_terminal_save_ours ();
+ debug_target.to_terminal_save_ours (&debug_target);
fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
}
static void
-debug_to_terminal_info (const char *arg, int from_tty)
+debug_to_terminal_info (struct target_ops *self,
+ const char *arg, int from_tty)
{
- debug_target.to_terminal_info (arg, from_tty);
+ debug_target.to_terminal_info (&debug_target, arg, from_tty);
fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
from_tty);
}
static void
-debug_to_load (char *args, int from_tty)
+debug_to_load (struct target_ops *self, char *args, int from_tty)
{
- debug_target.to_load (args, from_tty);
+ debug_target.to_load (&debug_target, args, from_tty);
fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
}
static void
-debug_to_post_startup_inferior (ptid_t ptid)
+debug_to_post_startup_inferior (struct target_ops *self, ptid_t ptid)
{
- debug_target.to_post_startup_inferior (ptid);
+ debug_target.to_post_startup_inferior (&debug_target, ptid);
fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
ptid_get_pid (ptid));
}
static int
-debug_to_insert_fork_catchpoint (int pid)
+debug_to_insert_fork_catchpoint (struct target_ops *self, int pid)
{
int retval;
- retval = debug_target.to_insert_fork_catchpoint (pid);
+ retval = debug_target.to_insert_fork_catchpoint (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
pid, retval);
}
static int
-debug_to_remove_fork_catchpoint (int pid)
+debug_to_remove_fork_catchpoint (struct target_ops *self, int pid)
{
int retval;
- retval = debug_target.to_remove_fork_catchpoint (pid);
+ retval = debug_target.to_remove_fork_catchpoint (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
pid, retval);
}
static int
-debug_to_insert_vfork_catchpoint (int pid)
+debug_to_insert_vfork_catchpoint (struct target_ops *self, int pid)
{
int retval;
- retval = debug_target.to_insert_vfork_catchpoint (pid);
+ retval = debug_target.to_insert_vfork_catchpoint (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
pid, retval);
}
static int
-debug_to_remove_vfork_catchpoint (int pid)
+debug_to_remove_vfork_catchpoint (struct target_ops *self, int pid)
{
int retval;
- retval = debug_target.to_remove_vfork_catchpoint (pid);
+ retval = debug_target.to_remove_vfork_catchpoint (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
pid, retval);
}
static int
-debug_to_insert_exec_catchpoint (int pid)
+debug_to_insert_exec_catchpoint (struct target_ops *self, int pid)
{
int retval;
- retval = debug_target.to_insert_exec_catchpoint (pid);
+ retval = debug_target.to_insert_exec_catchpoint (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
pid, retval);
}
static int
-debug_to_remove_exec_catchpoint (int pid)
+debug_to_remove_exec_catchpoint (struct target_ops *self, int pid)
{
int retval;
- retval = debug_target.to_remove_exec_catchpoint (pid);
+ retval = debug_target.to_remove_exec_catchpoint (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
pid, retval);
}
static int
-debug_to_has_exited (int pid, int wait_status, int *exit_status)
+debug_to_has_exited (struct target_ops *self,
+ int pid, int wait_status, int *exit_status)
{
int has_exited;
- has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
+ has_exited = debug_target.to_has_exited (&debug_target,
+ pid, wait_status, exit_status);
fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
pid, wait_status, *exit_status, has_exited);
}
static int
-debug_to_can_run (void)
+debug_to_can_run (struct target_ops *self)
{
int retval;
- retval = debug_target.to_can_run ();
+ retval = debug_target.to_can_run (&debug_target);
fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
}
static void
-debug_to_stop (ptid_t ptid)
+debug_to_stop (struct target_ops *self, ptid_t ptid)
{
- debug_target.to_stop (ptid);
+ debug_target.to_stop (&debug_target, ptid);
fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
target_pid_to_str (ptid));
}
static void
-debug_to_rcmd (char *command,
+debug_to_rcmd (struct target_ops *self, char *command,
struct ui_file *outbuf)
{
- debug_target.to_rcmd (command, outbuf);
+ debug_target.to_rcmd (&debug_target, command, outbuf);
fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
}
static char *
-debug_to_pid_to_exec_file (int pid)
+debug_to_pid_to_exec_file (struct target_ops *self, int pid)
{
char *exec_file;
- exec_file = debug_target.to_pid_to_exec_file (pid);
+ exec_file = debug_target.to_pid_to_exec_file (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
pid, exec_file);
int from_tty)
{
if ((current_target.to_rcmd
- == (void (*) (char *, struct ui_file *)) tcomplain)
+ == (void (*) (struct target_ops *, char *, struct ui_file *)) tcomplain)
|| (current_target.to_rcmd == debug_to_rcmd
&& (debug_target.to_rcmd
- == (void (*) (char *, struct ui_file *)) tcomplain)))
+ == (void (*) (struct target_ops *,
+ char *, struct ui_file *)) tcomplain)))
error (_("\"monitor\" command not supported by this target."));
target_rcmd (cmd, gdb_stdtarg);
}