gdbserver: turn target ops 'read_pc' and 'write_pc' into methods

[deliverable/binutils-gdb.git] / gdbserver / target.cc

diff --git a/gdbserver/target.cc b/gdbserver/target.cc
index f88e9faf19163ce95194e986d67a5904e3901dc6..4f8d91c171f30bf1d8f7096be06eebd2bbd6b0b8 100644 (file)
--- a/gdbserver/target.cc
+++ b/gdbserver/target.cc
@@ -21,6 +21,7 @@
 #include "server.h"
 #include "tracepoint.h"
 #include "gdbsupport/byte-vector.h"
+#include "hostio.h"
 
 process_stratum_target *the_target;
 
@@ -120,7 +121,7 @@ int
 read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 {
   int res;
-  res = (*the_target->read_memory) (memaddr, myaddr, len);
+  res = the_target->pt->read_memory (memaddr, myaddr, len);
   check_mem_read (memaddr, myaddr, len);
   return res;
 }
@@ -151,7 +152,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->write_memory) (memaddr, buffer.data (), len);
+  return the_target->pt->write_memory (memaddr, buffer.data (), len);
 }
 
 ptid_t
@@ -259,22 +260,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
@@ -316,14 +302,6 @@ kill_inferior (process_info *proc)
   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
@@ -408,3 +386,243 @@ process_target::done_accessing_memory ()
 {
   /* Nop.  */
 }
+
+void
+process_target::look_up_symbols ()
+{
+  /* Nop.  */
+}
+
+bool
+process_target::supports_read_auxv ()
+{
+  return false;
+}
+
+int
+process_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)
+{
+  return false;
+}
+
+int
+process_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)
+{
+  return 1;
+}
+
+bool
+process_target::stopped_by_sw_breakpoint ()
+{
+  return false;
+}
+
+bool
+process_target::supports_stopped_by_sw_breakpoint ()
+{
+  return false;
+}
+
+bool
+process_target::stopped_by_hw_breakpoint ()
+{
+  return false;
+}
+
+bool
+process_target::supports_stopped_by_hw_breakpoint ()
+{
+  return false;
+}
+
+bool
+process_target::supports_hardware_single_step ()
+{
+  return false;
+}
+
+bool
+process_target::stopped_by_watchpoint ()
+{
+  return false;
+}
+
+CORE_ADDR
+process_target::stopped_data_address ()
+{
+  return 0;
+}
+
+bool
+process_target::supports_read_offsets ()
+{
+  return false;
+}
+
+int
+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");
+}