* (struct remote_state): New type, only containing

	buf and buf_size.
	(remote_state): New variable.
	(get_remote_state): New function.
	(struct remote_arch_state): Renamed from struct remote_state.
	Removed buf and buf_size.
	(get_remote_arch_state): Renamed from get_remote_state.  All
	necessary callers updated to call this function.
	(init_remote_state): Initialize the architecture-specific state.
	Update the target-specific state if necessary.
	(get_remote_packet_size): New function.  All previous references
	changed to use this accessor function.
	(packet_reg_from_regnum, packet_reg_from_pnum): Take a
	remote_arch_state instead of a remote_state.  All callers changed.
	(_initialize_remote): Initialize the packet buffer here.

2 files changed, 156 insertions, 95 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 6468fdb..c09c929 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,6 +1,24 @@
+2006-06-08  Daniel Jacobowitz  <dan@codesourcery.com>
+
+	* (struct remote_state): New type, only containing
+	buf and buf_size.
+	(remote_state): New variable.
+	(get_remote_state): New function.
+	(struct remote_arch_state): Renamed from struct remote_state.
+	Removed buf and buf_size.
+	(get_remote_arch_state): Renamed from get_remote_state.  All
+	necessary callers updated to call this function.
+	(init_remote_state): Initialize the architecture-specific state.
+	Update the target-specific state if necessary.
+	(get_remote_packet_size): New function.  All previous references
+	changed to use this accessor function.
+	(packet_reg_from_regnum, packet_reg_from_pnum): Take a
+	remote_arch_state instead of a remote_state.  All callers changed.
+	(_initialize_remote): Initialize the packet buffer here.
+
 2006-06-06  Nathan Sidwell  <nathan@codesourcery.com>
 
-	* gdb/remote.c (remote_insert_watchpoint): Return -1, rather than
+	* remote.c (remote_insert_watchpoint): Return -1, rather than
 	fatal error if packet is disabled.
 	(remote_remove_watchpoint, remote_insert_hw_breakpoint,
 	remote_remove_hw_breakpoint): Likewise.
diff --git a/gdb/remote.c b/gdb/remote.c
index 529343d..bf182b6 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -188,12 +188,35 @@ static void update_packet_config (struct packet_config *config);
 
 void _initialize_remote (void);
 
-/* Description of the remote protocol.  Strictly speaking, when the
-   target is open()ed, remote.c should create a per-target description
-   of the remote protocol using that target's architecture.
-   Unfortunately, the target stack doesn't include local state.  For
-   the moment keep the information in the target's architecture
-   object.  Sigh..  */
+/* Description of the remote protocol state for the currently
+   connected target.  This is per-target state, and independent of the
+   selected architecture.  */
+
+struct remote_state
+{
+  /* A buffer to use for incoming packets, and its current size.  The
+     buffer is grown dynamically for larger incoming packets.
+     Outgoing packets may also be constructed in this buffer.
+     BUF_SIZE is always at least REMOTE_PACKET_SIZE;
+     REMOTE_PACKET_SIZE should be used to limit the length of outgoing
+     packets.  */
+  char *buf;
+  long buf_size;
+};
+
+/* This data could be associated with a target, but we do not always
+   have access to the current target when we need it, so for now it is
+   static.  This will be fine for as long as only one target is in use
+   at a time.  */
+static struct remote_state remote_state;
+
+static struct remote_state *
+get_remote_state (void)
+{
+  return &remote_state;
+}
+
+/* Description of the remote protocol for a given architecture.  */
 
 struct packet_reg
 {
@@ -206,7 +229,7 @@ struct packet_reg
   /* char *name; == REGISTER_NAME (regnum); at present.  */
 };
 
-struct remote_state
+struct remote_arch_state
 {
   /* Description of the remote protocol registers.  */
   long sizeof_g_packet;
@@ -226,23 +249,14 @@ struct remote_state
   /* This is the maximum size (in chars) of a non read/write packet.
      It is also used as a cap on the size of read/write packets.  */
   long remote_packet_size;
-
-  /* A buffer to use for incoming packets, and its current size.  The
-     buffer is grown dynamically for larger incoming packets.
-     Outgoing packets may also be constructed in this buffer.
-     BUF_SIZE is always at least REMOTE_PACKET_SIZE;
-     REMOTE_PACKET_SIZE should be used to limit the length of outgoing
-     packets.  */
-  char *buf;
-  long buf_size;
 };
 
 
 /* Handle for retreving the remote protocol data from gdbarch.  */
 static struct gdbarch_data *remote_gdbarch_data_handle;
 
-static struct remote_state *
-get_remote_state (void)
+static struct remote_arch_state *
+get_remote_arch_state (void)
 {
   return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
 }
@@ -251,16 +265,19 @@ static void *
 init_remote_state (struct gdbarch *gdbarch)
 {
   int regnum;
-  struct remote_state *rs = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_state);
+  struct remote_state *rs = get_remote_state ();
+  struct remote_arch_state *rsa;
+
+  rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
 
-  rs->sizeof_g_packet = 0;
+  rsa->sizeof_g_packet = 0;
 
   /* Assume a 1:1 regnum<->pnum table.  */
-  rs->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, NUM_REGS + NUM_PSEUDO_REGS,
-				     struct packet_reg);
+  rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, NUM_REGS + NUM_PSEUDO_REGS,
+				      struct packet_reg);
   for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
     {
-      struct packet_reg *r = &rs->regs[regnum];
+      struct packet_reg *r = &rsa->regs[regnum];
       r->pnum = regnum;
       r->regnum = regnum;
       r->offset = DEPRECATED_REGISTER_BYTE (regnum);
@@ -269,7 +286,7 @@ init_remote_state (struct gdbarch *gdbarch)
 
       /* Compute packet size by accumulating the size of all registers.  */
       if (regnum < NUM_REGS)
-	rs->sizeof_g_packet += register_size (current_gdbarch, regnum);
+	rsa->sizeof_g_packet += register_size (current_gdbarch, regnum);
     }
 
   /* Default maximum number of characters in a packet body. Many
@@ -278,52 +295,63 @@ init_remote_state (struct gdbarch *gdbarch)
      as the maximum packet-size to ensure that the packet and an extra
      NUL character can always fit in the buffer.  This stops GDB
      trashing stubs that try to squeeze an extra NUL into what is
-     already a full buffer (As of 1999-12-04 that was most stubs.  */
-  rs->remote_packet_size = 400 - 1;
+     already a full buffer (As of 1999-12-04 that was most stubs).  */
+  rsa->remote_packet_size = 400 - 1;
 
-  /* Should rs->sizeof_g_packet needs more space than the
+  /* This one is filled in when a ``g'' packet is received.  */
+  rsa->actual_register_packet_size = 0;
+
+  /* Should rsa->sizeof_g_packet needs more space than the
      default, adjust the size accordingly. Remember that each byte is
      encoded as two characters. 32 is the overhead for the packet
      header / footer. NOTE: cagney/1999-10-26: I suspect that 8
      (``$NN:G...#NN'') is a better guess, the below has been padded a
      little.  */
-  if (rs->sizeof_g_packet > ((rs->remote_packet_size - 32) / 2))
-    rs->remote_packet_size = (rs->sizeof_g_packet * 2 + 32);
+  if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
+    rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);
 
-  /* This one is filled in when a ``g'' packet is received.  */
-  rs->actual_register_packet_size = 0;
-
-  /* Create the buffer at a default size.  Note that this would
-     leak memory if the gdbarch were ever destroyed; there's no
-     way to register a destructor for it, and we can't realloc
-     using the gdbarch obstack.  But gdbarches are never
-     destroyed.  */
-  rs->buf_size = rs->remote_packet_size;
-  rs->buf = xmalloc (rs->buf_size);
+  /* Make sure that the packet buffer is plenty big enough for
+     this architecture.  */
+  if (rs->buf_size < rsa->remote_packet_size)
+    {
+      rs->buf_size = 2 * rsa->remote_packet_size;
+      rs->buf = xmalloc (rs->buf_size);
+    }
 
-  return rs;
+  return rsa;
+}
+
+/* Return the current allowed size of a remote packet.  This is
+   inferred from the current architecture, and should be used to
+   limit the length of outgoing packets.  */
+static long
+get_remote_packet_size (void)
+{
+  struct remote_arch_state *rsa = get_remote_arch_state ();
+
+  return rsa->remote_packet_size;
 }
 
 static struct packet_reg *
-packet_reg_from_regnum (struct remote_state *rs, long regnum)
+packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
 {
   if (regnum < 0 && regnum >= NUM_REGS + NUM_PSEUDO_REGS)
     return NULL;
   else
     {
-      struct packet_reg *r = &rs->regs[regnum];
+      struct packet_reg *r = &rsa->regs[regnum];
       gdb_assert (r->regnum == regnum);
       return r;
     }
 }
 
 static struct packet_reg *
-packet_reg_from_pnum (struct remote_state *rs, LONGEST pnum)
+packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
 {
   int i;
   for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
     {
-      struct packet_reg *r = &rs->regs[i];
+      struct packet_reg *r = &rsa->regs[i];
       if (r->pnum == pnum)
 	return r;
     }
@@ -393,8 +421,8 @@ static int remote_async_terminal_ours_p;
 
 
 /* User configurable variables for the number of characters in a
-   memory read/write packet.  MIN (rs->remote_packet_size,
-   rs->sizeof_g_packet) is the default.  Some targets need smaller
+   memory read/write packet.  MIN (rsa->remote_packet_size,
+   rsa->sizeof_g_packet) is the default.  Some targets need smaller
    values (fifo overruns, et.al.) and some users need larger values
    (speed up transfers).  The variables ``preferred_*'' (the user
    request), ``current_*'' (what was actually set) and ``forced_*''
@@ -414,6 +442,8 @@ static long
 get_memory_packet_size (struct memory_packet_config *config)
 {
   struct remote_state *rs = get_remote_state ();
+  struct remote_arch_state *rsa = get_remote_arch_state ();
+
   /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
      law?) that some hosts don't cope very well with large alloca()
      calls.  Eventually the alloca() code will be replaced by calls to
@@ -436,15 +466,15 @@ get_memory_packet_size (struct memory_packet_config *config)
     }
   else
     {
-      what_they_get = rs->remote_packet_size;
+      what_they_get = get_remote_packet_size ();
       /* Limit the packet to the size specified by the user.  */
       if (config->size > 0
 	  && what_they_get > config->size)
 	what_they_get = config->size;
       /* Limit it to the size of the targets ``g'' response.  */
-      if ((rs->actual_register_packet_size) > 0
-	  && what_they_get > (rs->actual_register_packet_size))
-	what_they_get = (rs->actual_register_packet_size);
+      if ((rsa->actual_register_packet_size) > 0
+	  && what_they_get > (rsa->actual_register_packet_size))
+	what_they_get = (rsa->actual_register_packet_size);
     }
   if (what_they_get > MAX_REMOTE_PACKET_SIZE)
     what_they_get = MAX_REMOTE_PACKET_SIZE;
@@ -561,13 +591,12 @@ show_memory_read_packet_size (char *args, int from_tty)
 static long
 get_memory_read_packet_size (void)
 {
-  struct remote_state *rs = get_remote_state ();
   long size = get_memory_packet_size (&memory_read_packet_config);
   /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
      extra buffer size argument before the memory read size can be
-     increased beyond RS->remote_packet_size.  */
-  if (size > rs->remote_packet_size)
-    size = rs->remote_packet_size;
+     increased beyond this.  */
+  if (size > get_remote_packet_size ())
+    size = get_remote_packet_size ();
   return size;
 }
 
@@ -922,9 +951,9 @@ set_thread (int th, int gen)
       buf[3] = '\0';
     }
   else if (th < 0)
-    xsnprintf (&buf[2], rs->remote_packet_size - 2, "-%x", -th);
+    xsnprintf (&buf[2], get_remote_packet_size () - 2, "-%x", -th);
   else
-    xsnprintf (&buf[2], rs->remote_packet_size - 2, "%x", th);
+    xsnprintf (&buf[2], get_remote_packet_size () - 2, "%x", th);
   putpkt (buf);
   getpkt (&rs->buf, &rs->buf_size, 0);
   if (gen)
@@ -943,9 +972,9 @@ remote_thread_alive (ptid_t ptid)
   char *buf = rs->buf;
 
   if (tid < 0)
-    xsnprintf (buf, rs->remote_packet_size, "T-%08x", -tid);
+    xsnprintf (buf, get_remote_packet_size (), "T-%08x", -tid);
   else
-    xsnprintf (buf, rs->remote_packet_size, "T%08x", tid);
+    xsnprintf (buf, get_remote_packet_size (), "T%08x", tid);
   putpkt (buf);
   getpkt (&rs->buf, &rs->buf_size, 0);
   return (buf[0] == 'O' && buf[1] == 'K');
@@ -1512,8 +1541,8 @@ remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
   int result = 1;
 
   /* Trancate result limit to be smaller than the packet size.  */
-  if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= rs->remote_packet_size)
-    result_limit = (rs->remote_packet_size / BUF_THREAD_ID_SIZE) - 2;
+  if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= get_remote_packet_size ())
+    result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
 
   pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
   putpkt (rs->buf);
@@ -1734,7 +1763,7 @@ remote_threads_extra_info (struct thread_info *tp)
     {
       char *bufp = rs->buf;
 
-      xsnprintf (bufp, rs->remote_packet_size, "qThreadExtraInfo,%x", 
+      xsnprintf (bufp, get_remote_packet_size (), "qThreadExtraInfo,%x",
 		 PIDGET (tp->ptid));
       putpkt (bufp);
       getpkt (&rs->buf, &rs->buf_size, 0);
@@ -1786,7 +1815,7 @@ extended_remote_restart (void)
 
   /* Send the restart command; for reasons I don't understand the
      remote side really expects a number after the "R".  */
-  xsnprintf (rs->buf, rs->remote_packet_size, "R%x", 0);
+  xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0);
   putpkt (rs->buf);
 
   /* Now query for status so this looks just like we restarted
@@ -1979,7 +2008,7 @@ remote_check_symbols (struct objfile *objfile)
 
   /* Allocate a message buffer.  We can't reuse the input buffer in RS,
      because we need both at the same time.  */
-  msg = alloca (rs->remote_packet_size);
+  msg = alloca (get_remote_packet_size ());
 
   reply = rs->buf;
 
@@ -1996,9 +2025,9 @@ remote_check_symbols (struct objfile *objfile)
       msg[end] = '\0';
       sym = lookup_minimal_symbol (msg, NULL, NULL);
       if (sym == NULL)
-	xsnprintf (msg, rs->remote_packet_size, "qSymbol::%s", &reply[8]);
+	xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
       else
-	xsnprintf (msg, rs->remote_packet_size, "qSymbol:%s:%s",
+	xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
 		   paddr_nz (SYMBOL_VALUE_ADDRESS (sym)),
 		   &reply[8]);
       putpkt (msg);
@@ -2378,7 +2407,7 @@ remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal)
 	outbuf = xstrprintf ("vCont;c:%x", pid);
     }
 
-  gdb_assert (outbuf && strlen (outbuf) < rs->remote_packet_size);
+  gdb_assert (outbuf && strlen (outbuf) < get_remote_packet_size ());
   old_cleanup = make_cleanup (xfree, outbuf);
 
   putpkt (outbuf);
@@ -2668,6 +2697,7 @@ static ptid_t
 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 ();
   char *buf = rs->buf;
   ULONGEST thread_num = -1;
   ULONGEST addr;
@@ -2764,7 +2794,7 @@ Packet: '%s'\n"),
 		  }
 		else
 		  {
-		    struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
+		    struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
 		    p = p1;
 
 		    if (*p++ != ':')
@@ -2857,6 +2887,7 @@ static ptid_t
 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 ();
   char *buf = rs->buf;
   ULONGEST thread_num = -1;
   ULONGEST addr;
@@ -2960,7 +2991,7 @@ Packet: '%s'\n"),
 
 		else
 		  {
-		    struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
+		    struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
 		    p = p1;
 		    if (*p++ != ':')
 		      error (_("Malformed packet(b) (missing colon): %s\n\
@@ -3105,16 +3136,17 @@ static void
 remote_fetch_registers (int regnum)
 {
   struct remote_state *rs = get_remote_state ();
+  struct remote_arch_state *rsa = get_remote_arch_state ();
   char *buf = rs->buf;
   int i;
   char *p;
-  char *regs = alloca (rs->sizeof_g_packet);
+  char *regs = alloca (rsa->sizeof_g_packet);
 
   set_thread (PIDGET (inferior_ptid), 1);
 
   if (regnum >= 0)
     {
-      struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
+      struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
       gdb_assert (reg != NULL);
       if (!reg->in_g_packet)
 	internal_error (__FILE__, __LINE__,
@@ -3153,11 +3185,11 @@ remote_fetch_registers (int regnum)
   /* 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
      target can safely receive.  */
-  if ((rs->actual_register_packet_size) == 0)
-    (rs->actual_register_packet_size) = strlen (buf);
+  if ((rsa->actual_register_packet_size) == 0)
+    (rsa->actual_register_packet_size) = strlen (buf);
 
   /* Unimplemented registers read as all bits zero.  */
-  memset (regs, 0, rs->sizeof_g_packet);
+  memset (regs, 0, rsa->sizeof_g_packet);
 
   /* We can get out of synch in various cases.  If the first character
      in the buffer is not a hex character, assume that has happened
@@ -3178,7 +3210,7 @@ remote_fetch_registers (int regnum)
      register cacheing/storage mechanism.  */
 
   p = buf;
-  for (i = 0; i < rs->sizeof_g_packet; i++)
+  for (i = 0; i < rsa->sizeof_g_packet; i++)
     {
       if (p[0] == 0)
 	break;
@@ -3209,7 +3241,7 @@ remote_fetch_registers (int regnum)
     int i;
     for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
       {
-	struct packet_reg *r = &rs->regs[i];
+	struct packet_reg *r = &rsa->regs[i];
 	if (r->in_g_packet)
 	  {
 	    if (r->offset * 2 >= strlen (buf))
@@ -3241,7 +3273,7 @@ remote_fetch_registers (int regnum)
 static void
 remote_prepare_to_store (void)
 {
-  struct remote_state *rs = get_remote_state ();
+  struct remote_arch_state *rsa = get_remote_arch_state ();
   int i;
   gdb_byte buf[MAX_REGISTER_SIZE];
 
@@ -3252,8 +3284,8 @@ remote_prepare_to_store (void)
     case PACKET_SUPPORT_UNKNOWN:
       /* Make sure all the necessary registers are cached.  */
       for (i = 0; i < NUM_REGS; i++)
-	if (rs->regs[i].in_g_packet)
-	  regcache_raw_read (current_regcache, rs->regs[i].regnum, buf);
+	if (rsa->regs[i].in_g_packet)
+	  regcache_raw_read (current_regcache, rsa->regs[i].regnum, buf);
       break;
     case PACKET_ENABLE:
       break;
@@ -3267,13 +3299,14 @@ static int
 store_register_using_P (int regnum)
 {
   struct remote_state *rs = get_remote_state ();
-  struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
+  struct remote_arch_state *rsa = get_remote_arch_state ();
+  struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
   /* Try storing a single register.  */
   char *buf = rs->buf;
   gdb_byte regp[MAX_REGISTER_SIZE];
   char *p;
 
-  xsnprintf (buf, rs->remote_packet_size, "P%s=", phex_nz (reg->pnum, 0));
+  xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
   p = buf + strlen (buf);
   regcache_raw_collect (current_regcache, reg->regnum, regp);
   bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
@@ -3290,6 +3323,7 @@ static void
 remote_store_registers (int regnum)
 {
   struct remote_state *rs = get_remote_state ();
+  struct remote_arch_state *rsa = get_remote_arch_state ();
   gdb_byte *regs;
   char *p;
 
@@ -3328,11 +3362,11 @@ remote_store_registers (int regnum)
      local buffer.  */
   {
     int i;
-    regs = alloca (rs->sizeof_g_packet);
-    memset (regs, 0, rs->sizeof_g_packet);
+    regs = alloca (rsa->sizeof_g_packet);
+    memset (regs, 0, rsa->sizeof_g_packet);
     for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
       {
-	struct packet_reg *r = &rs->regs[i];
+	struct packet_reg *r = &rsa->regs[i];
 	if (r->in_g_packet)
 	  regcache_raw_collect (current_regcache, r->regnum, regs + r->offset);
       }
@@ -3798,14 +3832,13 @@ putpkt (char *buf)
 
 /* Send a packet to the remote machine, with error checking.  The data
    of the packet is in BUF.  The string in BUF can be at most
-   RS->remote_packet_size - 5 to account for the $, # and checksum,
+   get_remote_packet_size () - 5 to account for the $, # and checksum,
    and for a possible /0 if we are debugging (remote_debug) and want
    to print the sent packet as a string.  */
 
 static int
 putpkt_binary (char *buf, int cnt)
 {
-  struct remote_state *rs = get_remote_state ();
   int i;
   unsigned char csum = 0;
   char *buf2 = alloca (cnt + 6);
@@ -4753,7 +4786,7 @@ compare_sections_command (char *args, int from_tty)
       matched = 1;		/* do this section */
       lma = s->lma;
       /* FIXME: assumes lma can fit into long.  */
-      xsnprintf (rs->buf, rs->remote_packet_size, "qCRC:%lx,%lx",
+      xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
 		 (long) lma, (long) size);
       putpkt (rs->buf);
 
@@ -4849,8 +4882,8 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
 	  unsigned int total = 0;
 	  while (len > 0)
 	    {
-	      LONGEST n = min ((rs->remote_packet_size - 2) / 2, len);
-	      snprintf (rs->buf, rs->remote_packet_size,
+	      LONGEST n = min ((get_remote_packet_size () - 2) / 2, len);
+	      snprintf (rs->buf, get_remote_packet_size (),
 			"qPart:auxv:read::%s,%s",
 			phex_nz (offset, sizeof offset),
 			phex_nz (n, sizeof n));
@@ -4885,12 +4918,12 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
   /* Note: a zero OFFSET and LEN can be used to query the minimum
      buffer size.  */
   if (offset == 0 && len == 0)
-    return (rs->remote_packet_size);
-  /* Minimum outbuf size is RS->remote_packet_size. If LEN is not
+    return (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 < rs->remote_packet_size)
+  if (len < get_remote_packet_size ())
     return -1;
-  len = rs->remote_packet_size;
+  len = get_remote_packet_size ();
 
   /* Except for querying the minimum buffer size, target must be open.  */
   if (!remote_desc)
@@ -4909,7 +4942,7 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
      (remote_debug), we have PBUFZIZ - 7 left to pack the query
      string.  */
   i = 0;
-  while (annex[i] && (i < (rs->remote_packet_size - 8)))
+  while (annex[i] && (i < (get_remote_packet_size () - 8)))
     {
       /* Bad caller may have sent forbidden characters.  */
       gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
@@ -4948,7 +4981,7 @@ remote_rcmd (char *command,
   strcpy (buf, "qRcmd,");
   p = strchr (buf, '\0');
 
-  if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > rs->remote_packet_size)
+  if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ())
     error (_("\"monitor\" command ``%s'' is too long."), command);
 
   /* Encode the actual command.  */
@@ -5466,6 +5499,8 @@ remote_new_objfile (struct objfile *objfile)
 void
 _initialize_remote (void)
 {
+  struct remote_state *rs;
+
   /* architecture specific data */
   remote_gdbarch_data_handle = 
     gdbarch_data_register_post_init (init_remote_state);
@@ -5475,6 +5510,14 @@ _initialize_remote (void)
   DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size);
   deprecated_register_gdbarch_swap (NULL, 0, build_remote_gdbarch_data);
 
+  /* Initialize the per-target state.  At the moment there is only one
+     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->buf_size = 400;
+  rs->buf = xmalloc (rs->buf_size);
+
   init_remote_ops ();
   add_target (&remote_ops);