PR remote/2158

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

diff --git a/gdb/remote.c b/gdb/remote.c
index 687a5d8f7e370a8f93b0c8139f421d10ea5325b2..d8d42f61865cc6606d335019bab284a3c246203e 100644 (file)
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -60,6 +60,8 @@
 
 #include "remote-fileio.h"
 
 
 #include "remote-fileio.h"
 

+#include "memory-map.h"
+

 /* The size to align memory write packets, when practical.  The protocol
    does not guarantee any alignment, and gdb will generate short
    writes and unaligned writes, but even as a best-effort attempt this
 /* The size to align memory write packets, when practical.  The protocol
    does not guarantee any alignment, and gdb will generate short
    writes and unaligned writes, but even as a best-effort attempt this


@@ -242,7 +244,7 @@ struct remote_state
 static struct remote_state remote_state;
 
 static struct remote_state *
 static struct remote_state remote_state;
 
 static struct remote_state *

-get_remote_state (void)
+get_remote_state_raw (void)

 {
   return &remote_state;
 }
 {
   return &remote_state;
 }


@@ -255,7 +257,7 @@ struct packet_reg
   long regnum; /* GDB's internal register number.  */
   LONGEST pnum; /* Remote protocol register number.  */
   int in_g_packet; /* Always part of G packet.  */
   long regnum; /* GDB's internal register number.  */
   LONGEST pnum; /* Remote protocol register number.  */
   int in_g_packet; /* Always part of G packet.  */

-  /* long size in bytes;  == register_size (current_gdbarch, regnum); 
+  /* long size in bytes;  == register_size (current_gdbarch, regnum);

      at present.  */
   /* char *name; == REGISTER_NAME (regnum); at present.  */
 };
      at present.  */
   /* char *name; == REGISTER_NAME (regnum); at present.  */
 };


@@ -292,11 +294,26 @@ get_remote_arch_state (void)
   return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
 }
 
   return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
 }
 

+/* Fetch the global remote target state.  */
+
+static struct remote_state *
+get_remote_state (void)
+{
+  /* Make sure that the remote architecture state has been
+     initialized, because doing so might reallocate rs->buf.  Any
+     function which calls getpkt also needs to be mindful of changes
+     to rs->buf, but this call limits the number of places which run
+     into trouble.  */
+  get_remote_arch_state ();
+
+  return get_remote_state_raw ();
+}
+

 static void *
 init_remote_state (struct gdbarch *gdbarch)
 {
   int regnum;
 static void *
 init_remote_state (struct gdbarch *gdbarch)
 {
   int regnum;

-  struct remote_state *rs = get_remote_state ();
+  struct remote_state *rs = get_remote_state_raw ();

   struct remote_arch_state *rsa;
 
   rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
   struct remote_arch_state *rsa;
 
   rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);


@@ -751,12 +768,42 @@ add_packet_config_cmd (struct packet_config *config, const char *name,
 }
 
 static enum packet_result
 }
 
 static enum packet_result

-packet_ok (const char *buf, struct packet_config *config)
+packet_check_result (const char *buf)

 {
   if (buf[0] != '\0')
     {
       /* The stub recognized the packet request.  Check that the
         operation succeeded.  */
 {
   if (buf[0] != '\0')
     {
       /* The stub recognized the packet request.  Check that the
         operation succeeded.  */

+      if (buf[0] == 'E'
+         && isxdigit (buf[1]) && isxdigit (buf[2])
+         && buf[3] == '\0')
+       /* "Enn"  - definitly an error.  */
+       return PACKET_ERROR;
+
+      /* Always treat "E." as an error.  This will be used for
+        more verbose error messages, such as E.memtypes.  */
+      if (buf[0] == 'E' && buf[1] == '.')
+       return PACKET_ERROR;
+
+      /* The packet may or may not be OK.  Just assume it is.  */
+      return PACKET_OK;
+    }
+  else
+    /* The stub does not support the packet.  */
+    return PACKET_UNKNOWN;
+}
+
+static enum packet_result
+packet_ok (const char *buf, struct packet_config *config)
+{
+  enum packet_result result;
+
+  result = packet_check_result (buf);
+  switch (result)
+    {
+    case PACKET_OK:
+    case PACKET_ERROR:
+      /* The stub recognized the packet request.  */

       switch (config->support)
        {
        case PACKET_SUPPORT_UNKNOWN:
       switch (config->support)
        {
        case PACKET_SUPPORT_UNKNOWN:


@@ -773,19 +820,8 @@ packet_ok (const char *buf, struct packet_config *config)
        case PACKET_ENABLE:
          break;
        }
        case PACKET_ENABLE:
          break;
        }

-      if (buf[0] == 'O' && buf[1] == 'K' && buf[2] == '\0')
-       /* "OK" - definitly OK.  */
-       return PACKET_OK;
-      if (buf[0] == 'E'
-         && isxdigit (buf[1]) && isxdigit (buf[2])
-         && buf[3] == '\0')
-       /* "Enn"  - definitly an error.  */
-       return PACKET_ERROR;
-      /* The packet may or may not be OK.  Just assume it is.  */
-      return PACKET_OK;
-    }
-  else
-    {
+      break;
+    case PACKET_UNKNOWN:

       /* The stub does not support the packet.  */
       switch (config->support)
        {
       /* The stub does not support the packet.  */
       switch (config->support)
        {


@@ -810,8 +846,10 @@ packet_ok (const char *buf, struct packet_config *config)
        case PACKET_DISABLE:
          break;
        }
        case PACKET_DISABLE:
          break;
        }

-      return PACKET_UNKNOWN;
+      break;

     }
     }

+
+  return result;

 }
 
 enum {
 }
 
 enum {


@@ -826,6 +864,7 @@ enum {
   PACKET_Z3,
   PACKET_Z4,
   PACKET_qXfer_auxv,
   PACKET_Z3,
   PACKET_Z4,
   PACKET_qXfer_auxv,

+  PACKET_qXfer_memory_map,

   PACKET_qGetTLSAddr,
   PACKET_qSupported,
   PACKET_MAX
   PACKET_qGetTLSAddr,
   PACKET_qSupported,
   PACKET_MAX


@@ -1003,15 +1042,14 @@ remote_thread_alive (ptid_t ptid)
 {
   struct remote_state *rs = get_remote_state ();
   int tid = PIDGET (ptid);
 {
   struct remote_state *rs = get_remote_state ();
   int tid = PIDGET (ptid);

-  char *buf = rs->buf;

 
   if (tid < 0)
 
   if (tid < 0)

-    xsnprintf (buf, get_remote_packet_size (), "T-%08x", -tid);
+    xsnprintf (rs->buf, get_remote_packet_size (), "T-%08x", -tid);

   else
   else

-    xsnprintf (buf, get_remote_packet_size (), "T%08x", tid);
-  putpkt (buf);
+    xsnprintf (rs->buf, get_remote_packet_size (), "T%08x", tid);
+  putpkt (rs->buf);

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

-  return (buf[0] == 'O' && buf[1] == 'K');
+  return (rs->buf[0] == 'O' && rs->buf[1] == 'K');

 }
 
 /* About these extended threadlist and threadinfo packets.  They are
 }
 
 /* About these extended threadlist and threadinfo packets.  They are


@@ -1041,12 +1079,12 @@ typedef int gdb_threadref;      /* Internal GDB thread reference.  */
 struct gdb_ext_thread_info
   {
     threadref threadid;                /* External form of thread reference.  */
 struct gdb_ext_thread_info
   {
     threadref threadid;                /* External form of thread reference.  */

-    int active;                        /* Has state interesting to GDB? 
+    int active;                        /* Has state interesting to GDB?

                                   regs, stack.  */
                                   regs, stack.  */

-    char display[256];         /* Brief state display, name, 
+    char display[256];         /* Brief state display, name,

                                   blocked/suspended.  */
     char shortname[32];                /* To be used to name threads.  */
                                   blocked/suspended.  */
     char shortname[32];                /* To be used to name threads.  */

-    char more_display[256];    /* Long info, statistics, queue depth, 
+    char more_display[256];    /* Long info, statistics, queue depth,

                                   whatever.  */
   };
 
                                   whatever.  */
   };
 


@@ -1092,7 +1130,7 @@ static void copy_threadref (threadref *dest, threadref *src);
 
 static int threadmatch (threadref *dest, threadref *src);
 
 
 static int threadmatch (threadref *dest, threadref *src);
 

-static char *pack_threadinfo_request (char *pkt, int mode, 
+static char *pack_threadinfo_request (char *pkt, int mode,

                                      threadref *id);
 
 static int remote_unpack_thread_info_response (char *pkt,
                                      threadref *id);
 
 static int remote_unpack_thread_info_response (char *pkt,


@@ -1101,7 +1139,7 @@ static int remote_unpack_thread_info_response (char *pkt,
                                               *info);
 
 
                                               *info);
 
 

-static int remote_get_threadinfo (threadref *threadid, 
+static int remote_get_threadinfo (threadref *threadid,

                                  int fieldset, /*TAG mask */
                                  struct gdb_ext_thread_info *info);
 
                                  int fieldset, /*TAG mask */
                                  struct gdb_ext_thread_info *info);
 


@@ -1112,14 +1150,14 @@ static char *pack_threadlist_request (char *pkt, int startflag,
 static int parse_threadlist_response (char *pkt,
                                      int result_limit,
                                      threadref *original_echo,
 static int parse_threadlist_response (char *pkt,
                                      int result_limit,
                                      threadref *original_echo,

-                                     threadref *resultlist, 
+                                     threadref *resultlist,

                                      int *doneflag);
 
 static int remote_get_threadlist (int startflag,
                                  threadref *nextthread,
                                  int result_limit,
                                  int *done,
                                      int *doneflag);
 
 static int remote_get_threadlist (int startflag,
                                  threadref *nextthread,
                                  int result_limit,
                                  int *done,

-                                 int *result_count, 
+                                 int *result_count,

                                  threadref *threadlist);
 
 typedef int (*rmt_thread_action) (threadref *ref, void *context);
                                  threadref *threadlist);
 
 typedef int (*rmt_thread_action) (threadref *ref, void *context);


@@ -1188,7 +1226,7 @@ unpack_varlen_hex (char *buff,    /* packet to parse */
                   ULONGEST *result)
 {
   int nibble;
                   ULONGEST *result)
 {
   int nibble;

-  int retval = 0;
+  ULONGEST retval = 0;

 
   while (ishex (*buff, &nibble))
     {
 
   while (ishex (*buff, &nibble))
     {


@@ -1510,12 +1548,11 @@ remote_get_threadinfo (threadref *threadid, int fieldset,       /* TAG mask */
 {
   struct remote_state *rs = get_remote_state ();
   int result;
 {
   struct remote_state *rs = get_remote_state ();
   int result;

-  char *threadinfo_pkt = rs->buf;

 
 

-  pack_threadinfo_request (threadinfo_pkt, fieldset, threadid);
-  putpkt (threadinfo_pkt);
+  pack_threadinfo_request (rs->buf, fieldset, threadid);
+  putpkt (rs->buf);

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

-  result = remote_unpack_thread_info_response (threadinfo_pkt + 2,
+  result = remote_unpack_thread_info_response (rs->buf + 2,

                                               threadid, info);
   return result;
 }
                                               threadid, info);
   return result;
 }


@@ -1571,7 +1608,6 @@ remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
 {
   struct remote_state *rs = get_remote_state ();
   static threadref echo_nextthread;
 {
   struct remote_state *rs = get_remote_state ();
   static threadref echo_nextthread;

-  char *threadlist_packet = rs->buf;

   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.  */


@@ -1688,17 +1724,16 @@ static ptid_t
 remote_current_thread (ptid_t oldpid)
 {
   struct remote_state *rs = get_remote_state ();
 remote_current_thread (ptid_t oldpid)
 {
   struct remote_state *rs = get_remote_state ();

-  char *buf = rs->buf;

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

-  if (buf[0] == 'Q' && buf[1] == 'C')
+  if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')

     /* Use strtoul here, so we'll correctly parse values whose highest
        bit is set.  The protocol carries them as a simple series of
        hex digits; in the absence of a sign, strtol will see such
        values as positive numbers out of range for signed 'long', and
        return LONG_MAX to indicate an overflow.  */
     /* Use strtoul here, so we'll correctly parse values whose highest
        bit is set.  The protocol carries them as a simple series of
        hex digits; in the absence of a sign, strtol will see such
        values as positive numbers out of range for signed 'long', and
        return LONG_MAX to indicate an overflow.  */

-    return pid_to_ptid (strtoul (&buf[2], NULL, 16));
+    return pid_to_ptid (strtoul (&rs->buf[2], NULL, 16));

   else
     return oldpid;
 }
   else
     return oldpid;
 }


@@ -1736,8 +1771,8 @@ remote_threads_info (void)
   if (use_threadinfo_query)
     {
       putpkt ("qfThreadInfo");
   if (use_threadinfo_query)
     {
       putpkt ("qfThreadInfo");

-      bufp = rs->buf;

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

+      bufp = rs->buf;

       if (bufp[0] != '\0')             /* q packet recognized */
        {
          while (*bufp++ == 'm')        /* reply contains one or more TID */
       if (bufp[0] != '\0')             /* q packet recognized */
        {
          while (*bufp++ == 'm')        /* reply contains one or more TID */


@@ -1756,8 +1791,8 @@ remote_threads_info (void)
                }
              while (*bufp++ == ',');   /* comma-separated list */
              putpkt ("qsThreadInfo");
                }
              while (*bufp++ == ',');   /* comma-separated list */
              putpkt ("qsThreadInfo");

-             bufp = rs->buf;

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

+             bufp = rs->buf;

            }
          return;       /* done */
        }
            }
          return;       /* done */
        }


@@ -1795,16 +1830,14 @@ remote_threads_extra_info (struct thread_info *tp)
 
   if (use_threadextra_query)
     {
 
   if (use_threadextra_query)
     {

-      char *bufp = rs->buf;
-
-      xsnprintf (bufp, get_remote_packet_size (), "qThreadExtraInfo,%x",
+      xsnprintf (rs->buf, get_remote_packet_size (), "qThreadExtraInfo,%x",

                 PIDGET (tp->ptid));
                 PIDGET (tp->ptid));

-      putpkt (bufp);
+      putpkt (rs->buf);

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

-      if (bufp[0] != 0)
+      if (rs->buf[0] != 0)

        {
        {

-         n = min (strlen (bufp) / 2, sizeof (display_buf));
-         result = hex2bin (bufp, (gdb_byte *) display_buf, n);
+         n = min (strlen (rs->buf) / 2, sizeof (display_buf));
+         result = hex2bin (rs->buf, (gdb_byte *) display_buf, n);

          display_buf [result] = '\0';
          return display_buf;
        }
          display_buf [result] = '\0';
          return display_buf;
        }


@@ -1819,13 +1852,13 @@ remote_threads_extra_info (struct thread_info *tp)
     if (threadinfo.active)
       {
        if (*threadinfo.shortname)
     if (threadinfo.active)
       {
        if (*threadinfo.shortname)

-         n += xsnprintf (&display_buf[0], sizeof (display_buf) - n, 
+         n += xsnprintf (&display_buf[0], sizeof (display_buf) - n,

                          " Name: %s,", threadinfo.shortname);
        if (*threadinfo.display)
                          " Name: %s,", threadinfo.shortname);
        if (*threadinfo.display)

-         n += xsnprintf (&display_buf[n], sizeof (display_buf) - n, 
+         n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,

                          " State: %s,", threadinfo.display);
        if (*threadinfo.more_display)
                          " State: %s,", threadinfo.display);
        if (*threadinfo.more_display)

-         n += xsnprintf (&display_buf[n], sizeof (display_buf) - n, 
+         n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,

                          " Priority: %s", threadinfo.more_display);
 
        if (n > 0)
                          " Priority: %s", threadinfo.more_display);
 
        if (n > 0)


@@ -1853,7 +1886,7 @@ extended_remote_restart (void)
   putpkt (rs->buf);
 
   remote_fileio_reset ();
   putpkt (rs->buf);
 
   remote_fileio_reset ();

-  
+

   /* Now query for status so this looks just like we restarted
      gdbserver from scratch.  */
   putpkt ("?");
   /* Now query for status so this looks just like we restarted
      gdbserver from scratch.  */
   putpkt ("?");


@@ -1876,7 +1909,7 @@ static void
 get_offsets (void)
 {
   struct remote_state *rs = get_remote_state ();
 get_offsets (void)
 {
   struct remote_state *rs = get_remote_state ();

-  char *buf = rs->buf;
+  char *buf;

   char *ptr;
   int lose;
   CORE_ADDR text_addr, data_addr, bss_addr;
   char *ptr;
   int lose;
   CORE_ADDR text_addr, data_addr, bss_addr;


@@ -1884,6 +1917,7 @@ get_offsets (void)
 
   putpkt ("qOffsets");
   getpkt (&rs->buf, &rs->buf_size, 0);
 
   putpkt ("qOffsets");
   getpkt (&rs->buf, &rs->buf_size, 0);

+  buf = rs->buf;

 
   if (buf[0] == '\000')
     return;                    /* Return silently.  Stub doesn't support
 
   if (buf[0] == '\000')
     return;                    /* Return silently.  Stub doesn't support


@@ -2046,13 +2080,12 @@ remote_check_symbols (struct objfile *objfile)
      because we need both at the same time.  */
   msg = alloca (get_remote_packet_size ());
 
      because we need both at the same time.  */
   msg = alloca (get_remote_packet_size ());
 

-  reply = rs->buf;
-

   /* Invite target to request symbol lookups.  */
 
   putpkt ("qSymbol::");
   getpkt (&rs->buf, &rs->buf_size, 0);
   packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]);
   /* Invite target to request symbol lookups.  */
 
   putpkt ("qSymbol::");
   getpkt (&rs->buf, &rs->buf_size, 0);
   packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]);

+  reply = rs->buf;

 
   while (strncmp (reply, "qSymbol:", 8) == 0)
     {
 
   while (strncmp (reply, "qSymbol:", 8) == 0)
     {


@@ -2068,6 +2101,7 @@ remote_check_symbols (struct objfile *objfile)
                   &reply[8]);
       putpkt (msg);
       getpkt (&rs->buf, &rs->buf_size, 0);
                   &reply[8]);
       putpkt (msg);
       getpkt (&rs->buf, &rs->buf_size, 0);

+      reply = rs->buf;

     }
 }
 
     }
 }
 


@@ -2176,8 +2210,10 @@ remote_packet_size (const struct protocol_feature *feature,
 
 static struct protocol_feature remote_protocol_features[] = {
   { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
 
 static struct protocol_feature remote_protocol_features[] = {
   { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },

-  { "qPart:auxv:read", PACKET_DISABLE, remote_supported_packet,
-    PACKET_qXfer_auxv }
+  { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
+    PACKET_qXfer_auxv },
+  { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
+    PACKET_qXfer_memory_map }

 };
 
 static void
 };
 
 static void


@@ -2559,11 +2595,12 @@ bin2hex (const gdb_byte *bin, char *hex, int count)
 static void
 remote_vcont_probe (struct remote_state *rs)
 {
 static void
 remote_vcont_probe (struct remote_state *rs)
 {

-  char *buf = rs->buf;
+  char *buf;

 
 

-  strcpy (buf, "vCont?");
-  putpkt (buf);
+  strcpy (rs->buf, "vCont?");
+  putpkt (rs->buf);

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

+  buf = rs->buf;

 
   /* Make sure that the features we assume are supported.  */
   if (strncmp (buf, "vCont", 5) == 0)
 
   /* Make sure that the features we assume are supported.  */
   if (strncmp (buf, "vCont", 5) == 0)


@@ -2688,7 +2725,7 @@ static void
 remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
 {
   struct remote_state *rs = get_remote_state ();
 remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
 {
   struct remote_state *rs = get_remote_state ();

-  char *buf = rs->buf;
+  char *buf;

   int pid = PIDGET (ptid);
 
   last_sent_signal = siggnal;
   int pid = PIDGET (ptid);
 
   last_sent_signal = siggnal;


@@ -2709,6 +2746,7 @@ remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
   else
     set_thread (pid, 0);       /* Run this thread.  */
 
   else
     set_thread (pid, 0);       /* Run this thread.  */
 

+  buf = rs->buf;

   if (siggnal != TARGET_SIGNAL_0)
     {
       buf[0] = step ? 'S' : 'C';
   if (siggnal != TARGET_SIGNAL_0)
     {
       buf[0] = step ? 'S' : 'C';


@@ -2813,10 +2851,10 @@ cleanup_sigint_signal_handler (void *dummy)
 {
   signal (SIGINT, handle_sigint);
   if (sigint_remote_twice_token)
 {
   signal (SIGINT, handle_sigint);
   if (sigint_remote_twice_token)

-    delete_async_signal_handler ((struct async_signal_handler **) 
+    delete_async_signal_handler ((struct async_signal_handler **)

                                 &sigint_remote_twice_token);
   if (sigint_remote_token)
                                 &sigint_remote_twice_token);
   if (sigint_remote_token)

-    delete_async_signal_handler ((struct async_signal_handler **) 
+    delete_async_signal_handler ((struct async_signal_handler **)

                                 &sigint_remote_token);
 }
 
                                 &sigint_remote_token);
 }
 


@@ -2959,7 +2997,6 @@ remote_wait (ptid_t ptid, struct target_waitstatus *status)
 {
   struct remote_state *rs = get_remote_state ();
   struct remote_arch_state *rsa = get_remote_arch_state ();
 {
   struct remote_state *rs = get_remote_state ();
   struct remote_arch_state *rsa = get_remote_arch_state ();

-  char *buf = rs->buf;

   ULONGEST thread_num = -1;
   ULONGEST addr;
 
   ULONGEST thread_num = -1;
   ULONGEST addr;
 


@@ -2968,12 +3005,14 @@ remote_wait (ptid_t ptid, struct target_waitstatus *status)
 
   while (1)
     {
 
   while (1)
     {

-      char *p;
+      char *buf, *p;

 
       ofunc = signal (SIGINT, remote_interrupt);
       getpkt (&rs->buf, &rs->buf_size, 1);
       signal (SIGINT, ofunc);
 
 
       ofunc = signal (SIGINT, remote_interrupt);
       getpkt (&rs->buf, &rs->buf_size, 1);
       signal (SIGINT, ofunc);
 

+      buf = rs->buf;
+

       /* This is a hook for when we need to do something (perhaps the
          collection of trace data) every time the target stops.  */
       if (deprecated_target_wait_loop_hook)
       /* This is a hook for when we need to do something (perhaps the
          collection of trace data) every time the target stops.  */
       if (deprecated_target_wait_loop_hook)


@@ -3069,18 +3108,18 @@ Packet: '%s'\n"),
                             phex_nz (pnum, 0), p, buf);
 
                    fieldsize = hex2bin (p, regs,
                             phex_nz (pnum, 0), p, buf);
 
                    fieldsize = hex2bin (p, regs,

-                                        register_size (current_gdbarch, 
+                                        register_size (current_gdbarch,

                                                        reg->regnum));
                    p += 2 * fieldsize;
                                                        reg->regnum));
                    p += 2 * fieldsize;

-                   if (fieldsize < register_size (current_gdbarch, 
+                   if (fieldsize < register_size (current_gdbarch,

                                                   reg->regnum))
                      warning (_("Remote reply is too short: %s"), buf);
                                                   reg->regnum))
                      warning (_("Remote reply is too short: %s"), buf);

-                   regcache_raw_supply (current_regcache, 
+                   regcache_raw_supply (current_regcache,

                                         reg->regnum, regs);
                  }
 
                if (*p++ != ';')
                                         reg->regnum, regs);
                  }
 
                if (*p++ != ';')

-                 error (_("Remote register badly formatted: %s\nhere: %s"), 
+                 error (_("Remote register badly formatted: %s\nhere: %s"),

                         buf, p);
              }
          }
                         buf, p);
              }
          }


@@ -3149,7 +3188,6 @@ remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
 {
   struct remote_state *rs = get_remote_state ();
   struct remote_arch_state *rsa = get_remote_arch_state ();
 {
   struct remote_state *rs = get_remote_state ();
   struct remote_arch_state *rsa = get_remote_arch_state ();

-  char *buf = rs->buf;

   ULONGEST thread_num = -1;
   ULONGEST addr;
 
   ULONGEST thread_num = -1;
   ULONGEST addr;
 


@@ -3160,7 +3198,7 @@ remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
 
   while (1)
     {
 
   while (1)
     {

-      char *p;
+      char *buf, *p;

 
       if (!target_is_async_p ())
        ofunc = signal (SIGINT, remote_interrupt);
 
       if (!target_is_async_p ())
        ofunc = signal (SIGINT, remote_interrupt);


@@ -3172,6 +3210,8 @@ remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
       if (!target_is_async_p ())
        signal (SIGINT, ofunc);
 
       if (!target_is_async_p ())
        signal (SIGINT, ofunc);
 

+      buf = rs->buf;
+

       /* This is a hook for when we need to do something (perhaps the
          collection of trace data) every time the target stops.  */
       if (deprecated_target_wait_loop_hook)
       /* This is a hook for when we need to do something (perhaps the
          collection of trace data) every time the target stops.  */
       if (deprecated_target_wait_loop_hook)


@@ -3265,10 +3305,10 @@ Packet: '%s'\n"),
                             pnum, p, buf);
 
                    fieldsize = hex2bin (p, regs,
                             pnum, p, buf);
 
                    fieldsize = hex2bin (p, regs,

-                                        register_size (current_gdbarch, 
+                                        register_size (current_gdbarch,

                                                        reg->regnum));
                    p += 2 * fieldsize;
                                                        reg->regnum));
                    p += 2 * fieldsize;

-                   if (fieldsize < register_size (current_gdbarch, 
+                   if (fieldsize < register_size (current_gdbarch,

                                                   reg->regnum))
                      warning (_("Remote reply is too short: %s"), buf);
                    regcache_raw_supply (current_regcache, reg->regnum, regs);
                                                   reg->regnum))
                      warning (_("Remote reply is too short: %s"), buf);
                    regcache_raw_supply (current_regcache, reg->regnum, regs);


@@ -3352,16 +3392,18 @@ static int
 fetch_register_using_p (int regnum)
 {
   struct remote_state *rs = get_remote_state ();
 fetch_register_using_p (int regnum)
 {
   struct remote_state *rs = get_remote_state ();

-  char *buf = rs->buf, *p;
+  char *buf, *p;

   char regp[MAX_REGISTER_SIZE];
   int i;
 
   char regp[MAX_REGISTER_SIZE];
   int i;
 

-  p = buf;
+  p = rs->buf;

   *p++ = 'p';
   p += hexnumstr (p, regnum);
   *p++ = '\0';
   remote_send (&rs->buf, &rs->buf_size);
 
   *p++ = 'p';
   p += hexnumstr (p, regnum);
   *p++ = '\0';
   remote_send (&rs->buf, &rs->buf_size);
 

+  buf = rs->buf;
+

   /* If the stub didn't recognize the packet, or if we got an error,
      tell our caller.  */
   if (buf[0] == '\0' || buf[0] == 'E')
   /* If the stub didn't recognize the packet, or if we got an error,
      tell our caller.  */
   if (buf[0] == '\0' || buf[0] == 'E')


@@ -3398,7 +3440,7 @@ remote_fetch_registers (int regnum)
 {
   struct remote_state *rs = get_remote_state ();
   struct remote_arch_state *rsa = get_remote_arch_state ();
 {
   struct remote_state *rs = get_remote_state ();
   struct remote_arch_state *rsa = get_remote_arch_state ();

-  char *buf = rs->buf;
+  char *buf;

   int i;
   char *p;
   char *regs = alloca (rsa->sizeof_g_packet);
   int i;
   char *p;
   char *regs = alloca (rsa->sizeof_g_packet);


@@ -3440,8 +3482,9 @@ remote_fetch_registers (int regnum)
            }
        }
 
            }
        }
 

-  sprintf (buf, "g");
+  sprintf (rs->buf, "g");

   remote_send (&rs->buf, &rs->buf_size);
   remote_send (&rs->buf, &rs->buf_size);

+  buf = rs->buf;

 
   /* Save the size of the packet sent to us by the target.  Its used
      as a heuristic when determining the max size of packets that the
 
   /* Save the size of the packet sent to us by the target.  Its used
      as a heuristic when determining the max size of packets that the


@@ -3464,6 +3507,7 @@ remote_fetch_registers (int regnum)
        fprintf_unfiltered (gdb_stdlog,
                            "Bad register packet; fetching a new packet\n");
       getpkt (&rs->buf, &rs->buf_size, 0);
        fprintf_unfiltered (gdb_stdlog,
                            "Bad register packet; fetching a new packet\n");
       getpkt (&rs->buf, &rs->buf_size, 0);

+      buf = rs->buf;

     }
 
   /* Reply describes registers byte by byte, each byte encoded as two
     }
 
   /* Reply describes registers byte by byte, each byte encoded as two


@@ -3573,7 +3617,7 @@ store_register_using_P (int regnum)
   bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
   remote_send (&rs->buf, &rs->buf_size);
 
   bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
   remote_send (&rs->buf, &rs->buf_size);
 

-  return buf[0] != '\0';
+  return rs->buf[0] != '\0';

 }
 
 
 }
 
 


@@ -3810,10 +3854,9 @@ check_binary_download (CORE_ADDR addr)
       break;
     case PACKET_SUPPORT_UNKNOWN:
       {
       break;
     case PACKET_SUPPORT_UNKNOWN:
       {

-       char *buf = rs->buf;

        char *p;
 
        char *p;
 

-       p = buf;
+       p = rs->buf;

        *p++ = 'X';
        p += hexnumstr (p, (ULONGEST) addr);
        *p++ = ',';
        *p++ = 'X';
        p += hexnumstr (p, (ULONGEST) addr);
        *p++ = ',';


@@ -3821,10 +3864,10 @@ check_binary_download (CORE_ADDR addr)
        *p++ = ':';
        *p = '\0';
 
        *p++ = ':';
        *p = '\0';
 

-       putpkt_binary (buf, (int) (p - buf));
+       putpkt_binary (rs->buf, (int) (p - rs->buf));

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

-       if (buf[0] == '\0')
+       if (rs->buf[0] == '\0')

          {
            if (remote_debug)
              fprintf_unfiltered (gdb_stdlog,
          {
            if (remote_debug)
              fprintf_unfiltered (gdb_stdlog,


@@ -3845,68 +3888,92 @@ check_binary_download (CORE_ADDR addr)
 
 /* Write memory data directly to the remote machine.
    This does not inform the data cache; the data cache uses this.
 
 /* Write memory data directly to the remote machine.
    This does not inform the data cache; the data cache uses this.

+   HEADER is the starting part of the packet.

    MEMADDR is the address in the remote memory space.
    MYADDR is the address of the buffer in our space.
    LEN is the number of bytes.
    MEMADDR is the address in the remote memory space.
    MYADDR is the address of the buffer in our space.
    LEN is the number of bytes.

+   PACKET_FORMAT should be either 'X' or 'M', and indicates if we
+   should send data as binary ('X'), or hex-encoded ('M').

 
 

-   Returns number of bytes transferred, or 0 (setting errno) for
+   The function creates packet of the form
+       <HEADER><ADDRESS>,<LENGTH>:<DATA>
+
+   where encoding of <DATA> is termined by PACKET_FORMAT.
+
+   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.  */
 
    error.  Only transfer a single packet.  */
 

-int
-remote_write_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
+static int
+remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
+                       const gdb_byte *myaddr, int len,
+                       char packet_format, int use_length)

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

-  char *buf;

   char *p;
   char *p;

-  char *plen;
-  int plenlen;
+  char *plen = NULL;
+  int plenlen = 0;

   int todo;
   int nr_bytes;
   int payload_size;
   int payload_length;
   int todo;
   int nr_bytes;
   int payload_size;
   int payload_length;

+  int header_length;

 
 

-  /* Verify that the target can support a binary download.  */
-  check_binary_download (memaddr);
+  if (packet_format != 'X' && packet_format != 'M')
+    internal_error (__FILE__, __LINE__,
+                   "remote_write_bytes_aux: bad packet format");
+
+  /* Should this be the selected frame?  */
+  gdbarch_remote_translate_xfer_address (current_gdbarch,
+                                        current_regcache,
+                                        memaddr, len,
+                                        &memaddr, &len);
+
+  if (len <= 0)
+    return 0;

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

-  
+

   /* The packet buffer will be large enough for the payload;
      get_memory_packet_size ensures this.  */
   /* The packet buffer will be large enough for the payload;
      get_memory_packet_size ensures this.  */

-  buf = rs->buf;
+  rs->buf[0] = '\0';

 
   /* Compute the size of the actual payload by subtracting out the
      packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
      */
 
   /* Compute the size of the actual payload by subtracting out the
      packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
      */

-  payload_size -= strlen ("$M,:#NN");
+  payload_size -= strlen ("$,:#NN");
+  if (!use_length)
+    /* The comma won't be used. */
+    payload_size += 1;
+  header_length = strlen (header);
+  payload_size -= header_length;

   payload_size -= hexnumlen (memaddr);
 
   payload_size -= hexnumlen (memaddr);
 

-  /* Construct the packet header: "[MX]<memaddr>,<len>:".   */
+  /* Construct the packet excluding the data: "<header><memaddr>,<len>:".  */

 
 

-  /* Append "[XM]".  Compute a best guess of the number of bytes
-     actually transfered.  */
-  p = buf;
-  switch (remote_protocol_packets[PACKET_X].support)
+  strcat (rs->buf, header);
+  p = rs->buf + strlen (header);
+
+  /* Compute a best guess of the number of bytes actually transfered.  */
+  if (packet_format == 'X')

     {
     {

-    case PACKET_ENABLE:
-      *p++ = 'X';

       /* Best guess at number of bytes that will fit.  */
       todo = min (len, payload_size);
       /* Best guess at number of bytes that will fit.  */
       todo = min (len, payload_size);

-      payload_size -= hexnumlen (todo);
+      if (use_length)
+       payload_size -= hexnumlen (todo);

       todo = min (todo, payload_size);
       todo = min (todo, payload_size);

-      break;
-    case PACKET_DISABLE:
-      *p++ = 'M';
+    }
+  else
+    {

       /* Num bytes that will fit.  */
       todo = min (len, payload_size / 2);
       /* Num bytes that will fit.  */
       todo = min (len, payload_size / 2);

-      payload_size -= hexnumlen (todo);
+      if (use_length)
+       payload_size -= hexnumlen (todo);

       todo = min (todo, payload_size / 2);
       todo = min (todo, payload_size / 2);

-      break;
-    case PACKET_SUPPORT_UNKNOWN:
-      internal_error (__FILE__, __LINE__,
-                     _("remote_write_bytes: bad internal state"));
-    default:
-      internal_error (__FILE__, __LINE__, _("bad switch"));

     }
     }

+

   if (todo <= 0)
     internal_error (__FILE__, __LINE__,
                    _("minumum packet size too small to write data"));
   if (todo <= 0)
     internal_error (__FILE__, __LINE__,
                    _("minumum packet size too small to write data"));


@@ -3920,23 +3987,25 @@ remote_write_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
   memaddr = remote_address_masked (memaddr);
   p += hexnumstr (p, (ULONGEST) memaddr);
 
   memaddr = remote_address_masked (memaddr);
   p += hexnumstr (p, (ULONGEST) memaddr);
 

-  /* Append ",".  */
-  *p++ = ',';
+  if (use_length)
+    {
+      /* Append ",".  */
+      *p++ = ',';

 
 

-  /* Append <len>.  Retain the location/size of <len>.  It may need to
-     be adjusted once the packet body has been created.  */
-  plen = p;
-  plenlen = hexnumstr (p, (ULONGEST) todo);
-  p += plenlen;
+      /* Append <len>.  Retain the location/size of <len>.  It may need to
+        be adjusted once the packet body has been created.  */
+      plen = p;
+      plenlen = hexnumstr (p, (ULONGEST) todo);
+      p += plenlen;
+    }

 
   /* Append ":".  */
   *p++ = ':';
   *p = '\0';
 
   /* Append the packet body.  */
 
   /* Append ":".  */
   *p++ = ':';
   *p = '\0';
 
   /* Append the packet body.  */

-  switch (remote_protocol_packets[PACKET_X].support)
+  if (packet_format == 'X')

     {
     {

-    case PACKET_ENABLE:

       /* Binary mode.  Send target system values byte by byte, in
         increasing byte addresses.  Only escape certain critical
         characters.  */
       /* Binary mode.  Send target system values byte by byte, in
         increasing byte addresses.  Only escape certain critical
         characters.  */


@@ -3944,8 +4013,9 @@ remote_write_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
                                             payload_size);
 
       /* If not all TODO bytes fit, then we'll need another packet.  Make
                                             payload_size);
 
       /* If not all TODO bytes fit, then we'll need another packet.  Make

-        a second try to keep the end of the packet aligned.  */
-      if (nr_bytes < todo)
+        a second try to keep the end of the packet aligned.  Don't do
+        this if the packet is tiny.  */
+      if (nr_bytes < todo && nr_bytes > 2 * REMOTE_ALIGN_WRITES)

        {
          int new_nr_bytes;
 
        {
          int new_nr_bytes;
 


@@ -3958,7 +4028,7 @@ remote_write_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
        }
 
       p += payload_length;
        }
 
       p += payload_length;

-      if (nr_bytes < todo)
+      if (use_length && nr_bytes < todo)

        {
          /* Escape chars have filled up the buffer prematurely,
             and we have actually sent fewer bytes than planned.
        {
          /* Escape chars have filled up the buffer prematurely,
             and we have actually sent fewer bytes than planned.


@@ -3967,25 +4037,20 @@ remote_write_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
          plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
          *plen = ':';  /* overwrite \0 from hexnumnstr() */
        }
          plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
          *plen = ':';  /* overwrite \0 from hexnumnstr() */
        }

-      break;
-    case PACKET_DISABLE:
+    }
+  else
+    {

       /* Normal mode: Send target system values byte by byte, in
         increasing byte addresses.  Each byte is encoded as a two hex
         value.  */
       nr_bytes = bin2hex (myaddr, p, todo);
       p += 2 * nr_bytes;
       /* Normal mode: Send target system values byte by byte, in
         increasing byte addresses.  Each byte is encoded as a two hex
         value.  */
       nr_bytes = bin2hex (myaddr, p, todo);
       p += 2 * nr_bytes;

-      break;
-    case PACKET_SUPPORT_UNKNOWN:
-      internal_error (__FILE__, __LINE__,
-                     _("remote_write_bytes: bad internal state"));
-    default:
-      internal_error (__FILE__, __LINE__, _("bad switch"));

     }
 
     }
 

-  putpkt_binary (buf, (int) (p - buf));
+  putpkt_binary (rs->buf, (int) (p - rs->buf));

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

-  if (buf[0] == 'E')
+  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
     {
       /* There is no correspondance between what the remote protocol
         uses for errors and errno codes.  We would like a cleaner way


@@ -4000,6 +4065,42 @@ remote_write_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
   return nr_bytes;
 }
 
   return nr_bytes;
 }
 

+/* Write memory data directly to the remote machine.
+   This does not inform the data cache; the data cache uses this.
+   MEMADDR is the address in the remote memory space.
+   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.  */
+
+int
+remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
+{
+  char *packet_format = 0;
+
+  /* Check whether the target supports binary download.  */
+  check_binary_download (memaddr);
+
+  switch (remote_protocol_packets[PACKET_X].support)
+    {
+    case PACKET_ENABLE:
+      packet_format = "X";
+      break;
+    case PACKET_DISABLE:
+      packet_format = "M";
+      break;
+    case PACKET_SUPPORT_UNKNOWN:
+      internal_error (__FILE__, __LINE__,
+                     _("remote_write_bytes: bad internal state"));
+    default:
+      internal_error (__FILE__, __LINE__, _("bad switch"));
+    }
+
+  return remote_write_bytes_aux (packet_format,
+                                memaddr, myaddr, len, packet_format[0], 1);
+}
+

 /* Read memory data directly from the remote machine.
    This does not use the data cache; the data cache uses this.
    MEMADDR is the address in the remote memory space.
 /* Read memory data directly from the remote machine.
    This does not use the data cache; the data cache uses this.
    MEMADDR is the address in the remote memory space.


@@ -4019,14 +4120,21 @@ int
 remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
 {
   struct remote_state *rs = get_remote_state ();
 remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
 {
   struct remote_state *rs = get_remote_state ();

-  char *buf;

   int max_buf_size;            /* Max size of packet output buffer.  */
   int origlen;
 
   int max_buf_size;            /* Max size of packet output buffer.  */
   int origlen;
 

+  /* Should this be the selected frame?  */
+  gdbarch_remote_translate_xfer_address (current_gdbarch,
+                                        current_regcache,
+                                        memaddr, len,
+                                        &memaddr, &len);
+
+  if (len <= 0)
+    return 0;
+

   max_buf_size = get_memory_read_packet_size ();
   /* The packet buffer will be large enough for the payload;
      get_memory_packet_size ensures this.  */
   max_buf_size = get_memory_read_packet_size ();
   /* The packet buffer will be large enough for the payload;
      get_memory_packet_size ensures this.  */

-  buf = rs->buf;

 
   origlen = len;
   while (len > 0)
 
   origlen = len;
   while (len > 0)


@@ -4038,21 +4146,21 @@ remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
       todo = min (len, max_buf_size / 2);      /* num bytes that will fit */
 
       /* construct "m"<memaddr>","<len>" */
       todo = min (len, max_buf_size / 2);      /* num bytes that will fit */
 
       /* construct "m"<memaddr>","<len>" */

-      /* sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); */
+      /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */

       memaddr = remote_address_masked (memaddr);
       memaddr = remote_address_masked (memaddr);

-      p = buf;
+      p = rs->buf;

       *p++ = 'm';
       p += hexnumstr (p, (ULONGEST) memaddr);
       *p++ = ',';
       p += hexnumstr (p, (ULONGEST) todo);
       *p = '\0';
 
       *p++ = 'm';
       p += hexnumstr (p, (ULONGEST) memaddr);
       *p++ = ',';
       p += hexnumstr (p, (ULONGEST) todo);
       *p = '\0';
 

-      putpkt (buf);
+      putpkt (rs->buf);

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

-      if (buf[0] == 'E'
-         && isxdigit (buf[1]) && isxdigit (buf[2])
-         && 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
        {
          /* There is no correspondance between what the remote
             protocol uses for errors and errno codes.  We would like


@@ -4066,7 +4174,7 @@ remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
       /* Reply describes memory byte by byte,
          each byte encoded as two hex characters.  */
 
       /* Reply describes memory byte by byte,
          each byte encoded as two hex characters.  */
 

-      p = buf;
+      p = rs->buf;

       if ((i = hex2bin (p, myaddr, todo)) < todo)
        {
          /* Reply is short.  This means that we were able to read
       if ((i = hex2bin (p, myaddr, todo)) < todo)
        {
          /* Reply is short.  This means that we were able to read


@@ -4090,26 +4198,121 @@ 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 should_write, struct mem_attrib *attrib,
                    struct target_ops *target)
 {

-  CORE_ADDR targ_addr;
-  int targ_len;

   int res;
 
   int res;
 

-  /* Should this be the selected frame?  */
-  gdbarch_remote_translate_xfer_address (current_gdbarch, 
-                                        current_regcache,
-                                        mem_addr, mem_len,
-                                        &targ_addr, &targ_len);
-  if (targ_len <= 0)
-    return 0;
-

   if (should_write)
   if (should_write)

-    res = remote_write_bytes (targ_addr, buffer, targ_len);
+    res = remote_write_bytes (mem_addr, buffer, mem_len);

   else
   else

-    res = remote_read_bytes (targ_addr, buffer, targ_len);
+    res = remote_read_bytes (mem_addr, buffer, mem_len);

 
   return res;
 }
 
 
   return res;
 }
 

+/* Sends a packet with content determined by the printf format string
+   FORMAT and the remaining arguments, then gets the reply.  Returns
+   whether the packet was a success, a failure, or unknown.  */
+
+enum packet_result
+remote_send_printf (const char *format, ...)
+{
+  struct remote_state *rs = get_remote_state ();
+  int max_size = get_remote_packet_size ();
+
+  va_list ap;
+  va_start (ap, format);
+
+  rs->buf[0] = '\0';
+  if (vsnprintf (rs->buf, max_size, format, ap) >= max_size)
+    internal_error (__FILE__, __LINE__, "Too long remote packet.");
+
+  if (putpkt (rs->buf) < 0)
+    error (_("Communication problem with target."));
+
+  rs->buf[0] = '\0';
+  getpkt (&rs->buf, &rs->buf_size, 0);
+
+  return packet_check_result (rs->buf);
+}
+
+static void
+restore_remote_timeout (void *p)
+{
+  int value = *(int *)p;
+  remote_timeout = value;
+}
+
+/* Flash writing can take quite some time.  We'll set
+   effectively infinite timeout for flash operations.
+   In future, we'll need to decide on a better approach.  */
+static const int remote_flash_timeout = 1000;
+
+static void
+remote_flash_erase (struct target_ops *ops,
+                    ULONGEST address, LONGEST length)
+{
+  int saved_remote_timeout = remote_timeout;
+  enum packet_result ret;
+
+  struct cleanup *back_to = make_cleanup (restore_remote_timeout,
+                                          &saved_remote_timeout);
+  remote_timeout = remote_flash_timeout;
+
+  ret = remote_send_printf ("vFlashErase:%s,%s",
+                           paddr (address),
+                           phex (length, 4));
+  switch (ret)
+    {
+    case PACKET_UNKNOWN:
+      error (_("Remote target does not support flash erase"));
+    case PACKET_ERROR:
+      error (_("Error erasing flash with vFlashErase packet"));
+    default:
+      break;
+    }
+
+  do_cleanups (back_to);
+}
+
+static LONGEST
+remote_flash_write (struct target_ops *ops,
+                    ULONGEST address, LONGEST length,
+                    const gdb_byte *data)
+{
+  int saved_remote_timeout = remote_timeout;
+  int ret;
+  struct cleanup *back_to = make_cleanup (restore_remote_timeout,
+                                          &saved_remote_timeout);
+
+  remote_timeout = remote_flash_timeout;
+  ret = remote_write_bytes_aux ("vFlashWrite:", address, data, length, 'X', 0);
+  do_cleanups (back_to);
+
+  return ret;
+}
+
+static void
+remote_flash_done (struct target_ops *ops)
+{
+  int saved_remote_timeout = remote_timeout;
+  int ret;
+  struct cleanup *back_to = make_cleanup (restore_remote_timeout,
+                                          &saved_remote_timeout);
+
+  remote_timeout = remote_flash_timeout;
+  ret = remote_send_printf ("vFlashDone");
+  do_cleanups (back_to);
+
+  switch (ret)
+    {
+    case PACKET_UNKNOWN:
+      error (_("Remote target does not support vFlashDone"));
+    case PACKET_ERROR:
+      error (_("Error finishing flash operation"));
+    default:
+      break;
+    }
+}
+

 static void
 remote_files_info (struct target_ops *ignore)
 {
 static void
 remote_files_info (struct target_ops *ignore)
 {


@@ -4266,7 +4469,7 @@ putpkt_binary (char *buf, int cnt)
            case '$':
              {
                if (remote_debug)
            case '$':
              {
                if (remote_debug)

-                 fprintf_unfiltered (gdb_stdlog, 
+                 fprintf_unfiltered (gdb_stdlog,

                                      "Packet instead of Ack, ignoring it\n");
                /* It's probably an old response sent because an ACK
                   was lost.  Gobble up the packet and ack it so it
                                      "Packet instead of Ack, ignoring it\n");
                /* It's probably an old response sent because an ACK
                   was lost.  Gobble up the packet and ack it so it


@@ -4392,14 +4595,14 @@ read_frame (char **buf_p,
            if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
              {
                if (remote_debug)
            if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
              {
                if (remote_debug)

-                 fputs_filtered ("Timeout in checksum, retrying\n", 
+                 fputs_filtered ("Timeout in checksum, retrying\n",

                                  gdb_stdlog);
                return -1;
              }
            else if (check_0 < 0 || check_1 < 0)
              {
                if (remote_debug)
                                  gdb_stdlog);
                return -1;
              }
            else if (check_0 < 0 || check_1 < 0)
              {
                if (remote_debug)

-                 fputs_filtered ("Communication error in checksum\n", 
+                 fputs_filtered ("Communication error in checksum\n",

                                  gdb_stdlog);
                return -1;
              }
                                  gdb_stdlog);
                return -1;
              }


@@ -4566,7 +4769,7 @@ getpkt_sane (char **buf, long *sizeof_buf, int forever)
       serial_write (remote_desc, "-", 1);
     }
 
       serial_write (remote_desc, "-", 1);
     }
 

-  /* We have tried hard enough, and just can't receive the packet.  
+  /* We have tried hard enough, and just can't receive the packet.

      Give up.  */
 
   printf_unfiltered (_("Ignoring packet error, continuing...\n"));
      Give up.  */
 
   printf_unfiltered (_("Ignoring packet error, continuing...\n"));


@@ -4981,7 +5184,7 @@ remote_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
 
   if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
     return -1;
 
   if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
     return -1;

-  
+

   *(p++) = 'Z';
   *(p++) = '1';
   *(p++) = ',';
   *(p++) = 'Z';
   *(p++) = '1';
   *(p++) = ',';


@@ -5270,22 +5473,16 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
   char *p2;
   char query_type;
 
   char *p2;
   char query_type;
 

-  /* Handle memory using remote_xfer_memory.  */
+  /* Handle memory using the standard memory routines.  */

   if (object == TARGET_OBJECT_MEMORY)
     {
       int xfered;
       errno = 0;
 
       if (writebuf != NULL)
   if (object == TARGET_OBJECT_MEMORY)
     {
       int xfered;
       errno = 0;
 
       if (writebuf != NULL)

-       {
-         void *buffer = xmalloc (len);
-         struct cleanup *cleanup = make_cleanup (xfree, buffer);
-         memcpy (buffer, writebuf, len);
-         xfered = remote_xfer_memory (offset, buffer, len, 1, NULL, ops);
-         do_cleanups (cleanup);
-       }
+       xfered = remote_write_bytes (offset, writebuf, len);

       else
       else

-       xfered = remote_xfer_memory (offset, readbuf, len, 0, NULL, ops);
+       xfered = remote_read_bytes (offset, readbuf, len);

 
       if (xfered > 0)
        return xfered;
 
       if (xfered > 0)
        return xfered;


@@ -5295,9 +5492,27 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
        return -1;
     }
 
        return -1;
     }
 

-  /* Only handle reads.  */
-  if (writebuf != NULL || readbuf == NULL)
-    return -1;
+  /* Only handle flash writes.  */
+  if (writebuf != NULL)
+    {
+      LONGEST xfered;
+
+      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;
+
+       default:
+         return -1;
+       }
+    }

 
   /* Map pre-existing objects onto letters.  DO NOT do this for new
      objects!!!  Instead specify new query packets.  */
 
   /* Map pre-existing objects onto letters.  DO NOT do this for new
      objects!!!  Instead specify new query packets.  */


@@ -5312,6 +5527,11 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
       return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
                                &remote_protocol_packets[PACKET_qXfer_auxv]);
 
       return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
                                &remote_protocol_packets[PACKET_qXfer_auxv]);
 

+    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_memory_map]);
+

     default:
       return -1;
     }
     default:
       return -1;
     }


@@ -5368,8 +5588,7 @@ remote_rcmd (char *command,
             struct ui_file *outbuf)
 {
   struct remote_state *rs = get_remote_state ();
             struct ui_file *outbuf)
 {
   struct remote_state *rs = get_remote_state ();

-  char *buf = rs->buf;
-  char *p = buf;
+  char *p = rs->buf;

 
   if (!remote_desc)
     error (_("remote rcmd is only available after target open"));
 
   if (!remote_desc)
     error (_("remote rcmd is only available after target open"));


@@ -5379,10 +5598,10 @@ remote_rcmd (char *command,
     command = "";
 
   /* The query prefix.  */
     command = "";
 
   /* The query prefix.  */

-  strcpy (buf, "qRcmd,");
-  p = strchr (buf, '\0');
+  strcpy (rs->buf, "qRcmd,");
+  p = strchr (rs->buf, '\0');

 
 

-  if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ())
+  if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ())

     error (_("\"monitor\" command ``%s'' is too long."), command);
 
   /* Encode the actual command.  */
     error (_("\"monitor\" command ``%s'' is too long."), command);
 
   /* Encode the actual command.  */


@@ -5394,9 +5613,12 @@ remote_rcmd (char *command,
   /* get/display the response */
   while (1)
     {
   /* get/display the response */
   while (1)
     {

+      char *buf;
+

       /* XXX - see also tracepoint.c:remote_get_noisy_reply().  */
       /* XXX - see also tracepoint.c:remote_get_noisy_reply().  */

-      buf[0] = '\0';
+      rs->buf[0] = '\0';

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

+      buf = rs->buf;

       if (buf[0] == '\0')
        error (_("Target does not support this command."));
       if (buf[0] == 'O' && buf[1] != 'K')
       if (buf[0] == '\0')
        error (_("Target does not support this command."));
       if (buf[0] == 'O' && buf[1] != 'K')


@@ -5420,6 +5642,23 @@ remote_rcmd (char *command,
     }
 }
 
     }
 }
 

+static VEC(mem_region_s) *
+remote_memory_map (struct target_ops *ops)
+{
+  VEC(mem_region_s) *result = NULL;
+  char *text = target_read_stralloc (&current_target,
+                                    TARGET_OBJECT_MEMORY_MAP, NULL);
+
+  if (text)
+    {
+      struct cleanup *back_to = make_cleanup (xfree, text);
+      result = parse_memory_map (text);
+      do_cleanups (back_to);
+    }
+
+  return result;
+}
+

 static void
 packet_command (char *args, int from_tty)
 {
 static void
 packet_command (char *args, int from_tty)
 {


@@ -5692,6 +5931,9 @@ Specify the serial device it is connected to\n\
   remote_ops.to_has_execution = 1;
   remote_ops.to_has_thread_control = tc_schedlock;     /* can lock scheduler */
   remote_ops.to_magic = OPS_MAGIC;
   remote_ops.to_has_execution = 1;
   remote_ops.to_has_thread_control = tc_schedlock;     /* can lock scheduler */
   remote_ops.to_magic = OPS_MAGIC;

+  remote_ops.to_memory_map = remote_memory_map;
+  remote_ops.to_flash_erase = remote_flash_erase;
+  remote_ops.to_flash_done = remote_flash_done;

 }
 
 /* Set up the extended remote vector by making a copy of the standard
 }
 
 /* Set up the extended remote vector by making a copy of the standard


@@ -5731,7 +5973,7 @@ remote_is_async_p (void)
    will be able to delay notifying the client of an event until the
    point where an entire packet has been received.  */
 
    will be able to delay notifying the client of an event until the
    point where an entire packet has been received.  */
 

-static void (*async_client_callback) (enum inferior_event_type event_type, 
+static void (*async_client_callback) (enum inferior_event_type event_type,

                                      void *context);
 static void *async_client_context;
 static serial_event_ftype remote_async_serial_handler;
                                      void *context);
 static void *async_client_context;
 static serial_event_ftype remote_async_serial_handler;


@@ -5745,7 +5987,7 @@ remote_async_serial_handler (struct serial *scb, void *context)
 }
 
 static void
 }
 
 static void

-remote_async (void (*callback) (enum inferior_event_type event_type, 
+remote_async (void (*callback) (enum inferior_event_type event_type,

                                void *context), void *context)
 {
   if (current_target.to_async_mask_value == 0)
                                void *context), void *context)
 {
   if (current_target.to_async_mask_value == 0)


@@ -5772,7 +6014,7 @@ static void
 init_remote_async_ops (void)
 {
   remote_async_ops.to_shortname = "async";
 init_remote_async_ops (void)
 {
   remote_async_ops.to_shortname = "async";

-  remote_async_ops.to_longname = 
+  remote_async_ops.to_longname =

     "Remote serial target in async version of the gdb-specific protocol";
   remote_async_ops.to_doc =
     "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
     "Remote serial target in async version of the gdb-specific protocol";
   remote_async_ops.to_doc =
     "Use a remote computer via a serial line, using a gdb-specific protocol.\n\


@@ -5821,6 +6063,9 @@ Specify the serial device it is connected to (e.g. /dev/ttya).";
   remote_async_ops.to_async = remote_async;
   remote_async_ops.to_async_mask_value = 1;
   remote_async_ops.to_magic = OPS_MAGIC;
   remote_async_ops.to_async = remote_async;
   remote_async_ops.to_async_mask_value = 1;
   remote_async_ops.to_magic = OPS_MAGIC;

+  remote_async_ops.to_memory_map = remote_memory_map;
+  remote_async_ops.to_flash_erase = remote_flash_erase;
+  remote_async_ops.to_flash_done = remote_flash_done;

 }
 
 /* Set up the async extended remote vector by making a copy of the standard
 }
 
 /* Set up the async extended remote vector by making a copy of the standard


@@ -5900,7 +6145,7 @@ _initialize_remote (void)
   struct remote_state *rs;
 
   /* architecture specific data */
   struct remote_state *rs;
 
   /* architecture specific data */

-  remote_gdbarch_data_handle = 
+  remote_gdbarch_data_handle =

     gdbarch_data_register_post_init (init_remote_state);
 
   /* Old tacky stuff.  NOTE: This comes after the remote protocol so
     gdbarch_data_register_post_init (init_remote_state);
 
   /* Old tacky stuff.  NOTE: This comes after the remote protocol so


@@ -5912,7 +6157,7 @@ _initialize_remote (void)
      of these, not one per target.  Only one target is active at a
      time.  The default buffer size is unimportant; it will be expanded
      whenever a larger buffer is needed.  */
      of these, not one per target.  Only one target is active at a
      time.  The default buffer size is unimportant; it will be expanded
      whenever a larger buffer is needed.  */

-  rs = get_remote_state ();
+  rs = get_remote_state_raw ();

   rs->buf_size = 400;
   rs->buf = xmalloc (rs->buf_size);
 
   rs->buf_size = 400;
   rs->buf = xmalloc (rs->buf_size);
 


@@ -6061,6 +6306,9 @@ Show the maximum size of the address (in bits) in a memory packet."), NULL,
   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
                         "qXfer:auxv:read", "read-aux-vector", 0);
 
   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
                         "qXfer:auxv:read", "read-aux-vector", 0);
 

+  add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
+                        "qXfer:memory-map:read", "memory-map", 0);
+

   add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
                         "qGetTLSAddr", "get-thread-local-storage-address",
                         0);
   add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
                         "qGetTLSAddr", "get-thread-local-storage-address",
                         0);