/* 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 "bfd.h"
#include "symfile.h"
#include "target.h"
-/*#include "terminal.h" */
+#include "process-stratum-target.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>
/* 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.). */
remote_doc
};
-class remote_target : public target_ops
+class remote_target : public process_stratum_target
{
public:
- remote_target ()
- {
- to_stratum = process_stratum;
- }
+ remote_target () = default;
~remote_target () override;
const target_info &info () const override
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;
CORE_ADDR load_module_addr,
CORE_ADDR offset) override;
- bool has_all_memory () override { return default_child_has_all_memory (); }
- bool has_memory () override { return default_child_has_memory (); }
- bool has_stack () override { return default_child_has_stack (); }
- bool has_registers () override { return default_child_has_registers (); }
- bool has_execution (ptid_t ptid) override { return default_child_has_execution (ptid); }
-
bool can_execute_reverse () override;
std::vector<mem_region> memory_map () 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 ();
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 void remote_async_inferior_event_handler (gdb_client_data);
-static int remote_read_description_p (struct target_ops *target);
+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:"))
{
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,
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;
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;
}
|| remote_get_threads_with_qthreadinfo (&context)
|| remote_get_threads_with_ql (&context))
{
- struct thread_info *tp, *tmp;
-
got_list = 1;
if (context.items.empty ()
/* CONTEXT now holds the current thread list on the remote
target end. Delete GDB-side threads no longer found on the
target. */
- ALL_THREADS_SAFE (tp, tmp)
+ for (thread_info *tp : all_threads_safe ())
{
if (!context.contains_thread (tp->ptid))
{
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 ();
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::process_initial_stop_replies (int from_tty)
{
int pending_stop_replies = stop_reply_queue_length ();
- struct inferior *inf;
- struct thread_info *thread;
struct thread_info *selected = NULL;
struct thread_info *lowest_stopped = NULL;
struct thread_info *first = NULL;
ptid_t event_ptid;
struct target_waitstatus ws;
int ignore_event = 0;
- struct thread_info *thread;
memset (&ws, 0, sizeof (ws));
event_ptid = target_wait (waiton_ptid, &ws, TARGET_WNOHANG);
if (ignore_event)
continue;
- thread = find_thread_ptid (event_ptid);
+ struct thread_info *evthread = find_thread_ptid (event_ptid);
if (ws.kind == TARGET_WAITKIND_STOPPED)
{
instead of signal 0. Suppress it. */
if (sig == GDB_SIGNAL_TRAP)
sig = GDB_SIGNAL_0;
- thread->suspend.stop_signal = sig;
+ evthread->suspend.stop_signal = sig;
ws.value.sig = sig;
}
- thread->suspend.waitstatus = ws;
+ evthread->suspend.waitstatus = ws;
if (ws.kind != TARGET_WAITKIND_STOPPED
|| ws.value.sig != GDB_SIGNAL_0)
- thread->suspend.waitstatus_pending_p = 1;
+ evthread->suspend.waitstatus_pending_p = 1;
set_executing (event_ptid, 0);
set_running (event_ptid, 0);
- get_remote_thread_info (thread)->vcont_resumed = 0;
+ get_remote_thread_info (evthread)->vcont_resumed = 0;
}
/* "Notice" the new inferiors before anything related to
registers/memory. */
- ALL_INFERIORS (inf)
+ for (inferior *inf : all_non_exited_inferiors ())
{
- if (inf->pid == 0)
- continue;
-
inf->needs_setup = 1;
if (non_stop)
{
- thread = any_live_thread_of_inferior (inf);
+ thread_info *thread = any_live_thread_of_inferior (inf);
notice_new_inferior (thread, thread->state == THREAD_RUNNING,
from_tty);
}
/* If all threads of an inferior were already stopped, we
haven't setup the inferior yet. */
- ALL_INFERIORS (inf)
+ for (inferior *inf : all_non_exited_inferiors ())
{
- if (inf->pid == 0)
- continue;
-
if (inf->needs_setup)
{
- thread = any_live_thread_of_inferior (inf);
+ thread_info *thread = any_live_thread_of_inferior (inf);
switch_to_thread_no_regs (thread);
setup_inferior (0);
}
/* Now go over all threads that are stopped, and print their current
frame. If all-stop, then if there's a signalled thread, pick
that as current. */
- ALL_NON_EXITED_THREADS (thread)
+ for (thread_info *thread : all_non_exited_threads ())
{
if (first == NULL)
first = thread;
others with their status pending. */
if (!non_stop)
{
- thread = selected;
+ thread_info *thread = selected;
if (thread == NULL)
thread = lowest_stopped;
if (thread == NULL)
}
/* For "info program". */
- thread = inferior_thread ();
+ thread_info *thread = inferior_thread ();
if (thread->state == THREAD_STOPPED)
set_last_target_status (inferior_ptid, thread->suspend.waitstatus);
}
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. */
"warning: couldn't determine remote "
"current thread; picking first in list.\n");
- inferior_ptid = thread_list->ptid;
+ inferior_ptid = inferior_list->thread_list->ptid;
}
}
/* 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
/* First delete any symbols previously loaded from shared libraries. */
no_shared_libraries (NULL, 0);
- /* Start afresh. */
- init_thread_list ();
-
/* Start the remote connection. If error() or QUIT, discard this
target (we'd otherwise be in an inconsistent state) and then
propogate the error on up the exception chain. This ensures that
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')
;
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]))
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"));
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
remote_target::append_pending_thread_resumptions (char *p, char *endp,
ptid_t ptid)
{
- struct thread_info *thread;
-
- ALL_NON_EXITED_THREADS (thread)
- if (thread->ptid.matches (ptid)
- && inferior_ptid != thread->ptid
+ for (thread_info *thread : all_non_exited_threads (ptid))
+ if (inferior_ptid != thread->ptid
&& thread->suspend.stop_signal != GDB_SIGNAL_0)
{
p = append_resumption (p, endp, thread->ptid,
gdb_signal siggnal)
{
struct remote_state *rs = get_remote_state ();
- struct thread_info *thread;
char *buf;
rs->last_sent_signal = siggnal;
else
set_continue_thread (ptid);
- ALL_NON_EXITED_THREADS (thread)
+ 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
void
remote_target::commit_resume ()
{
- struct inferior *inf;
- struct thread_info *tp;
int any_process_wildcard;
int may_global_wildcard_vcont;
may_global_wildcard_vcont = 1;
/* And assume every process is individually wildcard-able too. */
- ALL_NON_EXITED_INFERIORS (inf)
+ for (inferior *inf : all_non_exited_inferiors ())
{
remote_inferior *priv = get_remote_inferior (inf);
disable process and global wildcard resumes appropriately. */
check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont);
- ALL_NON_EXITED_THREADS (tp)
+ for (thread_info *tp : all_non_exited_threads ())
{
/* If a thread of a process is not meant to be resumed, then we
can't wildcard that process. */
struct vcont_builder vcont_builder (this);
/* Threads first. */
- ALL_NON_EXITED_THREADS (tp)
+ for (thread_info *tp : all_non_exited_threads ())
{
remote_thread_info *remote_thr = get_remote_thread_info (tp);
supposed to be resumed. */
any_process_wildcard = 0;
- ALL_NON_EXITED_INFERIORS (inf)
+ for (inferior *inf : all_non_exited_inferiors ())
{
if (get_remote_inferior (inf)->may_wildcard_vcont)
{
}
else
{
- ALL_NON_EXITED_INFERIORS (inf)
+ for (inferior *inf : all_non_exited_inferiors ())
{
if (get_remote_inferior (inf)->may_wildcard_vcont)
{
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),
+ 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)
{
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;
void
remote_target::remove_new_fork_children (threads_listing_context *context)
{
- struct thread_info * thread;
int pid = -1;
struct notif_client *notif = ¬if_client_stop;
/* For any threads stopped at a fork event, remove the corresponding
fork child threads from the CONTEXT list. */
- ALL_NON_EXITED_THREADS (thread)
+ for (thread_info *thread : all_non_exited_threads ())
{
struct target_waitstatus *ws = thread_pending_fork_status (thread);
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;
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. */
+ char *pathname = (char *) xmalloc (pathlen + 1);
+ struct cleanup *old_chain = make_cleanup (xfree, pathname);
hex2bin (p1, (gdb_byte *) pathname, pathlen);
pathname[pathlen] = '\0';
+ discard_cleanups (old_chain);
/* This is freed during event handling. */
- event->ws.value.execd_pathname = xstrdup (pathname);
+ event->ws.value.execd_pathname = pathname;
event->ws.kind = TARGET_WAITKIND_EXECD;
/* Skip the registers included in this packet, since
break;
case 'w': /* Thread exited. */
{
- const char *p;
ULONGEST value;
event->ws.kind = TARGET_WAITKIND_THREAD_EXITED;
case 'W': /* Target exited. */
case 'X':
{
- const char *p;
int pid;
ULONGEST value;
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
/* 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. */
break;
case 'N': case 'T': case 'S': case 'X': case 'W':
{
- struct stop_reply *stop_reply;
-
/* There is a stop reply to handle. */
rs->waiting_for_stop_reply = 0;
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';
- if (vsnprintf (rs->buf, max_size, format, ap) >= max_size)
+ int size = vsnprintf (rs->buf.data (), max_size, format, ap);
+
+ va_end (ap);
+
+ if (size >= max_size)
internal_error (__FILE__, __LINE__, _("Too long remote packet."));
if (putpkt (rs->buf) < 0)
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_target::kill_new_fork_children (int pid)
{
remote_state *rs = get_remote_state ();
- struct thread_info *thread;
struct notif_client *notif = ¬if_client_stop;
/* Kill the fork child threads of any threads in process PID
that are stopped at a fork event. */
- ALL_NON_EXITED_THREADS (thread)
+ for (thread_info *thread : all_non_exited_threads ())
{
struct target_waitstatus *ws = &thread->pending_follow;
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]))
/* 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 ();
if (remote_exec_file[0])
error (_("Remote target does not support \"set remote exec-file\""));
if (!args.empty ())
- error (_("Remote target does not support \"set args\" or run <ARGS>"));
+ error (_("Remote target does not support \"set args\" or run ARGS"));
/* Fall back to "R". */
extended_remote_restart ();
}
- if (!have_inferiors ())
- {
- /* Clean up from the last time we ran, before we mark the target
- running again. This will mark breakpoints uninserted, and
- get_offsets may insert breakpoints. */
- init_thread_list ();
- init_wait_for_inferior ();
- }
-
/* 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");
}
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 result;
+ ULONGEST addr;
- unpack_varlen_hex (rs->buf, &result);
- return result;
+ unpack_varlen_hex (rs->buf.data (), &addr);
+ return addr;
}
else if (result == PACKET_UNKNOWN)
throw_error (TLS_GENERIC_ERROR,
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 result;
-
- unpack_varlen_hex (rs->buf, &result);
+ ULONGEST val;
+ unpack_varlen_hex (rs->buf.data (), &val);
if (addr)
- *addr = (CORE_ADDR) result;
+ *addr = (CORE_ADDR) val;
return true;
}
else if (result == PACKET_UNKNOWN)
struct remote_g_packet_guess
{
+ remote_g_packet_guess (int bytes_, const struct target_desc *tdesc_)
+ : bytes (bytes_),
+ tdesc (tdesc_)
+ {
+ }
+
int bytes;
const struct target_desc *tdesc;
};
-typedef struct remote_g_packet_guess remote_g_packet_guess_s;
-DEF_VEC_O(remote_g_packet_guess_s);
-struct remote_g_packet_data
+struct remote_g_packet_data : public allocate_on_obstack
{
- VEC(remote_g_packet_guess_s) *guesses;
+ std::vector<remote_g_packet_guess> guesses;
};
static struct gdbarch_data *remote_g_packet_data_handle;
static void *
remote_g_packet_data_init (struct obstack *obstack)
{
- return OBSTACK_ZALLOC (obstack, struct remote_g_packet_data);
+ return new (obstack) remote_g_packet_data;
}
void
struct remote_g_packet_data *data
= ((struct remote_g_packet_data *)
gdbarch_data (gdbarch, remote_g_packet_data_handle));
- struct remote_g_packet_guess new_guess, *guess;
- int ix;
gdb_assert (tdesc != NULL);
- for (ix = 0;
- VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
- ix++)
- if (guess->bytes == bytes)
+ for (const remote_g_packet_guess &guess : data->guesses)
+ if (guess.bytes == bytes)
internal_error (__FILE__, __LINE__,
_("Duplicate g packet description added for size %d"),
bytes);
- new_guess.bytes = bytes;
- new_guess.tdesc = tdesc;
- VEC_safe_push (remote_g_packet_guess_s, data->guesses, &new_guess);
+ data->guesses.emplace_back (bytes, tdesc);
}
-/* Return 1 if remote_read_description would do anything on this target
- and architecture, 0 otherwise. */
+/* Return true if remote_read_description would do anything on this target
+ and architecture, false otherwise. */
-static int
+static bool
remote_read_description_p (struct target_ops *target)
{
struct remote_g_packet_data *data
= ((struct remote_g_packet_data *)
gdbarch_data (target_gdbarch (), remote_g_packet_data_handle));
- if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
- return 1;
-
- return 0;
+ return !data->guesses.empty ();
}
const struct target_desc *
if (!target_has_execution || inferior_ptid == null_ptid)
return beneath ()->read_description ();
- if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
+ if (!data->guesses.empty ())
{
- struct remote_g_packet_guess *guess;
- int ix;
int bytes = send_g_packet ();
- for (ix = 0;
- VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
- ix++)
- if (guess->bytes == bytes)
- return guess->tdesc;
+ for (const remote_g_packet_guess &guess : data->guesses)
+ if (guess.bytes == bytes)
+ return guess.tdesc;
/* We discard the g packet. A minor optimization would be to
hold on to it, and fill the register cache once we have selected
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
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)
{
remote_target::remote_btrace_maybe_reopen ()
{
struct remote_state *rs = get_remote_state ();
- struct thread_info *tp;
int btrace_target_pushed = 0;
#if !defined (HAVE_LIBIPT)
int warned = 0;
scoped_restore_current_thread restore_thread;
- ALL_NON_EXITED_THREADS (tp)
+ for (thread_info *tp : all_non_exited_threads ())
{
set_general_thread (tp->ptid);
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), &rs->buf[2]);
else
error (_("Could not enable branch tracing for %s."),
target_pid_to_str (ptid));
{
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), &rs->buf[2]);
else
error (_("Could not disable branch tracing for %s."),
target_pid_to_str (tinfo->ptid));
int handle_len,
inferior *inf)
{
- struct thread_info *tp;
-
- ALL_NON_EXITED_THREADS (tp)
+ for (thread_info *tp : all_non_exited_threads ())
{
remote_thread_info *priv = get_remote_thread_info (tp);
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;
}