X-Git-Url: http://drtracing.org/?a=blobdiff_plain;ds=sidebyside;f=gdb%2Fgdbserver%2Ftarget.h;h=fce54e05adbc3b6509cb2c891a067154cc72cd4f;hb=a780ef4f27f8bc44082be81fdbee44bb11f1049c;hp=358a8ab77a8307fa2aced2e65990648006b8302b;hpb=37ce4055fe907b9edd25498dcda7a133dbd19784;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbserver/target.h b/gdb/gdbserver/target.h index 358a8ab77a..fce54e05ad 100644 --- a/gdb/gdbserver/target.h +++ b/gdb/gdbserver/target.h @@ -1,5 +1,5 @@ /* Target operations for the remote server for GDB. - Copyright (C) 2002-2015 Free Software Foundation, Inc. + Copyright (C) 2002-2018 Free Software Foundation, Inc. Contributed by MontaVista Software. @@ -28,6 +28,7 @@ #include "target/waitstatus.h" #include "mem-break.h" #include "btrace-common.h" +#include struct emit_ops; struct buffer; @@ -67,16 +68,17 @@ struct target_ops /* Start a new process. PROGRAM is a path to the program to execute. - ARGS is a standard NULL-terminated array of arguments, - to be passed to the inferior as ``argv''. + PROGRAM_ARGS is a standard NULL-terminated array of arguments, + to be passed to the inferior as ``argv'' (along with PROGRAM). Returns the new PID on success, -1 on failure. Registers the new process with the process list. */ + int (*create_inferior) (const char *program, + const std::vector &program_args); - int (*create_inferior) (char *program, char **args); - - /* Architecture-specific setup. */ - void (*arch_setup) (void); + /* Do additional setup after a new process is created, including + exec-wrapper completion. */ + void (*post_create_inferior) (void); /* Attach to a running process. @@ -88,21 +90,22 @@ struct target_ops int (*attach) (unsigned long pid); - /* Kill inferior PID. Return -1 on failure, and 0 on success. */ + /* Kill process PROC. Return -1 on failure, and 0 on success. */ - int (*kill) (int pid); + int (*kill) (process_info *proc); - /* Detach from inferior PID. Return -1 on failure, and 0 on + /* Detach from process PROC. Return -1 on failure, and 0 on success. */ - int (*detach) (int pid); + int (*detach) (process_info *proc); /* The inferior process has died. Do what is right. */ void (*mourn) (struct process_info *proc); - /* Wait for inferior PID to exit. */ - void (*join) (int pid); + /* Wait for process PROC to exit. */ + + void (*join) (process_info *proc); /* Return 1 iff the thread with process ID PID is alive. */ @@ -389,9 +392,6 @@ struct target_ops /* Return true if target supports debugging agent. */ int (*supports_agent) (void); - /* Check whether the target supports branch tracing. */ - int (*supports_btrace) (struct target_ops *, enum btrace_format); - /* Enable branch tracing for PTID based on CONF and allocate a branch trace target information struct for reading and for disabling branch trace. */ struct btrace_target_info *(*enable_btrace) @@ -453,26 +453,51 @@ struct target_ops specific meaning like the Z0 kind parameter. SIZE is set to the software breakpoint's length in memory. */ const gdb_byte *(*sw_breakpoint_from_kind) (int kind, int *size); + + /* Return the thread's name, or NULL if the target is unable to determine it. + The returned value must not be freed by the caller. */ + const char *(*thread_name) (ptid_t thread); + + /* Return the breakpoint kind for this target based on the current + processor state (e.g. the current instruction mode on ARM) and the + PC. The PCPTR is adjusted to the real memory location in case a flag + (e.g., the Thumb bit on ARM) is present in the PC. */ + int (*breakpoint_kind_from_current_state) (CORE_ADDR *pcptr); + + /* Returns true if the target can software single step. */ + int (*supports_software_single_step) (void); + + /* Return 1 if the target supports catch syscall, 0 (or leave the + callback NULL) otherwise. */ + int (*supports_catch_syscall) (void); + + /* Return tdesc index for IPA. */ + int (*get_ipa_tdesc_idx) (void); + + /* Thread ID to (numeric) thread handle: Return true on success and + false for failure. Return pointer to thread handle via HANDLE + and the handle's length via HANDLE_LEN. */ + bool (*thread_handle) (ptid_t ptid, gdb_byte **handle, int *handle_len); }; extern struct target_ops *the_target; void set_target_ops (struct target_ops *); -#define create_inferior(program, args) \ - (*the_target->create_inferior) (program, args) +#define create_inferior(program, program_args) \ + (*the_target->create_inferior) (program, program_args) -#define target_arch_setup() \ - do \ - { \ - if (the_target->arch_setup != NULL) \ - (*the_target->arch_setup) (); \ +#define target_post_create_inferior() \ + do \ + { \ + if (the_target->post_create_inferior != NULL) \ + (*the_target->post_create_inferior) (); \ } while (0) #define myattach(pid) \ (*the_target->attach) (pid) -int kill_inferior (int); +int kill_inferior (process_info *proc); #define target_supports_fork_events() \ (the_target->supports_fork_events ? \ @@ -493,11 +518,8 @@ int kill_inferior (int); (*the_target->handle_new_gdb_connection) (); \ } while (0) -#define detach_inferior(pid) \ - (*the_target->detach) (pid) - -#define mourn_inferior(PROC) \ - (*the_target->mourn) (PROC) +#define detach_inferior(proc) \ + (*the_target->detach) (proc) #define mythread_alive(pid) \ (*the_target->thread_alive) (pid) @@ -508,8 +530,8 @@ int kill_inferior (int); #define store_inferior_registers(regcache, regno) \ (*the_target->store_registers) (regcache, regno) -#define join_inferior(pid) \ - (*the_target->join) (pid) +#define join_inferior(proc) \ + (*the_target->join) (proc) #define target_supports_non_stop() \ (the_target->supports_non_stop ? (*the_target->supports_non_stop ) () : 0) @@ -517,10 +539,6 @@ int kill_inferior (int); #define target_async(enable) \ (the_target->async ? (*the_target->async) (enable) : 0) -#define target_supports_multi_process() \ - (the_target->supports_multi_process ? \ - (*the_target->supports_multi_process) () : 0) - #define target_process_qsupported(features, count) \ do \ { \ @@ -528,6 +546,14 @@ int kill_inferior (int); the_target->process_qsupported (features, count); \ } while (0) +#define target_supports_catch_syscall() \ + (the_target->supports_catch_syscall ? \ + (*the_target->supports_catch_syscall) () : 0) + +#define target_get_ipa_tdesc_idx() \ + (the_target->get_ipa_tdesc_idx \ + ? (*the_target->get_ipa_tdesc_idx) () : 0) + #define target_supports_tracepoints() \ (the_target->supports_tracepoints \ ? (*the_target->supports_tracepoints) () : 0) @@ -595,21 +621,44 @@ int kill_inferior (int); (the_target->supports_agent ? \ (*the_target->supports_agent) () : 0) -#define target_supports_btrace(format) \ - (the_target->supports_btrace \ - ? (*the_target->supports_btrace) (the_target, format) : 0) +static inline struct btrace_target_info * +target_enable_btrace (ptid_t ptid, const struct btrace_config *conf) +{ + if (the_target->enable_btrace == nullptr) + error (_("Target does not support branch tracing.")); + + return (*the_target->enable_btrace) (ptid, conf); +} + +static inline int +target_disable_btrace (struct btrace_target_info *tinfo) +{ + if (the_target->disable_btrace == nullptr) + error (_("Target does not support branch tracing.")); + + return (*the_target->disable_btrace) (tinfo); +} -#define target_enable_btrace(ptid, conf) \ - (*the_target->enable_btrace) (ptid, conf) +static inline int +target_read_btrace (struct btrace_target_info *tinfo, + struct buffer *buffer, + enum btrace_read_type type) +{ + if (the_target->read_btrace == nullptr) + error (_("Target does not support branch tracing.")); -#define target_disable_btrace(tinfo) \ - (*the_target->disable_btrace) (tinfo) + return (*the_target->read_btrace) (tinfo, buffer, type); +} -#define target_read_btrace(tinfo, buffer, type) \ - (*the_target->read_btrace) (tinfo, buffer, type) +static inline int +target_read_btrace_conf (struct btrace_target_info *tinfo, + struct buffer *buffer) +{ + if (the_target->read_btrace_conf == nullptr) + error (_("Target does not support branch tracing.")); -#define target_read_btrace_conf(tinfo, buffer) \ - (*the_target->read_btrace_conf) (tinfo, buffer) + return (*the_target->read_btrace_conf) (tinfo, buffer); +} #define target_supports_range_stepping() \ (the_target->supports_range_stepping ? \ @@ -640,6 +689,15 @@ int kill_inferior (int); ? (*the_target->breakpoint_kind_from_pc) (pcptr) \ : default_breakpoint_kind_from_pc (pcptr)) +#define target_breakpoint_kind_from_current_state(pcptr) \ + (the_target->breakpoint_kind_from_current_state \ + ? (*the_target->breakpoint_kind_from_current_state) (pcptr) \ + : target_breakpoint_kind_from_pc (pcptr)) + +#define target_supports_software_single_step() \ + (the_target->supports_software_single_step ? \ + (*the_target->supports_software_single_step) () : 0) + /* Start non-stop mode, returns 0 on success, -1 on failure. */ int start_non_stop (int nonstop); @@ -647,28 +705,31 @@ int start_non_stop (int nonstop); ptid_t mywait (ptid_t ptid, struct target_waitstatus *ourstatus, int options, int connected_wait); -#define prepare_to_access_memory() \ - (the_target->prepare_to_access_memory \ - ? (*the_target->prepare_to_access_memory) () \ - : 0) +/* Prepare to read or write memory from the inferior process. See the + corresponding target_ops methods for more details. */ -#define done_accessing_memory() \ - do \ - { \ - if (the_target->done_accessing_memory) \ - (*the_target->done_accessing_memory) (); \ - } while (0) +int prepare_to_access_memory (void); +void done_accessing_memory (void); #define target_core_of_thread(ptid) \ (the_target->core_of_thread ? (*the_target->core_of_thread) (ptid) \ : -1) +#define target_thread_name(ptid) \ + (the_target->thread_name ? (*the_target->thread_name) (ptid) \ + : NULL) + +#define target_thread_handle(ptid, handle, handle_len) \ + (the_target->thread_handle ? (*the_target->thread_handle) \ + (ptid, handle, handle_len) \ + : false) + int read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len); int write_inferior_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len); -int set_desired_thread (int id); +int set_desired_thread (); const char *target_pid_to_str (ptid_t);