/* Documentation of what the two routines below are expected to do is
provided with the corresponding target_* macros. */
- int (*to_remove_watchpoint) (CORE_ADDR, int, int, struct expression *);
- int (*to_insert_watchpoint) (CORE_ADDR, int, int, struct expression *);
+ int (*to_remove_watchpoint) (struct target_ops *,
+ CORE_ADDR, int, int, struct expression *);
+ int (*to_insert_watchpoint) (struct target_ops *,
+ CORE_ADDR, int, int, struct expression *);
int (*to_insert_mask_watchpoint) (struct target_ops *,
CORE_ADDR, CORE_ADDR, int);
/* Documentation of this routine is provided with the corresponding
target_* macro. */
- int (*to_region_ok_for_hw_watchpoint) (CORE_ADDR, int);
+ int (*to_region_ok_for_hw_watchpoint) (struct target_ops *,
+ CORE_ADDR, int);
- int (*to_can_accel_watchpoint_condition) (CORE_ADDR, int, int,
+ int (*to_can_accel_watchpoint_condition) (struct target_ops *,
+ CORE_ADDR, int, int,
struct expression *);
int (*to_masked_watch_num_registers) (struct target_ops *,
CORE_ADDR, CORE_ADDR);
- void (*to_terminal_init) (void);
- void (*to_terminal_inferior) (void);
- void (*to_terminal_ours_for_output) (void);
- void (*to_terminal_ours) (void);
- void (*to_terminal_save_ours) (void);
- void (*to_terminal_info) (const char *, int);
+ void (*to_terminal_init) (struct target_ops *);
+ void (*to_terminal_inferior) (struct target_ops *);
+ void (*to_terminal_ours_for_output) (struct target_ops *);
+ void (*to_terminal_ours) (struct target_ops *);
+ void (*to_terminal_save_ours) (struct target_ops *);
+ void (*to_terminal_info) (struct target_ops *, const char *, int);
void (*to_kill) (struct target_ops *);
- void (*to_load) (char *, int);
+ void (*to_load) (struct target_ops *, char *, int);
void (*to_create_inferior) (struct target_ops *,
char *, char *, char **, int);
- void (*to_post_startup_inferior) (ptid_t);
- int (*to_insert_fork_catchpoint) (int);
- int (*to_remove_fork_catchpoint) (int);
- int (*to_insert_vfork_catchpoint) (int);
- int (*to_remove_vfork_catchpoint) (int);
+ void (*to_post_startup_inferior) (struct target_ops *, ptid_t);
+ int (*to_insert_fork_catchpoint) (struct target_ops *, int);
+ int (*to_remove_fork_catchpoint) (struct target_ops *, int);
+ int (*to_insert_vfork_catchpoint) (struct target_ops *, int);
+ int (*to_remove_vfork_catchpoint) (struct target_ops *, int);
int (*to_follow_fork) (struct target_ops *, int, int);
- int (*to_insert_exec_catchpoint) (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_insert_exec_catchpoint) (struct target_ops *, 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
mode. The default simply returns forward execution. */
- enum exec_direction_kind (*to_execution_direction) (void);
+ enum exec_direction_kind (*to_execution_direction) (struct target_ops *);
/* Does this target support debugging multiple processes
simultaneously? */
- int (*to_supports_multi_process) (void);
+ int (*to_supports_multi_process) (struct target_ops *);
/* Does this target support enabling and disabling tracepoints while a trace
experiment is running? */
- int (*to_supports_enable_disable_tracepoint) (void);
+ int (*to_supports_enable_disable_tracepoint) (struct target_ops *);
/* Does this target support disabling address space randomization? */
- int (*to_supports_disable_randomization) (void);
+ int (*to_supports_disable_randomization) (struct target_ops *);
/* Does this target support the tracenz bytecode for string collection? */
- int (*to_supports_string_tracing) (void);
+ int (*to_supports_string_tracing) (struct target_ops *);
/* Does this target support evaluation of breakpoint conditions on its
end? */
- int (*to_supports_evaluation_of_breakpoint_conditions) (void);
+ int (*to_supports_evaluation_of_breakpoint_conditions) (struct target_ops *);
/* Does this target support evaluation of breakpoint commands on its
end? */
- int (*to_can_run_breakpoint_commands) (void);
+ int (*to_can_run_breakpoint_commands) (struct target_ops *);
/* Determine current architecture of thread PTID.
/* Open FILENAME on the target, using FLAGS and MODE. Return a
target file descriptor, or -1 if an error occurs (and set
*TARGET_ERRNO). */
- int (*to_fileio_open) (const char *filename, int flags, int mode,
+ int (*to_fileio_open) (struct target_ops *,
+ const char *filename, int flags, int mode,
int *target_errno);
/* Write up to LEN bytes from WRITE_BUF to FD on the target.
Return the number of bytes written, or -1 if an error occurs
(and set *TARGET_ERRNO). */
- int (*to_fileio_pwrite) (int fd, const gdb_byte *write_buf, int len,
+ int (*to_fileio_pwrite) (struct target_ops *,
+ int fd, const gdb_byte *write_buf, int len,
ULONGEST offset, int *target_errno);
/* Read up to LEN bytes FD on the target into READ_BUF.
Return the number of bytes read, or -1 if an error occurs
(and set *TARGET_ERRNO). */
- int (*to_fileio_pread) (int fd, gdb_byte *read_buf, int len,
+ int (*to_fileio_pread) (struct target_ops *,
+ int fd, gdb_byte *read_buf, int len,
ULONGEST offset, int *target_errno);
/* Close FD on the target. Return 0, or -1 if an error occurs
(and set *TARGET_ERRNO). */
- int (*to_fileio_close) (int fd, int *target_errno);
+ int (*to_fileio_close) (struct target_ops *, int fd, int *target_errno);
/* Unlink FILENAME on the target. Return 0, or -1 if an error
occurs (and set *TARGET_ERRNO). */
- int (*to_fileio_unlink) (const char *filename, int *target_errno);
+ int (*to_fileio_unlink) (struct target_ops *,
+ const char *filename, int *target_errno);
/* Read value of symbolic link FILENAME on the target. Return a
null-terminated string allocated via xmalloc, or NULL if an error
occurs (and set *TARGET_ERRNO). */
- char *(*to_fileio_readlink) (const char *filename, int *target_errno);
+ char *(*to_fileio_readlink) (struct target_ops *,
+ const char *filename, int *target_errno);
/* Implement the "info proc" command. */
/* Tracepoint-related operations. */
/* Prepare the target for a tracing run. */
- void (*to_trace_init) (void);
+ void (*to_trace_init) (struct target_ops *);
/* Send full details of a tracepoint location to the target. */
void (*to_download_tracepoint) (struct bp_location *location);
simultaneously. */
#define target_supports_multi_process() \
- (*current_target.to_supports_multi_process) ()
+ (*current_target.to_supports_multi_process) (¤t_target)
/* Returns true if this target can disable address space randomization. */
while a trace experiment is running. */
#define target_supports_enable_disable_tracepoint() \
- (*current_target.to_supports_enable_disable_tracepoint) ()
+ (*current_target.to_supports_enable_disable_tracepoint) (¤t_target)
#define target_supports_string_tracing() \
- (*current_target.to_supports_string_tracing) ()
+ (*current_target.to_supports_string_tracing) (¤t_target)
/* Returns true if this target can handle breakpoint conditions
on its end. */
#define target_supports_evaluation_of_breakpoint_conditions() \
- (*current_target.to_supports_evaluation_of_breakpoint_conditions) ()
+ (*current_target.to_supports_evaluation_of_breakpoint_conditions) (¤t_target)
/* Returns true if this target can handle breakpoint commands
on its end. */
#define target_can_run_breakpoint_commands() \
- (*current_target.to_can_run_breakpoint_commands) ()
+ (*current_target.to_can_run_breakpoint_commands) (¤t_target)
extern int target_read_string (CORE_ADDR, char **, int, int *);
before we actually run the inferior. */
#define target_terminal_init() \
- (*current_target.to_terminal_init) ()
+ (*current_target.to_terminal_init) (¤t_target)
/* Put the inferior's terminal settings into effect.
This is preparation for starting or resuming the inferior. */
should be called to get back to a normal state of affairs. */
#define target_terminal_ours_for_output() \
- (*current_target.to_terminal_ours_for_output) ()
+ (*current_target.to_terminal_ours_for_output) (¤t_target)
/* Put our terminal settings into effect.
First record the inferior's terminal settings
so they can be restored properly later. */
#define target_terminal_ours() \
- (*current_target.to_terminal_ours) ()
+ (*current_target.to_terminal_ours) (¤t_target)
/* Save our terminal settings.
This is called from TUI after entering or leaving the curses
to take this change into account. */
#define target_terminal_save_ours() \
- (*current_target.to_terminal_save_ours) ()
+ (*current_target.to_terminal_save_ours) (¤t_target)
/* Print useful information about our terminal status, if such a thing
exists. */
#define target_terminal_info(arg, from_tty) \
- (*current_target.to_terminal_info) (arg, from_tty)
+ (*current_target.to_terminal_info) (¤t_target, arg, from_tty)
/* Kill the inferior process. Make it go away. */
Such targets will supply an appropriate definition for this function. */
#define target_post_startup_inferior(ptid) \
- (*current_target.to_post_startup_inferior) (ptid)
+ (*current_target.to_post_startup_inferior) (¤t_target, ptid)
/* On some targets, we can catch an inferior fork or vfork event when
it occurs. These functions insert/remove an already-created
catchpoint type is not supported and -1 for failure. */
#define target_insert_fork_catchpoint(pid) \
- (*current_target.to_insert_fork_catchpoint) (pid)
+ (*current_target.to_insert_fork_catchpoint) (¤t_target, pid)
#define target_remove_fork_catchpoint(pid) \
- (*current_target.to_remove_fork_catchpoint) (pid)
+ (*current_target.to_remove_fork_catchpoint) (¤t_target, pid)
#define target_insert_vfork_catchpoint(pid) \
- (*current_target.to_insert_vfork_catchpoint) (pid)
+ (*current_target.to_insert_vfork_catchpoint) (¤t_target, pid)
#define target_remove_vfork_catchpoint(pid) \
- (*current_target.to_remove_vfork_catchpoint) (pid)
+ (*current_target.to_remove_vfork_catchpoint) (¤t_target, pid)
/* If the inferior forks or vforks, this function will be called at
the next resume in order to perform any bookkeeping and fiddling
catchpoint type is not supported and -1 for failure. */
#define target_insert_exec_catchpoint(pid) \
- (*current_target.to_insert_exec_catchpoint) (pid)
+ (*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
(current_target.to_async (¤t_target, (CALLBACK), (CONTEXT)))
#define target_execution_direction() \
- (current_target.to_execution_direction ())
+ (current_target.to_execution_direction (¤t_target))
/* Converts a process id to a string. Usually, the string just contains
`process xyz', but on some systems it may contain
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. */
memory region, or zero if not supported. */
#define target_region_ok_for_hw_watchpoint(addr, len) \
- (*current_target.to_region_ok_for_hw_watchpoint) (addr, len)
+ (*current_target.to_region_ok_for_hw_watchpoint) (¤t_target, \
+ addr, len)
/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes.
-1 for failure. */
#define target_insert_watchpoint(addr, len, type, cond) \
- (*current_target.to_insert_watchpoint) (addr, len, type, cond)
+ (*current_target.to_insert_watchpoint) (¤t_target, \
+ addr, len, type, cond)
#define target_remove_watchpoint(addr, len, type, cond) \
- (*current_target.to_remove_watchpoint) (addr, len, type, cond)
+ (*current_target.to_remove_watchpoint) (¤t_target, \
+ addr, len, type, cond)
/* Insert a new masked watchpoint at ADDR using the mask MASK.
RW may be hw_read for a read watchpoint, hw_write for a write watchpoint
For this reason, GDB will still evaluate the condition expression when
the watchpoint triggers. */
#define target_can_accel_watchpoint_condition(addr, len, type, cond) \
- (*current_target.to_can_accel_watchpoint_condition) (addr, len, type, cond)
+ (*current_target.to_can_accel_watchpoint_condition) (¤t_target, \
+ addr, len, type, cond)
/* Return number of debug registers needed for a masked watchpoint,
-1 if masked watchpoints are not supported or -2 if the given address
/* 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,
/* Tracepoint-related operations. */
#define target_trace_init() \
- (*current_target.to_trace_init) ()
+ (*current_target.to_trace_init) (¤t_target)
#define target_download_tracepoint(t) \
(*current_target.to_download_tracepoint) (t)
#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)
projects / deliverable / binutils-gdb.git / blobdiff