X-Git-Url: http://drtracing.org/?a=blobdiff_plain;ds=sidebyside;f=gdbserver%2Ftarget.cc;h=b5190e1f52a28f09e9ac019b4d009dfb23bdb47f;hb=af0b2a3e85df9f49a3528e5b7578fcf9412f1acc;hp=49302f61dfb3657fd122f38004c945a2f48387f8;hpb=e2558df32b83c2e3b41829d46c0b3d09732d7176;p=deliverable%2Fbinutils-gdb.git diff --git a/gdbserver/target.cc b/gdbserver/target.cc index 49302f61df..b5190e1f52 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; @@ -57,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; @@ -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->supports_thread_stopped () + && target_thread_stopped (thread)) stopped = thread; if (first == NULL) @@ -109,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; @@ -120,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; } @@ -151,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 @@ -205,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); @@ -217,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. */ @@ -225,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. */ @@ -238,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. */ @@ -251,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. */ @@ -259,29 +264,13 @@ 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->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. */ @@ -313,31 +302,7 @@ kill_inferior (process_info *proc) { gdb_agent_about_to_close (proc->pid); - return the_target->pt->kill (proc); -} - -/* Target can do hardware single step. */ - -int -target_can_do_hardware_single_step (void) -{ - return 1; -} - -/* 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. */ @@ -392,19 +357,485 @@ 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_stratum_target::done_accessing_memory () +{ + /* Nop. */ +} + +void +process_stratum_target::look_up_symbols () +{ + /* Nop. */ +} + +bool +process_stratum_target::supports_read_auxv () +{ + return false; +} + +int +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_stratum_target::supports_z_point_type (char z_type) +{ + return false; +} + +int +process_stratum_target::insert_point (enum raw_bkpt_type type, + CORE_ADDR addr, + int size, raw_breakpoint *bp) +{ + return 1; +} + +int +process_stratum_target::remove_point (enum raw_bkpt_type type, + CORE_ADDR addr, + int size, raw_breakpoint *bp) +{ + return 1; +} + +bool +process_stratum_target::stopped_by_sw_breakpoint () +{ + return false; +} + +bool +process_stratum_target::supports_stopped_by_sw_breakpoint () +{ + return false; +} + +bool +process_stratum_target::stopped_by_hw_breakpoint () +{ + return false; +} + +bool +process_stratum_target::supports_stopped_by_hw_breakpoint () +{ + return false; +} + +bool +process_stratum_target::supports_hardware_single_step () +{ + return false; +} + +bool +process_stratum_target::stopped_by_watchpoint () +{ + return false; +} + +CORE_ADDR +process_stratum_target::stopped_data_address () { return 0; } +bool +process_stratum_target::supports_read_offsets () +{ + return false; +} + +int +process_stratum_target::read_offsets (CORE_ADDR *text, CORE_ADDR *data) +{ + gdb_assert_not_reached ("target op read_offsets not supported"); +} + +bool +process_stratum_target::supports_get_tls_address () +{ + return false; +} + +int +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::done_accessing_memory () +process_stratum_target::hostio_last_error (char *buf) +{ + hostio_last_error_from_errno (buf); +} + +bool +process_stratum_target::supports_qxfer_osdata () +{ + return false; +} + +int +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_stratum_target::supports_qxfer_siginfo () +{ + return false; +} + +int +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_stratum_target::supports_non_stop () +{ + return false; +} + +bool +process_stratum_target::async (bool enable) +{ + return false; +} + +int +process_stratum_target::start_non_stop (bool enable) +{ + if (enable) + return -1; + else + return 0; +} + +bool +process_stratum_target::supports_multi_process () +{ + return false; +} + +bool +process_stratum_target::supports_fork_events () +{ + return false; +} + +bool +process_stratum_target::supports_vfork_events () +{ + return false; +} + +bool +process_stratum_target::supports_exec_events () +{ + return false; +} + +void +process_stratum_target::handle_new_gdb_connection () { /* Nop. */ } + +int +process_stratum_target::handle_monitor_command (char *mon) +{ + return 0; +} + +int +process_stratum_target::core_of_thread (ptid_t ptid) +{ + return -1; +} + +bool +process_stratum_target::supports_read_loadmap () +{ + return false; +} + +int +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_stratum_target::process_qsupported (char **features, int count) +{ + /* Nop. */ +} + +bool +process_stratum_target::supports_tracepoints () +{ + return false; +} + +CORE_ADDR +process_stratum_target::read_pc (regcache *regcache) +{ + gdb_assert_not_reached ("process_target::read_pc: Unable to find PC"); +} + +void +process_stratum_target::write_pc (regcache *regcache, CORE_ADDR pc) +{ + gdb_assert_not_reached ("process_target::write_pc: Unable to update PC"); +} + +bool +process_stratum_target::supports_thread_stopped () +{ + return false; +} + +bool +process_stratum_target::thread_stopped (thread_info *thread) +{ + gdb_assert_not_reached ("target op thread_stopped not supported"); +} + +bool +process_stratum_target::supports_get_tib_address () +{ + return false; +} + +int +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; +}