/* Remote target communications for serial-line targets in custom GDB protocol
- Copyright (C) 1988-2018 Free Software Foundation, Inc.
+ Copyright (C) 1988-2020 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 "gdbsupport/filestuff.h"
+#include "gdbsupport/rsp-low.h"
#include "disasm.h"
#include "location.h"
-#include "gdb_sys_time.h"
+#include "gdbsupport/gdb_sys_time.h"
#include "event-loop.h"
#include "event-top.h"
#include "tracepoint.h"
#include "ax.h"
#include "ax-gdb.h"
-#include "agent.h"
+#include "gdbsupport/agent.h"
#include "btrace.h"
#include "record-btrace.h"
#include <algorithm>
-#include "common/scoped_restore.h"
-#include "environ.h"
-#include "common/byte-vector.h"
+#include "gdbsupport/scoped_restore.h"
+#include "gdbsupport/environ.h"
+#include "gdbsupport/byte-vector.h"
+#include <algorithm>
#include <unordered_map>
/* The remote target. */
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
bool S = false;
};
-/* About this many threadisds fit in a packet. */
+/* About this many threadids fit in a packet. */
#define MAXTHREADLISTRESULTS 32
/* 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.). */
/* The status of the stub support for the various vCont actions. */
vCont_action_support supports_vCont;
+ /* Whether vCont support was probed already. This is a workaround
+ until packet_support is per-connection. */
+ bool supports_vCont_probed;
/* True if the user has pressed Ctrl-C, but the target hasn't
responded to that. */
const target_info &info () const override
{ return remote_target_info; }
+ const char *connection_string () override;
+
thread_control_capabilities get_thread_control_capabilities () override
{ return tc_schedlock; }
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;
void async (int) override;
+ int async_wait_fd () override;
+
void thread_events (int) override;
int can_do_single_step () override;
const struct btrace_config *btrace_conf (const struct btrace_target_info *) override;
bool augmented_libraries_svr4_read () override;
int follow_fork (int, int) override;
- void follow_exec (struct inferior *, char *) override;
+ void follow_exec (struct inferior *, const char *) override;
int insert_fork_catchpoint (int) override;
int remove_fork_catchpoint (int) override;
int insert_vfork_catchpoint (int) override;
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 ();
};
/* Per-program-space data key. */
-static const struct program_space_data *remote_pspace_data;
+static const struct program_space_key<char, gdb::xfree_deleter<char>>
+ remote_pspace_data;
/* The variable registered as the control variable used by the
remote exec-file commands. While the remote exec-file setting is
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);
-static void remote_unpush_and_throw (void);
+static void remote_unpush_and_throw (remote_target *target);
/* For "remote". */
/* Controls whether GDB is willing to use range stepping. */
-static int use_range_stepping = 1;
-
-/* The max number of chars in debug output. The rest of chars are
- omitted. */
-
-#define REMOTE_DEBUG_MAX_CHAR 512
+static bool use_range_stepping = true;
/* Private data that we'll store in (struct thread_info)->priv. */
struct remote_thread_info : public private_thread_info
};
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;
return &m_remote_state;
}
-/* Cleanup routine for the remote module's pspace data. */
-
-static void
-remote_pspace_data_cleanup (struct program_space *pspace, void *arg)
-{
- char *remote_exec_file = (char *) arg;
-
- xfree (remote_exec_file);
-}
-
/* Fetch the remote exec-file from the current program space. */
static const char *
{
char *remote_exec_file;
- remote_exec_file
- = (char *) program_space_data (current_program_space,
- remote_pspace_data);
+ remote_exec_file = remote_pspace_data.get (current_program_space);
if (remote_exec_file == NULL)
return "";
static void
set_pspace_remote_exec_file (struct program_space *pspace,
- char *remote_exec_file)
+ const char *remote_exec_file)
{
- char *old_file = (char *) program_space_data (pspace, remote_pspace_data);
+ char *old_file = remote_pspace_data.get (pspace);
xfree (old_file);
- set_program_space_data (pspace, remote_pspace_data,
- xstrdup (remote_exec_file));
+ remote_pspace_data.set (pspace, xstrdup (remote_exec_file));
}
/* The "set/show remote exec-file" set command hook. */
show_remote_exec_file (struct ui_file *file, int from_tty,
struct cmd_list_element *cmd, const char *value)
{
- fprintf_filtered (file, "%s\n", remote_exec_file_var);
-}
-
-static int
-compare_pnums (const void *lhs_, const void *rhs_)
-{
- const struct packet_reg * const *lhs
- = (const struct packet_reg * const *) lhs_;
- const struct packet_reg * const *rhs
- = (const struct packet_reg * const *) rhs_;
-
- if ((*lhs)->pnum < (*rhs)->pnum)
- return -1;
- else if ((*lhs)->pnum == (*rhs)->pnum)
- return 0;
- else
- return 1;
+ fprintf_filtered (file, "%s\n", get_remote_exec_file ());
}
static int
if (regs[regnum].pnum != -1)
remote_regs[num_remote_regs++] = ®s[regnum];
- qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
- compare_pnums);
+ std::sort (remote_regs, remote_regs + num_remote_regs,
+ [] (const packet_reg *a, const packet_reg *b)
+ { return a->pnum < b->pnum; });
for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
{
static remote_target *
get_current_remote_target ()
{
- target_ops *proc_target = find_target_at (process_stratum);
+ target_ops *proc_target = current_inferior ()->process_target ();
return dynamic_cast<remote_target *> (proc_target);
}
to the remote target when gdb connects to it.
This is mostly needed when you debug the Linux kernel: The Linux kernel
expects BREAK g which is Magic SysRq g for connecting gdb. */
-static int interrupt_on_connect = 0;
+static bool interrupt_on_connect = false;
/* This variable is used to implement the "set/show remotebreak" commands.
Since these commands are now deprecated in favor of "set/show remote
interrupt-sequence", it no longer has any effect on the code. */
-static int remote_break;
+static bool remote_break;
static void
set_remotebreak (const char *args, int from_tty, struct cmd_list_element *c)
memory packets to ``host::sizeof long'' bytes - (typically 32
bits). Consequently, for 64 bit targets, the upper 32 bits of an
address was never sent. Since fixing this bug may cause a break in
- some remote targets this variable is principly provided to
+ some remote targets this variable is principally provided to
facilitate backward compatibility. */
static unsigned int remote_address_size;
/* 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;
}
}
}
+/* FIXME: needs to be per-remote-target. */
static struct memory_packet_config memory_write_packet_config =
{
"memory-write-packet-size",
"breakpoints is %s.\n"), value);
}
+/* Controls the maximum number of characters to display in the debug output
+ for each remote packet. The remaining characters are omitted. */
+
+static int remote_packet_max_chars = 512;
+
+/* Show the maximum number of characters to display for each remote packet
+ when remote debugging is enabled. */
+
+static void
+show_remote_packet_max_chars (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+ fprintf_filtered (file, _("Number of remote packet characters to "
+ "display is %s.\n"), value);
+}
+
long
remote_target::get_memory_write_packet_size ()
{
return get_memory_packet_size (&memory_write_packet_config);
}
+/* FIXME: needs to be per-remote-target. */
static struct memory_packet_config memory_read_packet_config =
{
"memory-read-packet-size",
config->name = name;
config->title = title;
- set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
+ set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
name, title);
show_doc = xstrprintf ("Show current use of remote "
- "protocol `%s' (%s) packet",
+ "protocol `%s' (%s) packet.",
name, title);
/* set/show TITLE-packet {auto,on,off} */
cmd_name = xstrprintf ("%s-packet", title);
if (buf[0] == 'E'
&& isxdigit (buf[1]) && isxdigit (buf[2])
&& buf[3] == '\0')
- /* "Enn" - definitly an error. */
+ /* "Enn" - definitely an error. */
return PACKET_ERROR;
/* Always treat "E." as an error. This will be used for
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,
PACKET_qXfer_libraries,
PACKET_qXfer_libraries_svr4,
PACKET_qXfer_memory_map,
- PACKET_qXfer_spu_read,
- PACKET_qXfer_spu_write,
PACKET_qXfer_osdata,
PACKET_qXfer_threads,
PACKET_qXfer_statictrace_read,
PACKET_MAX
};
+/* FIXME: needs to be per-remote-target. Ignoring this for now,
+ assuming all remote targets are the same server (thus all support
+ the same packets). */
static struct packet_config remote_protocol_packets[PACKET_MAX];
/* Returns the packet's corresponding "set remote foo-packet" command
\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;
between program/address spaces. We simply bind the inferior
to the program space's address space. */
inf = current_inferior ();
+
+ /* However, if the current inferior is already bound to a
+ process, find some other empty inferior. */
+ if (inf->pid != 0)
+ {
+ inf = nullptr;
+ for (inferior *it : all_inferiors ())
+ if (it->pid == 0)
+ {
+ inf = it;
+ break;
+ }
+ }
+ if (inf == nullptr)
+ {
+ /* Since all inferiors were already bound to a process, add
+ a new inferior. */
+ inf = add_inferior_with_spaces ();
+ }
+ switch_to_inferior_no_thread (inf);
+ push_target (this);
inferior_appeared (inf, pid);
}
}
static remote_thread_info *get_remote_thread_info (thread_info *thread);
-static remote_thread_info *get_remote_thread_info (ptid_t ptid);
+static remote_thread_info *get_remote_thread_info (remote_target *target,
+ ptid_t ptid);
/* Add thread PTID to GDB's thread list. Tag it as executing/running
according to RUNNING. */
might be confusing to the user. Be silent then, preserving the
age old behavior. */
if (rs->starting_up)
- thread = add_thread_silent (ptid);
+ thread = add_thread_silent (this, ptid);
else
- thread = add_thread (ptid);
+ thread = add_thread (this, ptid);
get_remote_thread_info (thread)->vcont_resumed = executing;
- set_executing (ptid, executing);
- set_running (ptid, running);
+ set_executing (this, ptid, executing);
+ set_running (this, ptid, running);
return thread;
}
/* If this is a new thread, add it to GDB's thread list.
If we leave it up to WFI to do this, bad things will happen. */
- thread_info *tp = find_thread_ptid (currthread);
+ thread_info *tp = find_thread_ptid (this, currthread);
if (tp != NULL && tp->state == THREAD_EXITED)
{
/* We're seeing an event on a thread id we knew had exited.
return;
}
- if (!in_thread_list (currthread))
+ if (!in_thread_list (this, currthread))
{
struct inferior *inf = NULL;
int pid = currthread.pid ();
stub doesn't support qC. This is the first stop reported
after an attach, so this is the main thread. Update the
ptid in the thread list. */
- if (in_thread_list (ptid_t (pid)))
- thread_change_ptid (inferior_ptid, currthread);
+ if (in_thread_list (this, ptid_t (pid)))
+ thread_change_ptid (this, inferior_ptid, currthread);
else
{
remote_add_thread (currthread, running, executing);
doesn't support qC. This is the first stop reported
after an attach, so this is the main thread. Update the
ptid in the thread list. */
- thread_change_ptid (inferior_ptid, currthread);
+ thread_change_ptid (this, inferior_ptid, currthread);
return;
}
extended-remote which already was debugging an inferior, we
may not know about it yet. Add it before adding its child
thread, so notifications are emitted in a sensible order. */
- if (find_inferior_pid (currthread.pid ()) == NULL)
+ if (find_inferior_pid (this, 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);
return static_cast<remote_thread_info *> (thread->priv.get ());
}
+/* Return PTID's private thread data, creating it if necessary. */
+
static remote_thread_info *
-get_remote_thread_info (ptid_t ptid)
+get_remote_thread_info (remote_target *target, ptid_t ptid)
{
- thread_info *thr = find_thread_ptid (ptid);
+ thread_info *thr = find_thread_ptid (target, ptid);
return get_remote_thread_info (thr);
}
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');
}
/* About these extended threadlist and threadinfo packets. They are
variable length packets but, the fields within them are often fixed
- length. They are redundent enough to send over UDP as is the
+ length. They are redundant enough to send over UDP as is the
remote protocol in general. There is a matching unit test module
in libstub. */
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. */
}
copy_threadref (&info->threadid, &ref);
- /* Loop on tagged fields , try to bail if somthing goes wrong. */
+ /* Loop on tagged fields , try to bail if something goes wrong. */
/* Packets are terminated with nulls. */
while ((pkt < limit) && mask && *pkt)
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);
struct remote_state *rs = get_remote_state ();
int result = 1;
- /* Trancate result limit to be smaller than the packet size. */
+ /* Truncate result limit to be smaller than the packet size. */
if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10)
>= get_remote_packet_size ())
result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
- pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
+ pack_threadlist_request (rs->buf.data (), startflag, result_limit,
+ nextthread);
putpkt (rs->buf);
- getpkt (&rs->buf, &rs->buf_size, 0);
- if (*rs->buf == '\0')
+ getpkt (&rs->buf, 0);
+ if (rs->buf[0] == '\0')
{
/* Packet not supported. */
return -1;
}
*result_count =
- parse_threadlist_response (rs->buf + 2, result_limit,
+ parse_threadlist_response (&rs->buf[2], result_limit,
&rs->echo_nextthread, threadlist, done);
if (!threadmatch (&rs->echo_nextthread, nextthread))
{
/* FIXME: This is a good reason to drop the packet. */
- /* Possably, there is a duplicate response. */
- /* Possabilities :
+ /* Possibly, there is a duplicate response. */
+ /* Possibilities :
retransmit immediatly - race conditions
retransmit after timeout - yes
exit
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;
}
target. */
for (thread_info *tp : all_threads_safe ())
{
+ if (tp->inf->process_target () != this)
+ continue;
+
if (!context.contains_thread (tp->ptid))
{
/* Not found. */
remote_notice_new_inferior (item.ptid, executing);
- thread_info *tp = find_thread_ptid (item.ptid);
+ thread_info *tp = find_thread_ptid (this, item.ptid);
remote_thread_info *info = get_remote_thread_info (tp);
info->core = item.core;
info->extra = std::move (item.extra);
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 ();
/* Make sure we leave stdin registered in the event loop. */
terminal_ours ();
- /* We don't have a connection to the remote stub anymore. Get rid
- of all the inferiors and their threads we were controlling.
- Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
- will be unable to find the thread corresponding to (pid, 0, 0). */
- inferior_ptid = null_ptid;
- discard_all_inferiors ();
-
trace_reset_local_state ();
delete this;
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. */
char *ptr;
int lose, num_segments = 0, do_sections, do_segments;
CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
- struct section_offsets *offs;
struct symfile_segment_data *data;
if (symfile_objfile == NULL)
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
else if (*ptr != '\0')
warning (_("Target reported unsupported offsets: %s"), buf);
- offs = ((struct section_offsets *)
- alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
- memcpy (offs, symfile_objfile->section_offsets,
- SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
+ section_offsets offs = symfile_objfile->section_offsets;
data = get_symfile_segment_data (symfile_objfile->obfd);
do_segments = (data != NULL);
if (do_sections)
{
- offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
+ offs[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
/* This is a temporary kludge to force data and bss to use the
same offsets because that's what nlmconv does now. The real
solution requires changes to the stub and remote.c that I
don't have time to do right now. */
- offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
- offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
+ offs[SECT_OFF_DATA (symfile_objfile)] = data_addr;
+ offs[SECT_OFF_BSS (symfile_objfile)] = data_addr;
}
objfile_relocate (symfile_objfile, offs);
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);
/* Add the main thread and switch to it. Don't try reading
registers yet, since we haven't fetched the target description
yet. */
- thread_info *tp = add_thread_silent (curr_ptid);
+ thread_info *tp = add_thread_silent (this, curr_ptid);
switch_to_thread_no_regs (tp);
}
if (ignore_event)
continue;
- struct thread_info *evthread = find_thread_ptid (event_ptid);
+ thread_info *evthread = find_thread_ptid (this, event_ptid);
if (ws.kind == TARGET_WAITKIND_STOPPED)
{
|| ws.value.sig != GDB_SIGNAL_0)
evthread->suspend.waitstatus_pending_p = 1;
- set_executing (event_ptid, 0);
- set_running (event_ptid, 0);
+ set_executing (this, event_ptid, 0);
+ set_running (this, event_ptid, 0);
get_remote_thread_info (evthread)->vcont_resumed = 0;
}
/* "Notice" the new inferiors before anything related to
registers/memory. */
- for (inferior *inf : all_non_exited_inferiors ())
+ for (inferior *inf : all_non_exited_inferiors (this))
{
inf->needs_setup = 1;
/* If all threads of an inferior were already stopped, we
haven't setup the inferior yet. */
- for (inferior *inf : all_non_exited_inferiors ())
+ for (inferior *inf : all_non_exited_inferiors (this))
{
if (inf->needs_setup)
{
/* 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. */
- for (thread_info *thread : all_non_exited_threads ())
+ for (thread_info *thread : all_non_exited_threads (this))
{
if (first == NULL)
first = thread;
/* For "info program". */
thread_info *thread = inferior_thread ();
if (thread->state == THREAD_STOPPED)
- set_last_target_status (inferior_ptid, thread->suspend.waitstatus);
+ set_last_target_status (this, inferior_ptid, thread->suspend.waitstatus);
}
/* Start the remote connection and sync state. */
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. */
/* Let the stub know that we want it to return the thread. */
set_continue_thread (minus_one_ptid);
- if (thread_count () == 0)
+ if (thread_count (this) == 0)
{
/* Target has no concept of threads at all. GDB treats
non-threaded target as single-threaded; add a main
says should be current. If we're reconnecting to a
multi-threaded program, this will ideally be the thread
that last reported an event before GDB disconnected. */
- inferior_ptid = get_current_thread (wait_status);
- if (inferior_ptid == null_ptid)
+ ptid_t curr_thread = get_current_thread (wait_status);
+ if (curr_thread == null_ptid)
{
/* Odd... The target was able to list threads, but not
tell us which thread was current (no "thread"
"warning: couldn't determine remote "
"current thread; picking first in list.\n");
- inferior_ptid = inferior_list->thread_list->ptid;
+ for (thread_info *tp : all_non_exited_threads (this,
+ minus_one_ptid))
+ {
+ switch_to_thread (tp);
+ break;
+ }
}
+ else
+ switch_to_thread (find_thread_ptid (this, curr_thread));
}
/* init_wait_for_inferior should be called before get_offsets in order
/* 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);
}
- if (thread_count () == 0)
+ if (thread_count (this) == 0)
{
if (!extended_p)
error (_("The target is not running (try extended-remote?)"));
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. */
insert_breakpoints ();
}
+const char *
+remote_target::connection_string ()
+{
+ remote_state *rs = get_remote_state ();
+
+ if (rs->remote_desc->name != NULL)
+ return rs->remote_desc->name;
+ else
+ return NULL;
+}
+
/* Open a connection to a remote debugger.
NAME is the filename used for communication. */
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
rs->explicit_packet_size = packet_size;
}
-void
+static void
remote_packet_size (remote_target *remote, const protocol_feature *feature,
enum packet_support support, const char *value)
{
remote_supported_packet, PACKET_augmented_libraries_svr4_read_feature },
{ "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_memory_map },
- { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
- PACKET_qXfer_spu_read },
- { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
- PACKET_qXfer_spu_write },
{ "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_osdata },
{ "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet,
else
{
char *copy = xstrdup (remote_support_xml + 13);
- char *p = strtok (copy, ",");
+ char *saveptr;
+ char *p = strtok_r (copy, ",", &saveptr);
do
{
return;
}
}
- while ((p = strtok (NULL, ",")) != NULL);
+ while ((p = strtok_r (NULL, ",", &saveptr)) != NULL);
xfree (copy);
remote_support_xml = reconcat (remote_support_xml,
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++)
{
if (query (_("The target is not responding to GDB commands.\n"
"Stop debugging it? ")))
- remote_unpush_and_throw ();
+ remote_unpush_and_throw (this);
}
/* If ^C has already been sent once, offer to disconnect. */
else if (!target_terminal::is_ours () && rs->ctrlc_pending_p)
curr_quit_handler_target->remote_serial_quit_handler ();
}
-/* Remove any of the remote.c targets from target stack. Upper targets depend
- on it so remove them first. */
+/* Remove the remote target from the target stack of each inferior
+ that is using it. Upper targets depend on it so remove them
+ first. */
static void
-remote_unpush_target (void)
+remote_unpush_target (remote_target *target)
{
- pop_all_targets_at_and_above (process_stratum);
+ /* We have to unpush the target from all inferiors, even those that
+ aren't running. */
+ scoped_restore_current_inferior restore_current_inferior;
+
+ for (inferior *inf : all_inferiors (target))
+ {
+ switch_to_inferior_no_thread (inf);
+ pop_all_targets_at_and_above (process_stratum);
+ generic_mourn_inferior ();
+ }
}
static void
-remote_unpush_and_throw (void)
+remote_unpush_and_throw (remote_target *target)
{
- remote_unpush_target ();
+ remote_unpush_target (target);
throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target."));
}
/* If we're connected to a running target, target_preopen will kill it.
Ask this question first, before target_preopen has a chance to kill
anything. */
- if (curr_remote != NULL && !have_inferiors ())
+ if (curr_remote != NULL && !target_has_execution)
{
if (from_tty
&& !query (_("Already connected to a remote target. Disconnect? ")))
}
/* 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);
+ remote_unpush_target (remote);
+ 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')
;
remote_detach_pid (pid);
/* Exit only if this is the only active inferior. */
- if (from_tty && !rs->extended && number_of_live_inferiors () == 1)
+ if (from_tty && !rs->extended && number_of_live_inferiors (this) == 1)
puts_filtered (_("Ending remote debugging.\n"));
- struct thread_info *tp = find_thread_ptid (inferior_ptid);
+ thread_info *tp = find_thread_ptid (this, inferior_ptid);
/* Check to see if we are detaching a fork parent. Note that if we
are detaching a fork child, tp == NULL. */
follow-exec-mode is "new". */
void
-remote_target::follow_exec (struct inferior *inf, char *execd_pathname)
+remote_target::follow_exec (struct inferior *inf, const char *execd_pathname)
{
/* We know that this is a target file name, so if it has the "target:"
prefix we strip it off before saving it in the program space. */
error (_("Argument given to \"disconnect\" when remotely debugging."));
/* Make sure we unpush even the extended remote targets. Calling
- target_mourn_inferior won't unpush, and remote_mourn won't
- unpush if there is more than one inferior left. */
- unpush_target (this);
- generic_mourn_inferior ();
+ target_mourn_inferior won't unpush, and
+ remote_target::mourn_inferior won't unpush if there is more than
+ one inferior left. */
+ remote_unpush_target (this);
if (from_tty)
puts_filtered ("Ending remote debugging.\n");
if (from_tty)
{
- char *exec_file = get_exec_file (0);
+ const char *exec_file = get_exec_file (0);
if (exec_file)
printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
- target_pid_to_str (ptid_t (pid)));
+ target_pid_to_str (ptid_t (pid)).c_str ());
else
printf_unfiltered (_("Attaching to %s\n"),
- target_pid_to_str (ptid_t (pid)));
-
- gdb_flush (gdb_stdout);
+ target_pid_to_str (ptid_t (pid)).c_str ());
}
- xsnprintf (rs->buf, get_remote_packet_size (), "vAttach;%x", pid);
+ xsnprintf (rs->buf.data (), get_remote_packet_size (), "vAttach;%x", pid);
putpkt (rs->buf);
- getpkt (&rs->buf, &rs->buf_size, 0);
+ getpkt (&rs->buf, 0);
switch (packet_ok (rs->buf,
&remote_protocol_packets[PACKET_vAttach]))
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);
inferior_ptid = remote_current_thread (inferior_ptid);
/* Add the main thread to the thread list. */
- thread_info *thr = add_thread_silent (inferior_ptid);
+ thread_info *thr = add_thread_silent (this, inferior_ptid);
/* Don't consider the thread stopped until we've processed the
saved stop reply. */
- set_executing (thr->ptid, true);
+ set_executing (this, thr->ptid, true);
}
/* Next, if the target can specify a description, read it. We do
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]);
+ rs->supports_vCont_probed = true;
}
/* Helper function for building "vCont" resumptions. Write a
{
/* If we don't know about the target thread's tid, then
we're resuming magic_null_ptid (see caller). */
- tp = find_thread_ptid (magic_null_ptid);
+ tp = find_thread_ptid (this, magic_null_ptid);
}
else
- tp = find_thread_ptid (ptid);
+ tp = find_thread_ptid (this, ptid);
gdb_assert (tp != NULL);
if (tp->control.may_range_step)
remote_target::append_pending_thread_resumptions (char *p, char *endp,
ptid_t ptid)
{
- for (thread_info *thread : all_non_exited_threads (ptid))
+ for (thread_info *thread : all_non_exited_threads (this, ptid))
if (inferior_ptid != thread->ptid
&& thread->suspend.stop_signal != GDB_SIGNAL_0)
{
else
set_continue_thread (ptid);
- for (thread_info *thread : all_non_exited_threads ())
+ for (thread_info *thread : all_non_exited_threads (this))
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;
remote_thread_info *remote_thr;
if (minus_one_ptid == ptid || ptid.is_pid ())
- remote_thr = get_remote_thread_info (inferior_ptid);
+ remote_thr = get_remote_thread_info (this, inferior_ptid);
else
- remote_thr = get_remote_thread_info (ptid);
+ remote_thr = get_remote_thread_info (this, ptid);
remote_thr->last_resume_step = step;
remote_thr->last_resume_sig = siggnal;
{
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
may_global_wildcard_vcont = 1;
/* And assume every process is individually wildcard-able too. */
- for (inferior *inf : all_non_exited_inferiors ())
+ for (inferior *inf : all_non_exited_inferiors (this))
{
remote_inferior *priv = get_remote_inferior (inf);
disable process and global wildcard resumes appropriately. */
check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont);
- for (thread_info *tp : all_non_exited_threads ())
+ for (thread_info *tp : all_non_exited_threads (this))
{
/* 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. */
- for (thread_info *tp : all_non_exited_threads ())
+ for (thread_info *tp : all_non_exited_threads (this))
{
remote_thread_info *remote_thr = get_remote_thread_info (tp);
supposed to be resumed. */
any_process_wildcard = 0;
- for (inferior *inf : all_non_exited_inferiors ())
+ for (inferior *inf : all_non_exited_inferiors (this))
{
if (get_remote_inferior (inf)->may_wildcard_vcont)
{
}
else
{
- for (inferior *inf : all_non_exited_inferiors ())
+ for (inferior *inf : all_non_exited_inferiors (this))
{
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)
+ /* FIXME: This supports_vCont_probed check is a workaround until
+ packet_support is per-connection. */
+ if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN
+ || !rs->supports_vCont_probed)
remote_vcont_probe ();
if (!rs->supports_vCont.t)
/* 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 ());
}
}
if (query (_("The target is not responding to interrupt requests.\n"
"Stop debugging it? ")))
{
- remote_unpush_target ();
+ remote_unpush_target (this);
throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target."));
}
}
}
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. */
return rs->stop_reply_queue.size ();
}
-void
+static 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. */
/* For any threads stopped at a fork event, remove the corresponding
fork child threads from the CONTEXT list. */
- for (thread_info *thread : all_non_exited_threads ())
+ for (thread_info *thread : all_non_exited_threads (this))
{
struct target_waitstatus *ws = thread_pending_fork_status (thread);
|| event->ws.kind == TARGET_WAITKIND_VFORKED)
*may_global_wildcard = 0;
- struct inferior *inf = find_inferior_ptid (event->ptid);
+ struct inferior *inf = find_inferior_ptid (this, event->ptid);
/* This may be the first time we heard about this process.
Regardless, we must not do a global wildcard resume, otherwise
/* 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 (rsa == NULL)
{
- inferior *inf = (event->ptid == null_ptid
- ? NULL
- : find_inferior_ptid (event->ptid));
+ inferior *inf
+ = (event->ptid == null_ptid
+ ? NULL
+ : find_inferior_ptid (this, event->ptid));
/* If this is the first time we learn anything
about this process, skip the registers
included in this packet, since we don't yet
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
{
case 'W': /* Target exited. */
case 'X':
{
- int pid;
ULONGEST value;
/* GDB used to accept only 2 hex chars here. Stubs should
event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
}
- /* If no process is specified, assume inferior_ptid. */
- pid = inferior_ptid.pid ();
+ /* If no process is specified, return null_ptid, and let the
+ caller figure out the right process to use. */
+ int pid = 0;
if (*p == '\0')
;
else if (*p == ';')
<GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
2.5) <-- (registers reply to step #2.3)
- Eventualy after step #2.5, we return to the event loop, which
+ Eventually after step #2.5, we return to the event loop, which
notices there's an event on the
REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
associated callback --- the function below. At this point, we're
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;
+ = get_thread_arch_regcache (this, ptid, stop_reply->arch);
- 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_thread_info *remote_thr = get_remote_thread_info (ptid);
+ remote_thread_info *remote_thr = get_remote_thread_info (this, ptid);
remote_thr->core = stop_reply->core;
remote_thr->stop_reason = stop_reply->stop_reason;
remote_thr->watch_data_address = stop_reply->watch_data_address;
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);
}
}
+/* Return the first resumed thread. */
+
+static ptid_t
+first_remote_resumed_thread (remote_target *target)
+{
+ for (thread_info *tp : all_non_exited_threads (target, minus_one_ptid))
+ if (tp->resumed)
+ return tp->ptid;
+ return null_ptid;
+}
+
/* Wait until the remote machine stops, then return, storing status in
STATUS just as `wait' would. */
_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 (event_ptid != null_ptid)
record_currthread (rs, event_ptid);
else
- event_ptid = inferior_ptid;
+ event_ptid = first_remote_resumed_thread (this);
}
else
- /* A process exit. Invalidate our notion of current thread. */
- record_currthread (rs, minus_one_ptid);
+ {
+ /* A process exit. Invalidate our notion of current thread. */
+ record_currthread (rs, minus_one_ptid);
+ /* It's possible that the packet did not include a pid. */
+ if (event_ptid == null_ptid)
+ event_ptid = first_remote_resumed_thread (this);
+ /* EVENT_PTID could still be NULL_PTID. Double-check. */
+ if (event_ptid == null_ptid)
+ event_ptid = magic_null_ptid;
+ }
return event_ptid;
}
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);
secp = target_section_by_addr (this, memaddr);
if (secp != NULL
- && (bfd_get_section_flags (secp->the_bfd_section->owner,
- secp->the_bfd_section)
- & SEC_READONLY))
+ && (bfd_section_flags (secp->the_bfd_section) & SEC_READONLY))
{
struct target_section *p;
ULONGEST memend = memaddr + len;
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 output compatibility with throw_perror_with_name. */
static void
-unpush_and_perror (const char *string)
+unpush_and_perror (remote_target *target, const char *string)
{
int saved_errno = errno;
- remote_unpush_target ();
+ remote_unpush_target (target);
throw_error (TARGET_CLOSE_ERROR, "%s: %s.", string,
safe_strerror (saved_errno));
}
switch ((enum serial_rc) ch)
{
case SERIAL_EOF:
- remote_unpush_target ();
+ remote_unpush_target (this);
throw_error (TARGET_CLOSE_ERROR, _("Remote connection closed"));
/* no return */
case SERIAL_ERROR:
- unpush_and_perror (_("Remote communication error. "
- "Target disconnected."));
+ unpush_and_perror (this, _("Remote communication error. "
+ "Target disconnected."));
/* no return */
case SERIAL_TIMEOUT:
break;
if (serial_write (rs->remote_desc, str, len))
{
- unpush_and_perror (_("Remote communication error. "
- "Target disconnected."));
+ unpush_and_perror (this, _("Remote communication error. "
+ "Target disconnected."));
}
if (rs->got_ctrlc_during_io)
*p = '\0';
int len = (int) (p - buf2);
+ int max_chars;
+
+ if (remote_packet_max_chars < 0)
+ max_chars = len;
+ else
+ max_chars = remote_packet_max_chars;
std::string str
- = escape_buffer (buf2, std::min (len, REMOTE_DEBUG_MAX_CHAR));
+ = escape_buffer (buf2, std::min (len, max_chars));
fprintf_unfiltered (gdb_stdlog, "Sending packet: %s", str.c_str ());
- if (len > REMOTE_DEBUG_MAX_CHAR)
+ if (len > max_chars)
fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
- len - REMOTE_DEBUG_MAX_CHAR);
+ len - max_chars);
fprintf_unfiltered (gdb_stdlog, "...");
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;
}
}
+/* Set this to the maximum number of seconds to wait instead of waiting forever
+ in target_wait(). If this timer times out, then it generates an error and
+ the command is aborted. This replaces most of the need for timeouts in the
+ GDB test suite, and makes it possible to distinguish between a hung target
+ and one with slow communications. */
+
+static int watchdog = 0;
+static void
+show_watchdog (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Watchdog timer is %s.\n"), value);
+}
+
/* Read a packet from the remote machine, with error checking, and
- store it in *BUF. Resize *BUF using xrealloc if necessary to hold
- the result, and update *SIZEOF_BUF. If FOREVER, wait forever
- rather than timing out; this is used (in synchronous mode) to wait
- for a target that is is executing user code to stop. */
+ store it in *BUF. Resize *BUF if necessary to hold the result. If
+ FOREVER, wait forever rather than timing out; this is used (in
+ synchronous mode) to wait for a target that is is executing user
+ code to stop. */
/* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
don't have to change all the calls to getpkt to deal with the
return value, because at the moment I don't know what the right
thing to do it for those. */
void
-remote_target::getpkt (char **buf, long *sizeof_buf, int forever)
+remote_target::getpkt (gdb::char_vector *buf, int forever)
{
- getpkt_sane (buf, sizeof_buf, forever);
+ getpkt_sane (buf, forever);
}
/* Read a packet from the remote machine, with error checking, and
- store it in *BUF. Resize *BUF using xrealloc if necessary to hold
- the result, and update *SIZEOF_BUF. If FOREVER, wait forever
- rather than timing out; this is used (in synchronous mode) to wait
- for a target that is is executing user code to stop. If FOREVER ==
- 0, this function is allowed to time out gracefully and return an
- indication of this to the caller. Otherwise return the number of
- bytes read. If EXPECTING_NOTIF, consider receiving a notification
- enough reason to return to the caller. *IS_NOTIF is an output
- boolean that indicates whether *BUF holds a notification or not
- (a regular packet). */
+ store it in *BUF. Resize *BUF if necessary to hold the result. If
+ FOREVER, wait forever rather than timing out; this is used (in
+ synchronous mode) to wait for a target that is is executing user
+ code to stop. If FOREVER == 0, this function is allowed to time
+ out gracefully and return an indication of this to the caller.
+ Otherwise return the number of bytes read. If EXPECTING_NOTIF,
+ consider receiving a notification enough reason to return to the
+ caller. *IS_NOTIF is an output boolean that indicates whether *BUF
+ holds a notification or not (a regular packet). */
int
-remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf,
+remote_target::getpkt_or_notif_sane_1 (gdb::char_vector *buf,
int forever, int expecting_notif,
int *is_notif)
{
previously cached response. */
rs->cached_wait_status = 0;
- strcpy (*buf, "timeout");
+ strcpy (buf->data (), "timeout");
if (forever)
timeout = watchdog > 0 ? watchdog : -1;
if (forever) /* Watchdog went off? Kill the target. */
{
- remote_unpush_target ();
+ remote_unpush_target (this);
throw_error (TARGET_CLOSE_ERROR,
_("Watchdog timeout has expired. "
"Target detached."));
{
/* 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)
{
+ int max_chars;
+
+ if (remote_packet_max_chars < 0)
+ max_chars = val;
+ else
+ max_chars = remote_packet_max_chars;
+
std::string str
- = escape_buffer (*buf,
- std::min (val, REMOTE_DEBUG_MAX_CHAR));
+ = escape_buffer (buf->data (),
+ std::min (val, max_chars));
fprintf_unfiltered (gdb_stdlog, "Packet received: %s",
str.c_str ());
- if (val > REMOTE_DEBUG_MAX_CHAR)
+ if (val > max_chars)
fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
- val - REMOTE_DEBUG_MAX_CHAR);
+ val - max_chars);
fprintf_unfiltered (gdb_stdlog, "\n");
}
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
/* Kill the fork child threads of any threads in process PID
that are stopped at a fork event. */
- for (thread_info *thread : all_non_exited_threads ())
+ for (thread_info *thread : all_non_exited_threads (this))
{
struct target_waitstatus *ws = &thread->pending_follow;
inferior, then we will tell gdbserver to exit and unpush the
target. */
if (res == -1 && !remote_multi_process_p (rs)
- && number_of_live_inferiors () == 1)
+ && number_of_live_inferiors (this) == 1)
{
remote_kill_k ();
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
discard_pending_stop_replies (current_inferior ());
/* In 'target remote' mode with one inferior, we close the connection. */
- if (!rs->extended && number_of_live_inferiors () <= 1)
+ if (!rs->extended && number_of_live_inferiors (this) <= 1)
{
- unpush_target (this);
-
- /* remote_close takes care of doing most of the clean up. */
- generic_mourn_inferior ();
+ remote_unpush_target (this);
return;
}
/* Call common code to mark the inferior as not running. */
generic_mourn_inferior ();
-
- if (!have_inferiors ())
- {
- if (!remote_multi_process_p (rs))
- {
- /* Check whether the target is running now - some remote stubs
- automatically restart after kill. */
- putpkt ("?");
- getpkt (&rs->buf, &rs->buf_size, 0);
-
- if (rs->buf[0] == 'S' || rs->buf[0] == 'T')
- {
- /* Assume that the target has been restarted. Set
- inferior_ptid so that bits of core GDB realizes
- there's something here, e.g., so that the user can
- say "kill" again. */
- inferior_ptid = magic_null_ptid;
- }
- }
- }
}
bool
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]))
{
}
-int remote_hw_watchpoint_limit = -1;
-int remote_hw_watchpoint_length_limit = -1;
-int remote_hw_breakpoint_limit = -1;
+static int remote_hw_watchpoint_limit = -1;
+static int remote_hw_watchpoint_length_limit = -1;
+static int remote_hw_breakpoint_limit = -1;
int
remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
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]);
if (read_only && (s->flags & SEC_READONLY) == 0)
continue; /* Skip writeable sections */
- size = bfd_get_section_size (s);
+ size = bfd_section_size (s);
if (size == 0)
continue; /* Skip zero-length section. */
- sectname = bfd_get_section_name (exec_bfd, s);
+ sectname = bfd_section_name (s);
if (args && strcmp (args, sectname) != 0)
continue; /* Not the section selected by user. */
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,
xfered_len);
}
- /* Handle SPU memory using qxfer packets. */
- if (object == TARGET_OBJECT_SPU)
- {
- if (readbuf)
- return remote_read_qxfer ("spu", annex, readbuf, offset, len,
- xfered_len, &remote_protocol_packets
- [PACKET_qXfer_spu_read]);
- else
- return remote_write_qxfer ("spu", annex, writebuf, offset, len,
- xfered_len, &remote_protocol_packets
- [PACKET_qXfer_spu_write]);
- }
-
/* Handle extra signal info using qxfer packets. */
if (object == TARGET_OBJECT_SIGNAL_INFO)
{
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");
}
{
char hexid[20];
- pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */
+ pack_threadid (&hexid[0], ref); /* Convert thread id into hex. */
hexid[16] = 0;
printf_filtered ("%s %s\n", title, (&hexid[0]));
}
{
add_com ("tlist", class_obscure, threadlist_test_cmd,
_("Fetch and print the remote list of "
- "thread identifiers, one pkt only"));
+ "thread identifiers, one pkt only."));
add_com ("tinfo", class_obscure, threadinfo_test_cmd,
- _("Fetch and display info about one thread"));
+ _("Fetch and display info about one thread."));
add_com ("tset", class_obscure, threadset_test_cmd,
- _("Test setting to a different thread"));
+ _("Test setting to a different thread."));
add_com ("tupd", class_obscure, threadlist_update_test_cmd,
- _("Iterate through updating all remote thread info"));
+ _("Iterate through updating all remote thread info."));
add_com ("talive", class_obscure, threadalive_test,
- _(" Remote thread alive test "));
+ _("Remote thread alive test."));
}
#endif /* 0 */
-/* Convert a thread ID to a string. Returns the string in a static
- buffer. */
+/* Convert a thread ID to a string. */
-const char *
+std::string
remote_target::pid_to_str (ptid_t ptid)
{
- static char buf[64];
struct remote_state *rs = get_remote_state ();
if (ptid == null_ptid)
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."));
}
remote_target::trace_set_readonly_regions ()
{
asection *s;
- bfd *abfd = NULL;
bfd_size_type size;
bfd_vma vma;
int anysecs = 0;
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];
continue;
anysecs = 1;
- vma = bfd_get_section_vma (abfd, s);
- size = bfd_get_section_size (s);
+ vma = bfd_section_vma (s);
+ size = bfd_section_size (s);
sprintf_vma (tmp1, vma);
sprintf_vma (tmp2, vma + size);
sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2);
- if (offset + sec_length + 1 > rs->buf_size)
+ if (offset + sec_length + 1 > rs->buf.size ())
{
if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE)
warning (_("\
Too many sections for read-only sections definition packet."));
break;
}
- xsnprintf (rs->buf + offset, rs->buf_size - offset, ":%s,%s",
+ xsnprintf (rs->buf.data () + offset, rs->buf.size () - offset, ":%s,%s",
tmp1, tmp2);
offset += sec_length;
}
if (anysecs)
{
putpkt (rs->buf);
- getpkt (&rs->buf, &rs->buf_size, 0);
+ getpkt (&rs->buf, 0);
}
}
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
{
/* Initialize it just to avoid a GCC false warning. */
char *p = NULL;
- /* FIXME we need to get register block size some other way. */
- extern int trace_regblock_size;
enum packet_result result;
struct remote_state *rs = get_remote_state ();
if (packet_support (PACKET_qTStatus) == PACKET_DISABLE)
return -1;
+ /* FIXME we need to get register block size some other way. */
trace_regblock_size
= rs->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet;
putpkt ("qTStatus");
- TRY
+ try
{
p = remote_get_noisy_reply ();
}
- CATCH (ex, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != TARGET_CLOSE_ERROR)
{
exception_fprintf (gdb_stderr, ex, "qTStatus: ");
return -1;
}
- throw_exception (ex);
+ throw;
}
- END_CATCH
result = packet_ok (p, &remote_protocol_packets[PACKET_qTStatus]);
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')
int
remote_target::core_of_thread (ptid_t ptid)
{
- struct thread_info *info = find_thread_ptid (ptid);
+ thread_info *info = find_thread_ptid (this, ptid);
if (info != NULL && info->priv != NULL)
return get_remote_thread_info (info)->core;
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)
{
int warned = 0;
#endif
+ /* Don't bother walking the entirety of the remote thread list when
+ we know the feature isn't supported by the remote. */
+ if (packet_support (PACKET_qXfer_btrace_conf) != PACKET_ENABLE)
+ return;
+
scoped_restore_current_thread restore_thread;
- for (thread_info *tp : all_non_exited_threads ())
+ for (thread_info *tp : all_non_exited_threads (this))
{
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).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);
remote_target::pid_to_exec_file (int pid)
{
static gdb::optional<gdb::char_vector> filename;
- struct inferior *inf;
char *annex = NULL;
if (packet_support (PACKET_qXfer_exec_file) != PACKET_ENABLE)
return NULL;
- inf = find_inferior_pid (pid);
+ inferior *inf = find_inferior_pid (this, pid);
if (inf == NULL)
internal_error (__FILE__, __LINE__,
_("not currently attached to process %d"), pid);
int handle_len,
inferior *inf)
{
- for (thread_info *tp : all_non_exited_threads ())
+ for (thread_info *tp : all_non_exited_threads (this))
{
remote_thread_info *priv = get_remote_thread_info (tp);
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 ()
{
inferior_event_handler (INF_REG_EVENT, data);
}
+int
+remote_target::async_wait_fd ()
+{
+ struct remote_state *rs = get_remote_state ();
+ return rs->remote_desc->fd;
+}
+
void
remote_target::async (int enable)
{
if (packet_support (PACKET_QThreadEvents) == PACKET_DISABLE)
return;
- xsnprintf (rs->buf, size, "QThreadEvents:%x", enable ? 1 : 0);
+ xsnprintf (rs->buf.data (), size, "QThreadEvents:%x", enable ? 1 : 0);
putpkt (rs->buf);
- getpkt (&rs->buf, &rs->buf_size, 0);
+ getpkt (&rs->buf, 0);
switch (packet_ok (rs->buf,
&remote_protocol_packets[PACKET_QThreadEvents]))
{
case PACKET_OK:
- if (strcmp (rs->buf, "OK") != 0)
- error (_("Remote refused setting thread events: %s"), rs->buf);
+ if (strcmp (rs->buf.data (), "OK") != 0)
+ error (_("Remote refused setting thread events: %s"), rs->buf.data ());
break;
case PACKET_ERROR:
- warning (_("Remote failure reply: %s"), rs->buf);
+ warning (_("Remote failure reply: %s"), rs->buf.data ());
break;
case PACKET_UNKNOWN:
break;
/* 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;
}
remote_g_packet_data_handle =
gdbarch_data_register_pre_init (remote_g_packet_data_init);
- remote_pspace_data
- = register_program_space_data_with_cleanup (NULL,
- remote_pspace_data_cleanup);
-
add_target (remote_target_info, remote_target::open);
add_target (extended_remote_target_info, extended_remote_target::open);
/* set/show remote ... */
add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
-Remote protocol specific variables\n\
+Remote protocol specific variables.\n\
Configure various remote-protocol specific variables such as\n\
-the packets being used"),
+the packets being used."),
&remote_set_cmdlist, "set remote ",
0 /* allow-unknown */, &setlist);
add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
-Remote protocol specific variables\n\
+Remote protocol specific variables.\n\
Configure various remote-protocol specific variables such as\n\
-the packets being used"),
+the packets being used."),
&remote_show_cmdlist, "show remote ",
0 /* allow-unknown */, &showlist);
add_setshow_boolean_cmd ("interrupt-on-connect", class_support,
&interrupt_on_connect, _("\
-Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
-Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
+Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
+Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
If set, interrupt sequence is sent to remote target."),
NULL, NULL,
&remote_set_cmdlist, &remote_show_cmdlist);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
"qXfer:memory-map:read", "memory-map", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read],
- "qXfer:spu:read", "read-spu-object", 0);
-
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write],
- "qXfer:spu:write", "write-spu-object", 0);
-
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata],
"qXfer:osdata:read", "osdata", 0);
documentation). */
add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
&remote_Z_packet_detect, _("\
-Set use of remote protocol `Z' packets"), _("\
-Show use of remote protocol `Z' packets "), _("\
+Set use of remote protocol `Z' packets."), _("\
+Show use of remote protocol `Z' packets."), _("\
When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
packets."),
set_remote_protocol_Z_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist);
add_prefix_cmd ("remote", class_files, remote_command, _("\
-Manipulate files on the remote system\n\
+Manipulate files on the remote system.\n\
Transfer files to and from the remote target system."),
&remote_cmdlist, "remote ",
0 /* allow-unknown */, &cmdlist);
add_setshow_string_noescape_cmd ("exec-file", class_files,
&remote_exec_file_var, _("\
-Set the remote pathname for \"run\""), _("\
-Show the remote pathname for \"run\""), NULL,
+Set the remote pathname for \"run\"."), _("\
+Show the remote pathname for \"run\"."), NULL,
set_remote_exec_file,
show_remote_exec_file,
&remote_set_cmdlist,
&setlist,
&showlist);
+ add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\
+Set watchdog timer."), _("\
+Show watchdog timer."), _("\
+When non-zero, this timeout is used instead of waiting forever for a target\n\
+to finish a low-level step or continue operation. If the specified amount\n\
+of time passes without a response from the target, an error occurs."),
+ NULL,
+ show_watchdog,
+ &setlist, &showlist);
+
+ add_setshow_zuinteger_unlimited_cmd ("remote-packet-max-chars", no_class,
+ &remote_packet_max_chars, _("\
+Set the maximum number of characters to display for each remote packet."), _("\
+Show the maximum number of characters to display for each remote packet."), _("\
+Specify \"unlimited\" to display all the characters."),
+ NULL, show_remote_packet_max_chars,
+ &setdebuglist, &showdebuglist);
+
/* Eventually initialize fileio. See fileio.c */
initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
-
- /* Take advantage of the fact that the TID field is not used, to tag
- special ptids with it set to != 0. */
- magic_null_ptid = ptid_t (42000, -1, 1);
- not_sent_ptid = ptid_t (42000, -2, 1);
- any_thread_ptid = ptid_t (42000, 0, 1);
}