X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fremote.c;h=3c544502a85a5db4c6ea52fc2aa56f6c8fa8477e;hb=228c8f4be0c428369ec6b68e25696863d1e62ed7;hp=949c69c1ccc46a3643468e60c3ccea6f66dbc979;hpb=bb27775165d9b992120371383012404e213b1981;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/remote.c b/gdb/remote.c
index 949c69c1cc..3c544502a8 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -28,7 +28,6 @@
 #include "symfile.h"
 #include "target.h"
 #include "process-stratum-target.h"
-/*#include "terminal.h" */
 #include "gdbcmd.h"
 #include "objfiles.h"
 #include "gdb-stabs.h"
@@ -43,12 +42,12 @@
 #include "cli/cli-setshow.h"
 #include "target-descriptions.h"
 #include "gdb_bfd.h"
-#include "filestuff.h"
-#include "rsp-low.h"
+#include "gdbsupport/filestuff.h"
+#include "gdbsupport/rsp-low.h"
 #include "disasm.h"
 #include "location.h"
 
-#include "gdb_sys_time.h"
+#include "gdbsupport/gdb_sys_time.h"
 
 #include "event-loop.h"
 #include "event-top.h"
@@ -69,13 +68,14 @@
 #include "tracepoint.h"
 #include "ax.h"
 #include "ax-gdb.h"
-#include "agent.h"
+#include "gdbsupport/agent.h"
 #include "btrace.h"
 #include "record-btrace.h"
 #include <algorithm>
-#include "common/scoped_restore.h"
-#include "environ.h"
-#include "common/byte-vector.h"
+#include "gdbsupport/scoped_restore.h"
+#include "gdbsupport/environ.h"
+#include "gdbsupport/byte-vector.h"
+#include <algorithm>
 #include <unordered_map>
 
 /* The remote target.  */
@@ -97,17 +97,7 @@ struct protocol_feature;
 struct packet_reg;
 
 struct stop_reply;
-static void stop_reply_xfree (struct stop_reply *);
-
-struct stop_reply_deleter
-{
-  void operator() (stop_reply *r) const
-  {
-    stop_reply_xfree (r);
-  }
-};
-
-typedef std::unique_ptr<stop_reply, stop_reply_deleter> stop_reply_up;
+typedef std::unique_ptr<stop_reply> stop_reply_up;
 
 /* Generic configuration support for packets the stub optionally
    supports.  Allows the user to specify the use of the packet as well
@@ -152,7 +142,7 @@ struct vCont_action_support
   bool S = false;
 };
 
-/* About this many threadisds fit in a packet.  */
+/* About this many threadids fit in a packet.  */
 
 #define MAXTHREADLISTRESULTS 32
 
@@ -246,11 +236,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.).  */
@@ -474,12 +463,12 @@ public:
 
   void mourn_inferior () override;
 
-  void pass_signals (int, const unsigned char *) override;
+  void pass_signals (gdb::array_view<const unsigned char>) override;
 
   int set_syscall_catchpoint (int, bool, int,
 			      gdb::array_view<const int>) override;
 
-  void program_signals (int, const unsigned char *) override;
+  void program_signals (gdb::array_view<const unsigned char>) override;
 
   bool thread_alive (ptid_t ptid) override;
 
@@ -487,7 +476,7 @@ public:
 
   void update_thread_list () override;
 
-  const char *pid_to_str (ptid_t) override;
+  std::string pid_to_str (ptid_t) override;
 
   const char *extra_thread_info (struct thread_info *) override;
 
@@ -497,6 +486,9 @@ public:
 					     int handle_len,
 					     inferior *inf) override;
 
+  gdb::byte_vector thread_info_to_thread_handle (struct thread_info *tp)
+						 override;
+
   void stop (ptid_t) override;
 
   void interrupt () override;
@@ -676,7 +668,7 @@ public:
   const struct btrace_config *btrace_conf (const struct btrace_target_info *) override;
   bool augmented_libraries_svr4_read () override;
   int follow_fork (int, int) override;
-  void follow_exec (struct inferior *, char *) override;
+  void follow_exec (struct inferior *, const char *) override;
   int insert_fork_catchpoint (int) override;
   int remove_fork_catchpoint (int) override;
   int insert_vfork_catchpoint (int) override;
@@ -776,7 +768,7 @@ public: /* Remote specific methods.  */
 
   char *remote_get_noisy_reply ();
   int remote_query_attached (int pid);
-  inferior *remote_add_inferior (int fake_pid_p, int pid, int attached,
+  inferior *remote_add_inferior (bool fake_pid_p, int pid, int attached,
 				 int try_open_exec);
 
   ptid_t remote_current_thread (ptid_t oldpid);
@@ -893,13 +885,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 ();
@@ -973,7 +970,8 @@ public:
 };
 
 /* Per-program-space data key.  */
-static const struct program_space_data *remote_pspace_data;
+static const struct program_space_key<char, gdb::xfree_deleter<char>>
+  remote_pspace_data;
 
 /* The variable registered as the control variable used by the
    remote exec-file commands.  While the remote exec-file setting is
@@ -1041,12 +1039,7 @@ static struct cmd_list_element *remote_show_cmdlist;
 
 /* Controls whether GDB is willing to use range stepping.  */
 
-static int use_range_stepping = 1;
-
-/* The max number of chars in debug output.  The rest of chars are
-   omitted.  */
-
-#define REMOTE_DEBUG_MAX_CHAR 512
+static bool use_range_stepping = true;
 
 /* Private data that we'll store in (struct thread_info)->priv.  */
 struct remote_thread_info : public private_thread_info
@@ -1086,18 +1079,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 +1122,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:"))
@@ -1157,12 +1146,12 @@ remote_target::remote_get_noisy_reply ()
 
 	  org_to = to;
 
-	  TRY
+	  try
 	    {
 	      gdbarch_relocate_instruction (target_gdbarch (), &to, from);
 	      relocated = 1;
 	    }
-	  CATCH (ex, RETURN_MASK_ALL)
+	  catch (const gdb_exception &ex)
 	    {
 	      if (ex.error == MEMORY_ERROR)
 		{
@@ -1181,13 +1170,12 @@ remote_target::remote_get_noisy_reply ()
 		}
 	      putpkt ("E01");
 	    }
-	  END_CATCH
 
 	  if (relocated)
 	    {
 	      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 +1202,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;
@@ -1241,16 +1226,6 @@ remote_target::get_remote_state ()
   return &m_remote_state;
 }
 
-/* Cleanup routine for the remote module's pspace data.  */
-
-static void
-remote_pspace_data_cleanup (struct program_space *pspace, void *arg)
-{
-  char *remote_exec_file = (char *) arg;
-
-  xfree (remote_exec_file);
-}
-
 /* Fetch the remote exec-file from the current program space.  */
 
 static const char *
@@ -1258,9 +1233,7 @@ get_remote_exec_file (void)
 {
   char *remote_exec_file;
 
-  remote_exec_file
-    = (char *) program_space_data (current_program_space,
-				   remote_pspace_data);
+  remote_exec_file = remote_pspace_data.get (current_program_space);
   if (remote_exec_file == NULL)
     return "";
 
@@ -1271,13 +1244,12 @@ get_remote_exec_file (void)
 
 static void
 set_pspace_remote_exec_file (struct program_space *pspace,
-			char *remote_exec_file)
+			     const char *remote_exec_file)
 {
-  char *old_file = (char *) program_space_data (pspace, remote_pspace_data);
+  char *old_file = remote_pspace_data.get (pspace);
 
   xfree (old_file);
-  set_program_space_data (pspace, remote_pspace_data,
-			  xstrdup (remote_exec_file));
+  remote_pspace_data.set (pspace, xstrdup (remote_exec_file));
 }
 
 /* The "set/show remote exec-file" set command hook.  */
@@ -1299,22 +1271,6 @@ show_remote_exec_file (struct ui_file *file, int from_tty,
   fprintf_filtered (file, "%s\n", remote_exec_file_var);
 }
 
-static int
-compare_pnums (const void *lhs_, const void *rhs_)
-{
-  const struct packet_reg * const *lhs
-    = (const struct packet_reg * const *) lhs_;
-  const struct packet_reg * const *rhs
-    = (const struct packet_reg * const *) rhs_;
-
-  if ((*lhs)->pnum < (*rhs)->pnum)
-    return -1;
-  else if ((*lhs)->pnum == (*rhs)->pnum)
-    return 0;
-  else
-    return 1;
-}
-
 static int
 map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs)
 {
@@ -1345,8 +1301,9 @@ map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs)
     if (regs[regnum].pnum != -1)
       remote_regs[num_remote_regs++] = &regs[regnum];
 
-  qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
-	 compare_pnums);
+  std::sort (remote_regs, remote_regs + num_remote_regs,
+	     [] (const packet_reg *a, const packet_reg *b)
+	      { return a->pnum < b->pnum; });
 
   for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
     {
@@ -1516,12 +1473,12 @@ show_interrupt_sequence (struct ui_file *file, int from_tty,
    to the remote target when gdb connects to it.
    This is mostly needed when you debug the Linux kernel: The Linux kernel
    expects BREAK g which is Magic SysRq g for connecting gdb.  */
-static int interrupt_on_connect = 0;
+static bool interrupt_on_connect = false;
 
 /* This variable is used to implement the "set/show remotebreak" commands.
    Since these commands are now deprecated in favor of "set/show remote
    interrupt-sequence", it no longer has any effect on the code.  */
-static int remote_break;
+static bool remote_break;
 
 static void
 set_remotebreak (const char *args, int from_tty, struct cmd_list_element *c)
@@ -1547,7 +1504,7 @@ show_remotebreak (struct ui_file *file, int from_tty,
    memory packets to ``host::sizeof long'' bytes - (typically 32
    bits).  Consequently, for 64 bit targets, the upper 32 bits of an
    address was never sent.  Since fixing this bug may cause a break in
-   some remote targets this variable is principly provided to
+   some remote targets this variable is principally provided to
    facilitate backward compatibility.  */
 
 static unsigned int remote_address_size;
@@ -1623,11 +1580,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;
 }
@@ -1753,6 +1707,23 @@ show_hardware_breakpoint_limit (struct ui_file *file, int from_tty,
 			    "breakpoints is %s.\n"), value);
 }
 
+/* Controls the maximum number of characters to display in the debug output
+   for each remote packet.  The remaining characters are omitted.  */
+
+static int remote_packet_max_chars = 512;
+
+/* Show the maximum number of characters to display for each remote packet
+   when remote debugging is enabled.  */
+
+static void
+show_remote_packet_max_chars (struct ui_file *file, int from_tty,
+			      struct cmd_list_element *c,
+			      const char *value)
+{
+  fprintf_filtered (file, _("Number of remote packet characters to "
+			    "display is %s.\n"), value);
+}
+
 long
 remote_target::get_memory_write_packet_size ()
 {
@@ -1852,10 +1823,10 @@ add_packet_config_cmd (struct packet_config *config, const char *name,
 
   config->name = name;
   config->title = title;
-  set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
+  set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
 			name, title);
   show_doc = xstrprintf ("Show current use of remote "
-			 "protocol `%s' (%s) packet",
+			 "protocol `%s' (%s) packet.",
 			 name, title);
   /* set/show TITLE-packet {auto,on,off} */
   cmd_name = xstrprintf ("%s-packet", title);
@@ -1891,7 +1862,7 @@ packet_check_result (const char *buf)
       if (buf[0] == 'E'
 	  && isxdigit (buf[1]) && isxdigit (buf[2])
 	  && buf[3] == '\0')
-	/* "Enn"  - definitly an error.  */
+	/* "Enn"  - definitely an error.  */
 	return PACKET_ERROR;
 
       /* Always treat "E." as an error.  This will be used for
@@ -1907,6 +1878,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 +1937,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,
@@ -1985,8 +1968,6 @@ enum {
   PACKET_qXfer_libraries,
   PACKET_qXfer_libraries_svr4,
   PACKET_qXfer_memory_map,
-  PACKET_qXfer_spu_read,
-  PACKET_qXfer_spu_write,
   PACKET_qXfer_osdata,
   PACKET_qXfer_threads,
   PACKET_qXfer_statictrace_read,
@@ -2302,9 +2283,11 @@ remote_target::remove_exec_catchpoint (int pid)
 
 
 
-static ptid_t magic_null_ptid;
-static ptid_t not_sent_ptid;
-static ptid_t any_thread_ptid;
+/* Take advantage of the fact that the TID field is not used, to tag
+   special ptids with it set to != 0.  */
+static const ptid_t magic_null_ptid (42000, -1, 1);
+static const ptid_t not_sent_ptid (42000, -2, 1);
+static const ptid_t any_thread_ptid (42000, 0, 1);
 
 /* Find out if the stub attached to PID (and hence GDB should offer to
    detach instead of killing it when bailing out).  */
@@ -2319,22 +2302,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;
@@ -2355,7 +2338,7 @@ remote_target::remote_query_attached (int pid)
    if no main executable is open already.  */
 
 inferior *
-remote_target::remote_add_inferior (int fake_pid_p, int pid, int attached,
+remote_target::remote_add_inferior (bool fake_pid_p, int pid, int attached,
 				    int try_open_exec)
 {
   struct inferior *inf;
@@ -2496,7 +2479,7 @@ remote_target::remote_notice_new_inferior (ptid_t currthread, int executing)
       if (find_inferior_pid (currthread.pid ()) == NULL)
 	{
 	  struct remote_state *rs = get_remote_state ();
-	  int fake_pid_p = !remote_multi_process_p (rs);
+	  bool fake_pid_p = !remote_multi_process_p (rs);
 
 	  inf = remote_add_inferior (fake_pid_p,
 				     currthread.pid (), -1, 1);
@@ -2555,16 +2538,16 @@ record_currthread (struct remote_state *rs, ptid_t currthread)
    it can simply pass through to the inferior without reporting.  */
 
 void
-remote_target::pass_signals (int numsigs, const unsigned char *pass_signals)
+remote_target::pass_signals (gdb::array_view<const unsigned char> pass_signals)
 {
   if (packet_support (PACKET_QPassSignals) != PACKET_DISABLE)
     {
       char *pass_packet, *p;
-      int count = 0, i;
+      int count = 0;
       struct remote_state *rs = get_remote_state ();
 
-      gdb_assert (numsigs < 256);
-      for (i = 0; i < numsigs; i++)
+      gdb_assert (pass_signals.size () < 256);
+      for (size_t i = 0; i < pass_signals.size (); i++)
 	{
 	  if (pass_signals[i])
 	    count++;
@@ -2572,7 +2555,7 @@ remote_target::pass_signals (int numsigs, const unsigned char *pass_signals)
       pass_packet = (char *) xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
       strcpy (pass_packet, "QPassSignals:");
       p = pass_packet + strlen (pass_packet);
-      for (i = 0; i < numsigs; i++)
+      for (size_t i = 0; i < pass_signals.size (); i++)
 	{
 	  if (pass_signals[i])
 	    {
@@ -2590,7 +2573,7 @@ remote_target::pass_signals (int numsigs, const 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 +2652,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;
@@ -2681,16 +2664,16 @@ remote_target::set_syscall_catchpoint (int pid, bool needed, int any_count,
    signals it should pass through to the inferior when detaching.  */
 
 void
-remote_target::program_signals (int numsigs, const unsigned char *signals)
+remote_target::program_signals (gdb::array_view<const unsigned char> signals)
 {
   if (packet_support (PACKET_QProgramSignals) != PACKET_DISABLE)
     {
       char *packet, *p;
-      int count = 0, i;
+      int count = 0;
       struct remote_state *rs = get_remote_state ();
 
-      gdb_assert (numsigs < 256);
-      for (i = 0; i < numsigs; i++)
+      gdb_assert (signals.size () < 256);
+      for (size_t i = 0; i < signals.size (); i++)
 	{
 	  if (signals[i])
 	    count++;
@@ -2698,7 +2681,7 @@ remote_target::program_signals (int numsigs, const unsigned char *signals)
       packet = (char *) xmalloc (count * 3 + strlen ("QProgramSignals:") + 1);
       strcpy (packet, "QProgramSignals:");
       p = packet + strlen (packet);
-      for (i = 0; i < numsigs; i++)
+      for (size_t i = 0; i < signals.size (); i++)
 	{
 	  if (signal_pass_state (i))
 	    {
@@ -2717,7 +2700,7 @@ remote_target::program_signals (int numsigs, const 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 +2719,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 +2736,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 +2813,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');
 }
 
@@ -2858,7 +2841,7 @@ remote_target::thread_name (struct thread_info *info)
 
 /* About these extended threadlist and threadinfo packets.  They are
    variable length packets but, the fields within them are often fixed
-   length.  They are redundent enough to send over UDP as is the
+   length.  They are redundant enough to send over UDP as is the
    remote protocol in general.  There is a matching unit test module
    in libstub.  */
 
@@ -3242,7 +3225,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.  */
@@ -3265,7 +3248,7 @@ remote_target::remote_unpack_thread_info_response (char *pkt,
     }
   copy_threadref (&info->threadid, &ref);
 
-  /* Loop on tagged fields , try to bail if somthing goes wrong.  */
+  /* Loop on tagged fields , try to bail if something goes wrong.  */
 
   /* Packets are terminated with nulls.  */
   while ((pkt < limit) && mask && *pkt)
@@ -3335,14 +3318,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 +3359,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);
@@ -3404,29 +3387,30 @@ remote_target::remote_get_threadlist (int startflag, threadref *nextthread,
   struct remote_state *rs = get_remote_state ();
   int result = 1;
 
-  /* Trancate result limit to be smaller than the packet size.  */
+  /* Truncate result limit to be smaller than the packet size.  */
   if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10)
       >= get_remote_packet_size ())
     result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
 
-  pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
+  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))
     {
       /* FIXME: This is a good reason to drop the packet.  */
-      /* Possably, there is a duplicate response.  */
-      /* Possabilities :
+      /* Possibly, there is a duplicate response.  */
+      /* Possibilities :
          retransmit immediatly - race conditions
          retransmit after timeout - yes
          exit
@@ -3598,7 +3582,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 +3717,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 +3730,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 +3867,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 +3917,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 +3949,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 +3966,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 +3992,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 ();
@@ -4052,7 +4036,7 @@ remote_target::~remote_target ()
   if (rs->remote_async_inferior_event_token)
     delete_async_event_handler (&rs->remote_async_inferior_event_token);
 
-  remote_notif_state_xfree (rs->notif_state);
+  delete rs->notif_state;
 }
 
 /* Query the remote side for the text, data and bss offsets.  */
@@ -4072,8 +4056,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
@@ -4311,7 +4295,7 @@ void
 remote_target::add_current_inferior_and_thread (char *wait_status)
 {
   struct remote_state *rs = get_remote_state ();
-  int fake_pid_p = 0;
+  bool fake_pid_p = false;
 
   inferior_ptid = null_ptid;
 
@@ -4321,7 +4305,7 @@ remote_target::add_current_inferior_and_thread (char *wait_status)
   if (curr_ptid != null_ptid)
     {
       if (!remote_multi_process_p (rs))
-	fake_pid_p = 1;
+	fake_pid_p = true;
     }
   else
     {
@@ -4330,7 +4314,7 @@ remote_target::add_current_inferior_and_thread (char *wait_status)
 	 double duty as both the pid of the target process (if it has
 	 such), and as a flag indicating that a target is active.  */
       curr_ptid = magic_null_ptid;
-      fake_pid_p = 1;
+      fake_pid_p = true;
     }
 
   remote_add_inferior (fake_pid_p, curr_ptid.pid (), -1, 1);
@@ -4563,12 +4547,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 +4572,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 +4581,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 +4608,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 +4625,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 +4645,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 +4662,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 +4728,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 +4747,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);
 	}
 
@@ -4788,7 +4774,7 @@ remote_target::start_remote (int from_tty, int extended_p)
       gdb_assert (wait_status == NULL);
 
       /* Report all signals during attach/startup.  */
-      pass_signals (0, NULL);
+      pass_signals ({});
 
       /* If there are already stopped threads, mark them stopped and
 	 report their stops before giving the prompt to the user.  */
@@ -4883,10 +4869,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 +4890,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 +4926,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 +4964,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 +4972,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
@@ -5075,7 +5056,7 @@ remote_target::remote_packet_size (const protocol_feature *feature,
   rs->explicit_packet_size = packet_size;
 }
 
-void
+static void
 remote_packet_size (remote_target *remote, const protocol_feature *feature,
 		    enum packet_support support, const char *value)
 {
@@ -5098,10 +5079,6 @@ static const struct protocol_feature remote_protocol_features[] = {
     remote_supported_packet, PACKET_augmented_libraries_svr4_read_feature },
   { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
     PACKET_qXfer_memory_map },
-  { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
-    PACKET_qXfer_spu_read },
-  { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
-    PACKET_qXfer_spu_write },
   { "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet,
     PACKET_qXfer_osdata },
   { "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet,
@@ -5204,7 +5181,8 @@ register_remote_support_xml (const char *xml)
   else
     {
       char *copy = xstrdup (remote_support_xml + 13);
-      char *p = strtok (copy, ",");
+      char *saveptr;
+      char *p = strtok_r (copy, ",", &saveptr);
 
       do
 	{
@@ -5215,7 +5193,7 @@ register_remote_support_xml (const char *xml)
 	      return;
 	    }
 	}
-      while ((p = strtok (NULL, ",")) != NULL);
+      while ((p = strtok_r (NULL, ",", &saveptr)) != NULL);
       xfree (copy);
 
       remote_support_xml = reconcat (remote_support_xml,
@@ -5291,21 +5269,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 +5360,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++)
@@ -5547,9 +5522,7 @@ remote_target::open_1 (const char *name, int from_tty, int extended_p)
     }
 
   /* Switch to using the remote target now.  */
-  push_target (remote);
-  /* The target stack owns the target now.  */
-  target_holder.release ();
+  push_target (std::move (target_holder));
 
   /* Register extra event sources in the event loop.  */
   rs->remote_async_inferior_event_token
@@ -5612,19 +5585,18 @@ remote_target::open_1 (const char *name, int from_tty, int extended_p)
      function.  See cli-dump.c.  */
   {
 
-    TRY
+    try
       {
 	remote->start_remote (from_tty, extended_p);
       }
-    CATCH (ex, RETURN_MASK_ALL)
+    catch (const gdb_exception &ex)
       {
 	/* Pop the partially set up target - unless something else did
 	   already before throwing the exception.  */
 	if (ex.error != TARGET_CLOSE_ERROR)
 	  remote_unpush_target ();
-	throw_exception (ex);
+	throw;
       }
-    END_CATCH
   }
 
   remote_btrace_reset (rs);
@@ -5649,12 +5621,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')
     ;
@@ -5772,7 +5744,7 @@ remote_target::follow_fork (int follow_child, int detach_fork)
    follow-exec-mode is "new".  */
 
 void
-remote_target::follow_exec (struct inferior *inf, char *execd_pathname)
+remote_target::follow_exec (struct inferior *inf, const char *execd_pathname)
 {
   /* We know that this is a target file name, so if it has the "target:"
      prefix we strip it off before saving it in the program space.  */
@@ -5820,21 +5792,19 @@ extended_remote_target::attach (const char *args, int from_tty)
 
   if (from_tty)
     {
-      char *exec_file = get_exec_file (0);
+      const char *exec_file = get_exec_file (0);
 
       if (exec_file)
 	printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
-			   target_pid_to_str (ptid_t (pid)));
+			   target_pid_to_str (ptid_t (pid)).c_str ());
       else
 	printf_unfiltered (_("Attaching to %s\n"),
-			   target_pid_to_str (ptid_t (pid)));
-
-      gdb_flush (gdb_stdout);
+			   target_pid_to_str (ptid_t (pid)).c_str ());
     }
 
-  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,22 +5813,22 @@ 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);
+	       target_pid_to_str (ptid_t (pid)).c_str (),
+	       rs->buf.data ());
       break;
     case PACKET_UNKNOWN:
       error (_("This target does not support attaching to a process"));
     default:
       error (_("Attaching to %s failed"),
-	     target_pid_to_str (ptid_t (pid)));
+	     target_pid_to_str (ptid_t (pid)).c_str ());
     }
 
-  set_current_inferior (remote_add_inferior (0, pid, 1, 0));
+  set_current_inferior (remote_add_inferior (false, pid, 1, 0));
 
   inferior_ptid = ptid_t (pid);
 
@@ -5911,7 +5881,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 +5916,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 +5958,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 +6098,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 +6154,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 +6196,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 +6204,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 +6338,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 +6357,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 +6580,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 +6618,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).c_str (),
+	   rs->buf.data ());
 }
 
 /* All-stop version of target_interrupt.  Sends a break or a ^C to
@@ -6682,15 +6654,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 +6671,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 ());
     }
 }
 
@@ -6815,11 +6787,9 @@ remote_console_output (const char *msg)
   gdb_flush (gdb_stdtarg);
 }
 
-DEF_VEC_O(cached_reg_t);
-
-typedef struct stop_reply
+struct stop_reply : public notif_event
 {
-  struct notif_event base;
+  ~stop_reply ();
 
   /* The identifier of the thread about this event  */
   ptid_t ptid;
@@ -6838,20 +6808,14 @@ typedef struct stop_reply
      efficient for those targets that provide critical registers as
      part of their normal status mechanism (as another roundtrip to
      fetch them is avoided).  */
-  VEC(cached_reg_t) *regcache;
+  std::vector<cached_reg_t> regcache;
 
   enum target_stop_reason stop_reason;
 
   CORE_ADDR watch_data_address;
 
   int core;
-} *stop_reply_p;
-
-static void
-stop_reply_xfree (struct stop_reply *r)
-{
-  notif_event_xfree ((struct notif_event *) r);
-}
+};
 
 /* Return the length of the stop reply queue.  */
 
@@ -6862,7 +6826,7 @@ remote_target::stop_reply_queue_length ()
   return rs->stop_reply_queue.size ();
 }
 
-void
+static void
 remote_notif_stop_parse (remote_target *remote,
 			 struct notif_client *self, const char *buf,
 			 struct notif_event *event)
@@ -6903,30 +6867,16 @@ remote_notif_stop_can_get_pending_events (remote_target *remote,
   return 0;
 }
 
-static void
-stop_reply_dtr (struct notif_event *event)
+stop_reply::~stop_reply ()
 {
-  struct stop_reply *r = (struct stop_reply *) event;
-  cached_reg_t *reg;
-  int ix;
-
-  for (ix = 0;
-       VEC_iterate (cached_reg_t, r->regcache, ix, reg);
-       ix++)
-    xfree (reg->data);
-
-  VEC_free (cached_reg_t, r->regcache);
+  for (cached_reg_t &reg : regcache)
+    xfree (reg.data);
 }
 
-static struct notif_event *
-remote_notif_stop_alloc_reply (void)
+static notif_event_up
+remote_notif_stop_alloc_reply ()
 {
-  /* We cast to a pointer to the "base class".  */
-  struct notif_event *r = (struct notif_event *) XNEW (struct stop_reply);
-
-  r->dtr = stop_reply_dtr;
-
-  return r;
+  return notif_event_up (new struct stop_reply ());
 }
 
 /* A client of notification Stop.  */
@@ -7069,7 +7019,7 @@ remote_target::discard_pending_stop_replies (struct inferior *inf)
   /* Discard the in-flight notification.  */
   if (reply != NULL && reply->ptid.pid () == inf->pid)
     {
-      stop_reply_xfree (reply);
+      delete reply;
       rns->pending_event[notif_client_stop.id] = NULL;
     }
 
@@ -7128,7 +7078,7 @@ remote_target::remote_notif_remove_queued_reply (ptid_t ptid)
   if (notif_debug)
     fprintf_unfiltered (gdb_stdlog,
 			"notif: discard queued event: 'Stop' in %s\n",
-			target_pid_to_str (ptid));
+			target_pid_to_str (ptid).c_str ());
 
   return result;
 }
@@ -7166,7 +7116,7 @@ remote_target::push_stop_reply (struct stop_reply *new_event)
   if (notif_debug)
     fprintf_unfiltered (gdb_stdlog,
 			"notif: push 'Stop' %s to queue %d\n",
-			target_pid_to_str (new_event->ptid),
+			target_pid_to_str (new_event->ptid).c_str (),
 			int (rs->stop_reply_queue.size ()));
 
   mark_async_event_handler (rs->remote_async_inferior_event_token);
@@ -7213,7 +7163,7 @@ remote_target::remote_parse_stop_reply (const char *buf, stop_reply *event)
   event->ws.kind = TARGET_WAITKIND_IGNORE;
   event->ws.value.integer = 0;
   event->stop_reason = TARGET_STOPPED_BY_NO_REASON;
-  event->regcache = NULL;
+  event->regcache.clear ();
   event->core = -1;
 
   switch (buf[0])
@@ -7338,7 +7288,6 @@ Packet: '%s'\n"),
 	  else if (strprefix (p, p1, "exec"))
 	    {
 	      ULONGEST ignored;
-	      char pathname[PATH_MAX];
 	      int pathlen;
 
 	      /* Determine the length of the execd pathname.  */
@@ -7347,11 +7296,13 @@ Packet: '%s'\n"),
 
 	      /* Save the pathname for event reporting and for
 		 the next run command.  */
-	      hex2bin (p1, (gdb_byte *) pathname, pathlen);
+	      gdb::unique_xmalloc_ptr<char[]> pathname
+		((char *) xmalloc (pathlen + 1));
+	      hex2bin (p1, (gdb_byte *) pathname.get (), pathlen);
 	      pathname[pathlen] = '\0';
 
 	      /* This is freed during event handling.  */
-	      event->ws.value.execd_pathname = xstrdup (pathname);
+	      event->ws.value.execd_pathname = pathname.release ();
 	      event->ws.kind = TARGET_WAITKIND_EXECD;
 
 	      /* Skip the registers included in this packet, since
@@ -7447,7 +7398,7 @@ Packet: '%s'\n"),
 		  if (fieldsize < register_size (event->arch, reg->regnum))
 		    warning (_("Remote reply is too short: %s"), buf);
 
-		  VEC_safe_push (cached_reg_t, event->regcache, &cached_reg);
+		  event->regcache.push_back (cached_reg);
 		}
 	      else
 		{
@@ -7584,7 +7535,7 @@ Packet: '%s'\n"),
       <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
     2.5) <-- (registers reply to step #2.3)
 
-   Eventualy after step #2.5, we return to the event loop, which
+   Eventually after step #2.5, we return to the event loop, which
    notices there's an event on the
    REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
    associated callback --- the function below.  At this point, we're
@@ -7609,16 +7560,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
@@ -7662,22 +7614,18 @@ remote_target::process_stop_reply (struct stop_reply *stop_reply,
       && status->kind != TARGET_WAITKIND_NO_RESUMED)
     {
       /* Expedited registers.  */
-      if (stop_reply->regcache)
+      if (!stop_reply->regcache.empty ())
 	{
 	  struct regcache *regcache
 	    = get_thread_arch_regcache (ptid, stop_reply->arch);
-	  cached_reg_t *reg;
-	  int ix;
 
-	  for (ix = 0;
-	       VEC_iterate (cached_reg_t, stop_reply->regcache, ix, reg);
-	       ix++)
-	  {
-	    regcache->raw_supply (reg->num, reg->data);
-	    xfree (reg->data);
-	  }
+	  for (cached_reg_t &reg : stop_reply->regcache)
+	    {
+	      regcache->raw_supply (reg.num, reg.data);
+	      xfree (reg.data);
+	    }
 
-	  VEC_free (cached_reg_t, stop_reply->regcache);
+	  stop_reply->regcache.clear ();
 	}
 
       remote_notice_new_inferior (ptid, 0);
@@ -7688,7 +7636,7 @@ remote_target::process_stop_reply (struct stop_reply *stop_reply,
       remote_thr->vcont_resumed = 0;
     }
 
-  stop_reply_xfree (stop_reply);
+  delete stop_reply;
   return ptid;
 }
 
@@ -7705,8 +7653,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 +7663,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 +7692,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 +7736,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 +7747,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 +7785,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 +7885,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 +7937,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 +7955,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 +7977,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 +8034,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 +8056,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 +8187,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 +8202,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 +8210,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 +8247,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 +8397,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 +8405,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 +8515,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 +8616,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 +8703,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);
@@ -8795,9 +8742,7 @@ remote_target::remote_xfer_live_readonly_partial (gdb_byte *readbuf,
 
   secp = target_section_by_addr (this, memaddr);
   if (secp != NULL
-      && (bfd_get_section_flags (secp->the_bfd_section->owner,
-				 secp->the_bfd_section)
-	  & SEC_READONLY))
+      && (bfd_section_flags (secp->the_bfd_section) & SEC_READONLY))
     {
       struct target_section *p;
       ULONGEST memend = memaddr + len;
@@ -8911,7 +8856,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 +8867,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);
 }
@@ -9186,15 +9131,21 @@ remote_target::putpkt_binary (const char *buf, int cnt)
 	  *p = '\0';
 
 	  int len = (int) (p - buf2);
+	  int max_chars;
+
+	  if (remote_packet_max_chars < 0)
+	    max_chars = len;
+	  else
+	    max_chars = remote_packet_max_chars;
 
 	  std::string str
-	    = escape_buffer (buf2, std::min (len, REMOTE_DEBUG_MAX_CHAR));
+	    = escape_buffer (buf2, std::min (len, max_chars));
 
 	  fprintf_unfiltered (gdb_stdlog, "Sending packet: %s", str.c_str ());
 
-	  if (len > REMOTE_DEBUG_MAX_CHAR)
+	  if (len > max_chars)
 	    fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
-				len - REMOTE_DEBUG_MAX_CHAR);
+				len - max_chars);
 
 	  fprintf_unfiltered (gdb_stdlog, "...");
 
@@ -9267,18 +9218,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 +9243,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 +9320,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 +9415,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 +9432,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;
@@ -9497,37 +9446,50 @@ remote_target::read_frame (char **buf_p, long *sizeof_buf)
     }
 }
 
+/* Set this to the maximum number of seconds to wait instead of waiting forever
+   in target_wait().  If this timer times out, then it generates an error and
+   the command is aborted.  This replaces most of the need for timeouts in the
+   GDB test suite, and makes it possible to distinguish between a hung target
+   and one with slow communications.  */
+
+static int watchdog = 0;
+static void
+show_watchdog (struct ui_file *file, int from_tty,
+	       struct cmd_list_element *c, const char *value)
+{
+  fprintf_filtered (file, _("Watchdog timer is %s.\n"), value);
+}
+
 /* 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 +9503,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 +9556,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;
 	    }
@@ -9619,16 +9581,23 @@ remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf,
 	{
 	  if (remote_debug)
 	    {
+	      int max_chars;
+
+	      if (remote_packet_max_chars < 0)
+		max_chars = val;
+	      else
+		max_chars = remote_packet_max_chars;
+
 	      std::string str
-		= escape_buffer (*buf,
-				 std::min (val, REMOTE_DEBUG_MAX_CHAR));
+		= escape_buffer (buf->data (),
+				 std::min (val, max_chars));
 
 	      fprintf_unfiltered (gdb_stdlog, "Packet received: %s",
 				  str.c_str ());
 
-	      if (val > REMOTE_DEBUG_MAX_CHAR)
+	      if (val > max_chars)
 		fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
-				    val - REMOTE_DEBUG_MAX_CHAR);
+				    val - max_chars);
 
 	      fprintf_unfiltered (gdb_stdlog, "\n");
 	    }
@@ -9649,7 +9618,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 +9627,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 +9638,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 +9748,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]))
@@ -9805,11 +9773,11 @@ remote_target::remote_kill_k ()
 {
   /* Catch errors so the user can quit from gdb even when we
      aren't on speaking terms with the remote system.  */
-  TRY
+  try
     {
       putpkt ("k");
     }
-  CATCH (ex, RETURN_MASK_ERROR)
+  catch (const gdb_exception_error &ex)
     {
       if (ex.error == TARGET_CLOSE_ERROR)
 	{
@@ -9825,9 +9793,8 @@ remote_target::remote_kill_k ()
       /* Otherwise, something went wrong.  We didn't actually kill
 	 the target.  Just propagate the exception, and let the
 	 user or higher layers decide what to do.  */
-      throw_exception (ex);
+      throw;
     }
-  END_CATCH
 }
 
 void
@@ -9888,7 +9855,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 +9881,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 +9903,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 +9921,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 +9929,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 +9967,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 +9987,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 +10020,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 +10073,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 +10103,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 +10189,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 +10206,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 +10238,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 +10255,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 +10288,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 +10300,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 +10337,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 +10349,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]))
     {
@@ -10403,9 +10370,9 @@ remote_target::remove_watchpoint (CORE_ADDR addr, int len,
 }
 
 
-int remote_hw_watchpoint_limit = -1;
-int remote_hw_watchpoint_length_limit = -1;
-int remote_hw_breakpoint_limit = -1;
+static int remote_hw_watchpoint_limit = -1;
+static int remote_hw_watchpoint_length_limit = -1;
+static int remote_hw_breakpoint_limit = -1;
 
 int
 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
@@ -10533,8 +10500,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 +10518,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 +10546,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 +10566,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 +10599,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 +10607,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]);
@@ -10693,11 +10660,11 @@ compare_sections_command (const char *args, int from_tty)
       if (read_only && (s->flags & SEC_READONLY) == 0)
 	continue;		/* Skip writeable sections */
 
-      size = bfd_get_section_size (s);
+      size = bfd_section_size (s);
       if (size == 0)
 	continue;		/* Skip zero-length section.  */
 
-      sectname = bfd_get_section_name (exec_bfd, s);
+      sectname = bfd_section_name (s);
       if (args && strcmp (args, sectname) != 0)
 	continue;		/* Not the section selected by user.  */
 
@@ -10752,7 +10719,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 +10727,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 +10784,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 +10794,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 +10808,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,
@@ -10896,19 +10864,6 @@ remote_target::xfer_partial (enum target_object object,
 				  xfered_len);
     }
 
-  /* Handle SPU memory using qxfer packets.  */
-  if (object == TARGET_OBJECT_SPU)
-    {
-      if (readbuf)
-	return remote_read_qxfer ("spu", annex, readbuf, offset, len,
-				  xfered_len, &remote_protocol_packets
-				  [PACKET_qXfer_spu_read]);
-      else
-	return remote_write_qxfer ("spu", annex, writebuf, offset, len,
-				   xfered_len, &remote_protocol_packets
-				   [PACKET_qXfer_spu_write]);
-    }
-
   /* Handle extra signal info using qxfer packets.  */
   if (object == TARGET_OBJECT_SIGNAL_INFO)
     {
@@ -11044,7 +10999,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 +11023,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 +11084,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 +11092,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 +11120,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 +11134,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 +11144,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 +11165,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 +11174,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 +11236,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");
 }
 
@@ -11339,7 +11295,7 @@ output_threadid (char *title, threadref *ref)
 {
   char hexid[20];
 
-  pack_threadid (&hexid[0], ref);	/* Convert threead id into hex.  */
+  pack_threadid (&hexid[0], ref);	/* Convert thread id into hex.  */
   hexid[16] = 0;
   printf_filtered ("%s  %s\n", title, (&hexid[0]));
 }
@@ -11421,26 +11377,24 @@ init_remote_threadtests (void)
 {
   add_com ("tlist", class_obscure, threadlist_test_cmd,
 	   _("Fetch and print the remote list of "
-	     "thread identifiers, one pkt only"));
+	     "thread identifiers, one pkt only."));
   add_com ("tinfo", class_obscure, threadinfo_test_cmd,
-	   _("Fetch and display info about one thread"));
+	   _("Fetch and display info about one thread."));
   add_com ("tset", class_obscure, threadset_test_cmd,
-	   _("Test setting to a different thread"));
+	   _("Test setting to a different thread."));
   add_com ("tupd", class_obscure, threadlist_update_test_cmd,
-	   _("Iterate through updating all remote thread info"));
+	   _("Iterate through updating all remote thread info."));
   add_com ("talive", class_obscure, threadalive_test,
-	   _(" Remote thread alive test "));
+	   _("Remote thread alive test."));
 }
 
 #endif /* 0 */
 
-/* Convert a thread ID to a string.  Returns the string in a static
-   buffer.  */
+/* Convert a thread ID to a string.  */
 
-const char *
+std::string
 remote_target::pid_to_str (ptid_t ptid)
 {
-  static char buf[64];
   struct remote_state *rs = get_remote_state ();
 
   if (ptid == null_ptid)
@@ -11459,27 +11413,22 @@ remote_target::pid_to_str (ptid_t ptid)
 	 attached to a process, and reporting yes to qAttached, hence
 	 no smart special casing here.  */
       if (!remote_multi_process_p (rs))
-	{
-	  xsnprintf (buf, sizeof buf, "Remote target");
-	  return buf;
-	}
+	return "Remote target";
 
       return normal_pid_to_str (ptid);
     }
   else
     {
       if (magic_null_ptid == ptid)
-	xsnprintf (buf, sizeof buf, "Thread <main>");
+	return "Thread <main>";
       else if (remote_multi_process_p (rs))
 	if (ptid.lwp () == 0)
 	  return normal_pid_to_str (ptid);
 	else
-	  xsnprintf (buf, sizeof buf, "Thread %d.%ld",
-		     ptid.pid (), ptid.lwp ());
+	  return string_printf ("Thread %d.%ld",
+				ptid.pid (), ptid.lwp ());
       else
-	xsnprintf (buf, sizeof buf, "Thread %ld",
-		   ptid.lwp ());
-      return buf;
+	return string_printf ("Thread %ld", ptid.lwp ());
     }
 }
 
@@ -11493,8 +11442,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 +11456,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 +11489,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 +11499,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 +11760,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 +11783,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 +11803,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 +11836,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 +11852,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 +11872,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 +11905,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 +11925,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 +11940,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 +11962,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 +11978,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 +12071,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 +12080,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 +12097,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 +12108,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 +12126,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 +12140,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 +12163,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 +12174,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)
@@ -12409,7 +12359,7 @@ public:
   DISABLE_COPY_AND_ASSIGN (scoped_remote_fd);
 
   /* Release ownership of the file descriptor, and return it.  */
-  int release () noexcept
+  ATTRIBUTE_UNUSED_RESULT int release () noexcept
   {
     int fd = m_fd;
     m_fd = -1;
@@ -12737,7 +12687,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 +12704,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 +12719,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 +12873,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 +12895,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 +12918,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 +12937,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 +12953,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 +12995,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 +13019,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 +13036,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."));
 }
 
@@ -13099,7 +13050,6 @@ void
 remote_target::trace_set_readonly_regions ()
 {
   asection *s;
-  bfd *abfd = NULL;
   bfd_size_type size;
   bfd_vma vma;
   int anysecs = 0;
@@ -13110,8 +13060,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];
@@ -13123,26 +13073,26 @@ remote_target::trace_set_readonly_regions ()
 	continue;
 
       anysecs = 1;
-      vma = bfd_get_section_vma (abfd, s);
-      size = bfd_get_section_size (s);
+      vma = bfd_section_vma (s);
+      size = bfd_section_size (s);
       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 +13103,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
@@ -13164,33 +13114,31 @@ remote_target::get_trace_status (struct trace_status *ts)
 {
   /* Initialize it just to avoid a GCC false warning.  */
   char *p = NULL;
-  /* FIXME we need to get register block size some other way.  */
-  extern int trace_regblock_size;
   enum packet_result result;
   struct remote_state *rs = get_remote_state ();
 
   if (packet_support (PACKET_qTStatus) == PACKET_DISABLE)
     return -1;
 
+  /* FIXME we need to get register block size some other way.  */
   trace_regblock_size
     = rs->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet;
 
   putpkt ("qTStatus");
 
-  TRY
+  try
     {
       p = remote_get_noisy_reply ();
     }
-  CATCH (ex, RETURN_MASK_ERROR)
+  catch (const gdb_exception_error &ex)
     {
       if (ex.error != TARGET_CLOSE_ERROR)
 	{
 	  exception_fprintf (gdb_stderr, ex, "qTStatus: ");
 	  return -1;
 	}
-      throw_exception (ex);
+      throw;
     }
-  END_CATCH
 
   result = packet_ok (p, &remote_protocol_packets[PACKET_qTStatus]);
 
@@ -13202,7 +13150,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 +13179,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 +13194,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 +13213,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 +13225,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 +13235,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 +13310,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 +13331,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 +13361,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 +13400,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 +13430,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 +13471,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 +13492,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 +13513,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 +13523,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 +13571,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 +13618,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 +13630,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 +13652,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)
 	{
@@ -13738,6 +13689,11 @@ remote_target::remote_btrace_maybe_reopen ()
   int warned = 0;
 #endif
 
+  /* Don't bother walking the entirety of the remote thread list when
+     we know the feature isn't supported by the remote.  */
+  if (packet_support (PACKET_qXfer_btrace_conf) != PACKET_ENABLE)
+    return;
+
   scoped_restore_current_thread restore_thread;
 
   for (thread_info *tp : all_non_exited_threads ())
@@ -13789,8 +13745,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,16 +13768,16 @@ 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).c_str (), &rs->buf[2]);
       else
 	error (_("Could not enable branch tracing for %s."),
-	       target_pid_to_str (ptid));
+	       target_pid_to_str (ptid).c_str ());
     }
 
   tinfo = XCNEW (struct btrace_target_info);
@@ -13829,16 +13785,15 @@ remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf)
 
   /* If we fail to read the configuration, we lose some information, but the
      tracing itself is not impacted.  */
-  TRY
+  try
     {
       btrace_read_config (&tinfo->conf);
     }
-  CATCH (err, RETURN_MASK_ERROR)
+  catch (const gdb_exception_error &err)
     {
       if (err.message != NULL)
-	warning ("%s", err.message);
+	warning ("%s", err.what ());
     }
-  END_CATCH
 
   return tinfo;
 }
@@ -13850,8 +13805,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,16 +13815,16 @@ 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).c_str (), &rs->buf[2]);
       else
 	error (_("Could not disable branch tracing for %s."),
-	       target_pid_to_str (tinfo->ptid));
+	       target_pid_to_str (tinfo->ptid).c_str ());
     }
 
   xfree (tinfo);
@@ -14042,6 +13997,13 @@ remote_target::thread_handle_to_thread_info (const gdb_byte *thread_handle,
   return NULL;
 }
 
+gdb::byte_vector
+remote_target::thread_info_to_thread_handle (struct thread_info *tp)
+{
+  remote_thread_info *priv = get_remote_thread_info (tp);
+  return priv->thread_handle;
+}
+
 bool
 remote_target::can_async_p ()
 {
@@ -14133,19 +14095,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 +14173,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 +14194,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;
 }
@@ -14297,10 +14259,6 @@ _initialize_remote (void)
   remote_g_packet_data_handle =
     gdbarch_data_register_pre_init (remote_g_packet_data_init);
 
-  remote_pspace_data
-    = register_program_space_data_with_cleanup (NULL,
-						remote_pspace_data_cleanup);
-
   add_target (remote_target_info, remote_target::open);
   add_target (extended_remote_target_info, extended_remote_target::open);
 
@@ -14314,15 +14272,15 @@ _initialize_remote (void)
   /* set/show remote ...  */
 
   add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
-Remote protocol specific variables\n\
+Remote protocol specific variables.\n\
 Configure various remote-protocol specific variables such as\n\
-the packets being used"),
+the packets being used."),
 		  &remote_set_cmdlist, "set remote ",
 		  0 /* allow-unknown */, &setlist);
   add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
-Remote protocol specific variables\n\
+Remote protocol specific variables.\n\
 Configure various remote-protocol specific variables such as\n\
-the packets being used"),
+the packets being used."),
 		  &remote_show_cmdlist, "show remote ",
 		  0 /* allow-unknown */, &showlist);
 
@@ -14366,8 +14324,8 @@ Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."
 
   add_setshow_boolean_cmd ("interrupt-on-connect", class_support,
 			   &interrupt_on_connect, _("\
-Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("		\
-Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("		\
+Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
+Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
 If set, interrupt sequence is sent to remote target."),
 			   NULL, NULL,
 			   &remote_set_cmdlist, &remote_show_cmdlist);
@@ -14515,12 +14473,6 @@ Show the maximum size of the address (in bits) in a memory packet."), NULL,
   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
 			 "qXfer:memory-map:read", "memory-map", 0);
 
-  add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read],
-                         "qXfer:spu:read", "read-spu-object", 0);
-
-  add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write],
-                         "qXfer:spu:write", "write-spu-object", 0);
-
   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata],
                         "qXfer:osdata:read", "osdata", 0);
 
@@ -14735,8 +14687,8 @@ Show the maximum size of the address (in bits) in a memory packet."), NULL,
      documentation).  */
   add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
 				&remote_Z_packet_detect, _("\
-Set use of remote protocol `Z' packets"), _("\
-Show use of remote protocol `Z' packets "), _("\
+Set use of remote protocol `Z' packets."), _("\
+Show use of remote protocol `Z' packets."), _("\
 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
 packets."),
 				set_remote_protocol_Z_packet_cmd,
@@ -14746,7 +14698,7 @@ packets."),
 				&remote_set_cmdlist, &remote_show_cmdlist);
 
   add_prefix_cmd ("remote", class_files, remote_command, _("\
-Manipulate files on the remote system\n\
+Manipulate files on the remote system.\n\
 Transfer files to and from the remote target system."),
 		  &remote_cmdlist, "remote ",
 		  0 /* allow-unknown */, &cmdlist);
@@ -14765,8 +14717,8 @@ Transfer files to and from the remote target system."),
 
   add_setshow_string_noescape_cmd ("exec-file", class_files,
 				   &remote_exec_file_var, _("\
-Set the remote pathname for \"run\""), _("\
-Show the remote pathname for \"run\""), NULL,
+Set the remote pathname for \"run\"."), _("\
+Show the remote pathname for \"run\"."), NULL,
 				   set_remote_exec_file,
 				   show_remote_exec_file,
 				   &remote_set_cmdlist,
@@ -14786,12 +14738,24 @@ stepping is supported by the target.  The default is on."),
 			   &setlist,
 			   &showlist);
 
+  add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\
+Set watchdog timer."), _("\
+Show watchdog timer."), _("\
+When non-zero, this timeout is used instead of waiting forever for a target\n\
+to finish a low-level step or continue operation.  If the specified amount\n\
+of time passes without a response from the target, an error occurs."),
+			    NULL,
+			    show_watchdog,
+			    &setlist, &showlist);
+
+  add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class,
+				       &remote_packet_max_chars, _("\
+Set the maximum number of characters to display for each remote packet."), _("\
+Show the maximum number of characters to display for each remote packet."), _("\
+Specify \"unlimited\" to display all the characters."),
+				       NULL, show_remote_packet_max_chars,
+				       &setdebuglist, &showdebuglist);
+
   /* Eventually initialize fileio.  See fileio.c */
   initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
-
-  /* Take advantage of the fact that the TID field is not used, to tag
-     special ptids with it set to != 0.  */
-  magic_null_ptid = ptid_t (42000, -1, 1);
-  not_sent_ptid = ptid_t (42000, -2, 1);
-  any_thread_ptid = ptid_t (42000, 0, 1);
 }