/* Remote target communications for serial-line targets in custom GDB protocol
- Copyright (C) 1988-2018 Free Software Foundation, Inc.
+ Copyright (C) 1988-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "symfile.h"
#include "target.h"
#include "process-stratum-target.h"
-/*#include "terminal.h" */
#include "gdbcmd.h"
#include "objfiles.h"
#include "gdb-stabs.h"
#include "cli/cli-setshow.h"
#include "target-descriptions.h"
#include "gdb_bfd.h"
-#include "filestuff.h"
-#include "rsp-low.h"
+#include "common/filestuff.h"
+#include "common/rsp-low.h"
#include "disasm.h"
#include "location.h"
-#include "gdb_sys_time.h"
+#include "common/gdb_sys_time.h"
#include "event-loop.h"
#include "event-top.h"
#include "tracepoint.h"
#include "ax.h"
#include "ax-gdb.h"
-#include "agent.h"
+#include "common/agent.h"
#include "btrace.h"
#include "record-btrace.h"
#include <algorithm>
#include "common/scoped_restore.h"
-#include "environ.h"
+#include "common/environ.h"
#include "common/byte-vector.h"
#include <unordered_map>
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
/* 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.). */
void mourn_inferior () override;
- void pass_signals (int, 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, unsigned char *) override;
+ void program_signals (gdb::array_view<const unsigned char>) override;
bool thread_alive (ptid_t ptid) override;
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;
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;
struct stop_reply *remote_notif_remove_queued_reply (ptid_t ptid);
struct stop_reply *queued_stop_reply (ptid_t ptid);
int peek_stop_reply (ptid_t ptid);
- void remote_parse_stop_reply (char *buf, stop_reply *event);
+ void remote_parse_stop_reply (const char *buf, stop_reply *event);
void remote_stop_ns (ptid_t ptid);
void remote_interrupt_as ();
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);
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 ();
static bool remote_read_description_p (struct target_ops *target);
-static void remote_console_output (char *msg);
+static void remote_console_output (const char *msg);
static void remote_btrace_reset (remote_state *rs);
};
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);
}
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:"))
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)
{
}
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);
}
}
/* 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;
/* 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;
}
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)
{
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,
\f
-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). */
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;
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;
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);
it can simply pass through to the inferior without reporting. */
void
-remote_target::pass_signals (int numsigs, 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++;
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])
{
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);
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;
signals it should pass through to the inferior when detaching. */
void
-remote_target::program_signals (int numsigs, 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++;
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))
{
|| 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;
{
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;
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
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');
}
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. */
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;
}
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);
>= 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))
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;
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 */
}
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;
}
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 ();
}
}
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);
/* 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);
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;
/* 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 ();
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. */
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
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;
if (curr_ptid != null_ptid)
{
if (!remote_multi_process_p (rs))
- fake_pid_p = 1;
+ fake_pid_p = true;
}
else
{
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);
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.
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;
}
{
/* 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
"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.
/* 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
/* 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 ())
{
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. */
/* 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. */
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);
}
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. */
void
remote_target::remote_check_symbols ()
{
- char *msg, *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
/* Allocate a message buffer. We can't reuse the input buffer in RS,
because we need both at the same time. */
- msg = (char *) xmalloc (get_remote_packet_size ());
- old_chain = make_cleanup (xfree, msg);
- reply = (char *) xmalloc (get_remote_packet_size ());
- make_cleanup (free_current_contents, &reply);
- reply_size = get_remote_packet_size ();
+ gdb::char_vector msg (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;
tmp = &reply[8];
- end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2);
+ end = hex2bin (tmp, reinterpret_cast <gdb_byte *> (msg.data ()),
+ strlen (tmp) / 2);
msg[end] = '\0';
- sym = lookup_minimal_symbol (msg, NULL, NULL);
+ sym = lookup_minimal_symbol (msg.data (), NULL, NULL);
if (sym.minsym == NULL)
- xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
+ xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol::%s",
+ &reply[8]);
else
{
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
sym_addr,
current_top_target ());
- xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
+ xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol:%s:%s",
phex_nz (sym_addr, addr_size), &reply[8]);
}
-
- putpkt (msg);
- getpkt (&reply, &reply_size, 0);
- }
- do_cleanups (old_chain);
+ putpkt (msg.data ());
+ getpkt (&reply, 0);
+ }
}
static struct serial *
{
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",
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
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;
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++)
}
/* 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
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);
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')
;
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]))
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);
else
{
gdb_assert (wait_status != NULL);
- strcpy (rs->buf, wait_status);
+ strcpy (rs->buf.data (), wait_status);
rs->cached_wait_status = 1;
}
}
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"))
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
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. */
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
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 ())
/* 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;
{
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;
}
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
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 ();
/* 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
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]))
{
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 ());
}
}
}
static void
-remote_console_output (char *msg)
+remote_console_output (const char *msg)
{
- char *p;
+ const char *p;
for (p = msg; p[0] && p[1]; p += 2)
{
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;
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. */
void
remote_notif_stop_parse (remote_target *remote,
- struct notif_client *self, char *buf,
+ struct notif_client *self, const char *buf,
struct notif_event *event)
{
remote->remote_parse_stop_reply (buf, (struct stop_reply *) event);
static void
remote_notif_stop_ack (remote_target *remote,
- struct notif_client *self, char *buf,
+ struct notif_client *self, const char *buf,
struct notif_event *event)
{
struct stop_reply *stop_reply = (struct stop_reply *) event;
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 ® : 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. */
/* 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;
}
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;
}
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);
result is stored in EVENT, or throws an error. */
void
-remote_target::remote_parse_stop_reply (char *buf, stop_reply *event)
+remote_target::remote_parse_stop_reply (const char *buf, stop_reply *event)
{
remote_arch_state *rsa = NULL;
ULONGEST addr;
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])
else if (strprefix (p, p1, "exec"))
{
ULONGEST ignored;
- char pathname[PATH_MAX];
int pathlen;
/* Determine the length of the execd pathname. */
/* 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
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
{
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
&& 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 ® : 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);
remote_thr->vcont_resumed = 0;
}
- stop_reply_xfree (stop_reply);
+ delete stop_reply;
return ptid;
}
/* 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)
/* 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;
}
}
/* 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);
}
}
_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. */
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. */
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;
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;
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
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;
}
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
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)
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);
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;
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]))
{
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:
/* 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
{
char *p;
- p = rs->buf;
+ p = rs->buf.data ();
*p++ = 'X';
p += hexnumstr (p, (ULONGEST) addr);
*p++ = ',';
*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')
{
/* 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')
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;
/* 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);
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);
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);
}
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;
}
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;
/* 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;
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);
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;
}
/* 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)
{
previously cached response. */
rs->cached_wait_status = 0;
- strcpy (*buf, "timeout");
+ strcpy (buf->data (), "timeout");
if (forever)
timeout = watchdog > 0 ? watchdog : -1;
{
/* 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;
}
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",
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",
if (is_notif != NULL)
*is_notif = 1;
- handle_notification (rs->notif_state, *buf);
+ handle_notification (rs->notif_state, buf->data ());
/* Notifications require no acknowledgement. */
}
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
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]))
{
/* 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)
{
/* 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
/* 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')
{
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')
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 ())
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]));
}
}
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]))
{
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);
}
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."));
}
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 ());
}
}
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 ();
}
/* 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. */
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';
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]))
{
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. */
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');
}
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);
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]))
{
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);
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]))
{
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';
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);
}
{
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;
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]))
{
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);
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]);
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));
/* 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;
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));
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
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,
gdb_assert (annex != NULL);
gdb_assert (readbuf != NULL);
- p2 = rs->buf;
+ p2 = rs->buf.data ();
*p2++ = 'q';
*p2++ = query_type;
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;
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)));
/* 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
{
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;
}
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"));
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);
/* 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
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')
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");
}
#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)
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 ());
}
}
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:");
*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)
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:");
*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;
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. */
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;
if (attachment_tmp != NULL)
{
*attachment = attachment_tmp;
- *attachment_len = bytes_read - (*attachment - rs->buf);
+ *attachment_len = bytes_read - (*attachment - rs->buf.data ());
}
return ret;
{
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;
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)
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)
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);
}
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;
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);
}
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;
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);
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);
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);
}
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)
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);
}
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;
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);
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;
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)
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;
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."));
}
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
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."));
}
}
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); */
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."));
}
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."));
}
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)
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,
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."));
}
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."));
}
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."));
}
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];
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);
}
}
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
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]);
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. */
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 ();
{
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 ();
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
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;
if (type != tfind_number)
set_remote_traceframe ();
- p = rs->buf;
+ p = rs->buf.data ();
strcpy (p, "QTFrame:");
p = strchr (p, '\0');
switch (type)
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)
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';
char *p;
int rslt;
- p = rs->buf;
+ p = rs->buf.data ();
strcpy (p, "qTBuffer:");
p += strlen (p);
p += hexnumstr (p, offset);
{
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')
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')
/* 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')
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);
&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 ());
}
}
{
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:");
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;
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];
conf->bts.size);
putpkt (buf);
- getpkt (&buf, &rs->buf_size, 0);
+ getpkt (&rs->buf, 0);
if (packet_ok (buf, packet) == PACKET_ERROR)
{
conf->pt.size);
putpkt (buf);
- getpkt (&buf, &rs->buf_size, 0);
+ getpkt (&rs->buf, 0);
if (packet_ok (buf, packet) == PACKET_ERROR)
{
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)
{
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);
/* 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;
}
{
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."));
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);
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 ()
{
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;
/* 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;
}
/* 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;
}
/* 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);
}