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