X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ftarget.h;h=34539c16ca55bd30d217ddf979d7f58715a3c3c0;hb=2117c711ae07700adb57ea5b5ca61e4c32d7e3d2;hp=b270c414e5ef4e54c5b9659a86ca5dcdc89f5109;hpb=7e18a8dc5941ffd8728075e2b135e5c9ea1b640e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/target.h b/gdb/target.h index b270c414e5..34539c16ca 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -409,13 +409,15 @@ struct target_ops 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 *) @@ -457,7 +459,8 @@ struct target_ops 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); @@ -475,9 +478,11 @@ struct target_ops 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; @@ -499,7 +504,8 @@ struct target_ops 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 *) @@ -512,7 +518,8 @@ 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 *, @@ -525,36 +532,55 @@ struct target_ops 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); - 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_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 *); @@ -573,13 +599,17 @@ 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 @@ -641,7 +671,8 @@ struct target_ops 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. @@ -649,32 +680,38 @@ struct target_ops 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. @@ -685,37 +722,45 @@ struct target_ops 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. @@ -727,7 +772,8 @@ struct target_ops 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. @@ -781,45 +827,56 @@ struct target_ops /* 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 @@ -828,43 +885,54 @@ struct target_ops 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: @@ -873,32 +941,37 @@ struct target_ops 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 @@ -913,14 +986,17 @@ struct target_ops 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 *) @@ -929,18 +1005,21 @@ 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. @@ -949,70 +1028,85 @@ struct target_ops 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. */ @@ -1746,8 +1840,7 @@ extern int target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask); /* 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 *); @@ -1922,12 +2015,8 @@ extern char *target_fileio_read_stralloc (const char *filename); /* 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);