X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ftarget.h;h=34539c16ca55bd30d217ddf979d7f58715a3c3c0;hb=2117c711ae07700adb57ea5b5ca61e4c32d7e3d2;hp=7bc6d32c7628729234814acddf412b0b9c391800;hpb=22bcceeec6bfd4373fa8d09acff66115800f0455;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/target.h b/gdb/target.h index 7bc6d32c76..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 *, @@ -527,7 +534,8 @@ struct target_ops 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_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) @@ -537,25 +545,33 @@ struct target_ops 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 *); + 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 *); + void (*to_program_signals) (struct target_ops *, int, unsigned char *) + TARGET_DEFAULT_IGNORE (); - 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); + 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); + 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); @@ -563,7 +579,8 @@ struct target_ops 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 *); + 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 *); @@ -654,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. @@ -662,18 +680,22 @@ 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 @@ -688,7 +710,8 @@ struct target_ops 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. @@ -699,7 +722,8 @@ 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 *) @@ -730,11 +754,13 @@ struct target_ops /* 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. @@ -915,14 +941,16 @@ 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. */ @@ -931,17 +959,19 @@ struct target_ops 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 @@ -956,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 *) @@ -972,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. @@ -992,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. */