int (*to_remove_vfork_catchpoint) (struct target_ops *, int);
int (*to_follow_fork) (struct target_ops *, int, int);
int (*to_insert_exec_catchpoint) (struct target_ops *, int);
- int (*to_remove_exec_catchpoint) (int);
- int (*to_set_syscall_catchpoint) (int, int, int, int, int *);
- int (*to_has_exited) (int, int, int *);
+ int (*to_remove_exec_catchpoint) (struct target_ops *, int);
+ int (*to_set_syscall_catchpoint) (struct target_ops *,
+ int, int, int, int, int *);
+ int (*to_has_exited) (struct target_ops *, int, int, int *);
void (*to_mourn_inferior) (struct target_ops *);
- int (*to_can_run) (void);
+ int (*to_can_run) (struct target_ops *);
/* Documentation of this routine is provided with the corresponding
target_* macro. */
- void (*to_pass_signals) (int, unsigned char *);
+ void (*to_pass_signals) (struct target_ops *, int, unsigned char *);
/* Documentation of this routine is provided with the
corresponding target_* function. */
- void (*to_program_signals) (int, unsigned char *);
+ void (*to_program_signals) (struct target_ops *, int, unsigned char *);
int (*to_thread_alive) (struct target_ops *, ptid_t ptid);
void (*to_find_new_threads) (struct target_ops *);
char *(*to_pid_to_str) (struct target_ops *, ptid_t);
- char *(*to_extra_thread_info) (struct thread_info *);
- char *(*to_thread_name) (struct thread_info *);
- void (*to_stop) (ptid_t);
- void (*to_rcmd) (char *command, struct ui_file *output);
- char *(*to_pid_to_exec_file) (int pid);
- void (*to_log_command) (const char *);
+ char *(*to_extra_thread_info) (struct target_ops *, struct thread_info *);
+ char *(*to_thread_name) (struct target_ops *, struct thread_info *);
+ void (*to_stop) (struct target_ops *, ptid_t);
+ void (*to_rcmd) (struct target_ops *,
+ char *command, struct ui_file *output);
+ char *(*to_pid_to_exec_file) (struct target_ops *, int pid);
+ void (*to_log_command) (struct target_ops *, const char *);
struct target_section_table *(*to_get_section_table) (struct target_ops *);
enum strata to_stratum;
int (*to_has_all_memory) (struct target_ops *);
TARGET_DEFAULT_FUNC (find_default_is_async_p);
void (*to_async) (struct target_ops *, async_callback_ftype *, void *)
TARGET_DEFAULT_NORETURN (tcomplain ());
- int (*to_supports_non_stop) (void);
+ int (*to_supports_non_stop) (struct target_ops *);
/* find_memory_regions support method for gcore */
- int (*to_find_memory_regions) (find_memory_region_ftype func, void *data);
+ int (*to_find_memory_regions) (struct target_ops *,
+ find_memory_region_ftype func, void *data);
/* make_corefile_notes support method for gcore */
- char * (*to_make_corefile_notes) (bfd *, int *);
+ char * (*to_make_corefile_notes) (struct target_ops *, bfd *, int *);
/* get_bookmark support method for bookmarks */
- gdb_byte * (*to_get_bookmark) (char *, int);
+ gdb_byte * (*to_get_bookmark) (struct target_ops *, char *, int);
/* goto_bookmark support method for bookmarks */
- void (*to_goto_bookmark) (gdb_byte *, int);
+ void (*to_goto_bookmark) (struct target_ops *, gdb_byte *, int);
/* Return the thread-local address at OFFSET in the
thread-local storage for the thread PTID and the shared library
or executable file given by OBJFILE. If that block of
based on LWP and THREAD. These values are extracted from the
task Private_Data section of the Ada Task Control Block, and
their interpretation depends on the target. */
- ptid_t (*to_get_ada_task_ptid) (long lwp, long thread);
+ ptid_t (*to_get_ada_task_ptid) (struct target_ops *,
+ long lwp, long thread);
/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
Return 0 if *READPTR is already at the end of the buffer.
CORE_ADDR *found_addrp);
/* Can target execute in reverse? */
- int (*to_can_execute_reverse) (void);
+ int (*to_can_execute_reverse) (struct target_ops *);
/* The direction the target is currently executing. Must be
implemented on targets that support reverse execution and async
(*current_target.to_insert_exec_catchpoint) (¤t_target, pid)
#define target_remove_exec_catchpoint(pid) \
- (*current_target.to_remove_exec_catchpoint) (pid)
+ (*current_target.to_remove_exec_catchpoint) (¤t_target, pid)
/* Syscall catch.
for failure. */
#define target_set_syscall_catchpoint(pid, needed, any_count, table_size, table) \
- (*current_target.to_set_syscall_catchpoint) (pid, needed, any_count, \
+ (*current_target.to_set_syscall_catchpoint) (¤t_target, \
+ pid, needed, any_count, \
table_size, table)
/* Returns TRUE if PID has exited. And, also sets EXIT_STATUS to the
exit code of PID, if any. */
#define target_has_exited(pid,wait_status,exit_status) \
- (*current_target.to_has_exited) (pid,wait_status,exit_status)
+ (*current_target.to_has_exited) (¤t_target, \
+ pid,wait_status,exit_status)
/* The debugger has completed a blocking wait() call. There is now
some process event that must be processed. This function should
/* Does target have enough data to do a run or attach command? */
#define target_can_run(t) \
- ((t)->to_can_run) ()
+ ((t)->to_can_run) (t)
/* Set list of signals to be handled in the target.
placed in OUTBUF. */
#define target_rcmd(command, outbuf) \
- (*current_target.to_rcmd) (command, outbuf)
+ (*current_target.to_rcmd) (¤t_target, command, outbuf)
/* Does the target include all of memory, or only part of it? This
is okay. */
#define target_extra_thread_info(TP) \
- (current_target.to_extra_thread_info (TP))
+ (current_target.to_extra_thread_info (¤t_target, TP))
/* Return the thread's name. A NULL result means that the target
could not determine this thread's name. */
it must persist. */
#define target_pid_to_exec_file(pid) \
- (current_target.to_pid_to_exec_file) (pid)
+ (current_target.to_pid_to_exec_file) (¤t_target, pid)
/* See the to_thread_architecture description in struct target_ops. */
*/
#define target_find_memory_regions(FUNC, DATA) \
- (current_target.to_find_memory_regions) (FUNC, DATA)
+ (current_target.to_find_memory_regions) (¤t_target, FUNC, DATA)
/*
* Compose corefile .note section.
*/
#define target_make_corefile_notes(BFD, SIZE_P) \
- (current_target.to_make_corefile_notes) (BFD, SIZE_P)
+ (current_target.to_make_corefile_notes) (¤t_target, BFD, SIZE_P)
/* Bookmark interfaces. */
#define target_get_bookmark(ARGS, FROM_TTY) \
- (current_target.to_get_bookmark) (ARGS, FROM_TTY)
+ (current_target.to_get_bookmark) (¤t_target, ARGS, FROM_TTY)
#define target_goto_bookmark(ARG, FROM_TTY) \
- (current_target.to_goto_bookmark) (ARG, FROM_TTY)
+ (current_target.to_goto_bookmark) (¤t_target, ARG, FROM_TTY)
/* Hardware watchpoint interfaces. */
/* Target can execute in reverse? */
#define target_can_execute_reverse \
(current_target.to_can_execute_reverse ? \
- current_target.to_can_execute_reverse () : 0)
+ current_target.to_can_execute_reverse (¤t_target) : 0)
extern const struct target_desc *target_read_description (struct target_ops *);
#define target_get_ada_task_ptid(lwp, tid) \
- (*current_target.to_get_ada_task_ptid) (lwp,tid)
+ (*current_target.to_get_ada_task_ptid) (¤t_target, lwp,tid)
/* Utility implementation of searching memory. */
extern int simple_search_memory (struct target_ops* ops,
#define target_log_command(p) \
do \
if (current_target.to_log_command) \
- (*current_target.to_log_command) (p); \
+ (*current_target.to_log_command) (¤t_target, \
+ p); \
while (0)