X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdbserver%2Ftarget.cc;h=4c92fa6f89dae3915aa36329dd1b3354a6a6fe6a;hb=c9b7b80460e47ea4554960af6814de71b3e427cb;hp=501a8d675db11a95ac11b18db15a80fcb53f82de;hpb=5203ae1e870191ef058c1b4590f9b9fbf6b594ed;p=deliverable%2Fbinutils-gdb.git diff --git a/gdbserver/target.cc b/gdbserver/target.cc index 501a8d675d..4c92fa6f89 100644 --- a/gdbserver/target.cc +++ b/gdbserver/target.cc @@ -21,6 +21,11 @@ #include "server.h" #include "tracepoint.h" #include "gdbsupport/byte-vector.h" +#include "hostio.h" +#include +#include +#include +#include process_stratum_target *the_target; @@ -65,8 +70,8 @@ prepare_to_access_memory (void) { if (mythread_alive (thread->id)) { - if (stopped == NULL && the_target->thread_stopped != NULL - && thread_stopped (thread)) + if (stopped == NULL && the_target->pt->supports_thread_stopped () + && target_thread_stopped (thread)) stopped = thread; if (first == NULL) @@ -259,22 +264,7 @@ target_continue (ptid_t ptid, enum gdb_signal signal) int target_supports_multi_process (void) { - return (the_target->supports_multi_process != NULL ? - (*the_target->supports_multi_process) () : 0); -} - -int -start_non_stop (int nonstop) -{ - if (the_target->start_non_stop == NULL) - { - if (nonstop) - return -1; - else - return 0; - } - - return (*the_target->start_non_stop) (nonstop); + return the_target->pt->supports_multi_process (); } void @@ -493,3 +483,321 @@ process_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 () +{ + return false; +} + +int +process_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) +{ + hostio_last_error_from_errno (buf); +} + +bool +process_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) +{ + gdb_assert_not_reached ("target op qxfer_osdata not supported"); +} + +bool +process_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) +{ + gdb_assert_not_reached ("target op qxfer_siginfo not supported"); +} + +bool +process_target::supports_non_stop () +{ + return false; +} + +bool +process_target::async (bool enable) +{ + return false; +} + +int +process_target::start_non_stop (bool enable) +{ + if (enable) + return -1; + else + return 0; +} + +bool +process_target::supports_multi_process () +{ + return false; +} + +bool +process_target::supports_fork_events () +{ + return false; +} + +bool +process_target::supports_vfork_events () +{ + return false; +} + +bool +process_target::supports_exec_events () +{ + return false; +} + +void +process_target::handle_new_gdb_connection () +{ + /* Nop. */ +} + +int +process_target::handle_monitor_command (char *mon) +{ + return 0; +} + +int +process_target::core_of_thread (ptid_t ptid) +{ + return -1; +} + +bool +process_target::supports_read_loadmap () +{ + return false; +} + +int +process_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) +{ + /* Nop. */ +} + +bool +process_target::supports_tracepoints () +{ + return false; +} + +CORE_ADDR +process_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) +{ + gdb_assert_not_reached ("process_target::write_pc: Unable to update PC"); +} + +bool +process_target::supports_thread_stopped () +{ + return false; +} + +bool +process_target::thread_stopped (thread_info *thread) +{ + gdb_assert_not_reached ("target op thread_stopped not supported"); +} + +bool +process_target::supports_get_tib_address () +{ + return false; +} + +int +process_target::get_tib_address (ptid_t ptid, CORE_ADDR *address) +{ + gdb_assert_not_reached ("target op get_tib_address not supported"); +} + +void +process_target::pause_all (bool freeze) +{ + /* Nop. */ +} + +void +process_target::unpause_all (bool unfreeze) +{ + /* Nop. */ +} + +void +process_target::stabilize_threads () +{ + /* Nop. */ +} + +bool +process_target::supports_fast_tracepoints () +{ + return false; +} + +int +process_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_target::get_min_fast_tracepoint_insn_len () +{ + return 0; +} + +struct emit_ops * +process_target::emit_ops () +{ + return nullptr; +} + +bool +process_target::supports_disable_randomization () +{ + return false; +} + +bool +process_target::supports_qxfer_libraries_svr4 () +{ + return false; +} + +int +process_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_target::supports_agent () +{ + return false; +} + +btrace_target_info * +process_target::enable_btrace (ptid_t ptid, const btrace_config *conf) +{ + error (_("Target does not support branch tracing.")); +} + +int +process_target::disable_btrace (btrace_target_info *tinfo) +{ + error (_("Target does not support branch tracing.")); +} + +int +process_target::read_btrace (btrace_target_info *tinfo, + buffer *buffer, + enum btrace_read_type type) +{ + error (_("Target does not support branch tracing.")); +} + +int +process_target::read_btrace_conf (const btrace_target_info *tinfo, + buffer *buffer) +{ + error (_("Target does not support branch tracing.")); +} + +bool +process_target::supports_range_stepping () +{ + return false; +} + +bool +process_target::supports_pid_to_exec_file () +{ + return false; +} + +char * +process_target::pid_to_exec_file (int pid) +{ + gdb_assert_not_reached ("target op pid_to_exec_file not supported"); +} + +bool +process_target::supports_multifs () +{ + return false; +} + +int +process_target::multifs_open (int pid, const char *filename, + int flags, mode_t mode) +{ + return open (filename, flags, mode); +} + +int +process_target::multifs_unlink (int pid, const char *filename) +{ + return unlink (filename); +} + +ssize_t +process_target::multifs_readlink (int pid, const char *filename, + char *buf, size_t bufsiz) +{ + return readlink (filename, buf, bufsiz); +}