Add target_ops argument to to_fileio_readlink

[deliverable/binutils-gdb.git] / gdb / remote.c

diff --git a/gdb/remote.c b/gdb/remote.c
index 469d8a49c52bcbd4fd90e527f59da29f452f8e75..866c5c00f965457803658537fd6c91292ca14f13 100644 (file)
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -1,6 +1,6 @@
 /* Remote target communications for serial-line targets in custom GDB protocol
 
 /* Remote target communications for serial-line targets in custom GDB protocol
 

-   Copyright (C) 1988-2013 Free Software Foundation, Inc.
+   Copyright (C) 1988-2014 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -20,7 +20,7 @@
 /* See the GDB User Guide for details of the GDB remote protocol.  */
 
 #include "defs.h"
 /* See the GDB User Guide for details of the GDB remote protocol.  */
 
 #include "defs.h"

-#include "gdb_string.h"
+#include <string.h>

 #include <ctype.h>
 #include <fcntl.h>
 #include "inferior.h"
 #include <ctype.h>
 #include <fcntl.h>
 #include "inferior.h"


@@ -45,8 +45,8 @@
 #include "target-descriptions.h"
 #include "gdb_bfd.h"
 #include "filestuff.h"
 #include "target-descriptions.h"
 #include "gdb_bfd.h"
 #include "filestuff.h"

+#include "rsp-low.h"

 
 

-#include <ctype.h>

 #include <sys/time.h>
 
 #include "event-loop.h"
 #include <sys/time.h>
 
 #include "event-loop.h"


@@ -60,7 +60,7 @@
 
 #include "remote-fileio.h"
 #include "gdb/fileio.h"
 
 #include "remote-fileio.h"
 #include "gdb/fileio.h"

-#include "gdb_stat.h"
+#include <sys/stat.h>

 #include "xml-support.h"
 
 #include "memory-map.h"
 #include "xml-support.h"
 
 #include "memory-map.h"


@@ -98,7 +98,8 @@ static void async_handle_remote_sigint_twice (int);
 
 static void remote_files_info (struct target_ops *ignore);
 
 
 static void remote_files_info (struct target_ops *ignore);
 

-static void remote_prepare_to_store (struct regcache *regcache);
+static void remote_prepare_to_store (struct target_ops *self,
+                                    struct regcache *regcache);

 
 static void remote_open (char *name, int from_tty);
 
 
 static void remote_open (char *name, int from_tty);
 


@@ -106,7 +107,7 @@ static void extended_remote_open (char *name, int from_tty);
 
 static void remote_open_1 (char *, int, struct target_ops *, int extended_p);
 
 
 static void remote_open_1 (char *, int, struct target_ops *, int extended_p);
 

-static void remote_close (void);
+static void remote_close (struct target_ops *self);

 
 static void remote_mourn (struct target_ops *ops);
 
 
 static void remote_mourn (struct target_ops *ops);
 


@@ -124,16 +125,14 @@ static void remote_serial_write (const char *str, int len);
 
 static void remote_kill (struct target_ops *ops);
 
 
 static void remote_kill (struct target_ops *ops);
 

-static int tohex (int nib);
-
-static int remote_can_async_p (void);
-
-static int remote_is_async_p (void);
+static int remote_can_async_p (struct target_ops *);

 
 

-static void remote_async (void (*callback) (enum inferior_event_type event_type,
-                                           void *context), void *context);
+static int remote_is_async_p (struct target_ops *);

 
 

-static void remote_detach (struct target_ops *ops, char *args, int from_tty);
+static void remote_async (struct target_ops *ops,
+                         void (*callback) (enum inferior_event_type event_type,
+                                           void *context),
+                         void *context);

 
 static void sync_remote_interrupt_twice (int signo);
 
 
 static void sync_remote_interrupt_twice (int signo);
 


@@ -154,9 +153,7 @@ static void init_remote_ops (void);
 
 static void init_extended_remote_ops (void);
 
 
 static void init_extended_remote_ops (void);
 

-static void remote_stop (ptid_t);
-
-static int ishex (int ch, int *val);
+static void remote_stop (struct target_ops *self, ptid_t);

 
 static int stubhex (int ch);
 
 
 static int stubhex (int ch);
 


@@ -178,8 +175,6 @@ static ptid_t remote_current_thread (ptid_t oldptid);
 
 static void remote_find_new_threads (void);
 
 
 static void remote_find_new_threads (void);
 

-static int fromhex (int a);
-

 static int putpkt_binary (char *buf, int cnt);
 
 static void check_binary_download (CORE_ADDR addr);
 static int putpkt_binary (char *buf, int cnt);
 
 static void check_binary_download (CORE_ADDR addr);


@@ -220,20 +215,20 @@ struct stop_reply;
 static void stop_reply_xfree (struct stop_reply *);
 static void remote_parse_stop_reply (char *, struct stop_reply *);
 static void push_stop_reply (struct stop_reply *);
 static void stop_reply_xfree (struct stop_reply *);
 static void remote_parse_stop_reply (char *, struct stop_reply *);
 static void push_stop_reply (struct stop_reply *);

-static void discard_pending_stop_replies (struct inferior *);
+static void discard_pending_stop_replies_in_queue (struct remote_state *);

 static int peek_stop_reply (ptid_t ptid);
 
 static void remote_async_inferior_event_handler (gdb_client_data);
 
 static int peek_stop_reply (ptid_t ptid);
 
 static void remote_async_inferior_event_handler (gdb_client_data);
 

-static void remote_terminal_ours (void);
+static void remote_terminal_ours (struct target_ops *self);

 
 static int remote_read_description_p (struct target_ops *target);
 
 static void remote_console_output (char *msg);
 
 
 static int remote_read_description_p (struct target_ops *target);
 
 static void remote_console_output (char *msg);
 

-static int remote_supports_cond_breakpoints (void);
+static int remote_supports_cond_breakpoints (struct target_ops *self);

 
 

-static int remote_can_run_breakpoint_commands (void);
+static int remote_can_run_breakpoint_commands (struct target_ops *self);

 
 /* For "remote".  */
 
 
 /* For "remote".  */
 


@@ -262,6 +257,15 @@ struct vCont_action_support
 
 static int use_range_stepping = 1;
 
 
 static int use_range_stepping = 1;
 

+#define OPAQUETHREADBYTES 8
+
+/* a 64 bit opaque identifier */
+typedef unsigned char threadref[OPAQUETHREADBYTES];
+
+/* About this many threadisds fit in a packet.  */
+
+#define MAXTHREADLISTRESULTS 32
+

 /* Description of the remote protocol state for the currently
    connected target.  This is per-target state, and independent of the
    selected architecture.  */
 /* Description of the remote protocol state for the currently
    connected target.  This is per-target state, and independent of the
    selected architecture.  */


@@ -405,6 +409,20 @@ struct remote_state
   void (*async_client_callback) (enum inferior_event_type event_type,
                                 void *context);
   void *async_client_context;
   void (*async_client_callback) (enum inferior_event_type event_type,
                                 void *context);
   void *async_client_context;

+
+  /* This is set to the data address of the access causing the target
+     to stop for a watchpoint.  */
+  CORE_ADDR remote_watch_data_address;
+
+  /* This is non-zero if target stopped for a watchpoint.  */
+  int remote_stopped_by_watchpoint_p;
+
+  threadref echo_nextthread;
+  threadref nextthread;
+  threadref resultthreadlist[MAXTHREADLISTRESULTS];
+
+  /* The state of remote notification.  */
+  struct remote_notif_state *notif_state;

 };
 
 /* Private data that we'll store in (struct thread_info)->private.  */
 };
 
 /* Private data that we'll store in (struct thread_info)->private.  */


@@ -789,17 +807,6 @@ packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
   return NULL;
 }
 
   return NULL;
 }
 

-/* FIXME: graces/2002-08-08: These variables should eventually be
-   bound to an instance of the target object (as in gdbarch-tdep()),
-   when such a thing exists.  */
-
-/* This is set to the data address of the access causing the target
-   to stop for a watchpoint.  */
-static CORE_ADDR remote_watch_data_address;
-
-/* This is non-zero if target stopped for a watchpoint.  */
-static int remote_stopped_by_watchpoint_p;
-

 static struct target_ops remote_ops;
 
 static struct target_ops extended_remote_ops;
 static struct target_ops remote_ops;
 
 static struct target_ops extended_remote_ops;


@@ -1552,7 +1559,18 @@ remote_add_inferior (int fake_pid_p, int pid, int attached)
 static void
 remote_add_thread (ptid_t ptid, int running)
 {
 static void
 remote_add_thread (ptid_t ptid, int running)
 {

-  add_thread (ptid);
+  struct remote_state *rs = get_remote_state ();
+
+  /* GDB historically didn't pull threads in the initial connection
+     setup.  If the remote target doesn't even have a concept of
+     threads (e.g., a bare-metal target), even if internally we
+     consider that a single-threaded target, mentioning a new thread
+     might be confusing to the user.  Be silent then, preserving the
+     age old behavior.  */
+  if (rs->starting_up)
+    add_thread_silent (ptid);
+  else
+    add_thread (ptid);

 
   set_executing (ptid, running);
   set_running (ptid, running);
 
   set_executing (ptid, running);
   set_running (ptid, running);


@@ -1630,9 +1648,15 @@ remote_notice_new_inferior (ptid_t currthread, int running)
 
       /* If we found a new inferior, let the common code do whatever
         it needs to with it (e.g., read shared libraries, insert
 
       /* If we found a new inferior, let the common code do whatever
         it needs to with it (e.g., read shared libraries, insert

-        breakpoints).  */
+        breakpoints), unless we're just setting up an all-stop
+        connection.  */

       if (inf != NULL)
       if (inf != NULL)

-       notice_new_inferior (currthread, running, 0);
+       {
+         struct remote_state *rs = get_remote_state ();
+
+         if (non_stop || !rs->starting_up)
+           notice_new_inferior (currthread, running, 0);
+       }

     }
 }
 
     }
 }
 


@@ -1671,7 +1695,8 @@ record_currthread (struct remote_state *rs, ptid_t currthread)
    it can simply pass through to the inferior without reporting.  */
 
 static void
    it can simply pass through to the inferior without reporting.  */
 
 static void

-remote_pass_signals (int numsigs, unsigned char *pass_signals)
+remote_pass_signals (struct target_ops *self,
+                    int numsigs, unsigned char *pass_signals)

 {
   if (remote_protocol_packets[PACKET_QPassSignals].support != PACKET_DISABLE)
     {
 {
   if (remote_protocol_packets[PACKET_QPassSignals].support != PACKET_DISABLE)
     {


@@ -1705,11 +1730,9 @@ remote_pass_signals (int numsigs, unsigned char *pass_signals)
       *p = 0;
       if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet))
        {
       *p = 0;
       if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet))
        {

-         char *buf = rs->buf;
-

          putpkt (pass_packet);
          getpkt (&rs->buf, &rs->buf_size, 0);
          putpkt (pass_packet);
          getpkt (&rs->buf, &rs->buf_size, 0);

-         packet_ok (buf, &remote_protocol_packets[PACKET_QPassSignals]);
+         packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]);

          if (rs->last_pass_packet)
            xfree (rs->last_pass_packet);
          rs->last_pass_packet = pass_packet;
          if (rs->last_pass_packet)
            xfree (rs->last_pass_packet);
          rs->last_pass_packet = pass_packet;


@@ -1723,7 +1746,8 @@ remote_pass_signals (int numsigs, unsigned char *pass_signals)
    signals it should pass through to the inferior when detaching.  */
 
 static void
    signals it should pass through to the inferior when detaching.  */
 
 static void

-remote_program_signals (int numsigs, unsigned char *signals)
+remote_program_signals (struct target_ops *self,
+                       int numsigs, unsigned char *signals)

 {
   if (remote_protocol_packets[PACKET_QProgramSignals].support != PACKET_DISABLE)
     {
 {
   if (remote_protocol_packets[PACKET_QProgramSignals].support != PACKET_DISABLE)
     {


@@ -1758,11 +1782,9 @@ remote_program_signals (int numsigs, unsigned char *signals)
       if (!rs->last_program_signals_packet
          || strcmp (rs->last_program_signals_packet, packet) != 0)
        {
       if (!rs->last_program_signals_packet
          || strcmp (rs->last_program_signals_packet, packet) != 0)
        {

-         char *buf = rs->buf;
-

          putpkt (packet);
          getpkt (&rs->buf, &rs->buf_size, 0);
          putpkt (packet);
          getpkt (&rs->buf, &rs->buf_size, 0);

-         packet_ok (buf, &remote_protocol_packets[PACKET_QProgramSignals]);
+         packet_ok (rs->buf, &remote_protocol_packets[PACKET_QProgramSignals]);

          xfree (rs->last_program_signals_packet);
          rs->last_program_signals_packet = packet;
        }
          xfree (rs->last_program_signals_packet);
          rs->last_program_signals_packet = packet;
        }


@@ -1877,11 +1899,6 @@ remote_thread_alive (struct target_ops *ops, ptid_t ptid)
    remote protocol in general.  There is a matching unit test module
    in libstub.  */
 
    remote protocol in general.  There is a matching unit test module
    in libstub.  */
 

-#define OPAQUETHREADBYTES 8
-
-/* a 64 bit opaque identifier */
-typedef unsigned char threadref[OPAQUETHREADBYTES];
-

 /* WARNING: This threadref data structure comes from the remote O.S.,
    libstub protocol encoding, and remote.c.  It is not particularly
    changable.  */
 /* WARNING: This threadref data structure comes from the remote O.S.,
    libstub protocol encoding, and remote.c.  It is not particularly
    changable.  */


@@ -1919,14 +1936,8 @@ struct gdb_ext_thread_info
 
 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
 
 
 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
 

-char *unpack_varlen_hex (char *buff, ULONGEST *result);
-

 static char *unpack_nibble (char *buf, int *val);
 
 static char *unpack_nibble (char *buf, int *val);
 

-static char *pack_nibble (char *buf, int nibble);
-
-static char *pack_hex_byte (char *pkt, int /* unsigned char */ byte);
-

 static char *unpack_byte (char *buf, int *value);
 
 static char *pack_int (char *buf, int value);
 static char *unpack_byte (char *buf, int *value);
 
 static char *pack_int (char *buf, int value);


@@ -2053,31 +2064,6 @@ read_ptid (char *buf, char **obuf)
   return ptid_build (pid, 0, tid);
 }
 
   return ptid_build (pid, 0, tid);
 }
 

-/* Encode 64 bits in 16 chars of hex.  */
-
-static const char hexchars[] = "0123456789abcdef";
-
-static int
-ishex (int ch, int *val)
-{
-  if ((ch >= 'a') && (ch <= 'f'))
-    {
-      *val = ch - 'a' + 10;
-      return 1;
-    }
-  if ((ch >= 'A') && (ch <= 'F'))
-    {
-      *val = ch - 'A' + 10;
-      return 1;
-    }
-  if ((ch >= '0') && (ch <= '9'))
-    {
-      *val = ch - '0';
-      return 1;
-    }
-  return 0;
-}
-

 static int
 stubhex (int ch)
 {
 static int
 stubhex (int ch)
 {


@@ -2107,23 +2093,6 @@ stub_unpack_int (char *buff, int fieldlength)
   return retval;
 }
 
   return retval;
 }
 

-char *
-unpack_varlen_hex (char *buff, /* packet to parse */
-                  ULONGEST *result)
-{
-  int nibble;
-  ULONGEST retval = 0;
-
-  while (ishex (*buff, &nibble))
-    {
-      buff++;
-      retval = retval << 4;
-      retval |= nibble & 0x0f;
-    }
-  *result = retval;
-  return buff;
-}
-

 static char *
 unpack_nibble (char *buf, int *val)
 {
 static char *
 unpack_nibble (char *buf, int *val)
 {


@@ -2131,21 +2100,6 @@ unpack_nibble (char *buf, int *val)
   return buf;
 }
 
   return buf;
 }
 

-static char *
-pack_nibble (char *buf, int nibble)
-{
-  *buf++ = hexchars[(nibble & 0x0f)];
-  return buf;
-}
-
-static char *
-pack_hex_byte (char *pkt, int byte)
-{
-  *pkt++ = hexchars[(byte >> 4) & 0xf];
-  *pkt++ = hexchars[(byte & 0xf)];
-  return pkt;
-}
-

 static char *
 unpack_byte (char *buf, int *value)
 {
 static char *
 unpack_byte (char *buf, int *value)
 {


@@ -2497,7 +2451,6 @@ remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
                       int *done, int *result_count, threadref *threadlist)
 {
   struct remote_state *rs = get_remote_state ();
                       int *done, int *result_count, threadref *threadlist)
 {
   struct remote_state *rs = get_remote_state ();

-  static threadref echo_nextthread;

   int result = 1;
 
   /* Trancate result limit to be smaller than the packet size.  */
   int result = 1;
 
   /* Trancate result limit to be smaller than the packet size.  */


@@ -2513,10 +2466,10 @@ remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
     return 0;
   else
     *result_count =
     return 0;
   else
     *result_count =

-      parse_threadlist_response (rs->buf + 2, result_limit, &echo_nextthread,
-                                 threadlist, done);
+      parse_threadlist_response (rs->buf + 2, result_limit,
+                                &rs->echo_nextthread, threadlist, done);

 
 

-  if (!threadmatch (&echo_nextthread, nextthread))
+  if (!threadmatch (&rs->echo_nextthread, nextthread))

     {
       /* FIXME: This is a good reason to drop the packet.  */
       /* Possably, there is a duplicate response.  */
     {
       /* FIXME: This is a good reason to drop the packet.  */
       /* Possably, there is a duplicate response.  */


@@ -2557,20 +2510,15 @@ remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
    quit_flag is required.  */
 
 
    quit_flag is required.  */
 
 

-/* About this many threadisds fit in a packet.  */
-
-#define MAXTHREADLISTRESULTS 32
-

 static int
 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
                            int looplimit)
 {
 static int
 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
                            int looplimit)
 {

+  struct remote_state *rs = get_remote_state ();

   int done, i, result_count;
   int startflag = 1;
   int result = 1;
   int loopcount = 0;
   int done, i, result_count;
   int startflag = 1;
   int result = 1;
   int loopcount = 0;

-  static threadref nextthread;
-  static threadref resultthreadlist[MAXTHREADLISTRESULTS];

 
   done = 0;
   while (!done)
 
   done = 0;
   while (!done)


@@ -2581,8 +2529,9 @@ remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
          warning (_("Remote fetch threadlist -infinite loop-."));
          break;
        }
          warning (_("Remote fetch threadlist -infinite loop-."));
          break;
        }

-      if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS,
-                                 &done, &result_count, resultthreadlist))
+      if (!remote_get_threadlist (startflag, &rs->nextthread,
+                                 MAXTHREADLISTRESULTS,
+                                 &done, &result_count, rs->resultthreadlist))

        {
          result = 0;
          break;
        {
          result = 0;
          break;


@@ -2591,10 +2540,11 @@ remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
       startflag = 0;
       /* Setup to resume next batch of thread references, set nextthread.  */
       if (result_count >= 1)
       startflag = 0;
       /* Setup to resume next batch of thread references, set nextthread.  */
       if (result_count >= 1)

-       copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
+       copy_threadref (&rs->nextthread,
+                       &rs->resultthreadlist[result_count - 1]);

       i = 0;
       while (result_count--)
       i = 0;
       while (result_count--)

-       if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
+       if (!(result = (*stepfunction) (&rs->resultthreadlist[i++], context)))

          break;
     }
   return result;
          break;
     }
   return result;


@@ -2858,7 +2808,7 @@ remote_threads_info (struct target_ops *ops)
  */
 
 static char *
  */
 
 static char *

-remote_threads_extra_info (struct thread_info *tp)
+remote_threads_extra_info (struct target_ops *self, struct thread_info *tp)

 {
   struct remote_state *rs = get_remote_state ();
   int result;
 {
   struct remote_state *rs = get_remote_state ();
   int result;


@@ -3019,7 +2969,7 @@ remote_static_tracepoint_markers_by_strid (const char *strid)
 /* Implement the to_get_ada_task_ptid function for the remote targets.  */
 
 static ptid_t
 /* Implement the to_get_ada_task_ptid function for the remote targets.  */
 
 static ptid_t

-remote_get_ada_task_ptid (long lwp, long thread)
+remote_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)

 {
   return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
 }
 {
   return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
 }


@@ -3043,7 +2993,7 @@ extended_remote_restart (void)
 /* Clean up connection to a remote debugger.  */
 
 static void
 /* Clean up connection to a remote debugger.  */
 
 static void

-remote_close (void)
+remote_close (struct target_ops *self)

 {
   struct remote_state *rs = get_remote_state ();
 
 {
   struct remote_state *rs = get_remote_state ();
 


@@ -3052,7 +3002,7 @@ remote_close (void)
 
   /* Make sure we leave stdin registered in the event loop, and we
      don't leave the async SIGINT signal handler installed.  */
 
   /* Make sure we leave stdin registered in the event loop, and we
      don't leave the async SIGINT signal handler installed.  */

-  remote_terminal_ours ();
+  remote_terminal_ours (self);

 
   serial_close (rs->remote_desc);
   rs->remote_desc = NULL;
 
   serial_close (rs->remote_desc);
   rs->remote_desc = NULL;


@@ -3064,16 +3014,14 @@ remote_close (void)
   inferior_ptid = null_ptid;
   discard_all_inferiors ();
 
   inferior_ptid = null_ptid;
   discard_all_inferiors ();
 

-  /* Stop replies may from inferiors which are still unknown to GDB.
-     We are closing the remote target, so we should discard
-     everything, including the stop replies from GDB-unknown
-     inferiors.  */
-  discard_pending_stop_replies (NULL);
+  /* We are closing the remote target, so we should discard
+     everything of this target.  */
+  discard_pending_stop_replies_in_queue (rs);

 
   if (remote_async_inferior_event_token)
     delete_async_event_handler (&remote_async_inferior_event_token);
 
 
   if (remote_async_inferior_event_token)
     delete_async_event_handler (&remote_async_inferior_event_token);
 

-  remote_notif_unregister_async_event_handler ();
+  remote_notif_state_xfree (rs->notif_state);

 
   trace_reset_local_state ();
 }
 
   trace_reset_local_state ();
 }


@@ -3311,6 +3259,28 @@ stop_reply_extract_thread (char *stop_reply)
   return null_ptid;
 }
 
   return null_ptid;
 }
 

+/* Determine the remote side's current thread.  If we have a stop
+   reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
+   "thread" register we can extract the current thread from.  If not,
+   ask the remote which is the current thread with qC.  The former
+   method avoids a roundtrip.  */
+
+static ptid_t
+get_current_thread (char *wait_status)
+{
+  ptid_t ptid;
+
+  /* Note we don't use remote_parse_stop_reply as that makes use of
+     the target architecture, which we haven't yet fully determined at
+     this point.  */
+  if (wait_status != NULL)
+    ptid = stop_reply_extract_thread (wait_status);
+  if (ptid_equal (ptid, null_ptid))
+    ptid = remote_current_thread (inferior_ptid);
+
+  return ptid;
+}
+

 /* Query the remote target for which is the current thread/process,
    add it to our tables, and update INFERIOR_PTID.  The caller is
    responsible for setting the state such that the remote end is ready
 /* Query the remote target for which is the current thread/process,
    add it to our tables, and update INFERIOR_PTID.  The caller is
    responsible for setting the state such that the remote end is ready


@@ -3331,18 +3301,8 @@ add_current_inferior_and_thread (char *wait_status)
 
   inferior_ptid = null_ptid;
 
 
   inferior_ptid = null_ptid;
 

-  /* Now, if we have thread information, update inferior_ptid.  First
-     if we have a stop reply handy, maybe it's a T stop reply with a
-     "thread" register we can extract the current thread from.  If
-     not, ask the remote which is the current thread, with qC.  The
-     former method avoids a roundtrip.  Note we don't use
-     remote_parse_stop_reply as that makes use of the target
-     architecture, which we haven't yet fully determined at this
-     point.  */
-  if (wait_status != NULL)
-    ptid = stop_reply_extract_thread (wait_status);
-  if (ptid_equal (ptid, null_ptid))
-    ptid = remote_current_thread (inferior_ptid);
+  /* Now, if we have thread information, update inferior_ptid.  */
+  ptid = get_current_thread (wait_status);

 
   if (!ptid_equal (ptid, null_ptid))
     {
 
   if (!ptid_equal (ptid, null_ptid))
     {


@@ -3512,10 +3472,35 @@ remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
          strcpy (wait_status, rs->buf);
        }
 
          strcpy (wait_status, rs->buf);
        }
 

+      /* Fetch thread list.  */
+      target_find_new_threads ();
+

       /* Let the stub know that we want it to return the thread.  */
       set_continue_thread (minus_one_ptid);
 
       /* Let the stub know that we want it to return the thread.  */
       set_continue_thread (minus_one_ptid);
 

-      add_current_inferior_and_thread (wait_status);
+      if (thread_count () == 0)
+       {
+         /* Target has no concept of threads at all.  GDB treats
+            non-threaded target as single-threaded; add a main
+            thread.  */
+         add_current_inferior_and_thread (wait_status);
+       }
+      else
+       {
+         /* We have thread information; select the thread the target
+            says should be current.  If we're reconnecting to a
+            multi-threaded program, this will ideally be the thread
+            that last reported an event before GDB disconnected.  */
+         inferior_ptid = get_current_thread (wait_status);
+         if (ptid_equal (inferior_ptid, null_ptid))
+           {
+             /* Odd... The target was able to list threads, but not
+                tell us which thread was current (no "thread"
+                register in T stop reply?).  Just pick the first
+                thread in the thread list then.  */
+             inferior_ptid = thread_list->ptid;
+           }
+       }

 
       /* init_wait_for_inferior should be called before get_offsets in order
         to manage `inserted' flag in bp loc in a correct state.
 
       /* init_wait_for_inferior should be called before get_offsets in order
         to manage `inserted' flag in bp loc in a correct state.


@@ -3569,7 +3554,7 @@ remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
 
          /* remote_notif_get_pending_replies acks this one, and gets
             the rest out.  */
 
          /* remote_notif_get_pending_replies acks this one, and gets
             the rest out.  */

-         notif_client_stop.pending_event
+         rs->notif_state->pending_event[notif_client_stop.id]

            = remote_notif_parse (notif, rs->buf);
          remote_notif_get_pending_events (notif);
 
            = remote_notif_parse (notif, rs->buf);
          remote_notif_get_pending_events (notif);
 


@@ -3609,13 +3594,13 @@ remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
       gdb_assert (wait_status == NULL);
 
       /* Report all signals during attach/startup.  */
       gdb_assert (wait_status == NULL);
 
       /* Report all signals during attach/startup.  */

-      remote_pass_signals (0, NULL);
+      remote_pass_signals (target, 0, NULL);

     }
 
   /* If we connected to a live target, do some additional setup.  */
   if (target_has_execution)
     {
     }
 
   /* If we connected to a live target, do some additional setup.  */
   if (target_has_execution)
     {

-      if (exec_bfd)    /* No use without an exec file.  */
+      if (symfile_objfile)     /* No use without a symbol-file.  */

        remote_check_symbols ();
     }
 
        remote_check_symbols ();
     }
 


@@ -4337,7 +4322,7 @@ remote_open_1 (char *name, int from_tty,
   remote_async_inferior_event_token
     = create_async_event_handler (remote_async_inferior_event_handler,
                                  NULL);
   remote_async_inferior_event_token
     = create_async_event_handler (remote_async_inferior_event_handler,
                                  NULL);

-  remote_notif_register_async_event_handler ();
+  rs->notif_state = remote_notif_state_allocate ();

 
   /* Reset the target state; these things will be queried either by
      remote_query_supported or as they are needed.  */
 
   /* Reset the target state; these things will be queried either by
      remote_query_supported or as they are needed.  */


@@ -4424,7 +4409,7 @@ remote_open_1 (char *name, int from_tty,
    die when it hits one.  */
 
 static void
    die when it hits one.  */
 
 static void

-remote_detach_1 (char *args, int from_tty, int extended)
+remote_detach_1 (const char *args, int from_tty, int extended)

 {
   int pid = ptid_get_pid (inferior_ptid);
   struct remote_state *rs = get_remote_state ();
 {
   int pid = ptid_get_pid (inferior_ptid);
   struct remote_state *rs = get_remote_state ();


@@ -4468,13 +4453,13 @@ remote_detach_1 (char *args, int from_tty, int extended)
 }
 
 static void
 }
 
 static void

-remote_detach (struct target_ops *ops, char *args, int from_tty)
+remote_detach (struct target_ops *ops, const char *args, int from_tty)

 {
   remote_detach_1 (args, from_tty, 0);
 }
 
 static void
 {
   remote_detach_1 (args, from_tty, 0);
 }
 
 static void

-extended_remote_detach (struct target_ops *ops, char *args, int from_tty)
+extended_remote_detach (struct target_ops *ops, const char *args, int from_tty)

 {
   remote_detach_1 (args, from_tty, 1);
 }
 {
   remote_detach_1 (args, from_tty, 1);
 }


@@ -4616,68 +4601,6 @@ extended_remote_attach (struct target_ops *ops, char *args, int from_tty)
   extended_remote_attach_1 (ops, args, from_tty);
 }
 
   extended_remote_attach_1 (ops, args, from_tty);
 }
 

-/* Convert hex digit A to a number.  */
-
-static int
-fromhex (int a)
-{
-  if (a >= '0' && a <= '9')
-    return a - '0';
-  else if (a >= 'a' && a <= 'f')
-    return a - 'a' + 10;
-  else if (a >= 'A' && a <= 'F')
-    return a - 'A' + 10;
-  else
-    error (_("Reply contains invalid hex digit %d"), a);
-}
-
-int
-hex2bin (const char *hex, gdb_byte *bin, int count)
-{
-  int i;
-
-  for (i = 0; i < count; i++)
-    {
-      if (hex[0] == 0 || hex[1] == 0)
-       {
-         /* Hex string is short, or of uneven length.
-            Return the count that has been converted so far.  */
-         return i;
-       }
-      *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
-      hex += 2;
-    }
-  return i;
-}
-
-/* Convert number NIB to a hex digit.  */
-
-static int
-tohex (int nib)
-{
-  if (nib < 10)
-    return '0' + nib;
-  else
-    return 'a' + nib - 10;
-}
-
-int
-bin2hex (const gdb_byte *bin, char *hex, int count)
-{
-  int i;
-
-  /* May use a length, or a nul-terminated string as input.  */
-  if (count == 0)
-    count = strlen ((char *) bin);
-
-  for (i = 0; i < count; i++)
-    {
-      *hex++ = tohex ((*bin >> 4) & 0xf);
-      *hex++ = tohex (*bin++ & 0xf);
-    }
-  *hex = 0;
-  return i;
-}

 \f
 /* Check for the availability of vCont.  This function should also check
    the response.  */
 \f
 /* Check for the availability of vCont.  This function should also check
    the response.  */


@@ -4931,7 +4854,7 @@ remote_resume (struct target_ops *ops,
      before resuming inferior, because inferior was stopped and no RSP
      traffic at that moment.  */
   if (!non_stop)
      before resuming inferior, because inferior was stopped and no RSP
      traffic at that moment.  */
   if (!non_stop)

-    remote_notif_process (&notif_client_stop);
+    remote_notif_process (rs->notif_state, &notif_client_stop);

 
   rs->last_sent_signal = siggnal;
   rs->last_sent_step = step;
 
   rs->last_sent_signal = siggnal;
   rs->last_sent_step = step;


@@ -5162,7 +5085,7 @@ remote_stop_as (ptid_t ptid)
    will eventually end up here.  */
 
 static void
    will eventually end up here.  */
 
 static void

-remote_stop (ptid_t ptid)
+remote_stop (struct target_ops *self, ptid_t ptid)

 {
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
 {
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");


@@ -5204,7 +5127,7 @@ Give up (and stop debugging it)? ")))
    is required.  */
 
 static void
    is required.  */
 
 static void

-remote_terminal_inferior (void)
+remote_terminal_inferior (struct target_ops *self)

 {
   if (!target_async_permitted)
     /* Nothing to do.  */
 {
   if (!target_async_permitted)
     /* Nothing to do.  */


@@ -5227,7 +5150,7 @@ remote_terminal_inferior (void)
 }
 
 static void
 }
 
 static void

-remote_terminal_ours (void)
+remote_terminal_ours (struct target_ops *self)

 {
   if (!target_async_permitted)
     /* Nothing to do.  */
 {
   if (!target_async_permitted)
     /* Nothing to do.  */


@@ -5273,6 +5196,11 @@ typedef struct stop_reply
   /* The identifier of the thread about this event  */
   ptid_t ptid;
 
   /* The identifier of the thread about this event  */
   ptid_t ptid;
 

+  /* The remote state this event is associated with.  When the remote
+     connection, represented by a remote_state object, is closed,
+     all the associated stop_reply events should be released.  */
+  struct remote_state *rs;
+

   struct target_waitstatus ws;
 
   /* Expedited registers.  This makes remote debugging a bit more
   struct target_waitstatus ws;
 
   /* Expedited registers.  This makes remote debugging a bit more


@@ -5284,9 +5212,6 @@ typedef struct stop_reply
   int stopped_by_watchpoint_p;
   CORE_ADDR watch_data_address;
 
   int stopped_by_watchpoint_p;
   CORE_ADDR watch_data_address;
 

-  int solibs_changed;
-  int replay_event;
-

   int core;
 } *stop_reply_p;
 
   int core;
 } *stop_reply_p;
 


@@ -5304,11 +5229,7 @@ static QUEUE (stop_reply_p) *stop_reply_queue;
 static void
 stop_reply_xfree (struct stop_reply *r)
 {
 static void
 stop_reply_xfree (struct stop_reply *r)
 {

-  if (r != NULL)
-    {
-      VEC_free (cached_reg_t, r->regcache);
-      xfree (r);
-    }
+  notif_event_xfree ((struct notif_event *) r);

 }
 
 static void
 }
 
 static void


@@ -5358,7 +5279,7 @@ static struct notif_event *
 remote_notif_stop_alloc_reply (void)
 {
   struct notif_event *r
 remote_notif_stop_alloc_reply (void)
 {
   struct notif_event *r

-    = (struct notif_event *) XMALLOC (struct stop_reply);
+    = (struct notif_event *) XNEW (struct stop_reply);

 
   r->dtr = stop_reply_dtr;
 
 
   r->dtr = stop_reply_dtr;
 


@@ -5375,7 +5296,7 @@ struct notif_client notif_client_stop =
   remote_notif_stop_ack,
   remote_notif_stop_can_get_pending_events,
   remote_notif_stop_alloc_reply,
   remote_notif_stop_ack,
   remote_notif_stop_can_get_pending_events,
   remote_notif_stop_alloc_reply,

-  NULL,
+  REMOTE_NOTIF_STOP,

 };
 
 /* A parameter to pass data in and out.  */
 };
 
 /* A parameter to pass data in and out.  */


@@ -5386,18 +5307,19 @@ struct queue_iter_param
   struct stop_reply *output;
 };
 
   struct stop_reply *output;
 };
 

-/* Remove all queue elements meet the condition it checks.  */
+/* Remove stop replies in the queue if its pid is equal to the given
+   inferior's pid.  */

 
 static int
 
 static int

-remote_notif_remove_all (QUEUE (stop_reply_p) *q,
-                        QUEUE_ITER (stop_reply_p) *iter,
-                        stop_reply_p event,
-                        void *data)
+remove_stop_reply_for_inferior (QUEUE (stop_reply_p) *q,
+                               QUEUE_ITER (stop_reply_p) *iter,
+                               stop_reply_p event,
+                               void *data)

 {
   struct queue_iter_param *param = data;
   struct inferior *inf = param->input;
 
 {
   struct queue_iter_param *param = data;
   struct inferior *inf = param->input;
 

-  if (inf == NULL || ptid_get_pid (event->ptid) == inf->pid)
+  if (ptid_get_pid (event->ptid) == inf->pid)

     {
       stop_reply_xfree (event);
       QUEUE_remove_elem (stop_reply_p, q, iter);
     {
       stop_reply_xfree (event);
       QUEUE_remove_elem (stop_reply_p, q, iter);


@@ -5406,24 +5328,29 @@ remote_notif_remove_all (QUEUE (stop_reply_p) *q,
   return 1;
 }
 
   return 1;
 }
 

-/* Discard all pending stop replies of inferior INF.  If INF is NULL,
-   discard everything.  */
+/* Discard all pending stop replies of inferior INF.  */

 
 static void
 discard_pending_stop_replies (struct inferior *inf)
 {
   int i;
   struct queue_iter_param param;
 
 static void
 discard_pending_stop_replies (struct inferior *inf)
 {
   int i;
   struct queue_iter_param param;

-  struct stop_reply *reply
-    = (struct stop_reply *) notif_client_stop.pending_event;
+  struct stop_reply *reply;
+  struct remote_state *rs = get_remote_state ();
+  struct remote_notif_state *rns = rs->notif_state;
+
+  /* This function can be notified when an inferior exists.  When the
+     target is not remote, the notification state is NULL.  */
+  if (rs->remote_desc == NULL)
+    return;
+
+  reply = (struct stop_reply *) rns->pending_event[notif_client_stop.id];

 
   /* Discard the in-flight notification.  */
 
   /* Discard the in-flight notification.  */

-  if (reply != NULL
-      && (inf == NULL
-         || ptid_get_pid (reply->ptid) == inf->pid))
+  if (reply != NULL && ptid_get_pid (reply->ptid) == inf->pid)

     {
       stop_reply_xfree (reply);
     {
       stop_reply_xfree (reply);

-      notif_client_stop.pending_event = NULL;
+      rns->pending_event[notif_client_stop.id] = NULL;

     }
 
   param.input = inf;
     }
 
   param.input = inf;


@@ -5431,7 +5358,43 @@ discard_pending_stop_replies (struct inferior *inf)
   /* Discard the stop replies we have already pulled with
      vStopped.  */
   QUEUE_iterate (stop_reply_p, stop_reply_queue,
   /* Discard the stop replies we have already pulled with
      vStopped.  */
   QUEUE_iterate (stop_reply_p, stop_reply_queue,

-                remote_notif_remove_all, &param);
+                remove_stop_reply_for_inferior, &param);
+}
+
+/* If its remote state is equal to the given remote state,
+   remove EVENT from the stop reply queue.  */
+
+static int
+remove_stop_reply_of_remote_state (QUEUE (stop_reply_p) *q,
+                                  QUEUE_ITER (stop_reply_p) *iter,
+                                  stop_reply_p event,
+                                  void *data)
+{
+  struct queue_iter_param *param = data;
+  struct remote_state *rs = param->input;
+
+  if (event->rs == rs)
+    {
+      stop_reply_xfree (event);
+      QUEUE_remove_elem (stop_reply_p, q, iter);
+    }
+
+  return 1;
+}
+
+/* Discard the stop replies for RS in stop_reply_queue.  */
+
+static void
+discard_pending_stop_replies_in_queue (struct remote_state *rs)
+{
+  struct queue_iter_param param;
+
+  param.input = rs;
+  param.output = NULL;
+  /* Discard the stop replies we have already pulled with
+     vStopped.  */
+  QUEUE_iterate (stop_reply_p, stop_reply_queue,
+                remove_stop_reply_of_remote_state, &param);

 }
 
 /* A parameter to pass data in and out.  */
 }
 
 /* A parameter to pass data in and out.  */


@@ -5544,10 +5507,9 @@ remote_parse_stop_reply (char *buf, struct stop_reply *event)
   char *p;
 
   event->ptid = null_ptid;
   char *p;
 
   event->ptid = null_ptid;

+  event->rs = get_remote_state ();

   event->ws.kind = TARGET_WAITKIND_IGNORE;
   event->ws.value.integer = 0;
   event->ws.kind = TARGET_WAITKIND_IGNORE;
   event->ws.value.integer = 0;

-  event->solibs_changed = 0;
-  event->replay_event = 0;

   event->stopped_by_watchpoint_p = 0;
   event->regcache = NULL;
   event->core = -1;
   event->stopped_by_watchpoint_p = 0;
   event->regcache = NULL;
   event->core = -1;


@@ -5611,15 +5573,14 @@ Packet: '%s'\n"),
                  while (*p_temp && *p_temp != ';')
                    p_temp++;
 
                  while (*p_temp && *p_temp != ';')
                    p_temp++;
 

-                 event->solibs_changed = 1;
+                 event->ws.kind = TARGET_WAITKIND_LOADED;

                  p = p_temp;
                }
              else if (strncmp (p, "replaylog", p1 - p) == 0)
                {
                  p = p_temp;
                }
              else if (strncmp (p, "replaylog", p1 - p) == 0)
                {

-                 /* NO_HISTORY event.
-                    p1 will indicate "begin" or "end", but
-                    it makes no difference for now, so ignore it.  */
-                 event->replay_event = 1;
+                 event->ws.kind = TARGET_WAITKIND_NO_HISTORY;
+                 /* p1 will indicate "begin" or "end", but it makes
+                    no difference for now, so ignore it.  */

                  p_temp = strchr (p1 + 1, ';');
                  if (p_temp)
                    p = p_temp;
                  p_temp = strchr (p1 + 1, ';');
                  if (p_temp)
                    p = p_temp;


@@ -5675,18 +5636,22 @@ Packet: '%s'\n"),
                   buf, p);
          ++p;
        }
                   buf, p);
          ++p;
        }

+
+      if (event->ws.kind != TARGET_WAITKIND_IGNORE)
+       break;
+

       /* fall through */
     case 'S':          /* Old style status, just signal only.  */
       /* fall through */
     case 'S':          /* Old style status, just signal only.  */

-      if (event->solibs_changed)
-       event->ws.kind = TARGET_WAITKIND_LOADED;
-      else if (event->replay_event)
-       event->ws.kind = TARGET_WAITKIND_NO_HISTORY;
-      else
-       {
-         event->ws.kind = TARGET_WAITKIND_STOPPED;
-         event->ws.value.sig = (enum gdb_signal)
-           (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
-       }
+      {
+       int sig;
+
+       event->ws.kind = TARGET_WAITKIND_STOPPED;
+       sig = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
+       if (GDB_SIGNAL_FIRST <= sig && sig < GDB_SIGNAL_LAST)
+         event->ws.value.sig = (enum gdb_signal) sig;
+       else
+         event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
+      }

       break;
     case 'W':          /* Target exited.  */
     case 'X':
       break;
     case 'W':          /* Target exited.  */
     case 'X':


@@ -5710,7 +5675,10 @@ Packet: '%s'\n"),
          {
            /* The remote process exited with a signal.  */
            event->ws.kind = TARGET_WAITKIND_SIGNALLED;
          {
            /* The remote process exited with a signal.  */
            event->ws.kind = TARGET_WAITKIND_SIGNALLED;

-           event->ws.value.sig = (enum gdb_signal) value;
+           if (GDB_SIGNAL_FIRST <= value && value < GDB_SIGNAL_LAST)
+             event->ws.value.sig = (enum gdb_signal) value;
+           else
+             event->ws.value.sig = GDB_SIGNAL_UNKNOWN;

          }
 
        /* If no process is specified, assume inferior_ptid.  */
          }
 
        /* If no process is specified, assume inferior_ptid.  */


@@ -5793,7 +5761,7 @@ remote_notif_get_pending_events (struct notif_client *nc)
 {
   struct remote_state *rs = get_remote_state ();
 
 {
   struct remote_state *rs = get_remote_state ();
 

-  if (nc->pending_event)
+  if (rs->notif_state->pending_event[nc->id] != NULL)

     {
       if (notif_debug)
        fprintf_unfiltered (gdb_stdlog,
     {
       if (notif_debug)
        fprintf_unfiltered (gdb_stdlog,


@@ -5801,8 +5769,8 @@ remote_notif_get_pending_events (struct notif_client *nc)
                            nc->name);
 
       /* acknowledge */
                            nc->name);
 
       /* acknowledge */

-      nc->ack (nc, rs->buf, nc->pending_event);
-      nc->pending_event = NULL;
+      nc->ack (nc, rs->buf, rs->notif_state->pending_event[nc->id]);
+      rs->notif_state->pending_event[nc->id] = NULL;

 
       while (1)
        {
 
       while (1)
        {


@@ -5843,6 +5811,8 @@ process_stop_reply (struct stop_reply *stop_reply,
   if (status->kind != TARGET_WAITKIND_EXITED
       && status->kind != TARGET_WAITKIND_SIGNALLED)
     {
   if (status->kind != TARGET_WAITKIND_EXITED
       && status->kind != TARGET_WAITKIND_SIGNALLED)
     {

+      struct remote_state *rs = get_remote_state ();
+

       /* Expedited registers.  */
       if (stop_reply->regcache)
        {
       /* Expedited registers.  */
       if (stop_reply->regcache)
        {


@@ -5858,8 +5828,8 @@ process_stop_reply (struct stop_reply *stop_reply,
          VEC_free (cached_reg_t, stop_reply->regcache);
        }
 
          VEC_free (cached_reg_t, stop_reply->regcache);
        }
 

-      remote_stopped_by_watchpoint_p = stop_reply->stopped_by_watchpoint_p;
-      remote_watch_data_address = stop_reply->watch_data_address;
+      rs->remote_stopped_by_watchpoint_p = stop_reply->stopped_by_watchpoint_p;
+      rs->remote_watch_data_address = stop_reply->watch_data_address;

 
       remote_notice_new_inferior (ptid, 0);
       demand_private_info (ptid)->core = stop_reply->core;
 
       remote_notice_new_inferior (ptid, 0);
       demand_private_info (ptid)->core = stop_reply->core;


@@ -5905,7 +5875,7 @@ remote_wait_ns (ptid_t ptid, struct target_waitstatus *status, int options)
 
       /* Acknowledge a pending stop reply that may have arrived in the
         mean time.  */
 
       /* Acknowledge a pending stop reply that may have arrived in the
         mean time.  */

-      if (notif_client_stop.pending_event != NULL)
+      if (rs->notif_state->pending_event[notif_client_stop.id] != NULL)

        remote_notif_get_pending_events (&notif_client_stop);
 
       /* If indeed we noticed a stop reply, we're done.  */
        remote_notif_get_pending_events (&notif_client_stop);
 
       /* If indeed we noticed a stop reply, we're done.  */


@@ -5985,7 +5955,7 @@ remote_wait_as (ptid_t ptid, struct target_waitstatus *status, int options)
 
   buf = rs->buf;
 
 
   buf = rs->buf;
 

-  remote_stopped_by_watchpoint_p = 0;
+  rs->remote_stopped_by_watchpoint_p = 0;

 
   /* We got something.  */
   rs->waiting_for_stop_reply = 0;
 
   /* We got something.  */
   rs->waiting_for_stop_reply = 0;


@@ -6367,7 +6337,7 @@ remote_fetch_registers (struct target_ops *ops,
    first.  */
 
 static void
    first.  */
 
 static void

-remote_prepare_to_store (struct regcache *regcache)
+remote_prepare_to_store (struct target_ops *self, struct regcache *regcache)

 {
   struct remote_arch_state *rsa = get_remote_arch_state ();
   int i;
 {
   struct remote_arch_state *rsa = get_remote_arch_state ();
   int i;


@@ -6583,91 +6553,6 @@ remote_address_masked (CORE_ADDR addr)
   return addr;
 }
 
   return addr;
 }
 

-/* Convert BUFFER, binary data at least LEN bytes long, into escaped
-   binary data in OUT_BUF.  Set *OUT_LEN to the length of the data
-   encoded in OUT_BUF, and return the number of bytes in OUT_BUF
-   (which may be more than *OUT_LEN due to escape characters).  The
-   total number of bytes in the output buffer will be at most
-   OUT_MAXLEN.  */
-
-static int
-remote_escape_output (const gdb_byte *buffer, int len,
-                     gdb_byte *out_buf, int *out_len,
-                     int out_maxlen)
-{
-  int input_index, output_index;
-
-  output_index = 0;
-  for (input_index = 0; input_index < len; input_index++)
-    {
-      gdb_byte b = buffer[input_index];
-
-      if (b == '$' || b == '#' || b == '}')
-       {
-         /* These must be escaped.  */
-         if (output_index + 2 > out_maxlen)
-           break;
-         out_buf[output_index++] = '}';
-         out_buf[output_index++] = b ^ 0x20;
-       }
-      else
-       {
-         if (output_index + 1 > out_maxlen)
-           break;
-         out_buf[output_index++] = b;
-       }
-    }
-
-  *out_len = input_index;
-  return output_index;
-}
-
-/* Convert BUFFER, escaped data LEN bytes long, into binary data
-   in OUT_BUF.  Return the number of bytes written to OUT_BUF.
-   Raise an error if the total number of bytes exceeds OUT_MAXLEN.
-
-   This function reverses remote_escape_output.  It allows more
-   escaped characters than that function does, in particular because
-   '*' must be escaped to avoid the run-length encoding processing
-   in reading packets.  */
-
-static int
-remote_unescape_input (const gdb_byte *buffer, int len,
-                      gdb_byte *out_buf, int out_maxlen)
-{
-  int input_index, output_index;
-  int escaped;
-
-  output_index = 0;
-  escaped = 0;
-  for (input_index = 0; input_index < len; input_index++)
-    {
-      gdb_byte b = buffer[input_index];
-
-      if (output_index + 1 > out_maxlen)
-       {
-         warning (_("Received too much data from remote target;"
-                    " ignoring overflow."));
-         return output_index;
-       }
-
-      if (escaped)
-       {
-         out_buf[output_index++] = b ^ 0x20;
-         escaped = 0;
-       }
-      else if (b == '}')
-       escaped = 1;
-      else
-       out_buf[output_index++] = b;
-    }
-
-  if (escaped)
-    error (_("Unmatched escape character in target response."));
-
-  return output_index;
-}
-

 /* Determine whether the remote target supports binary downloading.
    This is accomplished by sending a no-op memory write of zero length
    to the target at the specified address. It does not suffice to send
 /* Determine whether the remote target supports binary downloading.
    This is accomplished by sending a no-op memory write of zero length
    to the target at the specified address. It does not suffice to send


@@ -6742,13 +6627,15 @@ check_binary_download (CORE_ADDR addr)
    If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
    are omitted.
 
    If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
    are omitted.
 

-   Returns the number of bytes transferred, or 0 (setting errno) for
-   error.  Only transfer a single packet.  */
+   Return the transferred status, error or OK (an
+   'enum target_xfer_status' value).  Save the number of bytes
+   transferred in *XFERED_LEN.  Only transfer a single packet.  */

 
 

-static int
+static enum target_xfer_status

 remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
 remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,

-                       const gdb_byte *myaddr, ssize_t len,
-                       char packet_format, int use_length)
+                       const gdb_byte *myaddr, ULONGEST len,
+                       ULONGEST *xfered_len, char packet_format,
+                       int use_length)

 {
   struct remote_state *rs = get_remote_state ();
   char *p;
 {
   struct remote_state *rs = get_remote_state ();
   char *p;


@@ -6764,8 +6651,8 @@ remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
     internal_error (__FILE__, __LINE__,
                    _("remote_write_bytes_aux: bad packet format"));
 
     internal_error (__FILE__, __LINE__,
                    _("remote_write_bytes_aux: bad packet format"));
 

-  if (len <= 0)
-    return 0;
+  if (len == 0)
+    return TARGET_XFER_EOF;

 
   payload_size = get_memory_write_packet_size ();
 
 
   payload_size = get_memory_write_packet_size ();
 


@@ -6884,18 +6771,12 @@ remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
   getpkt (&rs->buf, &rs->buf_size, 0);
 
   if (rs->buf[0] == 'E')
   getpkt (&rs->buf, &rs->buf_size, 0);
 
   if (rs->buf[0] == 'E')

-    {
-      /* There is no correspondance between what the remote protocol
-        uses for errors and errno codes.  We would like a cleaner way
-        of representing errors (big enough to include errno codes,
-        bfd_error codes, and others).  But for now just return EIO.  */
-      errno = EIO;
-      return 0;
-    }
+    return TARGET_XFER_E_IO;

 
   /* Return NR_BYTES, not TODO, in case escape chars caused us to send
      fewer bytes than we'd planned.  */
 
   /* Return NR_BYTES, not TODO, in case escape chars caused us to send
      fewer bytes than we'd planned.  */

-  return nr_bytes;
+  *xfered_len = (ULONGEST) nr_bytes;
+  return TARGET_XFER_OK;

 }
 
 /* Write memory data directly to the remote machine.
 }
 
 /* Write memory data directly to the remote machine.


@@ -6904,11 +6785,13 @@ remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
    MYADDR is the address of the buffer in our space.
    LEN is the number of bytes.
 
    MYADDR is the address of the buffer in our space.
    LEN is the number of bytes.
 

-   Returns number of bytes transferred, or 0 (setting errno) for
-   error.  Only transfer a single packet.  */
+   Return the transferred status, error or OK (an
+   'enum target_xfer_status' value).  Save the number of bytes
+   transferred in *XFERED_LEN.  Only transfer a single packet.  */

 
 

-static int
-remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
+static enum target_xfer_status
+remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, ULONGEST len,
+                   ULONGEST *xfered_len)

 {
   char *packet_format = 0;
 
 {
   char *packet_format = 0;
 


@@ -6931,7 +6814,8 @@ remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
     }
 
   return remote_write_bytes_aux (packet_format,
     }
 
   return remote_write_bytes_aux (packet_format,

-                                memaddr, myaddr, len, packet_format[0], 1);
+                                memaddr, myaddr, len, xfered_len,
+                                packet_format[0], 1);

 }
 
 /* Read memory data directly from the remote machine.
 }
 
 /* Read memory data directly from the remote machine.


@@ -6940,10 +6824,13 @@ remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
    MYADDR is the address of the buffer in our space.
    LEN is the number of bytes.
 
    MYADDR is the address of the buffer in our space.
    LEN is the number of bytes.
 

-   Returns number of bytes transferred, or 0 for error.  */
+   Return the transferred status, error or OK (an
+   'enum target_xfer_status' value).  Save the number of bytes
+   transferred in *XFERED_LEN.  */

 
 

-static int
-remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
+static enum target_xfer_status
+remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len,
+                  ULONGEST *xfered_len)

 {
   struct remote_state *rs = get_remote_state ();
   int max_buf_size;            /* Max size of packet output buffer.  */
 {
   struct remote_state *rs = get_remote_state ();
   int max_buf_size;            /* Max size of packet output buffer.  */


@@ -6951,7 +6838,7 @@ remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
   int todo;
   int i;
 
   int todo;
   int i;
 

-  if (len <= 0)
+  if (len == 0)

     return 0;
 
   max_buf_size = get_memory_read_packet_size ();
     return 0;
 
   max_buf_size = get_memory_read_packet_size ();


@@ -6974,46 +6861,17 @@ remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
   if (rs->buf[0] == 'E'
       && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
       && rs->buf[3] == '\0')
   if (rs->buf[0] == 'E'
       && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
       && rs->buf[3] == '\0')

-    {
-      /* There is no correspondance between what the remote protocol
-        uses for errors and errno codes.  We would like a cleaner way
-        of representing errors (big enough to include errno codes,
-        bfd_error codes, and others).  But for now just return
-        EIO.  */
-      errno = EIO;
-      return 0;
-    }
+    return TARGET_XFER_E_IO;

   /* Reply describes memory byte by byte, each byte encoded as two hex
      characters.  */
   p = rs->buf;
   i = hex2bin (p, myaddr, todo);
   /* Return what we have.  Let higher layers handle partial reads.  */
   /* Reply describes memory byte by byte, each byte encoded as two hex
      characters.  */
   p = rs->buf;
   i = hex2bin (p, myaddr, todo);
   /* Return what we have.  Let higher layers handle partial reads.  */

-  return i;
+  *xfered_len = (ULONGEST) i;
+  return TARGET_XFER_OK;

 }
 
 \f
 }
 
 \f

-/* Read or write LEN bytes from inferior memory at MEMADDR,
-   transferring to or from debugger address BUFFER.  Write to inferior
-   if SHOULD_WRITE is nonzero.  Returns length of data written or
-   read; 0 for error.  TARGET is unused.  */
-
-static int
-remote_xfer_memory (CORE_ADDR mem_addr, gdb_byte *buffer, int mem_len,
-                   int should_write, struct mem_attrib *attrib,
-                   struct target_ops *target)
-{
-  int res;
-
-  set_remote_traceframe ();
-  set_general_thread (inferior_ptid);
-
-  if (should_write)
-    res = remote_write_bytes (mem_addr, buffer, mem_len);
-  else
-    res = remote_read_bytes (mem_addr, buffer, mem_len);
-
-  return res;
-}

 
 /* Sends a packet with content determined by the printf format string
    FORMAT and the remaining arguments, then gets the reply.  Returns
 
 /* Sends a packet with content determined by the printf format string
    FORMAT and the remaining arguments, then gets the reply.  Returns


@@ -7082,18 +6940,19 @@ remote_flash_erase (struct target_ops *ops,
   do_cleanups (back_to);
 }
 
   do_cleanups (back_to);
 }
 

-static LONGEST
-remote_flash_write (struct target_ops *ops,
-                    ULONGEST address, LONGEST length,
-                    const gdb_byte *data)
+static enum target_xfer_status
+remote_flash_write (struct target_ops *ops, ULONGEST address,
+                   ULONGEST length, ULONGEST *xfered_len,
+                   const gdb_byte *data)

 {
   int saved_remote_timeout = remote_timeout;
 {
   int saved_remote_timeout = remote_timeout;

-  int ret;
+  enum target_xfer_status ret;

   struct cleanup *back_to = make_cleanup (restore_remote_timeout,
   struct cleanup *back_to = make_cleanup (restore_remote_timeout,

-                                          &saved_remote_timeout);
+                                         &saved_remote_timeout);

 
   remote_timeout = remote_flash_timeout;
 
   remote_timeout = remote_flash_timeout;

-  ret = remote_write_bytes_aux ("vFlashWrite:", address, data, length, 'X', 0);
+  ret = remote_write_bytes_aux ("vFlashWrite:", address, data, length,
+                               xfered_len,'X', 0);

   do_cleanups (back_to);
 
   return ret;
   do_cleanups (back_to);
 
   return ret;


@@ -7393,7 +7252,7 @@ putpkt_binary (char *buf, int cnt)
                                            str);
                        do_cleanups (old_chain);
                      }
                                            str);
                        do_cleanups (old_chain);
                      }

-                   handle_notification (rs->buf);
+                   handle_notification (rs->notif_state, rs->buf);

                    /* We're in sync now, rewait for the ack.  */
                    tcount = 0;
                  }
                    /* We're in sync now, rewait for the ack.  */
                    tcount = 0;
                  }


@@ -7678,7 +7537,7 @@ getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever,
      we get a packet.  */
   for (;;)
     {
      we get a packet.  */
   for (;;)
     {

-      /* If we get a timeout or bad checksm, retry up to MAX_TRIES
+      /* If we get a timeout or bad checksum, retry up to MAX_TRIES

         times.  */
       for (tries = 1; tries <= MAX_TRIES; tries++)
        {
         times.  */
       for (tries = 1; tries <= MAX_TRIES; tries++)
        {


@@ -7779,7 +7638,7 @@ getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever,
          if (is_notif != NULL)
            *is_notif = 1;
 
          if (is_notif != NULL)
            *is_notif = 1;
 

-         handle_notification (*buf);
+         handle_notification (rs->notif_state, *buf);

 
          /* Notifications require no acknowledgement.  */
 
 
          /* Notifications require no acknowledgement.  */
 


@@ -7804,23 +7663,39 @@ getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever,
 }
 
 \f
 }
 
 \f

-/* A helper function that just calls putpkt; for type correctness.  */
-
-static int
-putpkt_for_catch_errors (void *arg)
-{
-  return putpkt (arg);
-}
-

 static void
 remote_kill (struct target_ops *ops)
 {
 static void
 remote_kill (struct target_ops *ops)
 {

-  /* Use catch_errors so the user can quit from gdb even when we
+  volatile struct gdb_exception ex;
+
+  /* Catch errors so the user can quit from gdb even when we

      aren't on speaking terms with the remote system.  */
      aren't on speaking terms with the remote system.  */

-  catch_errors (putpkt_for_catch_errors, "k", "", RETURN_MASK_ERROR);
+  TRY_CATCH (ex, RETURN_MASK_ERROR)
+    {
+      putpkt ("k");
+    }
+  if (ex.reason < 0)
+    {
+      if (ex.error == TARGET_CLOSE_ERROR)
+       {
+         /* If we got an (EOF) error that caused the target
+            to go away, then we're done, that's what we wanted.
+            "k" is susceptible to cause a premature EOF, given
+            that the remote server isn't actually required to
+            reply to "k", and it can happen that it doesn't
+            even get to reply ACK to the "k".  */
+         return;
+       }

 
 

-  /* Don't wait for it to die.  I'm not really sure it matters whether
-     we do or not.  For the existing stubs, kill is a noop.  */
+       /* Otherwise, something went wrong.  We didn't actually kill
+          the target.  Just propagate the exception, and let the
+          user or higher layers decide what to do.  */
+       throw_exception (ex);
+    }
+
+  /* We've killed the remote end, we get to mourn it.  Since this is
+     target remote, single-process, mourning the inferior also
+     unpushes remote_ops.  */

   target_mourn_inferior ();
 }
 
   target_mourn_inferior ();
 }
 


@@ -7959,7 +7834,7 @@ extended_remote_mourn (struct target_ops *ops)
 }
 
 static int
 }
 
 static int

-extended_remote_supports_disable_randomization (void)
+extended_remote_supports_disable_randomization (struct target_ops *self)

 {
   return (remote_protocol_packets[PACKET_QDisableRandomization].support
          == PACKET_ENABLE);
 {
   return (remote_protocol_packets[PACKET_QDisableRandomization].support
          == PACKET_ENABLE);


@@ -7997,7 +7872,8 @@ extended_remote_run (char *args)
 
   if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ())
     error (_("Remote file name too long for run packet"));
 
   if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ())
     error (_("Remote file name too long for run packet"));

-  len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf + len, 0);
+  len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf + len,
+                     strlen (remote_exec_file));

 
   gdb_assert (args != NULL);
   if (*args)
 
   gdb_assert (args != NULL);
   if (*args)


@@ -8013,7 +7889,8 @@ extended_remote_run (char *args)
          if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ())
            error (_("Argument list too long for run packet"));
          rs->buf[len++] = ';';
          if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ())
            error (_("Argument list too long for run packet"));
          rs->buf[len++] = ';';

-         len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf + len, 0);
+         len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf + len,
+                             strlen (argv[i]));

        }
       do_cleanups (back_to);
     }
        }
       do_cleanups (back_to);
     }


@@ -8049,8 +7926,9 @@ extended_remote_run (char *args)
    environment.  */
 
 static void
    environment.  */
 
 static void

-extended_remote_create_inferior_1 (char *exec_file, char *args,
-                                  char **env, int from_tty)
+extended_remote_create_inferior (struct target_ops *ops,
+                                char *exec_file, char *args,
+                                char **env, int from_tty)

 {
   int run_worked;
   char *stop_reply;
 {
   int run_worked;
   char *stop_reply;


@@ -8062,7 +7940,7 @@ extended_remote_create_inferior_1 (char *exec_file, char *args,
     target_async (inferior_event_handler, 0);
 
   /* Disable address space randomization if requested (and supported).  */
     target_async (inferior_event_handler, 0);
 
   /* Disable address space randomization if requested (and supported).  */

-  if (extended_remote_supports_disable_randomization ())
+  if (extended_remote_supports_disable_randomization (ops))

     extended_remote_disable_randomization (disable_randomization);
 
   /* Now restart the remote server.  */
     extended_remote_disable_randomization (disable_randomization);
 
   /* Now restart the remote server.  */


@@ -8096,14 +7974,6 @@ extended_remote_create_inferior_1 (char *exec_file, char *args,
   /* Get updated offsets, if the stub uses qOffsets.  */
   get_offsets ();
 }
   /* Get updated offsets, if the stub uses qOffsets.  */
   get_offsets ();
 }

-
-static void
-extended_remote_create_inferior (struct target_ops *ops, 
-                                char *exec_file, char *args,
-                                char **env, int from_tty)
-{
-  extended_remote_create_inferior_1 (exec_file, args, env, from_tty);
-}

 \f
 
 /* Given a location's target info BP_TGT and the packet buffer BUF,  output
 \f
 
 /* Given a location's target info BP_TGT and the packet buffer BUF,  output


@@ -8139,8 +8009,6 @@ remote_add_target_side_condition (struct gdbarch *gdbarch,
        buf = pack_hex_byte (buf, aexpr->buf[i]);
       *buf = '\0';
     }
        buf = pack_hex_byte (buf, aexpr->buf[i]);
       *buf = '\0';
     }

-
-  VEC_free (agent_expr_p, bp_tgt->conditions);

   return 0;
 }
 
   return 0;
 }
 


@@ -8171,8 +8039,6 @@ remote_add_target_side_commands (struct gdbarch *gdbarch,
        buf = pack_hex_byte (buf, aexpr->buf[i]);
       *buf = '\0';
     }
        buf = pack_hex_byte (buf, aexpr->buf[i]);
       *buf = '\0';
     }

-
-  VEC_free (agent_expr_p, bp_tgt->tcommands);

 }
 
 /* Insert a breakpoint.  On targets that have software breakpoint
 }
 
 /* Insert a breakpoint.  On targets that have software breakpoint


@@ -8180,7 +8046,8 @@ remote_add_target_side_commands (struct gdbarch *gdbarch,
    which don't, we insert a traditional memory breakpoint.  */
 
 static int
    which don't, we insert a traditional memory breakpoint.  */
 
 static int

-remote_insert_breakpoint (struct gdbarch *gdbarch,
+remote_insert_breakpoint (struct target_ops *ops,
+                         struct gdbarch *gdbarch,

                          struct bp_target_info *bp_tgt)
 {
   /* Try the "Z" s/w breakpoint packet if it is not already disabled.
                          struct bp_target_info *bp_tgt)
 {
   /* Try the "Z" s/w breakpoint packet if it is not already disabled.


@@ -8214,10 +8081,10 @@ remote_insert_breakpoint (struct gdbarch *gdbarch,
       p += hexnumstr (p, addr);
       xsnprintf (p, endbuf - p, ",%d", bpsize);
 
       p += hexnumstr (p, addr);
       xsnprintf (p, endbuf - p, ",%d", bpsize);
 

-      if (remote_supports_cond_breakpoints ())
+      if (remote_supports_cond_breakpoints (ops))

        remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
 
        remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
 

-      if (remote_can_run_breakpoint_commands ())
+      if (remote_can_run_breakpoint_commands (ops))

        remote_add_target_side_commands (gdbarch, bp_tgt, p);
 
       putpkt (rs->buf);
        remote_add_target_side_commands (gdbarch, bp_tgt, p);
 
       putpkt (rs->buf);


@@ -8236,11 +8103,18 @@ remote_insert_breakpoint (struct gdbarch *gdbarch,
        }
     }
 
        }
     }
 

-  return memory_insert_breakpoint (gdbarch, bp_tgt);
+  /* If this breakpoint has target-side commands but this stub doesn't
+     support Z0 packets, throw error.  */
+  if (!VEC_empty (agent_expr_p, bp_tgt->tcommands))
+    throw_error (NOT_SUPPORTED_ERROR, _("\
+Target doesn't support breakpoints that have target side commands."));
+
+  return memory_insert_breakpoint (ops, gdbarch, bp_tgt);

 }
 
 static int
 }
 
 static int

-remote_remove_breakpoint (struct gdbarch *gdbarch,
+remote_remove_breakpoint (struct target_ops *ops,
+                         struct gdbarch *gdbarch,

                          struct bp_target_info *bp_tgt)
 {
   CORE_ADDR addr = bp_tgt->placed_address;
                          struct bp_target_info *bp_tgt)
 {
   CORE_ADDR addr = bp_tgt->placed_address;


@@ -8270,7 +8144,7 @@ remote_remove_breakpoint (struct gdbarch *gdbarch,
       return (rs->buf[0] == 'E');
     }
 
       return (rs->buf[0] == 'E');
     }
 

-  return memory_remove_breakpoint (gdbarch, bp_tgt);
+  return memory_remove_breakpoint (ops, gdbarch, bp_tgt);

 }
 
 static int
 }
 
 static int


@@ -8294,7 +8168,8 @@ watchpoint_to_Z_packet (int type)
 }
 
 static int
 }
 
 static int

-remote_insert_watchpoint (CORE_ADDR addr, int len, int type,
+remote_insert_watchpoint (struct target_ops *self,
+                         CORE_ADDR addr, int len, int type,

                          struct expression *cond)
 {
   struct remote_state *rs = get_remote_state ();
                          struct expression *cond)
 {
   struct remote_state *rs = get_remote_state ();


@@ -8343,7 +8218,8 @@ remote_watchpoint_addr_within_range (struct target_ops *target, CORE_ADDR addr,
 
 
 static int
 
 
 static int

-remote_remove_watchpoint (CORE_ADDR addr, int len, int type,
+remote_remove_watchpoint (struct target_ops *self,
+                         CORE_ADDR addr, int len, int type,

                          struct expression *cond)
 {
   struct remote_state *rs = get_remote_state ();
                          struct expression *cond)
 {
   struct remote_state *rs = get_remote_state ();


@@ -8385,7 +8261,8 @@ int remote_hw_watchpoint_length_limit = -1;
 int remote_hw_breakpoint_limit = -1;
 
 static int
 int remote_hw_breakpoint_limit = -1;
 
 static int

-remote_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
+remote_region_ok_for_hw_watchpoint (struct target_ops *self,
+                                   CORE_ADDR addr, int len)

 {
   if (remote_hw_watchpoint_length_limit == 0)
     return 0;
 {
   if (remote_hw_watchpoint_length_limit == 0)
     return 0;


@@ -8398,7 +8275,8 @@ remote_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
 }
 
 static int
 }
 
 static int

-remote_check_watch_resources (int type, int cnt, int ot)
+remote_check_watch_resources (struct target_ops *self,
+                             int type, int cnt, int ot)

 {
   if (type == bp_hardware_breakpoint)
     {
 {
   if (type == bp_hardware_breakpoint)
     {


@@ -8424,19 +8302,22 @@ remote_check_watch_resources (int type, int cnt, int ot)
 }
 
 static int
 }
 
 static int

-remote_stopped_by_watchpoint (void)
+remote_stopped_by_watchpoint (struct target_ops *ops)

 {
 {

-  return remote_stopped_by_watchpoint_p;
+  struct remote_state *rs = get_remote_state ();
+
+  return rs->remote_stopped_by_watchpoint_p;

 }
 
 static int
 remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
 {
 }
 
 static int
 remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
 {

+  struct remote_state *rs = get_remote_state ();

   int rc = 0;
 
   int rc = 0;
 

-  if (remote_stopped_by_watchpoint ())
+  if (remote_stopped_by_watchpoint (target))

     {
     {

-      *addr_p = remote_watch_data_address;
+      *addr_p = rs->remote_watch_data_address;

       rc = 1;
     }
 
       rc = 1;
     }
 


@@ -8445,7 +8326,7 @@ remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
 
 
 static int
 
 
 static int

-remote_insert_hw_breakpoint (struct gdbarch *gdbarch,
+remote_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,

                             struct bp_target_info *bp_tgt)
 {
   CORE_ADDR addr;
                             struct bp_target_info *bp_tgt)
 {
   CORE_ADDR addr;


@@ -8479,10 +8360,10 @@ remote_insert_hw_breakpoint (struct gdbarch *gdbarch,
   p += hexnumstr (p, (ULONGEST) addr);
   xsnprintf (p, endbuf - p, ",%x", bp_tgt->placed_size);
 
   p += hexnumstr (p, (ULONGEST) addr);
   xsnprintf (p, endbuf - p, ",%x", bp_tgt->placed_size);
 

-  if (remote_supports_cond_breakpoints ())
+  if (remote_supports_cond_breakpoints (self))

     remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
 
     remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
 

-  if (remote_can_run_breakpoint_commands ())
+  if (remote_can_run_breakpoint_commands (self))

     remote_add_target_side_commands (gdbarch, bp_tgt, p);
 
   putpkt (rs->buf);
     remote_add_target_side_commands (gdbarch, bp_tgt, p);
 
   putpkt (rs->buf);


@@ -8509,7 +8390,7 @@ remote_insert_hw_breakpoint (struct gdbarch *gdbarch,
 
 
 static int
 
 
 static int

-remote_remove_hw_breakpoint (struct gdbarch *gdbarch,
+remote_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,

                             struct bp_target_info *bp_tgt)
 {
   CORE_ADDR addr;
                             struct bp_target_info *bp_tgt)
 {
   CORE_ADDR addr;


@@ -8659,10 +8540,10 @@ the loaded file\n"));
    into remote target.  The number of bytes written to the remote
    target is returned, or -1 for error.  */
 
    into remote target.  The number of bytes written to the remote
    target is returned, or -1 for error.  */
 

-static LONGEST
+static enum target_xfer_status

 remote_write_qxfer (struct target_ops *ops, const char *object_name,
                     const char *annex, const gdb_byte *writebuf, 
 remote_write_qxfer (struct target_ops *ops, const char *object_name,
                     const char *annex, const gdb_byte *writebuf, 

-                    ULONGEST offset, LONGEST len, 
+                    ULONGEST offset, LONGEST len, ULONGEST *xfered_len,

                     struct packet_config *packet)
 {
   int i, buf_len;
                     struct packet_config *packet)
 {
   int i, buf_len;


@@ -8671,7 +8552,7 @@ remote_write_qxfer (struct target_ops *ops, const char *object_name,
   int max_size = get_memory_write_packet_size (); 
 
   if (packet->support == PACKET_DISABLE)
   int max_size = get_memory_write_packet_size (); 
 
   if (packet->support == PACKET_DISABLE)

-    return -1;
+    return TARGET_XFER_E_IO;

 
   /* Insert header.  */
   i = snprintf (rs->buf, max_size, 
 
   /* Insert header.  */
   i = snprintf (rs->buf, max_size, 


@@ -8687,10 +8568,12 @@ remote_write_qxfer (struct target_ops *ops, const char *object_name,
   if (putpkt_binary (rs->buf, i + buf_len) < 0
       || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
       || packet_ok (rs->buf, packet) != PACKET_OK)
   if (putpkt_binary (rs->buf, i + buf_len) < 0
       || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
       || packet_ok (rs->buf, packet) != PACKET_OK)

-    return -1;
+    return TARGET_XFER_E_IO;

 
   unpack_varlen_hex (rs->buf, &n);
 
   unpack_varlen_hex (rs->buf, &n);

-  return n;
+
+  *xfered_len = n;
+  return TARGET_XFER_OK;

 }
 
 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
 }
 
 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.


@@ -8700,17 +8583,18 @@ remote_write_qxfer (struct target_ops *ops, const char *object_name,
    EOF.  PACKET is checked and updated to indicate whether the remote
    target supports this object.  */
 
    EOF.  PACKET is checked and updated to indicate whether the remote
    target supports this object.  */
 

-static LONGEST
+static enum target_xfer_status

 remote_read_qxfer (struct target_ops *ops, const char *object_name,
                   const char *annex,
                   gdb_byte *readbuf, ULONGEST offset, LONGEST len,
 remote_read_qxfer (struct target_ops *ops, const char *object_name,
                   const char *annex,
                   gdb_byte *readbuf, ULONGEST offset, LONGEST len,

+                  ULONGEST *xfered_len,

                   struct packet_config *packet)
 {
   struct remote_state *rs = get_remote_state ();
   LONGEST i, n, packet_len;
 
   if (packet->support == PACKET_DISABLE)
                   struct packet_config *packet)
 {
   struct remote_state *rs = get_remote_state ();
   LONGEST i, n, packet_len;
 
   if (packet->support == PACKET_DISABLE)

-    return -1;
+    return TARGET_XFER_E_IO;

 
   /* Check whether we've cached an end-of-object packet that matches
      this request.  */
 
   /* Check whether we've cached an end-of-object packet that matches
      this request.  */


@@ -8719,7 +8603,8 @@ remote_read_qxfer (struct target_ops *ops, const char *object_name,
       if (strcmp (object_name, rs->finished_object) == 0
          && strcmp (annex ? annex : "", rs->finished_annex) == 0
          && offset == rs->finished_offset)
       if (strcmp (object_name, rs->finished_object) == 0
          && strcmp (annex ? annex : "", rs->finished_annex) == 0
          && offset == rs->finished_offset)

-       return 0;
+       return TARGET_XFER_EOF;
+

 
       /* Otherwise, we're now reading something different.  Discard
         the cache.  */
 
       /* Otherwise, we're now reading something different.  Discard
         the cache.  */


@@ -8740,12 +8625,12 @@ remote_read_qxfer (struct target_ops *ops, const char *object_name,
            phex_nz (n, sizeof n));
   i = putpkt (rs->buf);
   if (i < 0)
            phex_nz (n, sizeof n));
   i = putpkt (rs->buf);
   if (i < 0)

-    return -1;
+    return TARGET_XFER_E_IO;

 
   rs->buf[0] = '\0';
   packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0);
   if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
 
   rs->buf[0] = '\0';
   packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0);
   if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)

-    return -1;
+    return TARGET_XFER_E_IO;

 
   if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
     error (_("Unknown remote qXfer reply: %s"), rs->buf);
 
   if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
     error (_("Unknown remote qXfer reply: %s"), rs->buf);


@@ -8770,13 +8655,20 @@ remote_read_qxfer (struct target_ops *ops, const char *object_name,
       rs->finished_offset = offset + i;
     }
 
       rs->finished_offset = offset + i;
     }
 

-  return i;
+  if (i == 0)
+    return TARGET_XFER_EOF;
+  else
+    {
+      *xfered_len = i;
+      return TARGET_XFER_OK;
+    }

 }
 
 }
 

-static LONGEST
+static enum target_xfer_status

 remote_xfer_partial (struct target_ops *ops, enum target_object object,
                     const char *annex, gdb_byte *readbuf,
 remote_xfer_partial (struct target_ops *ops, enum target_object object,
                     const char *annex, gdb_byte *readbuf,

-                    const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
+                    const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
+                    ULONGEST *xfered_len)

 {
   struct remote_state *rs;
   int i;
 {
   struct remote_state *rs;
   int i;


@@ -8791,27 +8683,16 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
   /* Handle memory using the standard memory routines.  */
   if (object == TARGET_OBJECT_MEMORY)
     {
   /* Handle memory using the standard memory routines.  */
   if (object == TARGET_OBJECT_MEMORY)
     {

-      int xfered;
-
-      errno = 0;
-

       /* If the remote target is connected but not running, we should
         pass this request down to a lower stratum (e.g. the executable
         file).  */
       if (!target_has_execution)
       /* If the remote target is connected but not running, we should
         pass this request down to a lower stratum (e.g. the executable
         file).  */
       if (!target_has_execution)

-       return 0;
+       return TARGET_XFER_EOF;

 
       if (writebuf != NULL)
 
       if (writebuf != NULL)

-       xfered = remote_write_bytes (offset, writebuf, len);
+       return remote_write_bytes (offset, writebuf, len, xfered_len);

       else
       else

-       xfered = remote_read_bytes (offset, readbuf, len);
-
-      if (xfered > 0)
-       return xfered;
-      else if (xfered == 0 && errno == 0)
-       return 0;
-      else
-       return -1;
+       return remote_read_bytes (offset, readbuf, len, xfered_len);

     }
 
   /* Handle SPU memory using qxfer packets.  */
     }
 
   /* Handle SPU memory using qxfer packets.  */


@@ -8819,12 +8700,12 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
     {
       if (readbuf)
        return remote_read_qxfer (ops, "spu", annex, readbuf, offset, len,
     {
       if (readbuf)
        return remote_read_qxfer (ops, "spu", annex, readbuf, offset, len,

-                                 &remote_protocol_packets
-                                   [PACKET_qXfer_spu_read]);
+                                 xfered_len, &remote_protocol_packets
+                                 [PACKET_qXfer_spu_read]);

       else
        return remote_write_qxfer (ops, "spu", annex, writebuf, offset, len,
       else
        return remote_write_qxfer (ops, "spu", annex, writebuf, offset, len,

-                                  &remote_protocol_packets
-                                    [PACKET_qXfer_spu_write]);
+                                  xfered_len, &remote_protocol_packets
+                                  [PACKET_qXfer_spu_write]);

     }
 
   /* Handle extra signal info using qxfer packets.  */
     }
 
   /* Handle extra signal info using qxfer packets.  */


@@ -8832,11 +8713,11 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
     {
       if (readbuf)
        return remote_read_qxfer (ops, "siginfo", annex, readbuf, offset, len,
     {
       if (readbuf)
        return remote_read_qxfer (ops, "siginfo", annex, readbuf, offset, len,

-                                 &remote_protocol_packets
+                                 xfered_len, &remote_protocol_packets

                                  [PACKET_qXfer_siginfo_read]);
       else
        return remote_write_qxfer (ops, "siginfo", annex,
                                  [PACKET_qXfer_siginfo_read]);
       else
        return remote_write_qxfer (ops, "siginfo", annex,

-                                  writebuf, offset, len,
+                                  writebuf, offset, len, xfered_len,

                                   &remote_protocol_packets
                                   [PACKET_qXfer_siginfo_write]);
     }
                                   &remote_protocol_packets
                                   [PACKET_qXfer_siginfo_write]);
     }


@@ -8845,11 +8726,11 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
     {
       if (readbuf)
        return remote_read_qxfer (ops, "statictrace", annex,
     {
       if (readbuf)
        return remote_read_qxfer (ops, "statictrace", annex,

-                                 readbuf, offset, len,
+                                 readbuf, offset, len, xfered_len,

                                  &remote_protocol_packets
                                  [PACKET_qXfer_statictrace_read]);
       else
                                  &remote_protocol_packets
                                  [PACKET_qXfer_statictrace_read]);
       else

-       return -1;
+       return TARGET_XFER_E_IO;

     }
 
   /* Only handle flash writes.  */
     }
 
   /* Only handle flash writes.  */


@@ -8860,17 +8741,11 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
       switch (object)
        {
        case TARGET_OBJECT_FLASH:
       switch (object)
        {
        case TARGET_OBJECT_FLASH:

-         xfered = remote_flash_write (ops, offset, len, writebuf);
-
-         if (xfered > 0)
-           return xfered;
-         else if (xfered == 0 && errno == 0)
-           return 0;
-         else
-           return -1;
+         return remote_flash_write (ops, offset, len, xfered_len,
+                                    writebuf);

 
        default:
 
        default:

-         return -1;
+         return TARGET_XFER_E_IO;

        }
     }
 
        }
     }
 


@@ -8885,60 +8760,66 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
     case TARGET_OBJECT_AUXV:
       gdb_assert (annex == NULL);
       return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
     case TARGET_OBJECT_AUXV:
       gdb_assert (annex == NULL);
       return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,

+                               xfered_len,

                                &remote_protocol_packets[PACKET_qXfer_auxv]);
 
     case TARGET_OBJECT_AVAILABLE_FEATURES:
       return remote_read_qxfer
                                &remote_protocol_packets[PACKET_qXfer_auxv]);
 
     case TARGET_OBJECT_AVAILABLE_FEATURES:
       return remote_read_qxfer

-       (ops, "features", annex, readbuf, offset, len,
+       (ops, "features", annex, readbuf, offset, len, xfered_len,

         &remote_protocol_packets[PACKET_qXfer_features]);
 
     case TARGET_OBJECT_LIBRARIES:
       return remote_read_qxfer
         &remote_protocol_packets[PACKET_qXfer_features]);
 
     case TARGET_OBJECT_LIBRARIES:
       return remote_read_qxfer

-       (ops, "libraries", annex, readbuf, offset, len,
+       (ops, "libraries", annex, readbuf, offset, len, xfered_len,

         &remote_protocol_packets[PACKET_qXfer_libraries]);
 
     case TARGET_OBJECT_LIBRARIES_SVR4:
       return remote_read_qxfer
         &remote_protocol_packets[PACKET_qXfer_libraries]);
 
     case TARGET_OBJECT_LIBRARIES_SVR4:
       return remote_read_qxfer

-       (ops, "libraries-svr4", annex, readbuf, offset, len,
+       (ops, "libraries-svr4", annex, readbuf, offset, len, xfered_len,

         &remote_protocol_packets[PACKET_qXfer_libraries_svr4]);
 
     case TARGET_OBJECT_MEMORY_MAP:
       gdb_assert (annex == NULL);
       return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len,
         &remote_protocol_packets[PACKET_qXfer_libraries_svr4]);
 
     case TARGET_OBJECT_MEMORY_MAP:
       gdb_assert (annex == NULL);
       return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len,

+                                xfered_len,

                                &remote_protocol_packets[PACKET_qXfer_memory_map]);
 
     case TARGET_OBJECT_OSDATA:
       /* Should only get here if we're connected.  */
       gdb_assert (rs->remote_desc);
       return remote_read_qxfer
                                &remote_protocol_packets[PACKET_qXfer_memory_map]);
 
     case TARGET_OBJECT_OSDATA:
       /* Should only get here if we're connected.  */
       gdb_assert (rs->remote_desc);
       return remote_read_qxfer

-       (ops, "osdata", annex, readbuf, offset, len,
+       (ops, "osdata", annex, readbuf, offset, len, xfered_len,

         &remote_protocol_packets[PACKET_qXfer_osdata]);
 
     case TARGET_OBJECT_THREADS:
       gdb_assert (annex == NULL);
       return remote_read_qxfer (ops, "threads", annex, readbuf, offset, len,
         &remote_protocol_packets[PACKET_qXfer_osdata]);
 
     case TARGET_OBJECT_THREADS:
       gdb_assert (annex == NULL);
       return remote_read_qxfer (ops, "threads", annex, readbuf, offset, len,

+                               xfered_len,

                                &remote_protocol_packets[PACKET_qXfer_threads]);
 
     case TARGET_OBJECT_TRACEFRAME_INFO:
       gdb_assert (annex == NULL);
       return remote_read_qxfer
                                &remote_protocol_packets[PACKET_qXfer_threads]);
 
     case TARGET_OBJECT_TRACEFRAME_INFO:
       gdb_assert (annex == NULL);
       return remote_read_qxfer

-       (ops, "traceframe-info", annex, readbuf, offset, len,
+       (ops, "traceframe-info", annex, readbuf, offset, len, xfered_len,

         &remote_protocol_packets[PACKET_qXfer_traceframe_info]);
 
     case TARGET_OBJECT_FDPIC:
       return remote_read_qxfer (ops, "fdpic", annex, readbuf, offset, len,
         &remote_protocol_packets[PACKET_qXfer_traceframe_info]);
 
     case TARGET_OBJECT_FDPIC:
       return remote_read_qxfer (ops, "fdpic", annex, readbuf, offset, len,

+                               xfered_len,

                                &remote_protocol_packets[PACKET_qXfer_fdpic]);
 
     case TARGET_OBJECT_OPENVMS_UIB:
       return remote_read_qxfer (ops, "uib", annex, readbuf, offset, len,
                                &remote_protocol_packets[PACKET_qXfer_fdpic]);
 
     case TARGET_OBJECT_OPENVMS_UIB:
       return remote_read_qxfer (ops, "uib", annex, readbuf, offset, len,

+                               xfered_len,

                                &remote_protocol_packets[PACKET_qXfer_uib]);
 
     case TARGET_OBJECT_BTRACE:
       return remote_read_qxfer (ops, "btrace", annex, readbuf, offset, len,
                                &remote_protocol_packets[PACKET_qXfer_uib]);
 
     case TARGET_OBJECT_BTRACE:
       return remote_read_qxfer (ops, "btrace", annex, readbuf, offset, len,

+                               xfered_len,

         &remote_protocol_packets[PACKET_qXfer_btrace]);
 
     default:
         &remote_protocol_packets[PACKET_qXfer_btrace]);
 
     default:

-      return -1;
+      return TARGET_XFER_E_IO;

     }
 
   /* Note: a zero OFFSET and LEN can be used to query the minimum
     }
 
   /* Note: a zero OFFSET and LEN can be used to query the minimum


@@ -8948,7 +8829,7 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
   /* Minimum outbuf size is get_remote_packet_size ().  If LEN is not
      large enough let the caller deal with it.  */
   if (len < get_remote_packet_size ())
   /* Minimum outbuf size is get_remote_packet_size ().  If LEN is not
      large enough let the caller deal with it.  */
   if (len < get_remote_packet_size ())

-    return -1;
+    return TARGET_XFER_E_IO;

   len = get_remote_packet_size ();
 
   /* Except for querying the minimum buffer size, target must be open.  */
   len = get_remote_packet_size ();
 
   /* Except for querying the minimum buffer size, target must be open.  */


@@ -8980,12 +8861,13 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
 
   i = putpkt (rs->buf);
   if (i < 0)
 
   i = putpkt (rs->buf);
   if (i < 0)

-    return i;
+    return TARGET_XFER_E_IO;

 
   getpkt (&rs->buf, &rs->buf_size, 0);
   strcpy ((char *) readbuf, rs->buf);
 
 
   getpkt (&rs->buf, &rs->buf_size, 0);
   strcpy ((char *) readbuf, rs->buf);
 

-  return strlen ((char *) readbuf);
+  *xfered_len = strlen ((char *) readbuf);
+  return TARGET_XFER_OK;

 }
 
 static int
 }
 
 static int


@@ -9080,7 +8962,7 @@ remote_search_memory (struct target_ops* ops,
 }
 
 static void
 }
 
 static void

-remote_rcmd (char *command,
+remote_rcmd (struct target_ops *self, char *command,

             struct ui_file *outbuf)
 {
   struct remote_state *rs = get_remote_state ();
             struct ui_file *outbuf)
 {
   struct remote_state *rs = get_remote_state ();


@@ -9102,7 +8984,7 @@ remote_rcmd (char *command,
     error (_("\"monitor\" command ``%s'' is too long."), command);
 
   /* Encode the actual command.  */
     error (_("\"monitor\" command ``%s'' is too long."), command);
 
   /* Encode the actual command.  */

-  bin2hex ((gdb_byte *) command, p, 0);
+  bin2hex ((gdb_byte *) command, p, strlen (command));

 
   if (putpkt (rs->buf) < 0)
     error (_("Communication problem with target."));
 
   if (putpkt (rs->buf) < 0)
     error (_("Communication problem with target."));


@@ -9773,7 +9655,8 @@ remote_hostio_send_command (int command_bytes, int which_packet,
    *REMOTE_ERRNO).  */
 
 static int
    *REMOTE_ERRNO).  */
 
 static int

-remote_hostio_open (const char *filename, int flags, int mode,
+remote_hostio_open (struct target_ops *self,
+                   const char *filename, int flags, int mode,

                    int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();
                    int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();


@@ -9800,7 +9683,8 @@ remote_hostio_open (const char *filename, int flags, int mode,
    set *REMOTE_ERRNO).  */
 
 static int
    set *REMOTE_ERRNO).  */
 
 static int

-remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
+remote_hostio_pwrite (struct target_ops *self,
+                     int fd, const gdb_byte *write_buf, int len,

                      ULONGEST offset, int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();
                      ULONGEST offset, int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();


@@ -9828,7 +9712,8 @@ remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
    set *REMOTE_ERRNO).  */
 
 static int
    set *REMOTE_ERRNO).  */
 
 static int

-remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
+remote_hostio_pread (struct target_ops *self,
+                    int fd, gdb_byte *read_buf, int len,

                     ULONGEST offset, int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();
                     ULONGEST offset, int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();


@@ -9867,7 +9752,7 @@ remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
    (and set *REMOTE_ERRNO).  */
 
 static int
    (and set *REMOTE_ERRNO).  */
 
 static int

-remote_hostio_close (int fd, int *remote_errno)
+remote_hostio_close (struct target_ops *self, int fd, int *remote_errno)

 {
   struct remote_state *rs = get_remote_state ();
   char *p = rs->buf;
 {
   struct remote_state *rs = get_remote_state ();
   char *p = rs->buf;


@@ -9885,7 +9770,8 @@ remote_hostio_close (int fd, int *remote_errno)
    occurs (and set *REMOTE_ERRNO).  */
 
 static int
    occurs (and set *REMOTE_ERRNO).  */
 
 static int

-remote_hostio_unlink (const char *filename, int *remote_errno)
+remote_hostio_unlink (struct target_ops *self,
+                     const char *filename, int *remote_errno)

 {
   struct remote_state *rs = get_remote_state ();
   char *p = rs->buf;
 {
   struct remote_state *rs = get_remote_state ();
   char *p = rs->buf;


@@ -9905,7 +9791,8 @@ remote_hostio_unlink (const char *filename, int *remote_errno)
    occurs (and set *REMOTE_ERRNO).  */
 
 static char *
    occurs (and set *REMOTE_ERRNO).  */
 
 static char *

-remote_hostio_readlink (const char *filename, int *remote_errno)
+remote_hostio_readlink (struct target_ops *self,
+                       const char *filename, int *remote_errno)

 {
   struct remote_state *rs = get_remote_state ();
   char *p = rs->buf;
 {
   struct remote_state *rs = get_remote_state ();
   char *p = rs->buf;


@@ -10006,7 +9893,7 @@ remote_hostio_close_cleanup (void *opaque)
   int fd = *(int *) opaque;
   int remote_errno;
 
   int fd = *(int *) opaque;
   int remote_errno;
 

-  remote_hostio_close (fd, &remote_errno);
+  remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno);

 }
 
 
 }
 
 


@@ -10019,7 +9906,8 @@ remote_bfd_iovec_open (struct bfd *abfd, void *open_closure)
 
   gdb_assert (remote_filename_p (filename));
 
 
   gdb_assert (remote_filename_p (filename));
 

-  fd = remote_hostio_open (filename + 7, FILEIO_O_RDONLY, 0, &remote_errno);
+  fd = remote_hostio_open (find_target_at (process_stratum),
+                          filename + 7, FILEIO_O_RDONLY, 0, &remote_errno);

   if (fd == -1)
     {
       errno = remote_fileio_errno_to_host (remote_errno);
   if (fd == -1)
     {
       errno = remote_fileio_errno_to_host (remote_errno);


@@ -10042,7 +9930,7 @@ remote_bfd_iovec_close (struct bfd *abfd, void *stream)
 
   /* Ignore errors on close; these may happen if the remote
      connection was already torn down.  */
 
   /* Ignore errors on close; these may happen if the remote
      connection was already torn down.  */

-  remote_hostio_close (fd, &remote_errno);
+  remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno);

 
   /* Zero means success.  */
   return 0;
 
   /* Zero means success.  */
   return 0;


@@ -10059,7 +9947,8 @@ remote_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
   pos = 0;
   while (nbytes > pos)
     {
   pos = 0;
   while (nbytes > pos)
     {

-      bytes = remote_hostio_pread (fd, (gdb_byte *) buf + pos, nbytes - pos,
+      bytes = remote_hostio_pread (find_target_at (process_stratum),
+                                  fd, (gdb_byte *) buf + pos, nbytes - pos,

                                   offset + pos, &remote_errno);
       if (bytes == 0)
         /* Success, but no bytes, means end-of-file.  */
                                   offset + pos, &remote_errno);
       if (bytes == 0)
         /* Success, but no bytes, means end-of-file.  */


@@ -10088,7 +9977,9 @@ remote_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
 int
 remote_filename_p (const char *filename)
 {
 int
 remote_filename_p (const char *filename)
 {

-  return strncmp (filename, "remote:", 7) == 0;
+  return strncmp (filename,
+                 REMOTE_SYSROOT_PREFIX,
+                 sizeof (REMOTE_SYSROOT_PREFIX) - 1) == 0;

 }
 
 bfd *
 }
 
 bfd *


@@ -10123,7 +10014,8 @@ remote_file_put (const char *local_file, const char *remote_file, int from_tty)
     perror_with_name (local_file);
   back_to = make_cleanup_fclose (file);
 
     perror_with_name (local_file);
   back_to = make_cleanup_fclose (file);
 

-  fd = remote_hostio_open (remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
+  fd = remote_hostio_open (find_target_at (process_stratum),
+                          remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT

                                         | FILEIO_O_TRUNC),
                           0700, &remote_errno);
   if (fd == -1)
                                         | FILEIO_O_TRUNC),
                           0700, &remote_errno);
   if (fd == -1)


@@ -10167,7 +10059,8 @@ remote_file_put (const char *local_file, const char *remote_file, int from_tty)
       bytes += bytes_in_buffer;
       bytes_in_buffer = 0;
 
       bytes += bytes_in_buffer;
       bytes_in_buffer = 0;
 

-      retcode = remote_hostio_pwrite (fd, buffer, bytes,
+      retcode = remote_hostio_pwrite (find_target_at (process_stratum),
+                                     fd, buffer, bytes,

                                      offset, &remote_errno);
 
       if (retcode < 0)
                                      offset, &remote_errno);
 
       if (retcode < 0)


@@ -10186,7 +10079,7 @@ remote_file_put (const char *local_file, const char *remote_file, int from_tty)
     }
 
   discard_cleanups (close_cleanup);
     }
 
   discard_cleanups (close_cleanup);

-  if (remote_hostio_close (fd, &remote_errno))
+  if (remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno))

     remote_hostio_error (remote_errno);
 
   if (from_tty)
     remote_hostio_error (remote_errno);
 
   if (from_tty)


@@ -10207,7 +10100,8 @@ remote_file_get (const char *remote_file, const char *local_file, int from_tty)
   if (!rs->remote_desc)
     error (_("command can only be used with remote target"));
 
   if (!rs->remote_desc)
     error (_("command can only be used with remote target"));
 

-  fd = remote_hostio_open (remote_file, FILEIO_O_RDONLY, 0, &remote_errno);
+  fd = remote_hostio_open (find_target_at (process_stratum),
+                          remote_file, FILEIO_O_RDONLY, 0, &remote_errno);

   if (fd == -1)
     remote_hostio_error (remote_errno);
 
   if (fd == -1)
     remote_hostio_error (remote_errno);
 


@@ -10227,7 +10121,8 @@ remote_file_get (const char *remote_file, const char *local_file, int from_tty)
   offset = 0;
   while (1)
     {
   offset = 0;
   while (1)
     {

-      bytes = remote_hostio_pread (fd, buffer, io_size, offset, &remote_errno);
+      bytes = remote_hostio_pread (find_target_at (process_stratum),
+                                  fd, buffer, io_size, offset, &remote_errno);

       if (bytes == 0)
        /* Success, but no bytes, means end-of-file.  */
        break;
       if (bytes == 0)
        /* Success, but no bytes, means end-of-file.  */
        break;


@@ -10242,7 +10137,7 @@ remote_file_get (const char *remote_file, const char *local_file, int from_tty)
     }
 
   discard_cleanups (close_cleanup);
     }
 
   discard_cleanups (close_cleanup);

-  if (remote_hostio_close (fd, &remote_errno))
+  if (remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno))

     remote_hostio_error (remote_errno);
 
   if (from_tty)
     remote_hostio_error (remote_errno);
 
   if (from_tty)


@@ -10259,7 +10154,8 @@ remote_file_delete (const char *remote_file, int from_tty)
   if (!rs->remote_desc)
     error (_("command can only be used with remote target"));
 
   if (!rs->remote_desc)
     error (_("command can only be used with remote target"));
 

-  retcode = remote_hostio_unlink (remote_file, &remote_errno);
+  retcode = remote_hostio_unlink (find_target_at (process_stratum),
+                                 remote_file, &remote_errno);

   if (retcode == -1)
     remote_hostio_error (remote_errno);
 
   if (retcode == -1)
     remote_hostio_error (remote_errno);
 


@@ -10331,7 +10227,7 @@ remote_command (char *args, int from_tty)
 }
 
 static int
 }
 
 static int

-remote_can_execute_reverse (void)
+remote_can_execute_reverse (struct target_ops *self)

 {
   if (remote_protocol_packets[PACKET_bs].support == PACKET_ENABLE
       || remote_protocol_packets[PACKET_bc].support == PACKET_ENABLE)
 {
   if (remote_protocol_packets[PACKET_bs].support == PACKET_ENABLE
       || remote_protocol_packets[PACKET_bc].support == PACKET_ENABLE)


@@ -10341,20 +10237,20 @@ remote_can_execute_reverse (void)
 }
 
 static int
 }
 
 static int

-remote_supports_non_stop (void)
+remote_supports_non_stop (struct target_ops *self)

 {
   return 1;
 }
 
 static int
 {
   return 1;
 }
 
 static int

-remote_supports_disable_randomization (void)
+remote_supports_disable_randomization (struct target_ops *self)

 {
   /* Only supported in extended mode.  */
   return 0;
 }
 
 static int
 {
   /* Only supported in extended mode.  */
   return 0;
 }
 
 static int

-remote_supports_multi_process (void)
+remote_supports_multi_process (struct target_ops *self)

 {
   struct remote_state *rs = get_remote_state ();
 
 {
   struct remote_state *rs = get_remote_state ();
 


@@ -10374,7 +10270,7 @@ remote_supports_cond_tracepoints (void)
 }
 
 static int
 }
 
 static int

-remote_supports_cond_breakpoints (void)
+remote_supports_cond_breakpoints (struct target_ops *self)

 {
   struct remote_state *rs = get_remote_state ();
 
 {
   struct remote_state *rs = get_remote_state ();
 


@@ -10406,7 +10302,7 @@ remote_supports_install_in_trace (void)
 }
 
 static int
 }
 
 static int

-remote_supports_enable_disable_tracepoint (void)
+remote_supports_enable_disable_tracepoint (struct target_ops *self)

 {
   struct remote_state *rs = get_remote_state ();
 
 {
   struct remote_state *rs = get_remote_state ();
 


@@ -10414,7 +10310,7 @@ remote_supports_enable_disable_tracepoint (void)
 }
 
 static int
 }
 
 static int

-remote_supports_string_tracing (void)
+remote_supports_string_tracing (struct target_ops *self)

 {
   struct remote_state *rs = get_remote_state ();
 
 {
   struct remote_state *rs = get_remote_state ();
 


@@ -10422,7 +10318,7 @@ remote_supports_string_tracing (void)
 }
 
 static int
 }
 
 static int

-remote_can_run_breakpoint_commands (void)
+remote_can_run_breakpoint_commands (struct target_ops *self)

 {
   struct remote_state *rs = get_remote_state ();
 
 {
   struct remote_state *rs = get_remote_state ();
 


@@ -10717,7 +10613,7 @@ remote_download_trace_state_variable (struct trace_state_variable *tsv)
   p = rs->buf + strlen (rs->buf);
   if ((p - rs->buf) + strlen (tsv->name) * 2 >= get_remote_packet_size ())
     error (_("Trace state variable name too long for tsv definition packet"));
   p = rs->buf + strlen (rs->buf);
   if ((p - rs->buf) + strlen (tsv->name) * 2 >= get_remote_packet_size ())
     error (_("Trace state variable name too long for tsv definition packet"));

-  p += 2 * bin2hex ((gdb_byte *) (tsv->name), p, 0);
+  p += 2 * bin2hex ((gdb_byte *) (tsv->name), p, strlen (tsv->name));

   *p++ = '\0';
   putpkt (rs->buf);
   remote_get_noisy_reply (&target_buf, &target_buf_size);
   *p++ = '\0';
   putpkt (rs->buf);
   remote_get_noisy_reply (&target_buf, &target_buf_size);


@@ -11047,7 +10943,7 @@ remote_save_trace_data (const char *filename)
   p += strlen (p);
   if ((p - rs->buf) + strlen (filename) * 2 >= get_remote_packet_size ())
     error (_("Remote file name too long for trace save packet"));
   p += strlen (p);
   if ((p - rs->buf) + strlen (filename) * 2 >= get_remote_packet_size ())
     error (_("Remote file name too long for trace save packet"));

-  p += 2 * bin2hex ((gdb_byte *) filename, p, 0);
+  p += 2 * bin2hex ((gdb_byte *) filename, p, strlen (filename));

   *p++ = '\0';
   putpkt (rs->buf);
   reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
   *p++ = '\0';
   putpkt (rs->buf);
   reply = remote_get_noisy_reply (&target_buf, &target_buf_size);


@@ -11152,6 +11048,11 @@ remote_traceframe_info (void)
 {
   char *text;
 
 {
   char *text;
 

+  /* If current traceframe is not selected, don't bother the remote
+     stub.  */
+  if (get_traceframe_number () < 0)
+    return NULL;
+

   text = target_read_stralloc (&current_target,
                               TARGET_OBJECT_TRACEFRAME_INFO, NULL);
   if (text != NULL)
   text = target_read_stralloc (&current_target,
                               TARGET_OBJECT_TRACEFRAME_INFO, NULL);
   if (text != NULL)


@@ -11247,21 +11148,21 @@ remote_set_trace_notes (const char *user, const char *notes,
   if (user)
     {
       buf += xsnprintf (buf, endbuf - buf, "user:");
   if (user)
     {
       buf += xsnprintf (buf, endbuf - buf, "user:");

-      nbytes = bin2hex ((gdb_byte *) user, buf, 0);
+      nbytes = bin2hex ((gdb_byte *) user, buf, strlen (user));

       buf += 2 * nbytes;
       *buf++ = ';';
     }
   if (notes)
     {
       buf += xsnprintf (buf, endbuf - buf, "notes:");
       buf += 2 * nbytes;
       *buf++ = ';';
     }
   if (notes)
     {
       buf += xsnprintf (buf, endbuf - buf, "notes:");

-      nbytes = bin2hex ((gdb_byte *) notes, buf, 0);
+      nbytes = bin2hex ((gdb_byte *) notes, buf, strlen (notes));

       buf += 2 * nbytes;
       *buf++ = ';';
     }
   if (stop_notes)
     {
       buf += xsnprintf (buf, endbuf - buf, "tstop:");
       buf += 2 * nbytes;
       *buf++ = ';';
     }
   if (stop_notes)
     {
       buf += xsnprintf (buf, endbuf - buf, "tstop:");

-      nbytes = bin2hex ((gdb_byte *) stop_notes, buf, 0);
+      nbytes = bin2hex ((gdb_byte *) stop_notes, buf, strlen (stop_notes));

       buf += 2 * nbytes;
       *buf++ = ';';
     }
       buf += 2 * nbytes;
       *buf++ = ';';
     }


@@ -11316,7 +11217,7 @@ struct btrace_target_info
 /* Check whether the target supports branch tracing.  */
 
 static int
 /* Check whether the target supports branch tracing.  */
 
 static int

-remote_supports_btrace (void)
+remote_supports_btrace (struct target_ops *self)

 {
   if (remote_protocol_packets[PACKET_Qbtrace_off].support != PACKET_ENABLE)
     return 0;
 {
   if (remote_protocol_packets[PACKET_Qbtrace_off].support != PACKET_ENABLE)
     return 0;


@@ -11407,13 +11308,14 @@ remote_teardown_btrace (struct btrace_target_info *tinfo)
 
 /* Read the branch trace.  */
 
 
 /* Read the branch trace.  */
 

-static VEC (btrace_block_s) *
-remote_read_btrace (struct btrace_target_info *tinfo,
+static enum btrace_error
+remote_read_btrace (VEC (btrace_block_s) **btrace,
+                   struct btrace_target_info *tinfo,

                    enum btrace_read_type type)
 {
   struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace];
   struct remote_state *rs = get_remote_state ();
                    enum btrace_read_type type)
 {
   struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace];
   struct remote_state *rs = get_remote_state ();

-  VEC (btrace_block_s) *btrace = NULL;
+  struct cleanup *cleanup;

   const char *annex;
   char *xml;
 
   const char *annex;
   char *xml;
 


@@ -11426,12 +11328,15 @@ remote_read_btrace (struct btrace_target_info *tinfo,
 
   switch (type)
     {
 
   switch (type)
     {

-    case btrace_read_all:
+    case BTRACE_READ_ALL:

       annex = "all";
       break;
       annex = "all";
       break;

-    case btrace_read_new:
+    case BTRACE_READ_NEW:

       annex = "new";
       break;
       annex = "new";
       break;

+    case BTRACE_READ_DELTA:
+      annex = "delta";
+      break;

     default:
       internal_error (__FILE__, __LINE__,
                      _("Bad branch tracing read type: %u."),
     default:
       internal_error (__FILE__, __LINE__,
                      _("Bad branch tracing read type: %u."),


@@ -11440,15 +11345,14 @@ remote_read_btrace (struct btrace_target_info *tinfo,
 
   xml = target_read_stralloc (&current_target,
                               TARGET_OBJECT_BTRACE, annex);
 
   xml = target_read_stralloc (&current_target,
                               TARGET_OBJECT_BTRACE, annex);

-  if (xml != NULL)
-    {
-      struct cleanup *cleanup = make_cleanup (xfree, xml);
+  if (xml == NULL)
+    return BTRACE_ERR_UNKNOWN;

 
 

-      btrace = parse_xml_btrace (xml);
-      do_cleanups (cleanup);
-    }
+  cleanup = make_cleanup (xfree, xml);
+  *btrace = parse_xml_btrace (xml);
+  do_cleanups (cleanup);

 
 

-  return btrace;
+  return BTRACE_ERR_NONE;

 }
 
 static int
 }
 
 static int


@@ -11459,6 +11363,14 @@ remote_augmented_libraries_svr4_read (void)
   return rs->augmented_libraries_svr4_read;
 }
 
   return rs->augmented_libraries_svr4_read;
 }
 

+/* Implementation of to_load.  */
+
+static void
+remote_load (struct target_ops *self, char *name, int from_tty)
+{
+  generic_load (name, from_tty);
+}
+

 static void
 init_remote_ops (void)
 {
 static void
 init_remote_ops (void)
 {


@@ -11477,7 +11389,6 @@ Specify the serial device it is connected to\n\
   remote_ops.to_fetch_registers = remote_fetch_registers;
   remote_ops.to_store_registers = remote_store_registers;
   remote_ops.to_prepare_to_store = remote_prepare_to_store;
   remote_ops.to_fetch_registers = remote_fetch_registers;
   remote_ops.to_store_registers = remote_store_registers;
   remote_ops.to_prepare_to_store = remote_prepare_to_store;

-  remote_ops.deprecated_xfer_memory = remote_xfer_memory;

   remote_ops.to_files_info = remote_files_info;
   remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
   remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
   remote_ops.to_files_info = remote_files_info;
   remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
   remote_ops.to_remove_breakpoint = remote_remove_breakpoint;


@@ -11493,7 +11404,7 @@ Specify the serial device it is connected to\n\
   remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
   remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
   remote_ops.to_kill = remote_kill;
   remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
   remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
   remote_ops.to_kill = remote_kill;

-  remote_ops.to_load = generic_load;
+  remote_ops.to_load = remote_load;

   remote_ops.to_mourn_inferior = remote_mourn;
   remote_ops.to_pass_signals = remote_pass_signals;
   remote_ops.to_program_signals = remote_program_signals;
   remote_ops.to_mourn_inferior = remote_mourn;
   remote_ops.to_pass_signals = remote_pass_signals;
   remote_ops.to_program_signals = remote_program_signals;


@@ -11610,7 +11521,7 @@ Specify the serial device it is connected to (e.g. /dev/ttya).";
 }
 
 static int
 }
 
 static int

-remote_can_async_p (void)
+remote_can_async_p (struct target_ops *ops)

 {
   struct remote_state *rs = get_remote_state ();
 
 {
   struct remote_state *rs = get_remote_state ();
 


@@ -11623,7 +11534,7 @@ remote_can_async_p (void)
 }
 
 static int
 }
 
 static int

-remote_is_async_p (void)
+remote_is_async_p (struct target_ops *ops)

 {
   struct remote_state *rs = get_remote_state ();
 
 {
   struct remote_state *rs = get_remote_state ();
 


@@ -11658,8 +11569,10 @@ remote_async_inferior_event_handler (gdb_client_data data)
 }
 
 static void
 }
 
 static void

-remote_async (void (*callback) (enum inferior_event_type event_type,
-                               void *context), void *context)
+remote_async (struct target_ops *ops,
+             void (*callback) (enum inferior_event_type event_type,
+                               void *context),
+             void *context)

 {
   struct remote_state *rs = get_remote_state ();
 
 {
   struct remote_state *rs = get_remote_state ();