to xfree everything (including the "struct target_ops"). */
void (*to_xclose) (struct target_ops *targ);
void (*to_close) (struct target_ops *);
- void (*to_attach) (struct target_ops *ops, char *, int);
- void (*to_post_attach) (struct target_ops *, int);
- void (*to_detach) (struct target_ops *ops, const char *, int);
+ void (*to_attach) (struct target_ops *ops, char *, int)
+ TARGET_DEFAULT_FUNC (find_default_attach);
+ void (*to_post_attach) (struct target_ops *, int)
+ TARGET_DEFAULT_IGNORE ();
+ void (*to_detach) (struct target_ops *ops, const char *, int)
+ TARGET_DEFAULT_IGNORE ();
void (*to_disconnect) (struct target_ops *, char *, int);
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)
TARGET_DEFAULT_NORETURN (noprocess ());
- void (*to_fetch_registers) (struct target_ops *, struct regcache *, int);
+ void (*to_fetch_registers) (struct target_ops *, struct regcache *, int)
+ TARGET_DEFAULT_IGNORE ();
void (*to_store_registers) (struct target_ops *, struct regcache *, int)
TARGET_DEFAULT_NORETURN (noprocess ());
- void (*to_prepare_to_store) (struct target_ops *, struct regcache *);
+ void (*to_prepare_to_store) (struct target_ops *, struct regcache *)
+ TARGET_DEFAULT_NORETURN (noprocess ());
/* Transfer LEN bytes of memory between GDB address MYADDR and
target address MEMADDR. If WRITE, transfer them to the target, else
struct mem_attrib *attrib,
struct target_ops *target);
- void (*to_files_info) (struct target_ops *);
+ void (*to_files_info) (struct target_ops *)
+ TARGET_DEFAULT_IGNORE ();
int (*to_insert_breakpoint) (struct target_ops *, struct gdbarch *,
struct bp_target_info *)
TARGET_DEFAULT_FUNC (memory_insert_breakpoint);
int (*to_remove_breakpoint) (struct target_ops *, struct gdbarch *,
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_can_use_hw_breakpoint) (struct target_ops *, int, int, int)
+ TARGET_DEFAULT_RETURN (0);
+ int (*to_ranged_break_num_registers) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (-1);
int (*to_insert_hw_breakpoint) (struct target_ops *,
- struct gdbarch *, struct bp_target_info *);
+ struct gdbarch *, struct bp_target_info *)
+ TARGET_DEFAULT_RETURN (-1);
int (*to_remove_hw_breakpoint) (struct target_ops *,
- struct gdbarch *, struct bp_target_info *);
+ struct gdbarch *, struct bp_target_info *)
+ TARGET_DEFAULT_RETURN (-1);
/* Documentation of what the two routines below are expected to do is
provided with the corresponding target_* macros. */
int (*to_remove_watchpoint) (struct target_ops *,
- CORE_ADDR, int, int, struct expression *);
+ CORE_ADDR, int, int, struct expression *)
+ TARGET_DEFAULT_RETURN (-1);
int (*to_insert_watchpoint) (struct target_ops *,
- CORE_ADDR, int, int, struct expression *);
+ CORE_ADDR, int, int, struct expression *)
+ TARGET_DEFAULT_RETURN (-1);
int (*to_insert_mask_watchpoint) (struct target_ops *,
- CORE_ADDR, CORE_ADDR, int);
+ CORE_ADDR, CORE_ADDR, int)
+ TARGET_DEFAULT_RETURN (1);
int (*to_remove_mask_watchpoint) (struct target_ops *,
CORE_ADDR, CORE_ADDR, int);
int (*to_stopped_by_watchpoint) (struct target_ops *)
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);
+ CORE_ADDR, CORE_ADDR, int)
+ TARGET_DEFAULT_FUNC (default_watchpoint_addr_within_range);
/* Documentation of this routine is provided with the corresponding
target_* macro. */
int (*to_region_ok_for_hw_watchpoint) (struct target_ops *,
- CORE_ADDR, int);
+ CORE_ADDR, int)
+ TARGET_DEFAULT_FUNC (default_region_ok_for_hw_watchpoint);
int (*to_can_accel_watchpoint_condition) (struct target_ops *,
CORE_ADDR, int, int,
- struct expression *);
+ struct expression *)
+ TARGET_DEFAULT_RETURN (0);
int (*to_masked_watch_num_registers) (struct target_ops *,
CORE_ADDR, CORE_ADDR);
- 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_terminal_init) (struct target_ops *)
+ TARGET_DEFAULT_IGNORE ();
+ void (*to_terminal_inferior) (struct target_ops *)
+ TARGET_DEFAULT_IGNORE ();
+ void (*to_terminal_ours_for_output) (struct target_ops *)
+ TARGET_DEFAULT_IGNORE ();
+ void (*to_terminal_ours) (struct target_ops *)
+ TARGET_DEFAULT_IGNORE ();
+ void (*to_terminal_save_ours) (struct target_ops *)
+ TARGET_DEFAULT_IGNORE ();
+ void (*to_terminal_info) (struct target_ops *, const char *, int)
+ TARGET_DEFAULT_FUNC (default_terminal_info);
void (*to_kill) (struct target_ops *);
- void (*to_load) (struct target_ops *, char *, int);
+ void (*to_load) (struct target_ops *, char *, int)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
void (*to_create_inferior) (struct target_ops *,
char *, char *, char **, 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);
+ void (*to_post_startup_inferior) (struct target_ops *, ptid_t)
+ TARGET_DEFAULT_IGNORE ();
+ int (*to_insert_fork_catchpoint) (struct target_ops *, int)
+ TARGET_DEFAULT_RETURN (1);
+ int (*to_remove_fork_catchpoint) (struct target_ops *, int)
+ TARGET_DEFAULT_RETURN (1);
+ int (*to_insert_vfork_catchpoint) (struct target_ops *, int)
+ TARGET_DEFAULT_RETURN (1);
+ int (*to_remove_vfork_catchpoint) (struct target_ops *, int)
+ TARGET_DEFAULT_RETURN (1);
int (*to_follow_fork) (struct target_ops *, int, int);
- int (*to_insert_exec_catchpoint) (struct target_ops *, int);
- int (*to_remove_exec_catchpoint) (struct target_ops *, int);
+ int (*to_insert_exec_catchpoint) (struct target_ops *, int)
+ TARGET_DEFAULT_RETURN (1);
+ int (*to_remove_exec_catchpoint) (struct target_ops *, int)
+ TARGET_DEFAULT_RETURN (1);
int (*to_set_syscall_catchpoint) (struct target_ops *,
- int, int, int, int, int *);
- int (*to_has_exited) (struct target_ops *, int, int, int *);
+ int, int, int, int, int *)
+ TARGET_DEFAULT_RETURN (1);
+ int (*to_has_exited) (struct target_ops *, int, int, int *)
+ TARGET_DEFAULT_RETURN (0);
void (*to_mourn_inferior) (struct target_ops *);
int (*to_can_run) (struct target_ops *);
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 target_ops *, struct thread_info *);
- char *(*to_thread_name) (struct target_ops *, struct thread_info *);
- void (*to_stop) (struct target_ops *, ptid_t);
+ char *(*to_extra_thread_info) (struct target_ops *, struct thread_info *)
+ TARGET_DEFAULT_RETURN (0);
+ char *(*to_thread_name) (struct target_ops *, struct thread_info *)
+ TARGET_DEFAULT_RETURN (0);
+ void (*to_stop) (struct target_ops *, ptid_t)
+ TARGET_DEFAULT_IGNORE ();
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 *);
+ char *command, struct ui_file *output)
+ TARGET_DEFAULT_FUNC (default_rcmd);
+ char *(*to_pid_to_exec_file) (struct target_ops *, int pid)
+ TARGET_DEFAULT_RETURN (0);
+ void (*to_log_command) (struct target_ops *, const char *)
+ TARGET_DEFAULT_IGNORE ();
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_supports_non_stop) (struct target_ops *);
/* find_memory_regions support method for gcore */
int (*to_find_memory_regions) (struct target_ops *,
- find_memory_region_ftype func, void *data);
+ find_memory_region_ftype func, void *data)
+ TARGET_DEFAULT_FUNC (dummy_find_memory_regions);
/* make_corefile_notes support method for gcore */
- char * (*to_make_corefile_notes) (struct target_ops *, bfd *, int *);
+ char * (*to_make_corefile_notes) (struct target_ops *, bfd *, int *)
+ TARGET_DEFAULT_FUNC (dummy_make_corefile_notes);
/* get_bookmark support method for bookmarks */
- gdb_byte * (*to_get_bookmark) (struct target_ops *, char *, int);
+ gdb_byte * (*to_get_bookmark) (struct target_ops *, char *, int)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* goto_bookmark support method for bookmarks */
- void (*to_goto_bookmark) (struct target_ops *, gdb_byte *, int);
+ void (*to_goto_bookmark) (struct target_ops *, gdb_byte *, int)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* 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
task Private_Data section of the Ada Task Control Block, and
their interpretation depends on the target. */
ptid_t (*to_get_ada_task_ptid) (struct target_ops *,
- long lwp, long thread);
+ long lwp, long thread)
+ TARGET_DEFAULT_FUNC (default_get_ada_task_ptid);
/* 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) (struct target_ops *);
+ int (*to_can_execute_reverse) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* 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) (struct target_ops *);
+ enum exec_direction_kind (*to_execution_direction) (struct target_ops *)
+ TARGET_DEFAULT_FUNC (default_execution_direction);
/* Does this target support debugging multiple processes
simultaneously? */
- int (*to_supports_multi_process) (struct target_ops *);
+ int (*to_supports_multi_process) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Does this target support enabling and disabling tracepoints while a trace
experiment is running? */
- int (*to_supports_enable_disable_tracepoint) (struct target_ops *);
+ int (*to_supports_enable_disable_tracepoint) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Does this target support disabling address space randomization? */
int (*to_supports_disable_randomization) (struct target_ops *);
/* Does this target support the tracenz bytecode for string collection? */
- int (*to_supports_string_tracing) (struct target_ops *);
+ int (*to_supports_string_tracing) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Does this target support evaluation of breakpoint conditions on its
end? */
- int (*to_supports_evaluation_of_breakpoint_conditions) (struct target_ops *);
+ int (*to_supports_evaluation_of_breakpoint_conditions) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Does this target support evaluation of breakpoint commands on its
end? */
- int (*to_can_run_breakpoint_commands) (struct target_ops *);
+ int (*to_can_run_breakpoint_commands) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Determine current architecture of thread PTID.
ptrace operations need to operate according to target_gdbarch ().
The default implementation always returns target_gdbarch (). */
- struct gdbarch *(*to_thread_architecture) (struct target_ops *, ptid_t);
+ struct gdbarch *(*to_thread_architecture) (struct target_ops *, ptid_t)
+ TARGET_DEFAULT_FUNC (default_thread_architecture);
/* Determine current address space of thread PTID.
/* Tracepoint-related operations. */
/* Prepare the target for a tracing run. */
- void (*to_trace_init) (struct target_ops *);
+ void (*to_trace_init) (struct target_ops *)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Send full details of a tracepoint location to the target. */
void (*to_download_tracepoint) (struct target_ops *,
- struct bp_location *location);
+ struct bp_location *location)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Is the target able to download tracepoint locations in current
state? */
- int (*to_can_download_tracepoint) (struct target_ops *);
+ int (*to_can_download_tracepoint) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Send full details of a trace state variable to the target. */
void (*to_download_trace_state_variable) (struct target_ops *,
- struct trace_state_variable *tsv);
+ struct trace_state_variable *tsv)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Enable a tracepoint on the target. */
void (*to_enable_tracepoint) (struct target_ops *,
- struct bp_location *location);
+ struct bp_location *location)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Disable a tracepoint on the target. */
void (*to_disable_tracepoint) (struct target_ops *,
- struct bp_location *location);
+ struct bp_location *location)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Inform the target info of memory regions that are readonly
(such as text sections), and so it should return data from
those rather than look in the trace buffer. */
- void (*to_trace_set_readonly_regions) (struct target_ops *);
+ void (*to_trace_set_readonly_regions) (struct target_ops *)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Start a trace run. */
- void (*to_trace_start) (struct target_ops *);
+ void (*to_trace_start) (struct target_ops *)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Get the current status of a tracing run. */
- int (*to_get_trace_status) (struct target_ops *, struct trace_status *ts);
+ int (*to_get_trace_status) (struct target_ops *, struct trace_status *ts)
+ TARGET_DEFAULT_RETURN (-1);
void (*to_get_tracepoint_status) (struct target_ops *,
struct breakpoint *tp,
- struct uploaded_tp *utp);
+ struct uploaded_tp *utp)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Stop a trace run. */
- void (*to_trace_stop) (struct target_ops *);
+ void (*to_trace_stop) (struct target_ops *)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Ask the target to find a trace frame of the given type TYPE,
using NUM, ADDR1, and ADDR2 as search parameters. Returns the
operation fails. */
int (*to_trace_find) (struct target_ops *,
enum trace_find_type type, int num,
- CORE_ADDR addr1, CORE_ADDR addr2, int *tpp);
+ CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
+ TARGET_DEFAULT_RETURN (-1);
/* Get the value of the trace state variable number TSV, returning
1 if the value is known and writing the value itself into the
location pointed to by VAL, else returning 0. */
int (*to_get_trace_state_variable_value) (struct target_ops *,
- int tsv, LONGEST *val);
+ int tsv, LONGEST *val)
+ TARGET_DEFAULT_RETURN (0);
- int (*to_save_trace_data) (struct target_ops *, const char *filename);
+ int (*to_save_trace_data) (struct target_ops *, const char *filename)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
int (*to_upload_tracepoints) (struct target_ops *,
- struct uploaded_tp **utpp);
+ struct uploaded_tp **utpp)
+ TARGET_DEFAULT_RETURN (0);
int (*to_upload_trace_state_variables) (struct target_ops *,
- struct uploaded_tsv **utsvp);
+ struct uploaded_tsv **utsvp)
+ TARGET_DEFAULT_RETURN (0);
LONGEST (*to_get_raw_trace_data) (struct target_ops *, gdb_byte *buf,
- ULONGEST offset, LONGEST len);
+ ULONGEST offset, LONGEST len)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Get the minimum length of instruction on which a fast tracepoint
may be set on the target. If this operation is unsupported,
return -1. If for some reason the minimum length cannot be
determined, return 0. */
- int (*to_get_min_fast_tracepoint_insn_len) (struct target_ops *);
+ int (*to_get_min_fast_tracepoint_insn_len) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (-1);
/* Set the target's tracing behavior in response to unexpected
disconnection - set VAL to 1 to keep tracing, 0 to stop. */
- void (*to_set_disconnected_tracing) (struct target_ops *, int val);
- void (*to_set_circular_trace_buffer) (struct target_ops *, int val);
+ void (*to_set_disconnected_tracing) (struct target_ops *, int val)
+ TARGET_DEFAULT_IGNORE ();
+ void (*to_set_circular_trace_buffer) (struct target_ops *, int val)
+ TARGET_DEFAULT_IGNORE ();
/* Set the size of trace buffer in the target. */
- void (*to_set_trace_buffer_size) (struct target_ops *, LONGEST val);
+ void (*to_set_trace_buffer_size) (struct target_ops *, LONGEST val)
+ TARGET_DEFAULT_IGNORE ();
/* Add/change textual notes about the trace run, returning 1 if
successful, 0 otherwise. */
int (*to_set_trace_notes) (struct target_ops *,
const char *user, const char *notes,
- const char *stopnotes);
+ const char *stopnotes)
+ TARGET_DEFAULT_RETURN (0);
/* Return the processor core that thread PTID was last seen on.
This information is updated only when:
/* Return the address of the start of the Thread Information Block
a Windows OS specific feature. */
int (*to_get_tib_address) (struct target_ops *,
- ptid_t ptid, CORE_ADDR *addr);
+ ptid_t ptid, CORE_ADDR *addr)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Send the new settings of write permission variables. */
- void (*to_set_permissions) (struct target_ops *);
+ void (*to_set_permissions) (struct target_ops *)
+ TARGET_DEFAULT_IGNORE ();
/* Look for a static tracepoint marker at ADDR, and fill in MARKER
with its details. Return 1 on success, 0 on failure. */
int (*to_static_tracepoint_marker_at) (struct target_ops *, CORE_ADDR,
- struct static_tracepoint_marker *marker);
+ struct static_tracepoint_marker *marker)
+ TARGET_DEFAULT_RETURN (0);
/* Return a vector of all tracepoints markers string id ID, or all
markers if ID is NULL. */
- VEC(static_tracepoint_marker_p) *(*to_static_tracepoint_markers_by_strid)
- (struct target_ops *, const char *id);
+ VEC(static_tracepoint_marker_p) *(*to_static_tracepoint_markers_by_strid) (struct target_ops *, const char *id)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Return a traceframe info object describing the current
traceframe's contents. If the target doesn't support
is available in the read-only sections. This method should not
cache data; higher layers take care of caching, invalidating,
and re-fetching when necessary. */
- struct traceframe_info *(*to_traceframe_info) (struct target_ops *);
+ struct traceframe_info *(*to_traceframe_info) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Ask the target to use or not to use agent according to USE. Return 1
successful, 0 otherwise. */
- int (*to_use_agent) (struct target_ops *, int use);
+ int (*to_use_agent) (struct target_ops *, int use)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Is the target able to use agent in current state? */
- int (*to_can_use_agent) (struct target_ops *);
+ int (*to_can_use_agent) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Check whether the target supports branch tracing. */
int (*to_supports_btrace) (struct target_ops *)
void (*to_info_record) (struct target_ops *);
/* Save the recorded execution trace into a file. */
- void (*to_save_record) (const char *filename);
+ void (*to_save_record) (struct target_ops *, const char *filename);
/* Delete the recorded execution trace from the current position onwards. */
- void (*to_delete_record) (void);
+ void (*to_delete_record) (struct target_ops *);
/* Query if the record target is currently replaying. */
- int (*to_record_is_replaying) (void);
+ int (*to_record_is_replaying) (struct target_ops *);
/* Go to the begin of the execution trace. */
- void (*to_goto_record_begin) (void);
+ void (*to_goto_record_begin) (struct target_ops *);
/* Go to the end of the execution trace. */
- void (*to_goto_record_end) (void);
+ void (*to_goto_record_end) (struct target_ops *);
/* Go to a specific location in the recorded execution trace. */
- void (*to_goto_record) (ULONGEST insn);
+ void (*to_goto_record) (struct target_ops *, ULONGEST insn);
/* Disassemble SIZE instructions in the recorded execution trace from
the current position.
If SIZE < 0, disassemble abs (SIZE) preceding instructions; otherwise,
disassemble SIZE succeeding instructions. */
- void (*to_insn_history) (int size, int flags);
+ void (*to_insn_history) (struct target_ops *, int size, int flags);
/* Disassemble SIZE instructions in the recorded execution trace around
FROM.
If SIZE < 0, disassemble abs (SIZE) instructions before FROM; otherwise,
disassemble SIZE instructions after FROM. */
- void (*to_insn_history_from) (ULONGEST from, int size, int flags);
+ void (*to_insn_history_from) (struct target_ops *,
+ ULONGEST from, int size, int flags);
/* Disassemble a section of the recorded execution trace from instruction
BEGIN (inclusive) to instruction END (inclusive). */
- void (*to_insn_history_range) (ULONGEST begin, ULONGEST end, int flags);
+ void (*to_insn_history_range) (struct target_ops *,
+ ULONGEST begin, ULONGEST end, int flags);
/* Print a function trace of the recorded execution trace.
If SIZE < 0, print abs (SIZE) preceding functions; otherwise, print SIZE
succeeding functions. */
- void (*to_call_history) (int size, int flags);
+ void (*to_call_history) (struct target_ops *, int size, int flags);
/* Print a function trace of the recorded execution trace starting
at function FROM.
If SIZE < 0, print abs (SIZE) functions before FROM; otherwise, print
SIZE functions after FROM. */
- void (*to_call_history_from) (ULONGEST begin, int size, int flags);
+ void (*to_call_history_from) (struct target_ops *,
+ ULONGEST begin, int size, int flags);
/* Print a function trace of an execution trace section from function BEGIN
(inclusive) to function END (inclusive). */
- void (*to_call_history_range) (ULONGEST begin, ULONGEST end, int flags);
+ void (*to_call_history_range) (struct target_ops *,
+ ULONGEST begin, ULONGEST end, int flags);
/* Nonzero if TARGET_OBJECT_LIBRARIES_SVR4 may be read with a
non-empty annex. */
- int (*to_augmented_libraries_svr4_read) (void);
+ int (*to_augmented_libraries_svr4_read) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Those unwinders are tried before any other arch unwinders. Use NULL if
it is not used. */
/* Target can execute in reverse? */
#define target_can_execute_reverse \
- (current_target.to_can_execute_reverse ? \
- current_target.to_can_execute_reverse (¤t_target) : 0)
+ current_target.to_can_execute_reverse (¤t_target)
extern const struct target_desc *target_read_description (struct target_ops *);
(*current_target.to_can_use_agent) (¤t_target)
#define target_augmented_libraries_svr4_read() \
- (*current_target.to_augmented_libraries_svr4_read) ()
+ (*current_target.to_augmented_libraries_svr4_read) (¤t_target)
/* Command logging facility. */
-#define target_log_command(p) \
- do \
- if (current_target.to_log_command) \
- (*current_target.to_log_command) (¤t_target, \
- p); \
- while (0)
+#define target_log_command(p) \
+ (*current_target.to_log_command) (¤t_target, p)
extern int target_core_of_thread (ptid_t ptid);
projects / deliverable / binutils-gdb.git / blobdiff