diff mbox

Remove cleanup from remote.c

Message ID 20190106201224.16653-1-tom@tromey.com
State New
Headers show

Commit Message

Tom Tromey Jan. 6, 2019, 8:12 p.m. UTC
This removes the remaining cleanup from remote.c, by changing
remote_state::buf to be a gdb::char_vector, and then fixing up all the
fallout.  The resulting patch is somewhat ugly, but on the other hand,
it eliminates some possibilities for mistakes.

Regression tested using the
Fedora-x86_64-native-extended-gdbserver-m64 builder on the buildbot.

gdb/ChangeLog
2019-01-06  Tom Tromey  <tom@tromey.com>

	* remote.c (class remote_state) <buf>: Now a char_vector.
	<buf_size>: Remove.
	(remote_target::getpkt): Change type of buf.  Remove sizeof_buf
	parameter.
	(remote_target::getpkt_or_notif_sane_1)
	(remote_target::getpkt_sane)
	(remote_target::getpkt_or_notif_sane): Likewise.
	(class remote_target) <putpkt>: New overload.
	(remote_target::read_frame): Change type of "buf_p".  Remove
	sizeof_p parameter.
	(packet_ok): New overload.
	(packet_check_result): New overload.
	Update all uses.
---
 gdb/ChangeLog |  16 +
 gdb/remote.c  | 842 +++++++++++++++++++++++++-------------------------
 2 files changed, 440 insertions(+), 418 deletions(-)

Comments

Simon Marchi Jan. 7, 2019, 1:14 a.m. UTC | #1
On 2019-01-06 15:12, Tom Tromey wrote:
> This removes the remaining cleanup from remote.c, by changing
> remote_state::buf to be a gdb::char_vector, and then fixing up all the
> fallout.  The resulting patch is somewhat ugly, but on the other hand,
> it eliminates some possibilities for mistakes.
> 
> Regression tested using the
> Fedora-x86_64-native-extended-gdbserver-m64 builder on the buildbot.

All of this for a single cleanup :).  This is fine with me.  I think we 
could later get rid of a few ->data() by having some functions take a 
gdb::char_vector or gdb::array_view instead of a char*.

Simon
diff mbox

Patch

diff --git a/gdb/remote.c b/gdb/remote.c
index 324ed46809..b08e9b7751 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -246,11 +246,10 @@  public: /* data */
   /* 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;
+     The size of the buffer 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;
+  gdb::char_vector buf;
 
   /* True if we're going through initial connection setup (finding out
      about the remote side's threads, relocating symbols, etc.).  */
@@ -893,13 +892,18 @@  public: /* Remote specific methods.  */
   int putpkt (const char *buf);
   int putpkt_binary (const char *buf, int cnt);
 
+  int putpkt (const gdb::char_vector &buf)
+  {
+    return putpkt (buf.data ());
+  }
+
   void skip_frame ();
-  long read_frame (char **buf_p, long *sizeof_buf);
-  void getpkt (char **buf, long *sizeof_buf, int forever);
-  int getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever,
+  long read_frame (gdb::char_vector *buf_p);
+  void getpkt (gdb::char_vector *buf, int forever);
+  int getpkt_or_notif_sane_1 (gdb::char_vector *buf, int forever,
 			      int expecting_notif, int *is_notif);
-  int getpkt_sane (char **buf, long *sizeof_buf, int forever);
-  int getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever,
+  int getpkt_sane (gdb::char_vector *buf, int forever);
+  int getpkt_or_notif_sane (gdb::char_vector *buf, int forever,
 			    int *is_notif);
   int remote_vkill (int pid);
   void remote_kill_k ();
@@ -1086,18 +1090,14 @@  struct remote_thread_info : public private_thread_info
 };
 
 remote_state::remote_state ()
+  : buf (400)
 {
-  /* The default buffer size is unimportant; it will be expanded
-     whenever a larger buffer is needed. */
-  this->buf_size = 400;
-  this->buf = (char *) xmalloc (this->buf_size);
 }
 
 remote_state::~remote_state ()
 {
   xfree (this->last_pass_packet);
   xfree (this->last_program_signals_packet);
-  xfree (this->buf);
   xfree (this->finished_object);
   xfree (this->finished_annex);
 }
@@ -1133,8 +1133,8 @@  remote_target::remote_get_noisy_reply ()
       char *buf;
 
       QUIT;			/* Allow user to bail out with ^C.  */
-      getpkt (&rs->buf, &rs->buf_size, 0);
-      buf = rs->buf;
+      getpkt (&rs->buf, 0);
+      buf = rs->buf.data ();
       if (buf[0] == 'E')
 	trace_error (buf);
       else if (startswith (buf, "qRelocInsn:"))
@@ -1187,7 +1187,7 @@  remote_target::remote_get_noisy_reply ()
 	    {
 	      adjusted_size = to - org_to;
 
-	      xsnprintf (buf, rs->buf_size, "qRelocInsn:%x", adjusted_size);
+	      xsnprintf (buf, rs->buf.size (), "qRelocInsn:%x", adjusted_size);
 	      putpkt (buf);
 	    }
 	}
@@ -1214,11 +1214,8 @@  remote_state::get_remote_arch_state (struct gdbarch *gdbarch)
 
       /* Make sure that the packet buffer is plenty big enough for
 	 this architecture.  */
-      if (this->buf_size < rsa->remote_packet_size)
-	{
-	  this->buf_size = 2 * rsa->remote_packet_size;
-	  this->buf = (char *) xrealloc (this->buf, this->buf_size);
-	}
+      if (this->buf.size () < rsa->remote_packet_size)
+	this->buf.resize (2 * rsa->remote_packet_size);
     }
   else
     rsa = &it->second;
@@ -1623,11 +1620,8 @@  remote_target::get_memory_packet_size (struct memory_packet_config *config)
 
   /* Make sure there is room in the global buffer for this packet
      (including its trailing NUL byte).  */
-  if (rs->buf_size < what_they_get + 1)
-    {
-      rs->buf_size = 2 * what_they_get;
-      rs->buf = (char *) xrealloc (rs->buf, 2 * what_they_get);
-    }
+  if (rs->buf.size () < what_they_get + 1)
+    rs->buf.resize (2 * what_they_get);
 
   return what_they_get;
 }
@@ -1907,6 +1901,12 @@  packet_check_result (const char *buf)
     return PACKET_UNKNOWN;
 }
 
+static enum packet_result
+packet_check_result (const gdb::char_vector &buf)
+{
+  return packet_check_result (buf.data ());
+}
+
 static enum packet_result
 packet_ok (const char *buf, struct packet_config *config)
 {
@@ -1960,6 +1960,12 @@  packet_ok (const char *buf, struct packet_config *config)
   return result;
 }
 
+static enum packet_result
+packet_ok (const gdb::char_vector &buf, struct packet_config *config)
+{
+  return packet_ok (buf.data (), config);
+}
+
 enum {
   PACKET_vCont = 0,
   PACKET_X,
@@ -2319,22 +2325,22 @@  remote_target::remote_query_attached (int pid)
     return 0;
 
   if (remote_multi_process_p (rs))
-    xsnprintf (rs->buf, size, "qAttached:%x", pid);
+    xsnprintf (rs->buf.data (), size, "qAttached:%x", pid);
   else
-    xsnprintf (rs->buf, size, "qAttached");
+    xsnprintf (rs->buf.data (), size, "qAttached");
 
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   switch (packet_ok (rs->buf,
 		     &remote_protocol_packets[PACKET_qAttached]))
     {
     case PACKET_OK:
-      if (strcmp (rs->buf, "1") == 0)
+      if (strcmp (rs->buf.data (), "1") == 0)
 	return 1;
       break;
     case PACKET_ERROR:
-      warning (_("Remote failure reply: %s"), rs->buf);
+      warning (_("Remote failure reply: %s"), rs->buf.data ());
       break;
     case PACKET_UNKNOWN:
       break;
@@ -2590,7 +2596,7 @@  remote_target::pass_signals (int numsigs, unsigned char *pass_signals)
       if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet))
 	{
 	  putpkt (pass_packet);
-	  getpkt (&rs->buf, &rs->buf_size, 0);
+	  getpkt (&rs->buf, 0);
 	  packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]);
 	  if (rs->last_pass_packet)
 	    xfree (rs->last_pass_packet);
@@ -2669,7 +2675,7 @@  remote_target::set_syscall_catchpoint (int pid, bool needed, int any_count,
   struct remote_state *rs = get_remote_state ();
 
   putpkt (catch_packet);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
   result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_QCatchSyscalls]);
   if (result == PACKET_OK)
     return 0;
@@ -2717,7 +2723,7 @@  remote_target::program_signals (int numsigs, unsigned char *signals)
 	  || strcmp (rs->last_program_signals_packet, packet) != 0)
 	{
 	  putpkt (packet);
-	  getpkt (&rs->buf, &rs->buf_size, 0);
+	  getpkt (&rs->buf, 0);
 	  packet_ok (rs->buf, &remote_protocol_packets[PACKET_QProgramSignals]);
 	  xfree (rs->last_program_signals_packet);
 	  rs->last_program_signals_packet = packet;
@@ -2736,8 +2742,8 @@  remote_target::set_thread (ptid_t ptid, int gen)
 {
   struct remote_state *rs = get_remote_state ();
   ptid_t state = gen ? rs->general_thread : rs->continue_thread;
-  char *buf = rs->buf;
-  char *endbuf = rs->buf + get_remote_packet_size ();
+  char *buf = rs->buf.data ();
+  char *endbuf = buf + get_remote_packet_size ();
 
   if (state == ptid)
     return;
@@ -2753,7 +2759,7 @@  remote_target::set_thread (ptid_t ptid, int gen)
   else
     write_ptid (buf, endbuf, ptid);
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
   if (gen)
     rs->general_thread = ptid;
   else
@@ -2830,14 +2836,14 @@  remote_target::thread_alive (ptid_t ptid)
   if (remote_thread_always_alive (ptid))
     return 1;
 
-  p = rs->buf;
-  endp = rs->buf + get_remote_packet_size ();
+  p = rs->buf.data ();
+  endp = p + get_remote_packet_size ();
 
   *p++ = 'T';
   write_ptid (p, endp, ptid);
 
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
   return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
 }
 
@@ -3242,7 +3248,7 @@  remote_target::remote_unpack_thread_info_response (char *pkt,
   int mask, length;
   int tag;
   threadref ref;
-  char *limit = pkt + rs->buf_size; /* Plausible parsing limit.  */
+  char *limit = pkt + rs->buf.size (); /* Plausible parsing limit.  */
   int retval = 1;
 
   /* info->threadid = 0; FIXME: implement zero_threadref.  */
@@ -3335,14 +3341,14 @@  remote_target::remote_get_threadinfo (threadref *threadid,
   struct remote_state *rs = get_remote_state ();
   int result;
 
-  pack_threadinfo_request (rs->buf, fieldset, threadid);
+  pack_threadinfo_request (rs->buf.data (), fieldset, threadid);
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   if (rs->buf[0] == '\0')
     return 0;
 
-  result = remote_unpack_thread_info_response (rs->buf + 2,
+  result = remote_unpack_thread_info_response (&rs->buf[2],
 					       threadid, info);
   return result;
 }
@@ -3376,7 +3382,7 @@  remote_target::parse_threadlist_response (char *pkt, int result_limit,
 
   resultcount = 0;
   /* Assume the 'q' and 'M chars have been stripped.  */
-  limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE);
+  limit = pkt + (rs->buf.size () - BUF_THREAD_ID_SIZE);
   /* done parse past here */
   pkt = unpack_byte (pkt, &count);	/* count field */
   pkt = unpack_nibble (pkt, &done);
@@ -3409,17 +3415,18 @@  remote_target::remote_get_threadlist (int startflag, threadref *nextthread,
       >= get_remote_packet_size ())
     result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
 
-  pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
+  pack_threadlist_request (rs->buf.data (), startflag, result_limit,
+			   nextthread);
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
-  if (*rs->buf == '\0')
+  getpkt (&rs->buf, 0);
+  if (rs->buf[0] == '\0')
     {
       /* Packet not supported.  */
       return -1;
     }
 
   *result_count =
-    parse_threadlist_response (rs->buf + 2, result_limit,
+    parse_threadlist_response (&rs->buf[2], result_limit,
 			       &rs->echo_nextthread, threadlist, done);
 
   if (!threadmatch (&rs->echo_nextthread, nextthread))
@@ -3598,7 +3605,7 @@  remote_target::remote_current_thread (ptid_t oldpid)
   struct remote_state *rs = get_remote_state ();
 
   putpkt ("qC");
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
   if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
     {
       const char *obuf;
@@ -3733,8 +3740,8 @@  remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context *con
       const char *bufp;
 
       putpkt ("qfThreadInfo");
-      getpkt (&rs->buf, &rs->buf_size, 0);
-      bufp = rs->buf;
+      getpkt (&rs->buf, 0);
+      bufp = rs->buf.data ();
       if (bufp[0] != '\0')		/* q packet recognized */
 	{
 	  while (*bufp++ == 'm')	/* reply contains one or more TID */
@@ -3746,8 +3753,8 @@  remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context *con
 		}
 	      while (*bufp++ == ',');	/* comma-separated list */
 	      putpkt ("qsThreadInfo");
-	      getpkt (&rs->buf, &rs->buf_size, 0);
-	      bufp = rs->buf;
+	      getpkt (&rs->buf, 0);
+	      bufp = rs->buf.data ();
 	    }
 	  return 1;
 	}
@@ -3883,19 +3890,19 @@  remote_target::extra_thread_info (thread_info *tp)
 
   if (rs->use_threadextra_query)
     {
-      char *b = rs->buf;
-      char *endb = rs->buf + get_remote_packet_size ();
+      char *b = rs->buf.data ();
+      char *endb = b + get_remote_packet_size ();
 
       xsnprintf (b, endb - b, "qThreadExtraInfo,");
       b += strlen (b);
       write_ptid (b, endb, tp->ptid);
 
       putpkt (rs->buf);
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
       if (rs->buf[0] != 0)
 	{
-	  extra.resize (strlen (rs->buf) / 2);
-	  hex2bin (rs->buf, (gdb_byte *) &extra[0], extra.size ());
+	  extra.resize (strlen (rs->buf.data ()) / 2);
+	  hex2bin (rs->buf.data (), (gdb_byte *) &extra[0], extra.size ());
 	  return extra.c_str ();
 	}
     }
@@ -3933,14 +3940,14 @@  remote_target::static_tracepoint_marker_at (CORE_ADDR addr,
 					    struct static_tracepoint_marker *marker)
 {
   struct remote_state *rs = get_remote_state ();
-  char *p = rs->buf;
+  char *p = rs->buf.data ();
 
   xsnprintf (p, get_remote_packet_size (), "qTSTMat:");
   p += strlen (p);
   p += hexnumstr (p, addr);
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
-  p = rs->buf;
+  getpkt (&rs->buf, 0);
+  p = rs->buf.data ();
 
   if (*p == 'E')
     error (_("Remote failure reply: %s"), p);
@@ -3965,8 +3972,8 @@  remote_target::static_tracepoint_markers_by_strid (const char *strid)
   /* Ask for a first packet of static tracepoint marker
      definition.  */
   putpkt ("qTfSTM");
-  getpkt (&rs->buf, &rs->buf_size, 0);
-  p = rs->buf;
+  getpkt (&rs->buf, 0);
+  p = rs->buf.data ();
   if (*p == 'E')
     error (_("Remote failure reply: %s"), p);
 
@@ -3982,8 +3989,8 @@  remote_target::static_tracepoint_markers_by_strid (const char *strid)
       while (*p++ == ',');	/* comma-separated list */
       /* Ask for another packet of static tracepoint definition.  */
       putpkt ("qTsSTM");
-      getpkt (&rs->buf, &rs->buf_size, 0);
-      p = rs->buf;
+      getpkt (&rs->buf, 0);
+      p = rs->buf.data ();
     }
 
   return markers;
@@ -4008,7 +4015,7 @@  remote_target::extended_remote_restart ()
 
   /* Send the restart command; for reasons I don't understand the
      remote side really expects a number after the "R".  */
-  xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0);
+  xsnprintf (rs->buf.data (), get_remote_packet_size (), "R%x", 0);
   putpkt (rs->buf);
 
   remote_fileio_reset ();
@@ -4072,8 +4079,8 @@  remote_target::get_offsets ()
     return;
 
   putpkt ("qOffsets");
-  getpkt (&rs->buf, &rs->buf_size, 0);
-  buf = rs->buf;
+  getpkt (&rs->buf, 0);
+  buf = rs->buf.data ();
 
   if (buf[0] == '\000')
     return;			/* Return silently.  Stub doesn't support
@@ -4563,12 +4570,12 @@  remote_target::start_remote (int from_tty, int extended_p)
     const char v_mustreplyempty[] = "vMustReplyEmpty";
 
     putpkt (v_mustreplyempty);
-    getpkt (&rs->buf, &rs->buf_size, 0);
-    if (strcmp (rs->buf, "OK") == 0)
+    getpkt (&rs->buf, 0);
+    if (strcmp (rs->buf.data (), "OK") == 0)
       remote_protocol_packets[PACKET_vFile_setfs].support = PACKET_DISABLE;
-    else if (strcmp (rs->buf, "") != 0)
+    else if (strcmp (rs->buf.data (), "") != 0)
       error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty,
-	     rs->buf);
+	     rs->buf.data ());
   }
 
   /* Next, we possibly activate noack mode.
@@ -4588,7 +4595,7 @@  remote_target::start_remote (int from_tty, int extended_p)
   if (packet_config_support (noack_config) != PACKET_DISABLE)
     {
       putpkt ("QStartNoAckMode");
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
       if (packet_ok (rs->buf, noack_config) == PACKET_OK)
 	rs->noack_mode = 1;
     }
@@ -4597,7 +4604,7 @@  remote_target::start_remote (int from_tty, int extended_p)
     {
       /* Tell the remote that we are using the extended protocol.  */
       putpkt ("!");
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
     }
 
   /* Let the target know which signals it is allowed to pass down to
@@ -4624,10 +4631,11 @@  remote_target::start_remote (int from_tty, int extended_p)
 		 "does not support non-stop"));
 
       putpkt ("QNonStop:1");
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
 
-      if (strcmp (rs->buf, "OK") != 0)
-	error (_("Remote refused setting non-stop mode with: %s"), rs->buf);
+      if (strcmp (rs->buf.data (), "OK") != 0)
+	error (_("Remote refused setting non-stop mode with: %s"),
+	       rs->buf.data ());
 
       /* Find about threads and processes the stub is already
 	 controlling.  We default to adding them in the running state.
@@ -4640,10 +4648,11 @@  remote_target::start_remote (int from_tty, int extended_p)
       /* Don't assume that the stub can operate in all-stop mode.
 	 Request it explicitly.  */
       putpkt ("QNonStop:0");
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
 
-      if (strcmp (rs->buf, "OK") != 0)
-	error (_("Remote refused setting all-stop mode with: %s"), rs->buf);
+      if (strcmp (rs->buf.data (), "OK") != 0)
+	error (_("Remote refused setting all-stop mode with: %s"),
+	       rs->buf.data ());
     }
 
   /* Upload TSVs regardless of whether the target is running or not.  The
@@ -4659,7 +4668,7 @@  remote_target::start_remote (int from_tty, int extended_p)
 
   /* Check whether the target is running now.  */
   putpkt ("?");
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   if (!target_is_non_stop_p ())
     {
@@ -4676,8 +4685,8 @@  remote_target::start_remote (int from_tty, int extended_p)
       else
 	{
 	  /* Save the reply for later.  */
-	  wait_status = (char *) alloca (strlen (rs->buf) + 1);
-	  strcpy (wait_status, rs->buf);
+	  wait_status = (char *) alloca (strlen (rs->buf.data ()) + 1);
+	  strcpy (wait_status, rs->buf.data ());
 	}
 
       /* Fetch thread list.  */
@@ -4742,7 +4751,7 @@  remote_target::start_remote (int from_tty, int extended_p)
 
       /* Use the previously fetched status.  */
       gdb_assert (wait_status != NULL);
-      strcpy (rs->buf, wait_status);
+      strcpy (rs->buf.data (), wait_status);
       rs->cached_wait_status = 1;
 
       ::start_remote (from_tty); /* Initialize gdb process mechanisms.  */
@@ -4761,14 +4770,14 @@  remote_target::start_remote (int from_tty, int extended_p)
 	 reply.  In the latter case, there may be more than one thread
 	 stopped --- we pull them all out using the vStopped
 	 mechanism.  */
-      if (strcmp (rs->buf, "OK") != 0)
+      if (strcmp (rs->buf.data (), "OK") != 0)
 	{
 	  struct notif_client *notif = &notif_client_stop;
 
 	  /* remote_notif_get_pending_replies acks this one, and gets
 	     the rest out.  */
 	  rs->notif_state->pending_event[notif_client_stop.id]
-	    = remote_notif_parse (this, notif, rs->buf);
+	    = remote_notif_parse (this, notif, rs->buf.data ());
 	  remote_notif_get_pending_events (notif);
 	}
 
@@ -4883,10 +4892,8 @@  init_all_packet_configs (void)
 void
 remote_target::remote_check_symbols ()
 {
-  char *reply, *tmp;
+  char *tmp;
   int end;
-  long reply_size;
-  struct cleanup *old_chain;
 
   /* The remote side has no concept of inferiors that aren't running
      yet, it only knows about running processes.  If we're connected
@@ -4906,17 +4913,15 @@  remote_target::remote_check_symbols ()
   /* Allocate a message buffer.  We can't reuse the input buffer in RS,
      because we need both at the same time.  */
   gdb::char_vector msg (get_remote_packet_size ());
-  reply = (char *) xmalloc (get_remote_packet_size ());
-  old_chain = make_cleanup (free_current_contents, &reply);
-  reply_size = get_remote_packet_size ();
+  gdb::char_vector reply (get_remote_packet_size ());
 
   /* Invite target to request symbol lookups.  */
 
   putpkt ("qSymbol::");
-  getpkt (&reply, &reply_size, 0);
+  getpkt (&reply, 0);
   packet_ok (reply, &remote_protocol_packets[PACKET_qSymbol]);
 
-  while (startswith (reply, "qSymbol:"))
+  while (startswith (reply.data (), "qSymbol:"))
     {
       struct bound_minimal_symbol sym;
 
@@ -4944,10 +4949,8 @@  remote_target::remote_check_symbols ()
 	}
 
       putpkt (msg.data ());
-      getpkt (&reply, &reply_size, 0);
+      getpkt (&reply, 0);
     }
-
-  do_cleanups (old_chain);
 }
 
 static struct serial *
@@ -4984,7 +4987,7 @@  remote_target::set_permissions ()
 {
   struct remote_state *rs = get_remote_state ();
 
-  xsnprintf (rs->buf, get_remote_packet_size (), "QAllow:"
+  xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAllow:"
 	     "WriteReg:%x;WriteMem:%x;"
 	     "InsertBreak:%x;InsertTrace:%x;"
 	     "InsertFastTrace:%x;Stop:%x",
@@ -4992,12 +4995,13 @@  remote_target::set_permissions ()
 	     may_insert_breakpoints, may_insert_tracepoints,
 	     may_insert_fast_tracepoints, may_stop);
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   /* If the target didn't like the packet, warn the user.  Do not try
      to undo the user's settings, that would just be maddening.  */
-  if (strcmp (rs->buf, "OK") != 0)
-    warning (_("Remote refused setting permissions with: %s"), rs->buf);
+  if (strcmp (rs->buf.data (), "OK") != 0)
+    warning (_("Remote refused setting permissions with: %s"),
+	     rs->buf.data ());
 }
 
 /* This type describes each known response to the qSupported
@@ -5291,21 +5295,21 @@  remote_target::remote_query_supported ()
       q = "qSupported:" + q;
       putpkt (q.c_str ());
 
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
 
       /* If an error occured, warn, but do not return - just reset the
 	 buffer to empty and go on to disable features.  */
       if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
 	  == PACKET_ERROR)
 	{
-	  warning (_("Remote failure reply: %s"), rs->buf);
+	  warning (_("Remote failure reply: %s"), rs->buf.data ());
 	  rs->buf[0] = 0;
 	}
     }
 
   memset (seen, 0, sizeof (seen));
 
-  next = rs->buf;
+  next = rs->buf.data ();
   while (*next)
     {
       enum packet_support is_supported;
@@ -5382,11 +5386,8 @@  remote_target::remote_query_supported ()
      buffer size also.  We delay this until after parsing the entire
      qSupported packet, because this is the same buffer we were
      parsing.  */
-  if (rs->buf_size < rs->explicit_packet_size)
-    {
-      rs->buf_size = rs->explicit_packet_size;
-      rs->buf = (char *) xrealloc (rs->buf, rs->buf_size);
-    }
+  if (rs->buf.size () < rs->explicit_packet_size)
+    rs->buf.resize (rs->explicit_packet_size);
 
   /* Handle the defaults for unmentioned features.  */
   for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
@@ -5649,12 +5650,12 @@  remote_target::remote_detach_pid (int pid)
   set_general_process ();
 
   if (remote_multi_process_p (rs))
-    xsnprintf (rs->buf, get_remote_packet_size (), "D;%x", pid);
+    xsnprintf (rs->buf.data (), get_remote_packet_size (), "D;%x", pid);
   else
-    strcpy (rs->buf, "D");
+    strcpy (rs->buf.data (), "D");
 
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   if (rs->buf[0] == 'O' && rs->buf[1] == 'K')
     ;
@@ -5832,9 +5833,9 @@  extended_remote_target::attach (const char *args, int from_tty)
       gdb_flush (gdb_stdout);
     }
 
-  xsnprintf (rs->buf, get_remote_packet_size (), "vAttach;%x", pid);
+  xsnprintf (rs->buf.data (), get_remote_packet_size (), "vAttach;%x", pid);
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   switch (packet_ok (rs->buf,
 		     &remote_protocol_packets[PACKET_vAttach]))
@@ -5843,13 +5844,13 @@  extended_remote_target::attach (const char *args, int from_tty)
       if (!target_is_non_stop_p ())
 	{
 	  /* Save the reply for later.  */
-	  wait_status = (char *) alloca (strlen (rs->buf) + 1);
-	  strcpy (wait_status, rs->buf);
+	  wait_status = (char *) alloca (strlen (rs->buf.data ()) + 1);
+	  strcpy (wait_status, rs->buf.data ());
 	}
-      else if (strcmp (rs->buf, "OK") != 0)
+      else if (strcmp (rs->buf.data (), "OK") != 0)
 	error (_("Attaching to %s failed with: %s"),
 	       target_pid_to_str (ptid_t (pid)),
-	       rs->buf);
+	       rs->buf.data ());
       break;
     case PACKET_UNKNOWN:
       error (_("This target does not support attaching to a process"));
@@ -5911,7 +5912,7 @@  extended_remote_target::attach (const char *args, int from_tty)
       else
 	{
 	  gdb_assert (wait_status != NULL);
-	  strcpy (rs->buf, wait_status);
+	  strcpy (rs->buf.data (), wait_status);
 	  rs->cached_wait_status = 1;
 	}
     }
@@ -5946,10 +5947,10 @@  remote_target::remote_vcont_probe ()
   remote_state *rs = get_remote_state ();
   char *buf;
 
-  strcpy (rs->buf, "vCont?");
+  strcpy (rs->buf.data (), "vCont?");
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
-  buf = rs->buf;
+  getpkt (&rs->buf, 0);
+  buf = rs->buf.data ();
 
   /* Make sure that the features we assume are supported.  */
   if (startswith (buf, "vCont"))
@@ -5988,7 +5989,7 @@  remote_target::remote_vcont_probe ()
 	buf[0] = 0;
     }
 
-  packet_ok (buf, &remote_protocol_packets[PACKET_vCont]);
+  packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCont]);
 }
 
 /* Helper function for building "vCont" resumptions.  Write a
@@ -6128,7 +6129,7 @@  remote_target::remote_resume_with_hc (ptid_t ptid, int step,
   for (thread_info *thread : all_non_exited_threads ())
     resume_clear_thread_private_info (thread);
 
-  buf = rs->buf;
+  buf = rs->buf.data ();
   if (::execution_direction == EXEC_REVERSE)
     {
       /* We don't pass signals to the target in reverse exec mode.  */
@@ -6184,8 +6185,8 @@  remote_target::remote_resume_with_vcont (ptid_t ptid, int step,
   if (packet_support (PACKET_vCont) == PACKET_DISABLE)
     return 0;
 
-  p = rs->buf;
-  endp = rs->buf + get_remote_packet_size ();
+  p = rs->buf.data ();
+  endp = p + get_remote_packet_size ();
 
   /* If we could generate a wider range of packets, we'd have to worry
      about overflowing BUF.  Should there be a generic
@@ -6226,7 +6227,7 @@  remote_target::remote_resume_with_vcont (ptid_t ptid, int step,
       append_resumption (p, endp, ptid, step, siggnal);
     }
 
-  gdb_assert (strlen (rs->buf) < get_remote_packet_size ());
+  gdb_assert (strlen (rs->buf.data ()) < get_remote_packet_size ());
   putpkt (rs->buf);
 
   if (target_is_non_stop_p ())
@@ -6234,9 +6235,10 @@  remote_target::remote_resume_with_vcont (ptid_t ptid, int step,
       /* In non-stop, the stub replies to vCont with "OK".  The stop
 	 reply will be reported asynchronously by means of a `%Stop'
 	 notification.  */
-      getpkt (&rs->buf, &rs->buf_size, 0);
-      if (strcmp (rs->buf, "OK") != 0)
-	error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf);
+      getpkt (&rs->buf, 0);
+      if (strcmp (rs->buf.data (), "OK") != 0)
+	error (_("Unexpected vCont reply in non-stop mode: %s"),
+	       rs->buf.data ());
     }
 
   return 1;
@@ -6367,8 +6369,8 @@  vcont_builder::restart ()
 {
   struct remote_state *rs = m_remote->get_remote_state ();
 
-  m_p = rs->buf;
-  m_endp = rs->buf + m_remote->get_remote_packet_size ();
+  m_p = rs->buf.data ();
+  m_endp = m_p + m_remote->get_remote_packet_size ();
   m_p += xsnprintf (m_p, m_endp - m_p, "vCont");
   m_first_action = m_p;
 }
@@ -6386,9 +6388,9 @@  vcont_builder::flush ()
 
   rs = m_remote->get_remote_state ();
   m_remote->putpkt (rs->buf);
-  m_remote->getpkt (&rs->buf, &rs->buf_size, 0);
-  if (strcmp (rs->buf, "OK") != 0)
-    error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf);
+  m_remote->getpkt (&rs->buf, 0);
+  if (strcmp (rs->buf.data (), "OK") != 0)
+    error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf.data ());
 }
 
 /* The largest action is range-stepping, with its two addresses.  This
@@ -6609,8 +6611,8 @@  void
 remote_target::remote_stop_ns (ptid_t ptid)
 {
   struct remote_state *rs = get_remote_state ();
-  char *p = rs->buf;
-  char *endp = rs->buf + get_remote_packet_size ();
+  char *p = rs->buf.data ();
+  char *endp = p + get_remote_packet_size ();
 
   if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
     remote_vcont_probe ();
@@ -6647,9 +6649,10 @@  remote_target::remote_stop_ns (ptid_t ptid)
   /* In non-stop, we get an immediate OK reply.  The stop reply will
      come in asynchronously by notification.  */
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
-  if (strcmp (rs->buf, "OK") != 0)
-    error (_("Stopping %s failed: %s"), target_pid_to_str (ptid), rs->buf);
+  getpkt (&rs->buf, 0);
+  if (strcmp (rs->buf.data (), "OK") != 0)
+    error (_("Stopping %s failed: %s"), target_pid_to_str (ptid),
+	   rs->buf.data ());
 }
 
 /* All-stop version of target_interrupt.  Sends a break or a ^C to
@@ -6682,15 +6685,15 @@  void
 remote_target::remote_interrupt_ns ()
 {
   struct remote_state *rs = get_remote_state ();
-  char *p = rs->buf;
-  char *endp = rs->buf + get_remote_packet_size ();
+  char *p = rs->buf.data ();
+  char *endp = p + get_remote_packet_size ();
 
   xsnprintf (p, endp - p, "vCtrlC");
 
   /* In non-stop, we get an immediate OK reply.  The stop reply will
      come in asynchronously by notification.  */
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCtrlC]))
     {
@@ -6699,7 +6702,7 @@  remote_target::remote_interrupt_ns ()
     case PACKET_UNKNOWN:
       error (_("No support for interrupting the remote target."));
     case PACKET_ERROR:
-      error (_("Interrupting target failed: %s"), rs->buf);
+      error (_("Interrupting target failed: %s"), rs->buf.data ());
     }
 }
 
@@ -7609,16 +7612,17 @@  remote_target::remote_notif_get_pending_events (notif_client *nc)
 			    nc->name);
 
       /* acknowledge */
-      nc->ack (this, nc, rs->buf, rs->notif_state->pending_event[nc->id]);
+      nc->ack (this, nc, rs->buf.data (),
+	       rs->notif_state->pending_event[nc->id]);
       rs->notif_state->pending_event[nc->id] = NULL;
 
       while (1)
 	{
-	  getpkt (&rs->buf, &rs->buf_size, 0);
-	  if (strcmp (rs->buf, "OK") == 0)
+	  getpkt (&rs->buf, 0);
+	  if (strcmp (rs->buf.data (), "OK") == 0)
 	    break;
 	  else
-	    remote_notif_ack (this, nc, rs->buf);
+	    remote_notif_ack (this, nc, rs->buf.data ());
 	}
     }
   else
@@ -7705,8 +7709,7 @@  remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int optio
   /* If in non-stop mode, get out of getpkt even if a
      notification is received.	*/
 
-  ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
-			      0 /* forever */, &is_notif);
+  ret = getpkt_or_notif_sane (&rs->buf, 0 /* forever */, &is_notif);
   while (1)
     {
       if (ret != -1 && !is_notif)
@@ -7716,13 +7719,13 @@  remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int optio
 	    /* We're out of sync with the target now.  Did it continue
 	       or not?  We can't tell which thread it was in non-stop,
 	       so just ignore this.  */
-	    warning (_("Remote failure reply: %s"), rs->buf);
+	    warning (_("Remote failure reply: %s"), rs->buf.data ());
 	    break;
 	  case 'O':		/* Console output.  */
-	    remote_console_output (rs->buf + 1);
+	    remote_console_output (&rs->buf[1]);
 	    break;
 	  default:
-	    warning (_("Invalid remote reply: %s"), rs->buf);
+	    warning (_("Invalid remote reply: %s"), rs->buf.data ());
 	    break;
 	  }
 
@@ -7745,8 +7748,7 @@  remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int optio
 	}
 
       /* Otherwise do a blocking wait.  */
-      ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
-				  1 /* forever */, &is_notif);
+      ret = getpkt_or_notif_sane (&rs->buf, 1 /* forever */, &is_notif);
     }
 }
 
@@ -7790,8 +7792,7 @@  remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options)
 	 _never_ wait for ever -> test on target_is_async_p().
 	 However, before we do that we need to ensure that the caller
 	 knows how to take the target into/out of async mode.  */
-      ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
-				  forever, &is_notif);
+      ret = getpkt_or_notif_sane (&rs->buf, forever, &is_notif);
 
       /* GDB gets a notification.  Return to core as this event is
 	 not interesting.  */
@@ -7802,7 +7803,7 @@  remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options)
 	return minus_one_ptid;
     }
 
-  buf = rs->buf;
+  buf = rs->buf.data ();
 
   /* Assume that the target has acknowledged Ctrl-C unless we receive
      an 'F' or 'O' packet.  */
@@ -7840,7 +7841,7 @@  remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options)
 	stop_reply
 	  = (struct stop_reply *) remote_notif_parse (this,
 						      &notif_client_stop,
-						      rs->buf);
+						      rs->buf.data ());
 
 	event_ptid = process_stop_reply (stop_reply, status);
 	break;
@@ -7940,16 +7941,16 @@  remote_target::fetch_register_using_p (struct regcache *regcache,
   if (reg->pnum == -1)
     return 0;
 
-  p = rs->buf;
+  p = rs->buf.data ();
   *p++ = 'p';
   p += hexnumstr (p, reg->pnum);
   *p++ = '\0';
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
-  buf = rs->buf;
+  buf = rs->buf.data ();
 
-  switch (packet_ok (buf, &remote_protocol_packets[PACKET_p]))
+  switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_p]))
     {
     case PACKET_OK:
       break;
@@ -7992,12 +7993,12 @@  remote_target::send_g_packet ()
   struct remote_state *rs = get_remote_state ();
   int buf_len;
 
-  xsnprintf (rs->buf, get_remote_packet_size (), "g");
+  xsnprintf (rs->buf.data (), get_remote_packet_size (), "g");
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
   if (packet_check_result (rs->buf) == PACKET_ERROR)
     error (_("Could not read registers; remote failure reply '%s'"),
-           rs->buf);
+           rs->buf.data ());
 
   /* 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
@@ -8010,14 +8011,14 @@  remote_target::send_g_packet ()
       if (remote_debug)
 	fprintf_unfiltered (gdb_stdlog,
 			    "Bad register packet; fetching a new packet\n");
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
     }
 
-  buf_len = strlen (rs->buf);
+  buf_len = strlen (rs->buf.data ());
 
   /* Sanity check the received packet.  */
   if (buf_len % 2 != 0)
-    error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf);
+    error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf.data ());
 
   return buf_len / 2;
 }
@@ -8032,12 +8033,14 @@  remote_target::process_g_packet (struct regcache *regcache)
   char *p;
   char *regs;
 
-  buf_len = strlen (rs->buf);
+  buf_len = strlen (rs->buf.data ());
 
   /* Further sanity checks, with knowledge of the architecture.  */
   if (buf_len > 2 * rsa->sizeof_g_packet)
     error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
-	     "bytes): %s"), rsa->sizeof_g_packet, buf_len / 2, rs->buf);
+	     "bytes): %s"),
+	   rsa->sizeof_g_packet, buf_len / 2,
+	   rs->buf.data ());
 
   /* Save the size of the packet sent to us by the target.  It is used
      as a heuristic when determining the max size of packets that the
@@ -8087,7 +8090,7 @@  remote_target::process_g_packet (struct regcache *regcache)
      hex characters.  Suck them all up, then supply them to the
      register cacheing/storage mechanism.  */
 
-  p = rs->buf;
+  p = rs->buf.data ();
   for (i = 0; i < rsa->sizeof_g_packet; i++)
     {
       if (p[0] == 0 || p[1] == 0)
@@ -8109,13 +8112,13 @@  remote_target::process_g_packet (struct regcache *regcache)
 
       if (r->in_g_packet)
 	{
-	  if ((r->offset + reg_size) * 2 > strlen (rs->buf))
+	  if ((r->offset + reg_size) * 2 > strlen (rs->buf.data ()))
 	    /* This shouldn't happen - we adjusted in_g_packet above.  */
 	    internal_error (__FILE__, __LINE__,
 			    _("unexpected end of 'g' packet reply"));
 	  else if (rs->buf[r->offset * 2] == 'x')
 	    {
-	      gdb_assert (r->offset * 2 < strlen (rs->buf));
+	      gdb_assert (r->offset * 2 < strlen (rs->buf.data ()));
 	      /* The register isn't available, mark it as such (at
 		 the same time setting the value to zero).  */
 	      regcache->raw_supply (r->regnum, NULL);
@@ -8240,7 +8243,7 @@  remote_target::store_register_using_P (const struct regcache *regcache,
   struct gdbarch *gdbarch = regcache->arch ();
   struct remote_state *rs = get_remote_state ();
   /* Try storing a single register.  */
-  char *buf = rs->buf;
+  char *buf = rs->buf.data ();
   gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum));
   char *p;
 
@@ -8255,7 +8258,7 @@  remote_target::store_register_using_P (const struct regcache *regcache,
   regcache->raw_collect (reg->regnum, regp);
   bin2hex (regp, p, register_size (gdbarch, reg->regnum));
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
     {
@@ -8263,7 +8266,7 @@  remote_target::store_register_using_P (const struct regcache *regcache,
       return 1;
     case PACKET_ERROR:
       error (_("Could not write register \"%s\"; remote failure reply '%s'"),
-	     gdbarch_register_name (gdbarch, reg->regnum), rs->buf);
+	     gdbarch_register_name (gdbarch, reg->regnum), rs->buf.data ());
     case PACKET_UNKNOWN:
       return 0;
     default:
@@ -8300,14 +8303,14 @@  remote_target::store_registers_using_G (const struct regcache *regcache)
 
   /* Command describes registers byte by byte,
      each byte encoded as two hex characters.  */
-  p = rs->buf;
+  p = rs->buf.data ();
   *p++ = 'G';
   bin2hex (regs, p, rsa->sizeof_g_packet);
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
   if (packet_check_result (rs->buf) == PACKET_ERROR)
     error (_("Could not write registers; remote failure reply '%s'"), 
-	   rs->buf);
+	   rs->buf.data ());
 }
 
 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
@@ -8450,7 +8453,7 @@  remote_target::check_binary_download (CORE_ADDR addr)
       {
 	char *p;
 
-	p = rs->buf;
+	p = rs->buf.data ();
 	*p++ = 'X';
 	p += hexnumstr (p, (ULONGEST) addr);
 	*p++ = ',';
@@ -8458,8 +8461,8 @@  remote_target::check_binary_download (CORE_ADDR addr)
 	*p++ = ':';
 	*p = '\0';
 
-	putpkt_binary (rs->buf, (int) (p - rs->buf));
-	getpkt (&rs->buf, &rs->buf_size, 0);
+	putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ()));
+	getpkt (&rs->buf, 0);
 
 	if (rs->buf[0] == '\0')
 	  {
@@ -8568,8 +8571,8 @@  remote_target::remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
 
   /* Construct the packet excluding the data: "<header><memaddr>,<len>:".  */
 
-  strcat (rs->buf, header);
-  p = rs->buf + strlen (header);
+  strcat (rs->buf.data (), header);
+  p = rs->buf.data () + strlen (header);
 
   /* Compute a best guess of the number of bytes actually transfered.  */
   if (packet_format == 'X')
@@ -8669,8 +8672,8 @@  remote_target::remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
       units_written = todo_units;
     }
 
-  putpkt_binary (rs->buf, (int) (p - rs->buf));
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ()));
+  getpkt (&rs->buf, 0);
 
   if (rs->buf[0] == 'E')
     return TARGET_XFER_E_IO;
@@ -8756,21 +8759,21 @@  remote_target::remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr,
 
   /* Construct "m"<memaddr>","<len>".  */
   memaddr = remote_address_masked (memaddr);
-  p = rs->buf;
+  p = rs->buf.data ();
   *p++ = 'm';
   p += hexnumstr (p, (ULONGEST) memaddr);
   *p++ = ',';
   p += hexnumstr (p, (ULONGEST) todo_units);
   *p = '\0';
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
   if (rs->buf[0] == 'E'
       && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
       && rs->buf[3] == '\0')
     return TARGET_XFER_E_IO;
   /* Reply describes memory byte by byte, each byte encoded as two hex
      characters.  */
-  p = rs->buf;
+  p = rs->buf.data ();
   decoded_bytes = hex2bin (p, myaddr, todo_units * unit_size);
   /* Return what we have.  Let higher layers handle partial reads.  */
   *xfered_len_units = (ULONGEST) (decoded_bytes / unit_size);
@@ -8911,7 +8914,7 @@  remote_target::remote_send_printf (const char *format, ...)
   va_start (ap, format);
 
   rs->buf[0] = '\0';
-  int size = vsnprintf (rs->buf, max_size, format, ap);
+  int size = vsnprintf (rs->buf.data (), max_size, format, ap);
 
   va_end (ap);
 
@@ -8922,7 +8925,7 @@  remote_target::remote_send_printf (const char *format, ...)
     error (_("Communication problem with target."));
 
   rs->buf[0] = '\0';
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   return packet_check_result (rs->buf);
 }
@@ -9267,18 +9270,18 @@  remote_target::putpkt_binary (const char *buf, int cnt)
 		   for an ack.  */
 		/* We've found the start of a notification.  Now
 		   collect the data.  */
-		val = read_frame (&rs->buf, &rs->buf_size);
+		val = read_frame (&rs->buf);
 		if (val >= 0)
 		  {
 		    if (remote_debug)
 		      {
-			std::string str = escape_buffer (rs->buf, val);
+			std::string str = escape_buffer (rs->buf.data (), val);
 
 			fprintf_unfiltered (gdb_stdlog,
 					    "  Notification received: %s\n",
 					    str.c_str ());
 		      }
-		    handle_notification (rs->notif_state, rs->buf);
+		    handle_notification (rs->notif_state, rs->buf.data ());
 		    /* We're in sync now, rewait for the ack.  */
 		    tcount = 0;
 		  }
@@ -9292,7 +9295,7 @@  remote_target::putpkt_binary (const char *buf, int cnt)
 			    fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
 			  }
 			fputc_unfiltered (ch & 0177, gdb_stdlog);
-			fprintf_unfiltered (gdb_stdlog, "%s", rs->buf);
+			fprintf_unfiltered (gdb_stdlog, "%s", rs->buf.data ());
 		      }
 		  }
 		continue;
@@ -9369,19 +9372,19 @@  remote_target::skip_frame ()
 /* Come here after finding the start of the frame.  Collect the rest
    into *BUF, verifying the checksum, length, and handling run-length
    compression.  NUL terminate the buffer.  If there is not enough room,
-   expand *BUF using xrealloc.
+   expand *BUF.
 
    Returns -1 on error, number of characters in buffer (ignoring the
    trailing NULL) on success. (could be extended to return one of the
    SERIAL status indications).  */
 
 long
-remote_target::read_frame (char **buf_p, long *sizeof_buf)
+remote_target::read_frame (gdb::char_vector *buf_p)
 {
   unsigned char csum;
   long bc;
   int c;
-  char *buf = *buf_p;
+  char *buf = buf_p->data ();
   struct remote_state *rs = get_remote_state ();
 
   csum = 0;
@@ -9464,12 +9467,11 @@  remote_target::read_frame (char **buf_p, long *sizeof_buf)
 
 	    if (repeat > 0 && repeat <= 255 && bc > 0)
 	      {
-		if (bc + repeat - 1 >= *sizeof_buf - 1)
+		if (bc + repeat - 1 >= buf_p->size () - 1)
 		  {
 		    /* Make some more room in the buffer.  */
-		    *sizeof_buf += repeat;
-		    *buf_p = (char *) xrealloc (*buf_p, *sizeof_buf);
-		    buf = *buf_p;
+		    buf_p->resize (buf_p->size () + repeat);
+		    buf = buf_p->data ();
 		  }
 
 		memset (&buf[bc], buf[bc - 1], repeat);
@@ -9482,12 +9484,11 @@  remote_target::read_frame (char **buf_p, long *sizeof_buf)
 	    return -1;
 	  }
 	default:
-	  if (bc >= *sizeof_buf - 1)
+	  if (bc >= buf_p->size () - 1)
 	    {
 	      /* Make some more room in the buffer.  */
-	      *sizeof_buf *= 2;
-	      *buf_p = (char *) xrealloc (*buf_p, *sizeof_buf);
-	      buf = *buf_p;
+	      buf_p->resize (buf_p->size () * 2);
+	      buf = buf_p->data ();
 	    }
 
 	  buf[bc++] = c;
@@ -9498,36 +9499,35 @@  remote_target::read_frame (char **buf_p, long *sizeof_buf)
 }
 
 /* Read a packet from the remote machine, with error checking, and
-   store it in *BUF.  Resize *BUF using xrealloc if necessary to hold
-   the result, and update *SIZEOF_BUF.  If FOREVER, wait forever
-   rather than timing out; this is used (in synchronous mode) to wait
-   for a target that is is executing user code to stop.  */
+   store it in *BUF.  Resize *BUF if necessary to hold the result.  If
+   FOREVER, wait forever rather than timing out; this is used (in
+   synchronous mode) to wait for a target that is is executing user
+   code to stop.  */
 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
    don't have to change all the calls to getpkt to deal with the
    return value, because at the moment I don't know what the right
    thing to do it for those.  */
 
 void
-remote_target::getpkt (char **buf, long *sizeof_buf, int forever)
+remote_target::getpkt (gdb::char_vector *buf, int forever)
 {
-  getpkt_sane (buf, sizeof_buf, forever);
+  getpkt_sane (buf, forever);
 }
 
 
 /* Read a packet from the remote machine, with error checking, and
-   store it in *BUF.  Resize *BUF using xrealloc if necessary to hold
-   the result, and update *SIZEOF_BUF.  If FOREVER, wait forever
-   rather than timing out; this is used (in synchronous mode) to wait
-   for a target that is is executing user code to stop.  If FOREVER ==
-   0, this function is allowed to time out gracefully and return an
-   indication of this to the caller.  Otherwise return the number of
-   bytes read.  If EXPECTING_NOTIF, consider receiving a notification
-   enough reason to return to the caller.  *IS_NOTIF is an output
-   boolean that indicates whether *BUF holds a notification or not
-   (a regular packet).  */
+   store it in *BUF.  Resize *BUF if necessary to hold the result.  If
+   FOREVER, wait forever rather than timing out; this is used (in
+   synchronous mode) to wait for a target that is is executing user
+   code to stop.  If FOREVER == 0, this function is allowed to time
+   out gracefully and return an indication of this to the caller.
+   Otherwise return the number of bytes read.  If EXPECTING_NOTIF,
+   consider receiving a notification enough reason to return to the
+   caller.  *IS_NOTIF is an output boolean that indicates whether *BUF
+   holds a notification or not (a regular packet).  */
 
 int
-remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf,
+remote_target::getpkt_or_notif_sane_1 (gdb::char_vector *buf,
 				       int forever, int expecting_notif,
 				       int *is_notif)
 {
@@ -9541,7 +9541,7 @@  remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf,
      previously cached response.  */
   rs->cached_wait_status = 0;
 
-  strcpy (*buf, "timeout");
+  strcpy (buf->data (), "timeout");
 
   if (forever)
     timeout = watchdog > 0 ? watchdog : -1;
@@ -9594,7 +9594,7 @@  remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf,
 	    {
 	      /* We've found the start of a packet or notification.
 		 Now collect the data.  */
-	      val = read_frame (buf, sizeof_buf);
+	      val = read_frame (buf);
 	      if (val >= 0)
 		break;
 	    }
@@ -9620,7 +9620,7 @@  remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf,
 	  if (remote_debug)
 	    {
 	      std::string str
-		= escape_buffer (*buf,
+		= escape_buffer (buf->data (),
 				 std::min (val, REMOTE_DEBUG_MAX_CHAR));
 
 	      fprintf_unfiltered (gdb_stdlog, "Packet received: %s",
@@ -9649,7 +9649,7 @@  remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf,
 
 	  if (remote_debug)
 	    {
-	      std::string str = escape_buffer (*buf, val);
+	      std::string str = escape_buffer (buf->data (), val);
 
 	      fprintf_unfiltered (gdb_stdlog,
 				  "  Notification received: %s\n",
@@ -9658,7 +9658,7 @@  remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf,
 	  if (is_notif != NULL)
 	    *is_notif = 1;
 
-	  handle_notification (rs->notif_state, *buf);
+	  handle_notification (rs->notif_state, buf->data ());
 
 	  /* Notifications require no acknowledgement.  */
 
@@ -9669,17 +9669,16 @@  remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf,
 }
 
 int
-remote_target::getpkt_sane (char **buf, long *sizeof_buf, int forever)
+remote_target::getpkt_sane (gdb::char_vector *buf, int forever)
 {
-  return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 0, NULL);
+  return getpkt_or_notif_sane_1 (buf, forever, 0, NULL);
 }
 
 int
-remote_target::getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever,
+remote_target::getpkt_or_notif_sane (gdb::char_vector *buf, int forever,
 				     int *is_notif)
 {
-  return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 1,
-				 is_notif);
+  return getpkt_or_notif_sane_1 (buf, forever, 1, is_notif);
 }
 
 /* Kill any new fork children of process PID that haven't been
@@ -9780,9 +9779,9 @@  remote_target::remote_vkill (int pid)
   remote_state *rs = get_remote_state ();
 
   /* Tell the remote target to detach.  */
-  xsnprintf (rs->buf, get_remote_packet_size (), "vKill;%x", pid);
+  xsnprintf (rs->buf.data (), get_remote_packet_size (), "vKill;%x", pid);
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   switch (packet_ok (rs->buf,
 		     &remote_protocol_packets[PACKET_vKill]))
@@ -9888,7 +9887,7 @@  remote_target::mourn_inferior ()
 	  /* Check whether the target is running now - some remote stubs
 	     automatically restart after kill.	*/
 	  putpkt ("?");
-	  getpkt (&rs->buf, &rs->buf_size, 0);
+	  getpkt (&rs->buf, 0);
 
 	  if (rs->buf[0] == 'S' || rs->buf[0] == 'T')
 	    {
@@ -9914,8 +9913,8 @@  remote_target::extended_remote_disable_randomization (int val)
   struct remote_state *rs = get_remote_state ();
   char *reply;
 
-  xsnprintf (rs->buf, get_remote_packet_size (), "QDisableRandomization:%x",
-	     val);
+  xsnprintf (rs->buf.data (), get_remote_packet_size (),
+	     "QDisableRandomization:%x", val);
   putpkt (rs->buf);
   reply = remote_get_noisy_reply ();
   if (*reply == '\0')
@@ -9936,12 +9935,12 @@  remote_target::extended_remote_run (const std::string &args)
   if (packet_support (PACKET_vRun) == PACKET_DISABLE)
     return -1;
 
-  strcpy (rs->buf, "vRun;");
-  len = strlen (rs->buf);
+  strcpy (rs->buf.data (), "vRun;");
+  len = strlen (rs->buf.data ());
 
   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,
+  len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf.data () + len,
 		      strlen (remote_exec_file));
 
   if (!args.empty ())
@@ -9954,7 +9953,7 @@  remote_target::extended_remote_run (const std::string &args)
 	  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,
+	  len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf.data () + len,
 			      strlen (argv[i]));
 	}
     }
@@ -9962,7 +9961,7 @@  remote_target::extended_remote_run (const std::string &args)
   rs->buf[len++] = '\0';
 
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun]))
     {
@@ -10000,12 +9999,12 @@  remote_target::send_environment_packet (const char *action,
   std::string encoded_value = bin2hex ((const gdb_byte *) value,
 					 strlen (value));
 
-  xsnprintf (rs->buf, get_remote_packet_size (),
+  xsnprintf (rs->buf.data (), get_remote_packet_size (),
 	     "%s:%s", packet, encoded_value.c_str ());
 
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
-  if (strcmp (rs->buf, "OK") != 0)
+  getpkt (&rs->buf, 0);
+  if (strcmp (rs->buf.data (), "OK") != 0)
     warning (_("Unable to %s environment variable '%s' on remote."),
 	     action, value);
 }
@@ -10020,8 +10019,8 @@  remote_target::extended_remote_environment_support ()
   if (packet_support (PACKET_QEnvironmentReset) != PACKET_DISABLE)
     {
       putpkt ("QEnvironmentReset");
-      getpkt (&rs->buf, &rs->buf_size, 0);
-      if (strcmp (rs->buf, "OK") != 0)
+      getpkt (&rs->buf, 0);
+      if (strcmp (rs->buf.data (), "OK") != 0)
 	warning (_("Unable to reset environment on remote."));
     }
 
@@ -10053,26 +10052,26 @@  remote_target::extended_remote_set_inferior_cwd ()
 	  std::string hexpath = bin2hex ((const gdb_byte *) inferior_cwd,
 					 strlen (inferior_cwd));
 
-	  xsnprintf (rs->buf, get_remote_packet_size (),
+	  xsnprintf (rs->buf.data (), get_remote_packet_size (),
 		     "QSetWorkingDir:%s", hexpath.c_str ());
 	}
       else
 	{
 	  /* An empty inferior_cwd means that the user wants us to
 	     reset the remote server's inferior's cwd.  */
-	  xsnprintf (rs->buf, get_remote_packet_size (),
+	  xsnprintf (rs->buf.data (), get_remote_packet_size (),
 		     "QSetWorkingDir:");
 	}
 
       putpkt (rs->buf);
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
       if (packet_ok (rs->buf,
 		     &remote_protocol_packets[PACKET_QSetWorkingDir])
 	  != PACKET_OK)
 	error (_("\
 Remote replied unexpectedly while setting the inferior's working\n\
 directory: %s"),
-	       rs->buf);
+	       rs->buf.data ());
 
     }
 }
@@ -10106,14 +10105,14 @@  extended_remote_target::create_inferior (const char *exec_file,
      remote inferior using a shell.  */
   if (packet_support (PACKET_QStartupWithShell) != PACKET_DISABLE)
     {
-      xsnprintf (rs->buf, get_remote_packet_size (),
+      xsnprintf (rs->buf.data (), get_remote_packet_size (),
 		 "QStartupWithShell:%d", startup_with_shell ? 1 : 0);
       putpkt (rs->buf);
-      getpkt (&rs->buf, &rs->buf_size, 0);
-      if (strcmp (rs->buf, "OK") != 0)
+      getpkt (&rs->buf, 0);
+      if (strcmp (rs->buf.data (), "OK") != 0)
 	error (_("\
 Remote replied unexpectedly while setting startup-with-shell: %s"),
-	       rs->buf);
+	       rs->buf.data ());
     }
 
   extended_remote_environment_support ();
@@ -10136,7 +10135,7 @@  Remote replied unexpectedly while setting startup-with-shell: %s"),
     }
 
   /* vRun's success return is a stop reply.  */
-  stop_reply = run_worked ? rs->buf : NULL;
+  stop_reply = run_worked ? rs->buf.data () : NULL;
   add_current_inferior_and_thread (stop_reply);
 
   /* Get updated offsets, if the stub uses qOffsets.  */
@@ -10222,8 +10221,8 @@  remote_target::insert_breakpoint (struct gdbarch *gdbarch,
 	set_general_process ();
 
       rs = get_remote_state ();
-      p = rs->buf;
-      endbuf = rs->buf + get_remote_packet_size ();
+      p = rs->buf.data ();
+      endbuf = p + get_remote_packet_size ();
 
       *(p++) = 'Z';
       *(p++) = '0';
@@ -10239,7 +10238,7 @@  remote_target::insert_breakpoint (struct gdbarch *gdbarch,
 	remote_add_target_side_commands (gdbarch, bp_tgt, p);
 
       putpkt (rs->buf);
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
 
       switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
 	{
@@ -10271,8 +10270,8 @@  remote_target::remove_breakpoint (struct gdbarch *gdbarch,
 
   if (packet_support (PACKET_Z0) != PACKET_DISABLE)
     {
-      char *p = rs->buf;
-      char *endbuf = rs->buf + get_remote_packet_size ();
+      char *p = rs->buf.data ();
+      char *endbuf = p + get_remote_packet_size ();
 
       /* Make sure the remote is pointing at the right process, if
 	 necessary.  */
@@ -10288,7 +10287,7 @@  remote_target::remove_breakpoint (struct gdbarch *gdbarch,
       xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind);
 
       putpkt (rs->buf);
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
 
       return (rs->buf[0] == 'E');
     }
@@ -10321,7 +10320,7 @@  remote_target::insert_watchpoint (CORE_ADDR addr, int len,
 				  enum target_hw_bp_type type, struct expression *cond)
 {
   struct remote_state *rs = get_remote_state ();
-  char *endbuf = rs->buf + get_remote_packet_size ();
+  char *endbuf = rs->buf.data () + get_remote_packet_size ();
   char *p;
   enum Z_packet_type packet = watchpoint_to_Z_packet (type);
 
@@ -10333,14 +10332,14 @@  remote_target::insert_watchpoint (CORE_ADDR addr, int len,
   if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
     set_general_process ();
 
-  xsnprintf (rs->buf, endbuf - rs->buf, "Z%x,", packet);
-  p = strchr (rs->buf, '\0');
+  xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "Z%x,", packet);
+  p = strchr (rs->buf.data (), '\0');
   addr = remote_address_masked (addr);
   p += hexnumstr (p, (ULONGEST) addr);
   xsnprintf (p, endbuf - p, ",%x", len);
 
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
     {
@@ -10370,7 +10369,7 @@  remote_target::remove_watchpoint (CORE_ADDR addr, int len,
 				  enum target_hw_bp_type type, struct expression *cond)
 {
   struct remote_state *rs = get_remote_state ();
-  char *endbuf = rs->buf + get_remote_packet_size ();
+  char *endbuf = rs->buf.data () + get_remote_packet_size ();
   char *p;
   enum Z_packet_type packet = watchpoint_to_Z_packet (type);
 
@@ -10382,13 +10381,13 @@  remote_target::remove_watchpoint (CORE_ADDR addr, int len,
   if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
     set_general_process ();
 
-  xsnprintf (rs->buf, endbuf - rs->buf, "z%x,", packet);
-  p = strchr (rs->buf, '\0');
+  xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "z%x,", packet);
+  p = strchr (rs->buf.data (), '\0');
   addr = remote_address_masked (addr);
   p += hexnumstr (p, (ULONGEST) addr);
   xsnprintf (p, endbuf - p, ",%x", len);
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
     {
@@ -10533,8 +10532,8 @@  remote_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
     set_general_process ();
 
   rs = get_remote_state ();
-  p = rs->buf;
-  endbuf = rs->buf + get_remote_packet_size ();
+  p = rs->buf.data ();
+  endbuf = p + get_remote_packet_size ();
 
   *(p++) = 'Z';
   *(p++) = '1';
@@ -10551,14 +10550,14 @@  remote_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
     remote_add_target_side_commands (gdbarch, bp_tgt, p);
 
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
     {
     case PACKET_ERROR:
       if (rs->buf[1] == '.')
         {
-          message = strchr (rs->buf + 2, '.');
+          message = strchr (&rs->buf[2], '.');
           if (message)
             error (_("Remote failure reply: %s"), message + 1);
         }
@@ -10579,8 +10578,8 @@  remote_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
 {
   CORE_ADDR addr;
   struct remote_state *rs = get_remote_state ();
-  char *p = rs->buf;
-  char *endbuf = rs->buf + get_remote_packet_size ();
+  char *p = rs->buf.data ();
+  char *endbuf = p + get_remote_packet_size ();
 
   if (packet_support (PACKET_Z1) == PACKET_DISABLE)
     return -1;
@@ -10599,7 +10598,7 @@  remote_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
   xsnprintf (p, endbuf  - p, ",%x", bp_tgt->kind);
 
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
     {
@@ -10632,7 +10631,7 @@  remote_target::verify_memory (const gdb_byte *data, CORE_ADDR lma, ULONGEST size
       set_general_process ();
 
       /* FIXME: assumes lma can fit into long.  */
-      xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
+      xsnprintf (rs->buf.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
 		 (long) lma, (long) size);
       putpkt (rs->buf);
 
@@ -10640,7 +10639,7 @@  remote_target::verify_memory (const gdb_byte *data, CORE_ADDR lma, ULONGEST size
 	 reply.  */
       host_crc = xcrc32 (data, size, 0xffffffff);
 
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
 
       result = packet_ok (rs->buf,
 			  &remote_protocol_packets[PACKET_qCRC]);
@@ -10752,7 +10751,7 @@  remote_target::remote_write_qxfer (const char *object_name,
     return TARGET_XFER_E_IO;
 
   /* Insert header.  */
-  i = snprintf (rs->buf, max_size, 
+  i = snprintf (rs->buf.data (), max_size, 
 		"qXfer:%s:write:%s:%s:",
 		object_name, annex ? annex : "",
 		phex_nz (offset, sizeof offset));
@@ -10760,14 +10759,14 @@  remote_target::remote_write_qxfer (const char *object_name,
 
   /* Escape as much data as fits into rs->buf.  */
   buf_len = remote_escape_output 
-    (writebuf, len, 1, (gdb_byte *) rs->buf + i, &max_size, max_size);
+    (writebuf, len, 1, (gdb_byte *) rs->buf.data () + i, &max_size, max_size);
 
-  if (putpkt_binary (rs->buf, i + buf_len) < 0
-      || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
+  if (putpkt_binary (rs->buf.data (), i + buf_len) < 0
+      || getpkt_sane (&rs->buf, 0) < 0
       || packet_ok (rs->buf, packet) != PACKET_OK)
     return TARGET_XFER_E_IO;
 
-  unpack_varlen_hex (rs->buf, &n);
+  unpack_varlen_hex (rs->buf.data (), &n);
 
   *xfered_len = n;
   return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
@@ -10817,7 +10816,8 @@  remote_target::remote_read_qxfer (const char *object_name,
      the target is free to respond with slightly less data.  We subtract
      five to account for the response type and the protocol frame.  */
   n = std::min<LONGEST> (get_remote_packet_size () - 5, len);
-  snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
+  snprintf (rs->buf.data (), get_remote_packet_size () - 4,
+	    "qXfer:%s:read:%s:%s,%s",
 	    object_name, annex ? annex : "",
 	    phex_nz (offset, sizeof offset),
 	    phex_nz (n, sizeof n));
@@ -10826,12 +10826,12 @@  remote_target::remote_read_qxfer (const char *object_name,
     return TARGET_XFER_E_IO;
 
   rs->buf[0] = '\0';
-  packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0);
+  packet_len = getpkt_sane (&rs->buf, 0);
   if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
     return TARGET_XFER_E_IO;
 
   if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
-    error (_("Unknown remote qXfer reply: %s"), rs->buf);
+    error (_("Unknown remote qXfer reply: %s"), rs->buf.data ());
 
   /* 'm' means there is (or at least might be) more data after this
      batch.  That does not make sense unless there's at least one byte
@@ -10840,7 +10840,7 @@  remote_target::remote_read_qxfer (const char *object_name,
     error (_("Remote qXfer reply contained no data."));
 
   /* Got some data.  */
-  i = remote_unescape_input ((gdb_byte *) rs->buf + 1,
+  i = remote_unescape_input ((gdb_byte *) rs->buf.data () + 1,
 			     packet_len - 1, readbuf, n);
 
   /* 'l' is an EOF marker, possibly including a final block of data,
@@ -11044,7 +11044,7 @@  remote_target::xfer_partial (enum target_object object,
   gdb_assert (annex != NULL);
   gdb_assert (readbuf != NULL);
 
-  p2 = rs->buf;
+  p2 = rs->buf.data ();
   *p2++ = 'q';
   *p2++ = query_type;
 
@@ -11068,8 +11068,8 @@  remote_target::xfer_partial (enum target_object object,
   if (i < 0)
     return TARGET_XFER_E_IO;
 
-  getpkt (&rs->buf, &rs->buf_size, 0);
-  strcpy ((char *) readbuf, rs->buf);
+  getpkt (&rs->buf, 0);
+  strcpy ((char *) readbuf, rs->buf.data ());
 
   *xfered_len = strlen ((char *) readbuf);
   return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
@@ -11129,7 +11129,7 @@  remote_target::search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
   set_general_process ();
 
   /* Insert header.  */
-  i = snprintf (rs->buf, max_size, 
+  i = snprintf (rs->buf.data (), max_size, 
 		"qSearch:memory:%s;%s;",
 		phex_nz (start_addr, addr_size),
 		phex_nz (search_space_len, sizeof (search_space_len)));
@@ -11137,15 +11137,16 @@  remote_target::search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
 
   /* Escape as much data as fits into rs->buf.  */
   escaped_pattern_len =
-    remote_escape_output (pattern, pattern_len, 1, (gdb_byte *) rs->buf + i,
+    remote_escape_output (pattern, pattern_len, 1,
+			  (gdb_byte *) rs->buf.data () + i,
 			  &used_pattern_len, max_size);
 
   /* Bail if the pattern is too large.  */
   if (used_pattern_len != pattern_len)
     error (_("Pattern is too large to transmit to remote target."));
 
-  if (putpkt_binary (rs->buf, i + escaped_pattern_len) < 0
-      || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
+  if (putpkt_binary (rs->buf.data (), i + escaped_pattern_len) < 0
+      || getpkt_sane (&rs->buf, 0) < 0
       || packet_ok (rs->buf, packet) != PACKET_OK)
     {
       /* The request may not have worked because the command is not
@@ -11164,12 +11165,12 @@  remote_target::search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
     {
       found = 1;
       if (rs->buf[1] != ',')
-	error (_("Unknown qSearch:memory reply: %s"), rs->buf);
-      unpack_varlen_hex (rs->buf + 2, &found_addr);
+	error (_("Unknown qSearch:memory reply: %s"), rs->buf.data ());
+      unpack_varlen_hex (&rs->buf[2], &found_addr);
       *found_addrp = found_addr;
     }
   else
-    error (_("Unknown qSearch:memory reply: %s"), rs->buf);
+    error (_("Unknown qSearch:memory reply: %s"), rs->buf.data ());
 
   return found;
 }
@@ -11178,7 +11179,7 @@  void
 remote_target::rcmd (const char *command, struct ui_file *outbuf)
 {
   struct remote_state *rs = get_remote_state ();
-  char *p = rs->buf;
+  char *p = rs->buf.data ();
 
   if (!rs->remote_desc)
     error (_("remote rcmd is only available after target open"));
@@ -11188,10 +11189,10 @@  remote_target::rcmd (const char *command, struct ui_file *outbuf)
     command = "";
 
   /* The query prefix.  */
-  strcpy (rs->buf, "qRcmd,");
-  p = strchr (rs->buf, '\0');
+  strcpy (rs->buf.data (), "qRcmd,");
+  p = strchr (rs->buf.data (), '\0');
 
-  if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/)
+  if ((strlen (rs->buf.data ()) + strlen (command) * 2 + 8/*misc*/)
       > get_remote_packet_size ())
     error (_("\"monitor\" command ``%s'' is too long."), command);
 
@@ -11209,7 +11210,7 @@  remote_target::rcmd (const char *command, struct ui_file *outbuf)
       /* XXX - see also remote_get_noisy_reply().  */
       QUIT;			/* Allow user to bail out with ^C.  */
       rs->buf[0] = '\0';
-      if (getpkt_sane (&rs->buf, &rs->buf_size, 0) == -1)
+      if (getpkt_sane (&rs->buf, 0) == -1)
         { 
           /* Timeout.  Continue to (try to) read responses.
              This is better than stopping with an error, assuming the stub
@@ -11218,7 +11219,7 @@  remote_target::rcmd (const char *command, struct ui_file *outbuf)
              an effect similar to stop on timeout.  */
           continue;
         }
-      buf = rs->buf;
+      buf = rs->buf.data ();
       if (buf[0] == '\0')
 	error (_("Target does not support this command."));
       if (buf[0] == 'O' && buf[1] != 'K')
@@ -11280,9 +11281,9 @@  remote_target::packet_command (const char *args, int from_tty)
 
   remote_state *rs = get_remote_state ();
 
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
   puts_filtered ("received: ");
-  print_packet (rs->buf);
+  print_packet (rs->buf.data ());
   puts_filtered ("\n");
 }
 
@@ -11493,8 +11494,8 @@  remote_target::get_thread_local_address (ptid_t ptid, CORE_ADDR lm,
   if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE)
     {
       struct remote_state *rs = get_remote_state ();
-      char *p = rs->buf;
-      char *endp = rs->buf + get_remote_packet_size ();
+      char *p = rs->buf.data ();
+      char *endp = p + get_remote_packet_size ();
       enum packet_result result;
 
       strcpy (p, "qGetTLSAddr:");
@@ -11507,14 +11508,14 @@  remote_target::get_thread_local_address (ptid_t ptid, CORE_ADDR lm,
       *p++ = '\0';
 
       putpkt (rs->buf);
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
       result = packet_ok (rs->buf,
 			  &remote_protocol_packets[PACKET_qGetTLSAddr]);
       if (result == PACKET_OK)
 	{
 	  ULONGEST addr;
 
-	  unpack_varlen_hex (rs->buf, &addr);
+	  unpack_varlen_hex (rs->buf.data (), &addr);
 	  return addr;
 	}
       else if (result == PACKET_UNKNOWN)
@@ -11540,8 +11541,8 @@  remote_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr)
   if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE)
     {
       struct remote_state *rs = get_remote_state ();
-      char *p = rs->buf;
-      char *endp = rs->buf + get_remote_packet_size ();
+      char *p = rs->buf.data ();
+      char *endp = p + get_remote_packet_size ();
       enum packet_result result;
 
       strcpy (p, "qGetTIBAddr:");
@@ -11550,13 +11551,13 @@  remote_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr)
       *p++ = '\0';
 
       putpkt (rs->buf);
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
       result = packet_ok (rs->buf,
 			  &remote_protocol_packets[PACKET_qGetTIBAddr]);
       if (result == PACKET_OK)
 	{
 	  ULONGEST val;
-	  unpack_varlen_hex (rs->buf, &val);
+	  unpack_varlen_hex (rs->buf.data (), &val);
 	  if (addr)
 	    *addr = (CORE_ADDR) val;
 	  return true;
@@ -11811,8 +11812,8 @@  remote_target::remote_hostio_send_command (int command_bytes, int which_packet,
       return -1;
     }
 
-  putpkt_binary (rs->buf, command_bytes);
-  bytes_read = getpkt_sane (&rs->buf, &rs->buf_size, 0);
+  putpkt_binary (rs->buf.data (), command_bytes);
+  bytes_read = getpkt_sane (&rs->buf, 0);
 
   /* If it timed out, something is wrong.  Don't try to parse the
      buffer.  */
@@ -11834,7 +11835,7 @@  remote_target::remote_hostio_send_command (int command_bytes, int which_packet,
       break;
     }
 
-  if (remote_hostio_parse_result (rs->buf, &ret, remote_errno,
+  if (remote_hostio_parse_result (rs->buf.data (), &ret, remote_errno,
 				  &attachment_tmp))
     {
       *remote_errno = FILEIO_EINVAL;
@@ -11854,7 +11855,7 @@  remote_target::remote_hostio_send_command (int command_bytes, int which_packet,
   if (attachment_tmp != NULL)
     {
       *attachment = attachment_tmp;
-      *attachment_len = bytes_read - (*attachment - rs->buf);
+      *attachment_len = bytes_read - (*attachment - rs->buf.data ());
     }
 
   return ret;
@@ -11887,7 +11888,7 @@  remote_target::remote_hostio_set_filesystem (struct inferior *inf,
 {
   struct remote_state *rs = get_remote_state ();
   int required_pid = (inf == NULL || inf->fake_pid_p) ? 0 : inf->pid;
-  char *p = rs->buf;
+  char *p = rs->buf.data ();
   int left = get_remote_packet_size () - 1;
   char arg[9];
   int ret;
@@ -11903,7 +11904,7 @@  remote_target::remote_hostio_set_filesystem (struct inferior *inf,
   xsnprintf (arg, sizeof (arg), "%x", required_pid);
   remote_buffer_add_string (&p, &left, arg);
 
-  ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_setfs,
+  ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_setfs,
 				    remote_errno, NULL, NULL);
 
   if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
@@ -11923,7 +11924,7 @@  remote_target::remote_hostio_open (inferior *inf, const char *filename,
 				   int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();
-  char *p = rs->buf;
+  char *p = rs->buf.data ();
   int left = get_remote_packet_size () - 1;
 
   if (warn_if_slow)
@@ -11956,7 +11957,7 @@  remote_target::remote_hostio_open (inferior *inf, const char *filename,
 
   remote_buffer_add_int (&p, &left, mode);
 
-  return remote_hostio_send_command (p - rs->buf, PACKET_vFile_open,
+  return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_open,
 				     remote_errno, NULL, NULL);
 }
 
@@ -11976,7 +11977,7 @@  remote_target::remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
 				     ULONGEST offset, int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();
-  char *p = rs->buf;
+  char *p = rs->buf.data ();
   int left = get_remote_packet_size ();
   int out_len;
 
@@ -11991,9 +11992,10 @@  remote_target::remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
   remote_buffer_add_string (&p, &left, ",");
 
   p += remote_escape_output (write_buf, len, 1, (gdb_byte *) p, &out_len,
-			     get_remote_packet_size () - (p - rs->buf));
+			     (get_remote_packet_size ()
+			      - (p - rs->buf.data ())));
 
-  return remote_hostio_send_command (p - rs->buf, PACKET_vFile_pwrite,
+  return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pwrite,
 				     remote_errno, NULL, NULL);
 }
 
@@ -12012,7 +12014,7 @@  remote_target::remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len,
 					  ULONGEST offset, int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();
-  char *p = rs->buf;
+  char *p = rs->buf.data ();
   char *attachment;
   int left = get_remote_packet_size ();
   int ret, attachment_len;
@@ -12028,7 +12030,7 @@  remote_target::remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len,
 
   remote_buffer_add_int (&p, &left, offset);
 
-  ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_pread,
+  ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pread,
 				    remote_errno, &attachment,
 				    &attachment_len);
 
@@ -12121,7 +12123,7 @@  int
 remote_target::remote_hostio_close (int fd, int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();
-  char *p = rs->buf;
+  char *p = rs->buf.data ();
   int left = get_remote_packet_size () - 1;
 
   rs->readahead_cache.invalidate_fd (fd);
@@ -12130,7 +12132,7 @@  remote_target::remote_hostio_close (int fd, int *remote_errno)
 
   remote_buffer_add_int (&p, &left, fd);
 
-  return remote_hostio_send_command (p - rs->buf, PACKET_vFile_close,
+  return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_close,
 				     remote_errno, NULL, NULL);
 }
 
@@ -12147,7 +12149,7 @@  remote_target::remote_hostio_unlink (inferior *inf, const char *filename,
 				     int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();
-  char *p = rs->buf;
+  char *p = rs->buf.data ();
   int left = get_remote_packet_size () - 1;
 
   if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
@@ -12158,7 +12160,7 @@  remote_target::remote_hostio_unlink (inferior *inf, const char *filename,
   remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
 			   strlen (filename));
 
-  return remote_hostio_send_command (p - rs->buf, PACKET_vFile_unlink,
+  return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_unlink,
 				     remote_errno, NULL, NULL);
 }
 
@@ -12176,7 +12178,7 @@  remote_target::fileio_readlink (struct inferior *inf, const char *filename,
 				int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();
-  char *p = rs->buf;
+  char *p = rs->buf.data ();
   char *attachment;
   int left = get_remote_packet_size ();
   int len, attachment_len;
@@ -12190,7 +12192,7 @@  remote_target::fileio_readlink (struct inferior *inf, const char *filename,
   remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
 			   strlen (filename));
 
-  len = remote_hostio_send_command (p - rs->buf, PACKET_vFile_readlink,
+  len = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_readlink,
 				    remote_errno, &attachment,
 				    &attachment_len);
 
@@ -12213,7 +12215,7 @@  int
 remote_target::fileio_fstat (int fd, struct stat *st, int *remote_errno)
 {
   struct remote_state *rs = get_remote_state ();
-  char *p = rs->buf;
+  char *p = rs->buf.data ();
   int left = get_remote_packet_size ();
   int attachment_len, ret;
   char *attachment;
@@ -12224,7 +12226,7 @@  remote_target::fileio_fstat (int fd, struct stat *st, int *remote_errno)
 
   remote_buffer_add_int (&p, &left, fd);
 
-  ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_fstat,
+  ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_fstat,
 				    remote_errno, &attachment,
 				    &attachment_len);
   if (ret < 0)
@@ -12737,7 +12739,7 @@  remote_target::trace_init ()
 
   putpkt ("QTinit");
   remote_get_noisy_reply ();
-  if (strcmp (rs->buf, "OK") != 0)
+  if (strcmp (rs->buf.data (), "OK") != 0)
     error (_("Target does not support this command."));
 }
 
@@ -12754,13 +12756,13 @@  remote_target::remote_download_command_source (int num, ULONGEST addr,
   for (cmd = cmds; cmd; cmd = cmd->next)
     {
       QUIT;	/* Allow user to bail out with ^C.  */
-      strcpy (rs->buf, "QTDPsrc:");
+      strcpy (rs->buf.data (), "QTDPsrc:");
       encode_source_string (num, addr, "cmd", cmd->line,
-			    rs->buf + strlen (rs->buf),
-			    rs->buf_size - strlen (rs->buf));
+			    rs->buf.data () + strlen (rs->buf.data ()),
+			    rs->buf.size () - strlen (rs->buf.data ()));
       putpkt (rs->buf);
       remote_get_noisy_reply ();
-      if (strcmp (rs->buf, "OK"))
+      if (strcmp (rs->buf.data (), "OK"))
 	warning (_("Target does not support source download."));
 
       if (cmd->control_type == while_control
@@ -12769,13 +12771,13 @@  remote_target::remote_download_command_source (int num, ULONGEST addr,
 	  remote_download_command_source (num, addr, cmd->body_list_0.get ());
 
 	  QUIT;	/* Allow user to bail out with ^C.  */
-	  strcpy (rs->buf, "QTDPsrc:");
+	  strcpy (rs->buf.data (), "QTDPsrc:");
 	  encode_source_string (num, addr, "cmd", "end",
-				rs->buf + strlen (rs->buf),
-				rs->buf_size - strlen (rs->buf));
+				rs->buf.data () + strlen (rs->buf.data ()),
+				rs->buf.size () - strlen (rs->buf.data ()));
 	  putpkt (rs->buf);
 	  remote_get_noisy_reply ();
-	  if (strcmp (rs->buf, "OK"))
+	  if (strcmp (rs->buf.data (), "OK"))
 	    warning (_("Target does not support source download."));
 	}
     }
@@ -12923,7 +12925,7 @@  remote_target::download_tracepoint (struct bp_location *loc)
 
   putpkt (buf.data ());
   remote_get_noisy_reply ();
-  if (strcmp (rs->buf, "OK"))
+  if (strcmp (rs->buf.data (), "OK"))
     error (_("Target does not support tracepoints."));
 
   /* do_single_steps (t); */
@@ -12945,7 +12947,7 @@  remote_target::download_tracepoint (struct bp_location *loc)
 
       putpkt (buf.data ());
       remote_get_noisy_reply ();
-      if (strcmp (rs->buf, "OK"))
+      if (strcmp (rs->buf.data (), "OK"))
 	error (_("Error on target while setting tracepoints."));
     }
 
@@ -12968,7 +12970,7 @@  remote_target::download_tracepoint (struct bp_location *loc)
 
       putpkt (buf.data ());
       remote_get_noisy_reply ();
-      if (strcmp (rs->buf, "OK"))
+      if (strcmp (rs->buf.data (), "OK"))
 	error (_("Error on target while setting tracepoints."));
     }
 
@@ -12987,7 +12989,7 @@  remote_target::download_tracepoint (struct bp_location *loc)
 				buf.size () - strlen (buf.data ()));
 	  putpkt (buf.data ());
 	  remote_get_noisy_reply ();
-	  if (strcmp (rs->buf, "OK"))
+	  if (strcmp (rs->buf.data (), "OK"))
 	    warning (_("Target does not support source download."));
 	}
       if (b->cond_string)
@@ -13003,7 +13005,7 @@  remote_target::download_tracepoint (struct bp_location *loc)
 				buf.size () - strlen (buf.data ()));
 	  putpkt (buf.data ());
 	  remote_get_noisy_reply ();
-	  if (strcmp (rs->buf, "OK"))
+	  if (strcmp (rs->buf.data (), "OK"))
 	    warning (_("Target does not support source download."));
 	}
       remote_download_command_source (b->number, loc->address,
@@ -13045,19 +13047,20 @@  remote_target::download_trace_state_variable (const trace_state_variable &tsv)
   struct remote_state *rs = get_remote_state ();
   char *p;
 
-  xsnprintf (rs->buf, get_remote_packet_size (), "QTDV:%x:%s:%x:",
+  xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
 	     tsv.number, phex ((ULONGEST) tsv.initial_value, 8),
 	     tsv.builtin);
-  p = rs->buf + strlen (rs->buf);
-  if ((p - rs->buf) + tsv.name.length () * 2 >= get_remote_packet_size ())
+  p = rs->buf.data () + strlen (rs->buf.data ());
+  if ((p - rs->buf.data ()) + tsv.name.length () * 2
+      >= get_remote_packet_size ())
     error (_("Trace state variable name too long for tsv definition packet"));
   p += 2 * bin2hex ((gdb_byte *) (tsv.name.data ()), p, tsv.name.length ());
   *p++ = '\0';
   putpkt (rs->buf);
   remote_get_noisy_reply ();
-  if (*rs->buf == '\0')
+  if (rs->buf[0] == '\0')
     error (_("Target does not support this command."));
-  if (strcmp (rs->buf, "OK") != 0)
+  if (strcmp (rs->buf.data (), "OK") != 0)
     error (_("Error on target while downloading trace state variable."));
 }
 
@@ -13068,13 +13071,13 @@  remote_target::enable_tracepoint (struct bp_location *location)
   char addr_buf[40];
 
   sprintf_vma (addr_buf, location->address);
-  xsnprintf (rs->buf, get_remote_packet_size (), "QTEnable:%x:%s",
+  xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTEnable:%x:%s",
 	     location->owner->number, addr_buf);
   putpkt (rs->buf);
   remote_get_noisy_reply ();
-  if (*rs->buf == '\0')
+  if (rs->buf[0] == '\0')
     error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
-  if (strcmp (rs->buf, "OK") != 0)
+  if (strcmp (rs->buf.data (), "OK") != 0)
     error (_("Error on target while enabling tracepoint."));
 }
 
@@ -13085,13 +13088,13 @@  remote_target::disable_tracepoint (struct bp_location *location)
   char addr_buf[40];
 
   sprintf_vma (addr_buf, location->address);
-  xsnprintf (rs->buf, get_remote_packet_size (), "QTDisable:%x:%s",
+  xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDisable:%x:%s",
 	     location->owner->number, addr_buf);
   putpkt (rs->buf);
   remote_get_noisy_reply ();
-  if (*rs->buf == '\0')
+  if (rs->buf[0] == '\0')
     error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
-  if (strcmp (rs->buf, "OK") != 0)
+  if (strcmp (rs->buf.data (), "OK") != 0)
     error (_("Error on target while disabling tracepoint."));
 }
 
@@ -13110,8 +13113,8 @@  remote_target::trace_set_readonly_regions ()
 
   struct remote_state *rs = get_remote_state ();
 
-  strcpy (rs->buf, "QTro");
-  offset = strlen (rs->buf);
+  strcpy (rs->buf.data (), "QTro");
+  offset = strlen (rs->buf.data ());
   for (s = exec_bfd->sections; s; s = s->next)
     {
       char tmp1[40], tmp2[40];
@@ -13128,21 +13131,21 @@  remote_target::trace_set_readonly_regions ()
       sprintf_vma (tmp1, vma);
       sprintf_vma (tmp2, vma + size);
       sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2);
-      if (offset + sec_length + 1 > rs->buf_size)
+      if (offset + sec_length + 1 > rs->buf.size ())
 	{
 	  if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE)
 	    warning (_("\
 Too many sections for read-only sections definition packet."));
 	  break;
 	}
-      xsnprintf (rs->buf + offset, rs->buf_size - offset, ":%s,%s",
+      xsnprintf (rs->buf.data () + offset, rs->buf.size () - offset, ":%s,%s",
 		 tmp1, tmp2);
       offset += sec_length;
     }
   if (anysecs)
     {
       putpkt (rs->buf);
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
     }
 }
 
@@ -13153,10 +13156,10 @@  remote_target::trace_start ()
 
   putpkt ("QTStart");
   remote_get_noisy_reply ();
-  if (*rs->buf == '\0')
+  if (rs->buf[0] == '\0')
     error (_("Target does not support this command."));
-  if (strcmp (rs->buf, "OK") != 0)
-    error (_("Bogus reply from target: %s"), rs->buf);
+  if (strcmp (rs->buf.data (), "OK") != 0)
+    error (_("Bogus reply from target: %s"), rs->buf.data ());
 }
 
 int
@@ -13202,7 +13205,7 @@  remote_target::get_trace_status (struct trace_status *ts)
   ts->filename = NULL;
 
   if (*p++ != 'T')
-    error (_("Bogus trace status reply from target: %s"), rs->buf);
+    error (_("Bogus trace status reply from target: %s"), rs->buf.data ());
 
   /* Function 'parse_trace_status' sets default value of each field of
      'ts' at first, so we don't have to do it here.  */
@@ -13231,7 +13234,7 @@  remote_target::get_tracepoint_status (struct breakpoint *bp,
 	     any status.  */
 	  if (tp->number_on_target == 0)
 	    continue;
-	  xsnprintf (rs->buf, size, "qTP:%x:%s", tp->number_on_target,
+	  xsnprintf (rs->buf.data (), size, "qTP:%x:%s", tp->number_on_target,
 		     phex_nz (loc->address, 0));
 	  putpkt (rs->buf);
 	  reply = remote_get_noisy_reply ();
@@ -13246,7 +13249,7 @@  remote_target::get_tracepoint_status (struct breakpoint *bp,
     {
       utp->hit_count = 0;
       utp->traceframe_usage = 0;
-      xsnprintf (rs->buf, size, "qTP:%x:%s", utp->number,
+      xsnprintf (rs->buf.data (), size, "qTP:%x:%s", utp->number,
 		 phex_nz (utp->addr, 0));
       putpkt (rs->buf);
       reply = remote_get_noisy_reply ();
@@ -13265,10 +13268,10 @@  remote_target::trace_stop ()
 
   putpkt ("QTStop");
   remote_get_noisy_reply ();
-  if (*rs->buf == '\0')
+  if (rs->buf[0] == '\0')
     error (_("Target does not support this command."));
-  if (strcmp (rs->buf, "OK") != 0)
-    error (_("Bogus reply from target: %s"), rs->buf);
+  if (strcmp (rs->buf.data (), "OK") != 0)
+    error (_("Bogus reply from target: %s"), rs->buf.data ());
 }
 
 int
@@ -13277,7 +13280,7 @@  remote_target::trace_find (enum trace_find_type type, int num,
 			   int *tpp)
 {
   struct remote_state *rs = get_remote_state ();
-  char *endbuf = rs->buf + get_remote_packet_size ();
+  char *endbuf = rs->buf.data () + get_remote_packet_size ();
   char *p, *reply;
   int target_frameno = -1, target_tracept = -1;
 
@@ -13287,7 +13290,7 @@  remote_target::trace_find (enum trace_find_type type, int num,
   if (type != tfind_number)
     set_remote_traceframe ();
 
-  p = rs->buf;
+  p = rs->buf.data ();
   strcpy (p, "QTFrame:");
   p = strchr (p, '\0');
   switch (type)
@@ -13362,7 +13365,7 @@  remote_target::get_trace_state_variable_value (int tsvnum, LONGEST *val)
 
   set_remote_traceframe ();
 
-  xsnprintf (rs->buf, get_remote_packet_size (), "qTV:%x", tsvnum);
+  xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTV:%x", tsvnum);
   putpkt (rs->buf);
   reply = remote_get_noisy_reply ();
   if (reply && *reply)
@@ -13383,10 +13386,11 @@  remote_target::save_trace_data (const char *filename)
   struct remote_state *rs = get_remote_state ();
   char *p, *reply;
 
-  p = rs->buf;
+  p = rs->buf.data ();
   strcpy (p, "QTSave:");
   p += strlen (p);
-  if ((p - rs->buf) + strlen (filename) * 2 >= get_remote_packet_size ())
+  if ((p - rs->buf.data ()) + strlen (filename) * 2
+      >= get_remote_packet_size ())
     error (_("Remote file name too long for trace save packet"));
   p += 2 * bin2hex ((gdb_byte *) filename, p, strlen (filename));
   *p++ = '\0';
@@ -13412,7 +13416,7 @@  remote_target::get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len)
   char *p;
   int rslt;
 
-  p = rs->buf;
+  p = rs->buf.data ();
   strcpy (p, "qTBuffer:");
   p += strlen (p);
   p += hexnumstr (p, offset);
@@ -13451,7 +13455,8 @@  remote_target::set_disconnected_tracing (int val)
     {
       char *reply;
 
-      xsnprintf (rs->buf, get_remote_packet_size (), "QTDisconnected:%x", val);
+      xsnprintf (rs->buf.data (), get_remote_packet_size (),
+		 "QTDisconnected:%x", val);
       putpkt (rs->buf);
       reply = remote_get_noisy_reply ();
       if (*reply == '\0')
@@ -13480,7 +13485,8 @@  remote_target::set_circular_trace_buffer (int val)
   struct remote_state *rs = get_remote_state ();
   char *reply;
 
-  xsnprintf (rs->buf, get_remote_packet_size (), "QTBuffer:circular:%x", val);
+  xsnprintf (rs->buf.data (), get_remote_packet_size (),
+	     "QTBuffer:circular:%x", val);
   putpkt (rs->buf);
   reply = remote_get_noisy_reply ();
   if (*reply == '\0')
@@ -13520,7 +13526,7 @@  remote_target::get_min_fast_tracepoint_insn_len ()
   /* Make sure the remote is pointing at the right process.  */
   set_general_process ();
 
-  xsnprintf (rs->buf, get_remote_packet_size (), "qTMinFTPILen");
+  xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTMinFTPILen");
   putpkt (rs->buf);
   reply = remote_get_noisy_reply ();
   if (*reply == '\0')
@@ -13541,8 +13547,8 @@  remote_target::set_trace_buffer_size (LONGEST val)
   if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE)
     {
       struct remote_state *rs = get_remote_state ();
-      char *buf = rs->buf;
-      char *endbuf = rs->buf + get_remote_packet_size ();
+      char *buf = rs->buf.data ();
+      char *endbuf = buf + get_remote_packet_size ();
       enum packet_result result;
 
       gdb_assert (val >= 0 || val == -1);
@@ -13562,7 +13568,7 @@  remote_target::set_trace_buffer_size (LONGEST val)
 		  &remote_protocol_packets[PACKET_QTBuffer_size]);
 
       if (result != PACKET_OK)
-	warning (_("Bogus reply from target: %s"), rs->buf);
+	warning (_("Bogus reply from target: %s"), rs->buf.data ());
     }
 }
 
@@ -13572,8 +13578,8 @@  remote_target::set_trace_notes (const char *user, const char *notes,
 {
   struct remote_state *rs = get_remote_state ();
   char *reply;
-  char *buf = rs->buf;
-  char *endbuf = rs->buf + get_remote_packet_size ();
+  char *buf = rs->buf.data ();
+  char *endbuf = buf + get_remote_packet_size ();
   int nbytes;
 
   buf += xsnprintf (buf, endbuf - buf, "QTNotes:");
@@ -13620,11 +13626,11 @@  remote_target::use_agent (bool use)
       struct remote_state *rs = get_remote_state ();
 
       /* If the stub supports QAgent.  */
-      xsnprintf (rs->buf, get_remote_packet_size (), "QAgent:%d", use);
+      xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAgent:%d", use);
       putpkt (rs->buf);
-      getpkt (&rs->buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
 
-      if (strcmp (rs->buf, "OK") == 0)
+      if (strcmp (rs->buf.data (), "OK") == 0)
 	{
 	  ::use_agent = use;
 	  return true;
@@ -13667,7 +13673,7 @@  remote_target::btrace_sync_conf (const btrace_config *conf)
   char *buf, *pos, *endbuf;
 
   rs = get_remote_state ();
-  buf = rs->buf;
+  buf = rs->buf.data ();
   endbuf = buf + get_remote_packet_size ();
 
   packet = &remote_protocol_packets[PACKET_Qbtrace_conf_bts_size];
@@ -13679,7 +13685,7 @@  remote_target::btrace_sync_conf (const btrace_config *conf)
                         conf->bts.size);
 
       putpkt (buf);
-      getpkt (&buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
 
       if (packet_ok (buf, packet) == PACKET_ERROR)
 	{
@@ -13701,7 +13707,7 @@  remote_target::btrace_sync_conf (const btrace_config *conf)
                         conf->pt.size);
 
       putpkt (buf);
-      getpkt (&buf, &rs->buf_size, 0);
+      getpkt (&rs->buf, 0);
 
       if (packet_ok (buf, packet) == PACKET_ERROR)
 	{
@@ -13789,8 +13795,8 @@  remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf)
   struct btrace_target_info *tinfo = NULL;
   struct packet_config *packet = NULL;
   struct remote_state *rs = get_remote_state ();
-  char *buf = rs->buf;
-  char *endbuf = rs->buf + get_remote_packet_size ();
+  char *buf = rs->buf.data ();
+  char *endbuf = buf + get_remote_packet_size ();
 
   switch (conf->format)
     {
@@ -13812,13 +13818,13 @@  remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf)
 
   buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   if (packet_ok (rs->buf, packet) == PACKET_ERROR)
     {
       if (rs->buf[0] == 'E' && rs->buf[1] == '.')
 	error (_("Could not enable branch tracing for %s: %s"),
-	       target_pid_to_str (ptid), rs->buf + 2);
+	       target_pid_to_str (ptid), &rs->buf[2]);
       else
 	error (_("Could not enable branch tracing for %s."),
 	       target_pid_to_str (ptid));
@@ -13850,8 +13856,8 @@  remote_target::disable_btrace (struct btrace_target_info *tinfo)
 {
   struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off];
   struct remote_state *rs = get_remote_state ();
-  char *buf = rs->buf;
-  char *endbuf = rs->buf + get_remote_packet_size ();
+  char *buf = rs->buf.data ();
+  char *endbuf = buf + get_remote_packet_size ();
 
   if (packet_config_support (packet) != PACKET_ENABLE)
     error (_("Target does not support branch tracing."));
@@ -13860,13 +13866,13 @@  remote_target::disable_btrace (struct btrace_target_info *tinfo)
 
   buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   if (packet_ok (rs->buf, packet) == PACKET_ERROR)
     {
       if (rs->buf[0] == 'E' && rs->buf[1] == '.')
 	error (_("Could not disable branch tracing for %s: %s"),
-	       target_pid_to_str (tinfo->ptid), rs->buf + 2);
+	       target_pid_to_str (tinfo->ptid), &rs->buf[2]);
       else
 	error (_("Could not disable branch tracing for %s."),
 	       target_pid_to_str (tinfo->ptid));
@@ -14133,19 +14139,19 @@  remote_target::thread_events (int enable)
   if (packet_support (PACKET_QThreadEvents) == PACKET_DISABLE)
     return;
 
-  xsnprintf (rs->buf, size, "QThreadEvents:%x", enable ? 1 : 0);
+  xsnprintf (rs->buf.data (), size, "QThreadEvents:%x", enable ? 1 : 0);
   putpkt (rs->buf);
-  getpkt (&rs->buf, &rs->buf_size, 0);
+  getpkt (&rs->buf, 0);
 
   switch (packet_ok (rs->buf,
 		     &remote_protocol_packets[PACKET_QThreadEvents]))
     {
     case PACKET_OK:
-      if (strcmp (rs->buf, "OK") != 0)
-	error (_("Remote refused setting thread events: %s"), rs->buf);
+      if (strcmp (rs->buf.data (), "OK") != 0)
+	error (_("Remote refused setting thread events: %s"), rs->buf.data ());
       break;
     case PACKET_ERROR:
-      warning (_("Remote failure reply: %s"), rs->buf);
+      warning (_("Remote failure reply: %s"), rs->buf.data ());
       break;
     case PACKET_UNKNOWN:
       break;
@@ -14211,15 +14217,15 @@  remote_target::upload_tracepoints (struct uploaded_tp **utpp)
 
   /* Ask for a first packet of tracepoint definition.  */
   putpkt ("qTfP");
-  getpkt (&rs->buf, &rs->buf_size, 0);
-  p = rs->buf;
+  getpkt (&rs->buf, 0);
+  p = rs->buf.data ();
   while (*p && *p != 'l')
     {
       parse_tracepoint_definition (p, utpp);
       /* Ask for another packet of tracepoint definition.  */
       putpkt ("qTsP");
-      getpkt (&rs->buf, &rs->buf_size, 0);
-      p = rs->buf;
+      getpkt (&rs->buf, 0);
+      p = rs->buf.data ();
     }
   return 0;
 }
@@ -14232,15 +14238,15 @@  remote_target::upload_trace_state_variables (struct uploaded_tsv **utsvp)
 
   /* Ask for a first packet of variable definition.  */
   putpkt ("qTfV");
-  getpkt (&rs->buf, &rs->buf_size, 0);
-  p = rs->buf;
+  getpkt (&rs->buf, 0);
+  p = rs->buf.data ();
   while (*p && *p != 'l')
     {
       parse_tsv_definition (p, utsvp);
       /* Ask for another packet of variable definition.  */
       putpkt ("qTsV");
-      getpkt (&rs->buf, &rs->buf_size, 0);
-      p = rs->buf;
+      getpkt (&rs->buf, 0);
+      p = rs->buf.data ();
     }
   return 0;
 }