typedef void async_callback_ftype (enum inferior_event_type event_type,
void *context);
+/* These defines are used to mark target_ops methods. The script
+ make-target-delegates scans these and auto-generates the base
+ method implementations. There are four macros that can be used:
+
+ 1. TARGET_DEFAULT_IGNORE. There is no argument. The base method
+ does nothing. This is only valid if the method return type is
+ 'void'.
+
+ 2. TARGET_DEFAULT_NORETURN. The argument is a function call, like
+ 'tcomplain ()'. The base method simply makes this call, which is
+ assumed not to return.
+
+ 3. TARGET_DEFAULT_RETURN. The argument is a C expression. The
+ base method returns this expression's value.
+
+ 4. TARGET_DEFAULT_FUNC. The argument is the name of a function.
+ make-target-delegates does not generate a base method in this case,
+ but instead uses the argument function as the base method. */
+
+#define TARGET_DEFAULT_IGNORE()
+#define TARGET_DEFAULT_NORETURN(ARG)
+#define TARGET_DEFAULT_RETURN(ARG)
+#define TARGET_DEFAULT_FUNC(ARG)
+
struct target_ops
{
struct target_ops *beneath; /* To the target under this one. */
New re-entrant targets provide "to_xclose" and that is expected
to xfree everything (including the "struct target_ops"). */
void (*to_xclose) (struct target_ops *targ);
- void (*to_close) (void);
+ void (*to_close) (struct target_ops *);
void (*to_attach) (struct target_ops *ops, char *, int);
- void (*to_post_attach) (int);
+ void (*to_post_attach) (struct target_ops *, int);
void (*to_detach) (struct target_ops *ops, const char *, int);
void (*to_disconnect) (struct target_ops *, char *, int);
- void (*to_resume) (struct target_ops *, ptid_t, int, enum gdb_signal);
+ void (*to_resume) (struct target_ops *, ptid_t, int, enum gdb_signal)
+ TARGET_DEFAULT_NORETURN (noprocess ());
ptid_t (*to_wait) (struct target_ops *,
- ptid_t, struct target_waitstatus *, int);
+ ptid_t, struct target_waitstatus *, int)
+ TARGET_DEFAULT_NORETURN (noprocess ());
void (*to_fetch_registers) (struct target_ops *, struct regcache *, int);
- void (*to_store_registers) (struct target_ops *, struct regcache *, int);
+ void (*to_store_registers) (struct target_ops *, struct regcache *, int)
+ TARGET_DEFAULT_NORETURN (noprocess ());
void (*to_prepare_to_store) (struct target_ops *, struct regcache *);
/* Transfer LEN bytes of memory between GDB address MYADDR and
void (*to_files_info) (struct target_ops *);
int (*to_insert_breakpoint) (struct target_ops *, struct gdbarch *,
- struct bp_target_info *);
+ struct bp_target_info *)
+ TARGET_DEFAULT_FUNC (memory_insert_breakpoint);
int (*to_remove_breakpoint) (struct target_ops *, struct gdbarch *,
- struct bp_target_info *);
- int (*to_can_use_hw_breakpoint) (int, int, int);
+ struct bp_target_info *)
+ TARGET_DEFAULT_FUNC (memory_remove_breakpoint);
+ int (*to_can_use_hw_breakpoint) (struct target_ops *, int, int, int);
int (*to_ranged_break_num_registers) (struct target_ops *);
- int (*to_insert_hw_breakpoint) (struct gdbarch *, struct bp_target_info *);
- int (*to_remove_hw_breakpoint) (struct gdbarch *, struct bp_target_info *);
+ int (*to_insert_hw_breakpoint) (struct target_ops *,
+ struct gdbarch *, struct bp_target_info *);
+ int (*to_remove_hw_breakpoint) (struct target_ops *,
+ struct gdbarch *, struct bp_target_info *);
/* 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);
int (*to_remove_mask_watchpoint) (struct target_ops *,
CORE_ADDR, CORE_ADDR, int);
- int (*to_stopped_by_watchpoint) (struct target_ops *);
+ int (*to_stopped_by_watchpoint) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
int to_have_steppable_watchpoint;
int to_have_continuable_watchpoint;
- int (*to_stopped_data_address) (struct target_ops *, CORE_ADDR *);
+ int (*to_stopped_data_address) (struct target_ops *, CORE_ADDR *)
+ TARGET_DEFAULT_RETURN (0);
int (*to_watchpoint_addr_within_range) (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 *);
int to_has_thread_control; /* control thread execution */
int to_attach_no_wait;
/* ASYNC target controls */
- int (*to_can_async_p) (struct target_ops *);
- int (*to_is_async_p) (struct target_ops *);
- void (*to_async) (struct target_ops *,
- async_callback_ftype *, void *);
- int (*to_supports_non_stop) (void);
+ int (*to_can_async_p) (struct target_ops *)
+ TARGET_DEFAULT_FUNC (find_default_can_async_p);
+ int (*to_is_async_p) (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) (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
gdb_byte *readbuf,
const gdb_byte *writebuf,
ULONGEST offset, ULONGEST len,
- ULONGEST *xfered_len);
+ ULONGEST *xfered_len)
+ TARGET_DEFAULT_RETURN (TARGET_XFER_E_IO);
/* Returns the memory map for the target. A return value of NULL
means that no memory map is available. If a memory address
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);
int (*to_can_use_agent) (void);
/* Check whether the target supports branch tracing. */
- int (*to_supports_btrace) (void);
+ int (*to_supports_btrace) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Enable branch tracing for PTID and allocate a branch trace target
information struct for reading and for disabling branch trace. */
This operation provides a target-specific hook that allows the
necessary bookkeeping to be performed after an attach completes. */
#define target_post_attach(pid) \
- (*current_target.to_post_attach) (pid)
+ (*current_target.to_post_attach) (¤t_target, pid)
/* Takes a program previously attached to and detaches it.
The program may resume execution (some targets do, some don't) and will
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 *);
#define target_files_info() \
(*current_target.to_files_info) (¤t_target)
-/* Insert a hardware breakpoint at address BP_TGT->placed_address in
- the target machine. Returns 0 for success, and returns non-zero or
- throws an error (with a detailed failure reason error code and
- message) otherwise.
- Start the target search at OPS. */
-
-extern int forward_target_insert_breakpoint (struct target_ops *ops,
- struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt);
-
/* Insert a hardware breakpoint at address BP_TGT->placed_address in
the target machine. Returns 0 for success, and returns non-zero or
throws an error (with a detailed failure reason error code and
extern int target_insert_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt);
-/* Remove a breakpoint at address BP_TGT->placed_address in the target
- machine. Result is 0 for success, non-zero for error.
- Start the target search at OPS. */
-
-extern int forward_target_remove_breakpoint (struct target_ops *ops,
- struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt);
/* Remove a breakpoint at address BP_TGT->placed_address in the target
machine. Result is 0 for success, non-zero for error. */
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. */
(including this one?). OTHERTYPE is who knows what... */
#define target_can_use_hardware_watchpoint(TYPE,CNT,OTHERTYPE) \
- (*current_target.to_can_use_hw_breakpoint) (TYPE, CNT, OTHERTYPE);
+ (*current_target.to_can_use_hw_breakpoint) (¤t_target, \
+ TYPE, CNT, OTHERTYPE);
/* Returns the number of debug registers needed to watch the given
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
message) otherwise. */
#define target_insert_hw_breakpoint(gdbarch, bp_tgt) \
- (*current_target.to_insert_hw_breakpoint) (gdbarch, bp_tgt)
+ (*current_target.to_insert_hw_breakpoint) (¤t_target, \
+ gdbarch, bp_tgt)
#define target_remove_hw_breakpoint(gdbarch, bp_tgt) \
- (*current_target.to_remove_hw_breakpoint) (gdbarch, bp_tgt)
+ (*current_target.to_remove_hw_breakpoint) (¤t_target, \
+ gdbarch, bp_tgt)
/* Return number of debug registers needed for a ranged breakpoint,
or -1 if ranged breakpoints are not supported. */
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)
extern struct target_ops *find_target_beneath (struct target_ops *);
+/* Find the target at STRATUM. If no target is at that stratum,
+ return NULL. */
+
+struct target_ops *find_target_at (enum strata stratum);
+
/* Read OS data object of type TYPE from the target, and return it in
XML format. The result is NUL-terminated and returned as a string,
allocated using xmalloc. If an error occurs or the transfer is
void target_ignore (void);
/* See to_supports_btrace in struct target_ops. */
-extern int target_supports_btrace (void);
+#define target_supports_btrace() \
+ (current_target.to_supports_btrace (¤t_target))
/* See to_enable_btrace in struct target_ops. */
extern struct btrace_target_info *target_enable_btrace (ptid_t ptid);
projects / deliverable / binutils-gdb.git / blobdiff