X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdbserver%2Ftarget.cc;h=b5190e1f52a28f09e9ac019b4d009dfb23bdb47f;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=680addadf78de987d58a7ac930d9a1dc1615e3d3;hpb=4e2e869cb3336beb959a969e7b7c7897583ef16e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdbserver/target.cc b/gdbserver/target.cc index 680addadf7..b5190e1f52 100644 --- a/gdbserver/target.cc +++ b/gdbserver/target.cc @@ -22,6 +22,10 @@ #include "tracepoint.h" #include "gdbsupport/byte-vector.h" #include "hostio.h" +#include +#include +#include +#include process_stratum_target *the_target; @@ -58,7 +62,7 @@ prepare_to_access_memory (void) it. */ prev_general_thread = cs.general_thread; - int res = the_target->pt->prepare_to_access_memory (); + int res = the_target->prepare_to_access_memory (); if (res != 0) return res; @@ -66,7 +70,7 @@ prepare_to_access_memory (void) { if (mythread_alive (thread->id)) { - if (stopped == NULL && the_target->pt->supports_thread_stopped () + if (stopped == NULL && the_target->supports_thread_stopped () && target_thread_stopped (thread)) stopped = thread; @@ -110,7 +114,7 @@ done_accessing_memory (void) { client_state &cs = get_client_state (); - the_target->pt->done_accessing_memory (); + the_target->done_accessing_memory (); /* Restore the previous selected thread. */ cs.general_thread = prev_general_thread; @@ -121,7 +125,7 @@ int read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) { int res; - res = the_target->pt->read_memory (memaddr, myaddr, len); + res = the_target->read_memory (memaddr, myaddr, len); check_mem_read (memaddr, myaddr, len); return res; } @@ -152,7 +156,7 @@ target_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, update it. */ gdb::byte_vector buffer (myaddr, myaddr + len); check_mem_write (memaddr, buffer.data (), myaddr, len); - return the_target->pt->write_memory (memaddr, buffer.data (), len); + return the_target->write_memory (memaddr, buffer.data (), len); } ptid_t @@ -206,7 +210,7 @@ target_stop_and_wait (ptid_t ptid) resume_info.thread = ptid; resume_info.kind = resume_stop; resume_info.sig = GDB_SIGNAL_0; - the_target->pt->resume (&resume_info, 1); + the_target->resume (&resume_info, 1); non_stop = true; mywait (ptid, &status, 0, 0); @@ -218,7 +222,7 @@ target_stop_and_wait (ptid_t ptid) ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status, int options) { - return the_target->pt->wait (ptid, status, options); + return the_target->wait (ptid, status, options); } /* See target/target.h. */ @@ -226,7 +230,7 @@ target_wait (ptid_t ptid, struct target_waitstatus *status, int options) void target_mourn_inferior (ptid_t ptid) { - the_target->pt->mourn (find_process_pid (ptid.pid ())); + the_target->mourn (find_process_pid (ptid.pid ())); } /* See target/target.h. */ @@ -239,7 +243,7 @@ target_continue_no_signal (ptid_t ptid) resume_info.thread = ptid; resume_info.kind = resume_continue; resume_info.sig = GDB_SIGNAL_0; - the_target->pt->resume (&resume_info, 1); + the_target->resume (&resume_info, 1); } /* See target/target.h. */ @@ -252,7 +256,7 @@ target_continue (ptid_t ptid, enum gdb_signal signal) resume_info.thread = ptid; resume_info.kind = resume_continue; resume_info.sig = gdb_signal_to_host (signal); - the_target->pt->resume (&resume_info, 1); + the_target->resume (&resume_info, 1); } /* See target/target.h. */ @@ -260,14 +264,13 @@ target_continue (ptid_t ptid, enum gdb_signal signal) int target_supports_multi_process (void) { - return the_target->pt->supports_multi_process (); + return the_target->supports_multi_process (); } void set_target_ops (process_stratum_target *target) { - the_target = XNEW (process_stratum_target); - memcpy (the_target, target, sizeof (*the_target)); + the_target = target; } /* Convert pid to printable format. */ @@ -299,23 +302,7 @@ kill_inferior (process_info *proc) { gdb_agent_about_to_close (proc->pid); - return the_target->pt->kill (proc); -} - -/* Default implementation for breakpoint_kind_for_pc. - - The default behavior for targets that don't implement breakpoint_kind_for_pc - is to use the size of a breakpoint as the kind. */ - -int -default_breakpoint_kind_from_pc (CORE_ADDR *pcptr) -{ - int size = 0; - - gdb_assert (the_target->sw_breakpoint_from_kind != NULL); - - (*the_target->sw_breakpoint_from_kind) (0, &size); - return size; + return the_target->kill (proc); } /* Define it. */ @@ -370,177 +357,183 @@ target_terminal::info (const char *arg, int from_tty) See target.h for definitions. */ void -process_target::post_create_inferior () +process_stratum_target::post_create_inferior () { /* Nop. */ } int -process_target::prepare_to_access_memory () +process_stratum_target::prepare_to_access_memory () { return 0; } void -process_target::done_accessing_memory () +process_stratum_target::done_accessing_memory () { /* Nop. */ } void -process_target::look_up_symbols () +process_stratum_target::look_up_symbols () { /* Nop. */ } bool -process_target::supports_read_auxv () +process_stratum_target::supports_read_auxv () { return false; } int -process_target::read_auxv (CORE_ADDR offset, unsigned char *myaddr, - unsigned int len) +process_stratum_target::read_auxv (CORE_ADDR offset, unsigned char *myaddr, + unsigned int len) { gdb_assert_not_reached ("target op read_auxv not supported"); } bool -process_target::supports_z_point_type (char z_type) +process_stratum_target::supports_z_point_type (char z_type) { return false; } int -process_target::insert_point (enum raw_bkpt_type type, CORE_ADDR addr, - int size, raw_breakpoint *bp) +process_stratum_target::insert_point (enum raw_bkpt_type type, + CORE_ADDR addr, + int size, raw_breakpoint *bp) { return 1; } int -process_target::remove_point (enum raw_bkpt_type type, CORE_ADDR addr, - int size, raw_breakpoint *bp) +process_stratum_target::remove_point (enum raw_bkpt_type type, + CORE_ADDR addr, + int size, raw_breakpoint *bp) { return 1; } bool -process_target::stopped_by_sw_breakpoint () +process_stratum_target::stopped_by_sw_breakpoint () { return false; } bool -process_target::supports_stopped_by_sw_breakpoint () +process_stratum_target::supports_stopped_by_sw_breakpoint () { return false; } bool -process_target::stopped_by_hw_breakpoint () +process_stratum_target::stopped_by_hw_breakpoint () { return false; } bool -process_target::supports_stopped_by_hw_breakpoint () +process_stratum_target::supports_stopped_by_hw_breakpoint () { return false; } bool -process_target::supports_hardware_single_step () +process_stratum_target::supports_hardware_single_step () { return false; } bool -process_target::stopped_by_watchpoint () +process_stratum_target::stopped_by_watchpoint () { return false; } CORE_ADDR -process_target::stopped_data_address () +process_stratum_target::stopped_data_address () { return 0; } bool -process_target::supports_read_offsets () +process_stratum_target::supports_read_offsets () { return false; } int -process_target::read_offsets (CORE_ADDR *text, CORE_ADDR *data) +process_stratum_target::read_offsets (CORE_ADDR *text, CORE_ADDR *data) { gdb_assert_not_reached ("target op read_offsets not supported"); } bool -process_target::supports_get_tls_address () +process_stratum_target::supports_get_tls_address () { return false; } int -process_target::get_tls_address (thread_info *thread, CORE_ADDR offset, - CORE_ADDR load_module, CORE_ADDR *address) +process_stratum_target::get_tls_address (thread_info *thread, + CORE_ADDR offset, + CORE_ADDR load_module, + CORE_ADDR *address) { gdb_assert_not_reached ("target op get_tls_address not supported"); } void -process_target::hostio_last_error (char *buf) +process_stratum_target::hostio_last_error (char *buf) { hostio_last_error_from_errno (buf); } bool -process_target::supports_qxfer_osdata () +process_stratum_target::supports_qxfer_osdata () { return false; } int -process_target::qxfer_osdata (const char *annex, unsigned char *readbuf, - unsigned const char *writebuf, - CORE_ADDR offset, int len) +process_stratum_target::qxfer_osdata (const char *annex, + unsigned char *readbuf, + unsigned const char *writebuf, + CORE_ADDR offset, int len) { gdb_assert_not_reached ("target op qxfer_osdata not supported"); } bool -process_target::supports_qxfer_siginfo () +process_stratum_target::supports_qxfer_siginfo () { return false; } int -process_target::qxfer_siginfo (const char *annex, unsigned char *readbuf, - unsigned const char *writebuf, - CORE_ADDR offset, int len) +process_stratum_target::qxfer_siginfo (const char *annex, + unsigned char *readbuf, + unsigned const char *writebuf, + CORE_ADDR offset, int len) { gdb_assert_not_reached ("target op qxfer_siginfo not supported"); } bool -process_target::supports_non_stop () +process_stratum_target::supports_non_stop () { return false; } bool -process_target::async (bool enable) +process_stratum_target::async (bool enable) { return false; } int -process_target::start_non_stop (bool enable) +process_stratum_target::start_non_stop (bool enable) { if (enable) return -1; @@ -549,104 +542,300 @@ process_target::start_non_stop (bool enable) } bool -process_target::supports_multi_process () +process_stratum_target::supports_multi_process () { return false; } bool -process_target::supports_fork_events () +process_stratum_target::supports_fork_events () { return false; } bool -process_target::supports_vfork_events () +process_stratum_target::supports_vfork_events () { return false; } bool -process_target::supports_exec_events () +process_stratum_target::supports_exec_events () { return false; } void -process_target::handle_new_gdb_connection () +process_stratum_target::handle_new_gdb_connection () { /* Nop. */ } int -process_target::handle_monitor_command (char *mon) +process_stratum_target::handle_monitor_command (char *mon) { return 0; } int -process_target::core_of_thread (ptid_t ptid) +process_stratum_target::core_of_thread (ptid_t ptid) { return -1; } bool -process_target::supports_read_loadmap () +process_stratum_target::supports_read_loadmap () { return false; } int -process_target::read_loadmap (const char *annex, CORE_ADDR offset, - unsigned char *myaddr, unsigned int len) +process_stratum_target::read_loadmap (const char *annex, + CORE_ADDR offset, + unsigned char *myaddr, + unsigned int len) { gdb_assert_not_reached ("target op read_loadmap not supported"); } void -process_target::process_qsupported (char **features, int count) +process_stratum_target::process_qsupported (char **features, int count) { /* Nop. */ } bool -process_target::supports_tracepoints () +process_stratum_target::supports_tracepoints () { return false; } CORE_ADDR -process_target::read_pc (regcache *regcache) +process_stratum_target::read_pc (regcache *regcache) { gdb_assert_not_reached ("process_target::read_pc: Unable to find PC"); } void -process_target::write_pc (regcache *regcache, CORE_ADDR pc) +process_stratum_target::write_pc (regcache *regcache, CORE_ADDR pc) { gdb_assert_not_reached ("process_target::write_pc: Unable to update PC"); } bool -process_target::supports_thread_stopped () +process_stratum_target::supports_thread_stopped () { return false; } bool -process_target::thread_stopped (thread_info *thread) +process_stratum_target::thread_stopped (thread_info *thread) { gdb_assert_not_reached ("target op thread_stopped not supported"); } bool -process_target::supports_get_tib_address () +process_stratum_target::supports_get_tib_address () { return false; } int -process_target::get_tib_address (ptid_t ptid, CORE_ADDR *address) +process_stratum_target::get_tib_address (ptid_t ptid, CORE_ADDR *address) { gdb_assert_not_reached ("target op get_tib_address not supported"); } + +void +process_stratum_target::pause_all (bool freeze) +{ + /* Nop. */ +} + +void +process_stratum_target::unpause_all (bool unfreeze) +{ + /* Nop. */ +} + +void +process_stratum_target::stabilize_threads () +{ + /* Nop. */ +} + +bool +process_stratum_target::supports_fast_tracepoints () +{ + return false; +} + +int +process_stratum_target::install_fast_tracepoint_jump_pad + (CORE_ADDR tpoint, CORE_ADDR tpaddr, CORE_ADDR collector, + CORE_ADDR lockaddr, ULONGEST orig_size, CORE_ADDR *jump_entry, + CORE_ADDR *trampoline, ULONGEST *trampoline_size, + unsigned char *jjump_pad_insn, ULONGEST *jjump_pad_insn_size, + CORE_ADDR *adjusted_insn_addr, CORE_ADDR *adjusted_insn_addr_end, + char *err) +{ + gdb_assert_not_reached ("target op install_fast_tracepoint_jump_pad " + "not supported"); +} + +int +process_stratum_target::get_min_fast_tracepoint_insn_len () +{ + return 0; +} + +struct emit_ops * +process_stratum_target::emit_ops () +{ + return nullptr; +} + +bool +process_stratum_target::supports_disable_randomization () +{ + return false; +} + +bool +process_stratum_target::supports_qxfer_libraries_svr4 () +{ + return false; +} + +int +process_stratum_target::qxfer_libraries_svr4 (const char *annex, + unsigned char *readbuf, + unsigned const char *writebuf, + CORE_ADDR offset, int len) +{ + gdb_assert_not_reached ("target op qxfer_libraries_svr4 not supported"); +} + +bool +process_stratum_target::supports_agent () +{ + return false; +} + +btrace_target_info * +process_stratum_target::enable_btrace (ptid_t ptid, const btrace_config *conf) +{ + error (_("Target does not support branch tracing.")); +} + +int +process_stratum_target::disable_btrace (btrace_target_info *tinfo) +{ + error (_("Target does not support branch tracing.")); +} + +int +process_stratum_target::read_btrace (btrace_target_info *tinfo, + buffer *buffer, + enum btrace_read_type type) +{ + error (_("Target does not support branch tracing.")); +} + +int +process_stratum_target::read_btrace_conf (const btrace_target_info *tinfo, + buffer *buffer) +{ + error (_("Target does not support branch tracing.")); +} + +bool +process_stratum_target::supports_range_stepping () +{ + return false; +} + +bool +process_stratum_target::supports_pid_to_exec_file () +{ + return false; +} + +char * +process_stratum_target::pid_to_exec_file (int pid) +{ + gdb_assert_not_reached ("target op pid_to_exec_file not supported"); +} + +bool +process_stratum_target::supports_multifs () +{ + return false; +} + +int +process_stratum_target::multifs_open (int pid, const char *filename, + int flags, mode_t mode) +{ + return open (filename, flags, mode); +} + +int +process_stratum_target::multifs_unlink (int pid, const char *filename) +{ + return unlink (filename); +} + +ssize_t +process_stratum_target::multifs_readlink (int pid, const char *filename, + char *buf, size_t bufsiz) +{ + return readlink (filename, buf, bufsiz); +} + +int +process_stratum_target::breakpoint_kind_from_pc (CORE_ADDR *pcptr) +{ + /* The default behavior is to use the size of a breakpoint as the + kind. */ + int size = 0; + sw_breakpoint_from_kind (0, &size); + return size; +} + +int +process_stratum_target::breakpoint_kind_from_current_state (CORE_ADDR *pcptr) +{ + return breakpoint_kind_from_pc (pcptr); +} + +const char * +process_stratum_target::thread_name (ptid_t thread) +{ + return nullptr; +} + +bool +process_stratum_target::thread_handle (ptid_t ptid, gdb_byte **handle, + int *handle_len) +{ + return false; +} + +bool +process_stratum_target::supports_software_single_step () +{ + return false; +} + +bool +process_stratum_target::supports_catch_syscall () +{ + return false; +} + +int +process_stratum_target::get_ipa_tdesc_idx () +{ + return 0; +}