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_disconnect) (struct target_ops *, char *, int)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
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 *)
TARGET_DEFAULT_FUNC (memory_remove_breakpoint);
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 *);
+ 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 *)
TARGET_DEFAULT_RETURN (-1);
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);
+ CORE_ADDR, CORE_ADDR, int)
+ TARGET_DEFAULT_RETURN (1);
int (*to_stopped_by_watchpoint) (struct target_ops *)
TARGET_DEFAULT_RETURN (0);
int to_have_steppable_watchpoint;
struct expression *)
TARGET_DEFAULT_RETURN (0);
int (*to_masked_watch_num_registers) (struct target_ops *,
- CORE_ADDR, CORE_ADDR);
+ CORE_ADDR, CORE_ADDR)
+ TARGET_DEFAULT_RETURN (-1);
void (*to_terminal_init) (struct target_ops *)
TARGET_DEFAULT_IGNORE ();
void (*to_terminal_inferior) (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_kill) (struct target_ops *)
+ TARGET_DEFAULT_NORETURN (noprocess ());
void (*to_load) (struct target_ops *, char *, int)
TARGET_DEFAULT_NORETURN (tcomplain ());
void (*to_create_inferior) (struct target_ops *,
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);
- 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) (struct target_ops *, int);
- int (*to_remove_exec_catchpoint) (struct target_ops *, int);
+ 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)
+ TARGET_DEFAULT_FUNC (default_follow_fork);
+ 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 *);
- void (*to_mourn_inferior) (struct target_ops *);
- int (*to_can_run) (struct target_ops *);
+ 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 *)
+ TARGET_DEFAULT_FUNC (default_mourn_inferior);
+ int (*to_can_run) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Documentation of this routine is provided with the corresponding
target_* macro. */
- void (*to_pass_signals) (struct target_ops *, int, unsigned char *);
+ void (*to_pass_signals) (struct target_ops *, int, unsigned char *)
+ TARGET_DEFAULT_IGNORE ();
/* Documentation of this routine is provided with the
corresponding target_* function. */
- 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 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_program_signals) (struct target_ops *, int, unsigned char *)
+ TARGET_DEFAULT_IGNORE ();
+
+ int (*to_thread_alive) (struct target_ops *, ptid_t ptid)
+ TARGET_DEFAULT_RETURN (0);
+ void (*to_find_new_threads) (struct target_ops *)
+ TARGET_DEFAULT_IGNORE ();
+ char *(*to_pid_to_str) (struct target_ops *, ptid_t)
+ TARGET_DEFAULT_FUNC (default_pid_to_str);
+ 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)
TARGET_DEFAULT_FUNC (default_rcmd);
- 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 *);
+ 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 *)
+ TARGET_DEFAULT_RETURN (0);
enum strata to_stratum;
int (*to_has_all_memory) (struct target_ops *);
int (*to_has_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
This method should not cache data; if the memory map could
change unexpectedly, it should be invalidated, and higher
layers will re-fetch it. */
- VEC(mem_region_s) *(*to_memory_map) (struct target_ops *);
+ VEC(mem_region_s) *(*to_memory_map) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Erases the region of flash memory starting at ADDRESS, of
length LENGTH.
Precondition: both ADDRESS and ADDRESS+LENGTH should be aligned
on flash block boundaries, as reported by 'to_memory_map'. */
void (*to_flash_erase) (struct target_ops *,
- ULONGEST address, LONGEST length);
+ ULONGEST address, LONGEST length)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Finishes a flash memory write sequence. After this operation
all flash memory should be available for writing and the result
of reading from areas written by 'to_flash_write' should be
equal to what was written. */
- void (*to_flash_done) (struct target_ops *);
+ void (*to_flash_done) (struct target_ops *)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
- /* Describe the architecture-specific features of this target.
- Returns the description found, or NULL if no description
- was available. */
- const struct target_desc *(*to_read_description) (struct target_ops *ops);
+ /* Describe the architecture-specific features of this target. If
+ OPS doesn't have a description, this should delegate to the
+ "beneath" target. Returns the description found, or NULL if no
+ description was available. */
+ const struct target_desc *(*to_read_description) (struct target_ops *ops)
+ TARGET_DEFAULT_RETURN (0);
/* Build the PTID of the thread on which a given task is running,
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) (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.
Return -1 if there is insufficient buffer for a whole entry.
Return 1 if an entry was read into *TYPEP and *VALP. */
int (*to_auxv_parse) (struct target_ops *ops, gdb_byte **readptr,
- gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp);
+ gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
+ TARGET_DEFAULT_FUNC (default_auxv_parse);
/* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
sequence of bytes in PATTERN with length PATTERN_LEN.
int (*to_search_memory) (struct target_ops *ops,
CORE_ADDR start_addr, ULONGEST search_space_len,
const gdb_byte *pattern, ULONGEST pattern_len,
- CORE_ADDR *found_addrp);
+ CORE_ADDR *found_addrp)
+ TARGET_DEFAULT_FUNC (default_search_memory);
/* 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:
If the core cannot be determined -- either for the specified
thread, or right now, or in this debug session, or for this
target -- return -1. */
- int (*to_core_of_thread) (struct target_ops *, ptid_t ptid);
+ int (*to_core_of_thread) (struct target_ops *, ptid_t ptid)
+ TARGET_DEFAULT_RETURN (-1);
/* Verify that the memory in the [MEMADDR, MEMADDR+SIZE) range
matches the contents of [DATA,DATA+SIZE). Returns 1 if there's
a match, 0 if there's a mismatch, and -1 if an error is
encountered while reading memory. */
int (*to_verify_memory) (struct target_ops *, const gdb_byte *data,
- CORE_ADDR memaddr, ULONGEST size);
+ CORE_ADDR memaddr, ULONGEST size)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* 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 *)
/* Enable branch tracing for PTID and allocate a branch trace target
information struct for reading and for disabling branch trace. */
struct btrace_target_info *(*to_enable_btrace) (struct target_ops *,
- ptid_t ptid);
+ ptid_t ptid)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Disable branch tracing and deallocate TINFO. */
void (*to_disable_btrace) (struct target_ops *,
- struct btrace_target_info *tinfo);
+ struct btrace_target_info *tinfo)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Disable branch tracing and deallocate TINFO. This function is similar
to to_disable_btrace, except that it is called during teardown and is
only allowed to perform actions that are safe. A counter-example would
be attempting to talk to a remote target. */
void (*to_teardown_btrace) (struct target_ops *,
- struct btrace_target_info *tinfo);
+ struct btrace_target_info *tinfo)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Read branch trace data for the thread indicated by BTINFO into DATA.
DATA is cleared before new trace is added.
enum btrace_error (*to_read_btrace) (struct target_ops *self,
VEC (btrace_block_s) **data,
struct btrace_target_info *btinfo,
- enum btrace_read_type type);
+ enum btrace_read_type type)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Stop trace recording. */
- void (*to_stop_recording) (struct target_ops *);
+ void (*to_stop_recording) (struct target_ops *)
+ TARGET_DEFAULT_IGNORE ();
/* Print information about the recording. */
void (*to_info_record) (struct target_ops *);
/* Save the recorded execution trace into a file. */
- void (*to_save_record) (struct target_ops *, const char *filename);
+ void (*to_save_record) (struct target_ops *, const char *filename)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Delete the recorded execution trace from the current position onwards. */
- void (*to_delete_record) (struct target_ops *);
+ void (*to_delete_record) (struct target_ops *)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Query if the record target is currently replaying. */
- int (*to_record_is_replaying) (struct target_ops *);
+ int (*to_record_is_replaying) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* Go to the begin of the execution trace. */
- void (*to_goto_record_begin) (struct target_ops *);
+ void (*to_goto_record_begin) (struct target_ops *)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Go to the end of the execution trace. */
- void (*to_goto_record_end) (struct target_ops *);
+ void (*to_goto_record_end) (struct target_ops *)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Go to a specific location in the recorded execution trace. */
- void (*to_goto_record) (struct target_ops *, ULONGEST insn);
+ void (*to_goto_record) (struct target_ops *, ULONGEST insn)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* 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) (struct target_ops *, int size, int flags);
+ void (*to_insn_history) (struct target_ops *, int size, int flags)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* 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) (struct target_ops *,
- ULONGEST from, int size, int flags);
+ ULONGEST from, int size, int flags)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Disassemble a section of the recorded execution trace from instruction
BEGIN (inclusive) to instruction END (inclusive). */
void (*to_insn_history_range) (struct target_ops *,
- ULONGEST begin, ULONGEST end, int flags);
+ ULONGEST begin, ULONGEST end, int flags)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* 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) (struct target_ops *, int size, int flags);
+ void (*to_call_history) (struct target_ops *, int size, int flags)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* 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) (struct target_ops *,
- ULONGEST begin, int size, int flags);
+ ULONGEST begin, int size, int flags)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Print a function trace of an execution trace section from function BEGIN
(inclusive) to function END (inclusive). */
void (*to_call_history_range) (struct target_ops *,
- ULONGEST begin, ULONGEST end, int flags);
+ ULONGEST begin, ULONGEST end, int flags)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Nonzero if TARGET_OBJECT_LIBRARIES_SVR4 may be read with a
non-empty annex. */
- int (*to_augmented_libraries_svr4_read) (struct target_ops *);
+ 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 *);
/* 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