/* Remote target communications for serial-line targets in custom GDB protocol
- Copyright (C) 1988-2019 Free Software Foundation, Inc.
+ Copyright (C) 1988-2021 Free Software Foundation, Inc.
This file is part of GDB.
#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 "gdbsupport/event-loop.h"
#include "event-top.h"
#include "inf-loop.h"
#include <signal.h>
#include "serial.h"
-#include "gdbcore.h" /* for exec_bfd */
+#include "gdbcore.h"
#include "remote-fileio.h"
#include "gdb/fileio.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 "gdbsupport/search.h"
+#include <algorithm>
#include <unordered_map>
+#include "async-event.h"
+#include "gdbsupport/selftest.h"
/* The remote target. */
Specify the serial device it is connected to\n\
(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
+/* See remote.h */
+
+bool remote_debug = false;
+
#define OPAQUETHREADBYTES 8
/* a 64 bit opaque identifier */
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
/* 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 detach (inferior *, int) override;
void disconnect (const char *, int) override;
- void commit_resume () override;
+ void commit_resumed () override;
void resume (ptid_t, int, enum gdb_signal) override;
- ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
+ ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
+ bool has_pending_events () override;
void fetch_registers (struct regcache *, int) override;
void store_registers (struct regcache *, int) 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_fork (bool, bool) override;
+ void follow_exec (inferior *, ptid_t, const char *) override;
int insert_fork_catchpoint (int) override;
int remove_fork_catchpoint (int) override;
int insert_vfork_catchpoint (int) override;
int remove_exec_catchpoint (int) override;
enum exec_direction_kind execution_direction () override;
+ bool supports_memory_tagging () override;
+
+ bool fetch_memtags (CORE_ADDR address, size_t len,
+ gdb::byte_vector &tags, int type) override;
+
+ bool store_memtags (CORE_ADDR address, size_t len,
+ const gdb::byte_vector &tags, int type) override;
+
public: /* Remote specific methods. */
void remote_download_command_source (int num, ULONGEST addr,
ULONGEST offset, int *remote_errno);
int remote_hostio_send_command (int command_bytes, int which_packet,
- int *remote_errno, char **attachment,
+ int *remote_errno, const char **attachment,
int *attachment_len);
int remote_hostio_set_filesystem (struct inferior *inf,
int *remote_errno);
int remote_resume_with_vcont (ptid_t ptid, int step,
gdb_signal siggnal);
- void add_current_inferior_and_thread (char *wait_status);
+ thread_info *add_current_inferior_and_thread (const char *wait_status);
ptid_t wait_ns (ptid_t ptid, struct target_waitstatus *status,
- int options);
+ target_wait_flags options);
ptid_t wait_as (ptid_t ptid, target_waitstatus *status,
- int options);
+ target_wait_flags options);
ptid_t process_stop_reply (struct stop_reply *stop_reply,
target_waitstatus *status);
- void remote_notice_new_inferior (ptid_t currthread, int executing);
+ ptid_t select_thread_for_ambiguous_stop_reply
+ (const struct target_waitstatus *status);
+
+ void remote_notice_new_inferior (ptid_t currthread, bool executing);
void process_initial_stop_replies (int from_tty);
int stop_reply_queue_length ();
void check_pending_events_prevent_wildcard_vcont
- (int *may_global_wildcard_vcont);
+ (bool *may_global_wildcard_vcont);
void discard_pending_stop_replies_in_queue ();
struct stop_reply *remote_notif_remove_queued_reply (ptid_t ptid);
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);
- ptid_t get_current_thread (char *wait_status);
+ ptid_t get_current_thread (const char *wait_status);
void set_thread (ptid_t ptid, int gen);
void set_general_thread (ptid_t ptid);
char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
- int remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
+ int remote_unpack_thread_info_response (const char *pkt, threadref *expectedref,
gdb_ext_thread_info *info);
int remote_get_threadinfo (threadref *threadid, int fieldset,
gdb_ext_thread_info *info);
- int parse_threadlist_response (char *pkt, int result_limit,
+ int parse_threadlist_response (const char *pkt, int result_limit,
threadref *original_echo,
threadref *resultlist,
int *doneflag);
};
/* 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 void print_packet (const char *);
-static int stub_unpack_int (char *buff, int fieldlength);
+static int stub_unpack_int (const char *buff, int fieldlength);
struct packet_config;
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;
+static bool use_range_stepping = true;
+
+/* From the remote target's point of view, each thread is in one of these three
+ states. */
+enum class resume_state
+{
+ /* Not resumed - we haven't been asked to resume this thread. */
+ NOT_RESUMED,
+
+ /* We have been asked to resume this thread, but haven't sent a vCont action
+ for it yet. We'll need to consider it next time commit_resume is
+ called. */
+ RESUMED_PENDING_VCONT,
+
+ /* We have been asked to resume this thread, and we have sent a vCont action
+ for it. */
+ RESUMED,
+};
-/* The max number of chars in debug output. The rest of chars are
- omitted. */
+/* Information about a thread's pending vCont-resume. Used when a thread is in
+ the remote_resume_state::RESUMED_PENDING_VCONT state. remote_target::resume
+ stores this information which is then picked up by
+ remote_target::commit_resume to know which is the proper action for this
+ thread to include in the vCont packet. */
+struct resumed_pending_vcont_info
+{
+ /* True if the last resume call for this thread was a step request, false
+ if a continue request. */
+ bool step;
-#define REMOTE_DEBUG_MAX_CHAR 512
+ /* The signal specified in the last resume call for this thread. */
+ gdb_signal sig;
+};
/* Private data that we'll store in (struct thread_info)->priv. */
struct remote_thread_info : public private_thread_info
to stop for a watchpoint. */
CORE_ADDR watch_data_address = 0;
- /* Fields used by the vCont action coalescing implemented in
- remote_resume / remote_commit_resume. remote_resume stores each
- thread's last resume request in these fields, so that a later
- remote_commit_resume knows which is the proper action for this
- thread to include in the vCont packet. */
+ /* Get the thread's resume state. */
+ enum resume_state get_resume_state () const
+ {
+ return m_resume_state;
+ }
- /* True if the last target_resume call for this thread was a step
- request, false if a continue request. */
- int last_resume_step = 0;
+ /* Put the thread in the NOT_RESUMED state. */
+ void set_not_resumed ()
+ {
+ m_resume_state = resume_state::NOT_RESUMED;
+ }
- /* The signal specified in the last target_resume call for this
- thread. */
- gdb_signal last_resume_sig = GDB_SIGNAL_0;
+ /* Put the thread in the RESUMED_PENDING_VCONT state. */
+ void set_resumed_pending_vcont (bool step, gdb_signal sig)
+ {
+ m_resume_state = resume_state::RESUMED_PENDING_VCONT;
+ m_resumed_pending_vcont_info.step = step;
+ m_resumed_pending_vcont_info.sig = sig;
+ }
+
+ /* Get the information this thread's pending vCont-resumption.
+
+ Must only be called if the thread is in the RESUMED_PENDING_VCONT resume
+ state. */
+ const struct resumed_pending_vcont_info &resumed_pending_vcont_info () const
+ {
+ gdb_assert (m_resume_state == resume_state::RESUMED_PENDING_VCONT);
+
+ return m_resumed_pending_vcont_info;
+ }
+
+ /* Put the thread in the VCONT_RESUMED state. */
+ void set_resumed ()
+ {
+ m_resume_state = resume_state::RESUMED;
+ }
+
+private:
+ /* Resume state for this thread. This is used to implement vCont action
+ coalescing (only when the target operates in non-stop mode).
- /* Whether this thread was already vCont-resumed on the remote
- side. */
- int vcont_resumed = 0;
+ remote_target::resume moves the thread to the RESUMED_PENDING_VCONT state,
+ which notes that this thread must be considered in the next commit_resume
+ call.
+
+ remote_target::commit_resume sends a vCont packet with actions for the
+ threads in the RESUMED_PENDING_VCONT state and moves them to the
+ VCONT_RESUMED state.
+
+ When reporting a stop to the core for a thread, that thread is moved back
+ to the NOT_RESUMED state. */
+ enum resume_state m_resume_state = resume_state::NOT_RESUMED;
+
+ /* Extra info used if the thread is in the RESUMED_PENDING_VCONT state. */
+ struct resumed_pending_vcont_info m_resumed_pending_vcont_info;
};
remote_state::remote_state ()
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)
{
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;
}
}
+/* 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);
- add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
- &config->detect, set_doc,
- show_doc, NULL, /* help_doc */
- NULL,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist);
+ set_show_commands cmds
+ = add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
+ &config->detect, set_doc,
+ show_doc, NULL, /* help_doc */
+ NULL,
+ show_remote_protocol_packet_cmd,
+ &remote_set_cmdlist, &remote_show_cmdlist);
+
/* The command code copies the documentation strings. */
xfree (set_doc);
xfree (show_doc);
+
/* set/show remote NAME-packet {auto,on,off} -- legacy. */
if (legacy)
{
char *legacy_name;
legacy_name = xstrprintf ("%s-packet", name);
- add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
+ add_alias_cmd (legacy_name, cmds.set, class_obscure, 0,
&remote_set_cmdlist);
- add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
+ add_alias_cmd (legacy_name, cmds.show, class_obscure, 0,
&remote_show_cmdlist);
}
}
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
/* The stub recognized the packet request. */
if (config->support == PACKET_SUPPORT_UNKNOWN)
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "Packet %s (%s) is supported\n",
- config->name, config->title);
+ remote_debug_printf ("Packet %s (%s) is supported",
+ config->name, config->title);
config->support = PACKET_ENABLE;
}
break;
config->name, config->title);
}
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "Packet %s (%s) is NOT supported\n",
- config->name, config->title);
+ remote_debug_printf ("Packet %s (%s) is NOT supported",
+ config->name, config->title);
config->support = PACKET_DISABLE;
break;
}
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,
/* Support TARGET_WAITKIND_NO_RESUMED. */
PACKET_no_resumed,
+ /* Support for memory tagging, allocation tag fetch/store
+ packets and the tag violation stop replies. */
+ PACKET_memory_tagging_feature,
+
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
return packet_support (PACKET_exec_event_feature) == PACKET_ENABLE;
}
+/* Returns true if memory tagging is supported, false otherwise. */
+
+static bool
+remote_memory_tagging_p ()
+{
+ return packet_support (PACKET_memory_tagging_feature) == PACKET_ENABLE;
+}
+
/* Insert fork catchpoint target routine. If fork events are enabled
then return success, nothing more to do. */
\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). */
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);
+ inf->push_target (this);
inferior_appeared (inf, pid);
}
if (try_open_exec && get_exec_file (0) == NULL)
exec_file_locate_attach (pid, 0, 1);
+ /* Check for exec file mismatch, and let the user solve it. */
+ validate_exec_file (1);
+
return inf;
}
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);
+
+ /* We start by assuming threads are resumed. That state then gets updated
+ when we process a matching stop reply. */
+ get_remote_thread_info (thread)->set_resumed ();
- 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;
}
thread is (internally) executing or stopped. */
void
-remote_target::remote_notice_new_inferior (ptid_t currthread, int executing)
+remote_target::remote_notice_new_inferior (ptid_t currthread, bool executing)
{
/* In non-stop mode, we assume new found threads are (externally)
running until proven otherwise with a stop reply. In all-stop,
we can only get here if all threads are stopped. */
- int running = target_is_non_stop_p () ? 1 : 0;
+ bool running = target_is_non_stop_p ();
/* 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);
- inferior_ptid = currthread;
+ thread_info *thr
+ = remote_add_thread (currthread, running, executing);
+ switch_to_thread (thr);
}
return;
}
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);
}
putpkt (pass_packet);
getpkt (&rs->buf, 0);
packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]);
- if (rs->last_pass_packet)
- xfree (rs->last_pass_packet);
+ xfree (rs->last_pass_packet);
rs->last_pass_packet = pass_packet;
}
else
}
}
- if (remote_debug)
- {
- fprintf_unfiltered (gdb_stdlog,
- "remote_set_syscall_catchpoint "
- "pid %d needed %d any_count %d n_sysno %d\n",
- pid, needed, any_count, n_sysno);
- }
+ remote_debug_printf ("pid %d needed %d any_count %d n_sysno %d",
+ pid, needed, any_count, n_sysno);
std::string built_packet;
if (needed)
/* 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. */
#define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
-static char *unpack_nibble (char *buf, int *val);
+static const char *unpack_nibble (const char *buf, int *val);
-static char *unpack_byte (char *buf, int *value);
+static const char *unpack_byte (const char *buf, int *value);
static char *pack_int (char *buf, int value);
-static char *unpack_int (char *buf, int *value);
+static const char *unpack_int (const char *buf, int *value);
-static char *unpack_string (char *src, char *dest, int length);
+static const char *unpack_string (const char *src, char *dest, int length);
static char *pack_threadid (char *pkt, threadref *id);
-static char *unpack_threadid (char *inbuf, threadref *id);
+static const char *unpack_threadid (const char *inbuf, threadref *id);
void int_to_threadref (threadref *id, int value);
}
static int
-stub_unpack_int (char *buff, int fieldlength)
+stub_unpack_int (const char *buff, int fieldlength)
{
int nibble;
int retval = 0;
return retval;
}
-static char *
-unpack_nibble (char *buf, int *val)
+static const char *
+unpack_nibble (const char *buf, int *val)
{
*val = fromhex (*buf++);
return buf;
}
-static char *
-unpack_byte (char *buf, int *value)
+static const char *
+unpack_byte (const char *buf, int *value)
{
*value = stub_unpack_int (buf, 2);
return buf + 2;
return buf;
}
-static char *
-unpack_int (char *buf, int *value)
+static const char *
+unpack_int (const char *buf, int *value)
{
*value = stub_unpack_int (buf, 8);
return buf + 8;
}
#endif /* 0 (unused) */
-static char *
-unpack_string (char *src, char *dest, int length)
+static const char *
+unpack_string (const char *src, char *dest, int length)
{
while (length--)
*dest++ = *src++;
}
-static char *
-unpack_threadid (char *inbuf, threadref *id)
+static const char *
+unpack_threadid (const char *inbuf, threadref *id)
{
char *altref;
- char *limit = inbuf + BUF_THREAD_ID_SIZE;
+ const char *limit = inbuf + BUF_THREAD_ID_SIZE;
int x, y;
altref = (char *) id;
the process. */
int
-remote_target::remote_unpack_thread_info_response (char *pkt,
+remote_target::remote_unpack_thread_info_response (const char *pkt,
threadref *expectedref,
gdb_ext_thread_info *info)
{
int mask, length;
int tag;
threadref ref;
- char *limit = pkt + rs->buf.size (); /* Plausible parsing limit. */
+ const 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)
/* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
int
-remote_target::parse_threadlist_response (char *pkt, int result_limit,
+remote_target::parse_threadlist_response (const char *pkt, int result_limit,
threadref *original_echo,
threadref *resultlist,
int *doneflag)
{
struct remote_state *rs = get_remote_state ();
- char *limit;
int count, resultcount, done;
resultcount = 0;
/* Assume the 'q' and 'M chars have been stripped. */
- limit = pkt + (rs->buf.size () - BUF_THREAD_ID_SIZE);
+ const char *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;
if (!threadmatch (&rs->echo_nextthread, nextthread))
{
/* FIXME: This is a good reason to drop the packet. */
- /* Possably, there is a duplicate response. */
- /* Possabilities :
- retransmit immediatly - race conditions
- retransmit after timeout - yes
- exit
- wait for packet, then exit
+ /* Possibly, there is a duplicate response. */
+ /* Possibilities :
+ retransmit immediatly - race conditions
+ retransmit after timeout - yes
+ exit
+ wait for packet, then exit
*/
warning (_("HMM: threadlist did not echo arg thread, dropping it."));
return 0; /* I choose simply exiting. */
{
auto match_ptid = [&] (const thread_item &item)
{
- return item.ptid == ptid;
+ return item.ptid == ptid;
};
auto it = std::remove_if (this->items.begin (),
ptid_t result;
result = read_ptid (&rs->buf[2], &obuf);
- if (*obuf != '\0' && remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "warning: garbage in qC reply\n");
+ if (*obuf != '\0')
+ remote_debug_printf ("warning: garbage in qC reply");
return result;
}
return 0;
}
+/* Return true if INF only has one non-exited thread. */
+
+static bool
+has_single_non_exited_thread (inferior *inf)
+{
+ int count = 0;
+ for (thread_info *tp ATTRIBUTE_UNUSED : inf->non_exited_threads ())
+ if (++count > 1)
+ break;
+ return count == 1;
+}
+
/* Implement the to_update_thread_list function for the remote
targets. */
target. */
for (thread_info *tp : all_threads_safe ())
{
+ if (tp->inf->process_target () != this)
+ continue;
+
if (!context.contains_thread (tp->ptid))
{
+ /* Do not remove the thread if it is the last thread in
+ the inferior. This situation happens when we have a
+ pending exit process status to process. Otherwise we
+ may end up with a seemingly live inferior (i.e. pid
+ != 0) that has no threads. */
+ if (has_single_non_exited_thread (tp->inf))
+ continue;
+
/* Not found. */
delete_thread (tp);
}
executing until proven otherwise with a stop reply.
In all-stop, we can only get here if all threads are
stopped. */
- int executing = target_is_non_stop_p () ? 1 : 0;
+ bool executing = target_is_non_stop_p ();
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);
/* 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)
+ if (current_program_space->symfile_object_file == NULL)
return;
putpkt ("qOffsets");
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));
+ objfile *objf = current_program_space->symfile_object_file;
+ section_offsets offs = objf->section_offsets;
- data = get_symfile_segment_data (symfile_objfile->obfd);
+ symfile_segment_data_up data = get_symfile_segment_data (objf->obfd);
do_segments = (data != NULL);
do_sections = num_segments == 0;
by assuming that the .text and .data offsets apply to the whole
text and data segments. Convert the offsets given in the packet
to base addresses for symfile_map_offsets_to_segments. */
- else if (data && data->num_segments == 2)
+ else if (data != nullptr && data->segments.size () == 2)
{
- segments[0] = data->segment_bases[0] + text_addr;
- segments[1] = data->segment_bases[1] + data_addr;
+ segments[0] = data->segments[0].base + text_addr;
+ segments[1] = data->segments[1].base + data_addr;
num_segments = 2;
}
/* If the object file has only one segment, assume that it is text
but programs with no code are useless. Of course the code might
have ended up in the data segment... to detect that we would need
the permissions here. */
- else if (data && data->num_segments == 1)
+ else if (data && data->segments.size () == 1)
{
- segments[0] = data->segment_bases[0] + text_addr;
+ segments[0] = data->segments[0].base + text_addr;
num_segments = 1;
}
/* There's no way to relocate by segment. */
if (do_segments)
{
- int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data,
- offs, num_segments, segments);
+ int ret = symfile_map_offsets_to_segments (objf->obfd,
+ data.get (), offs,
+ num_segments, segments);
if (ret == 0 && !do_sections)
error (_("Can not handle qOffsets TextSeg "
do_sections = 0;
}
- if (data)
- free_symfile_segment_data (data);
-
if (do_sections)
{
- offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
+ offs[SECT_OFF_TEXT (objf)] = 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 (objf)] = data_addr;
+ offs[SECT_OFF_BSS (objf)] = data_addr;
}
- objfile_relocate (symfile_objfile, offs);
+ objfile_relocate (objf, offs);
}
/* Send interrupt_sequence to remote target. */
and extract the PTID. Returns NULL_PTID if not found. */
static ptid_t
-stop_reply_extract_thread (char *stop_reply)
+stop_reply_extract_thread (const char *stop_reply)
{
if (stop_reply[0] == 'T' && strlen (stop_reply) > 3)
{
method avoids a roundtrip. */
ptid_t
-remote_target::get_current_thread (char *wait_status)
+remote_target::get_current_thread (const char *wait_status)
{
ptid_t ptid = null_ptid;
whose response is a stop reply from which we can also try
extracting the thread. If the target doesn't support the explicit
qC query, we infer the current thread from that stop reply, passed
- in in WAIT_STATUS, which may be NULL. */
+ in in WAIT_STATUS, which may be NULL.
-void
-remote_target::add_current_inferior_and_thread (char *wait_status)
+ The function returns pointer to the main thread of the inferior. */
+
+thread_info *
+remote_target::add_current_inferior_and_thread (const char *wait_status)
{
struct remote_state *rs = get_remote_state ();
- int fake_pid_p = 0;
+ bool fake_pid_p = false;
- inferior_ptid = null_ptid;
+ switch_to_no_thread ();
- /* Now, if we have thread information, update inferior_ptid. */
+ /* Now, if we have thread information, update the current thread's
+ ptid. */
ptid_t curr_ptid = get_current_thread (wait_status);
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);
+
+ return tp;
}
/* Print info about a thread that was found already stopped on
case TARGET_WAITKIND_SIGNALLED:
case TARGET_WAITKIND_EXITED:
/* We shouldn't see these, but if we do, just ignore. */
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "remote: event ignored\n");
+ remote_debug_printf ("event ignored");
ignore_event = 1;
break;
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);
- get_remote_thread_info (evthread)->vcont_resumed = 0;
+ set_executing (this, event_ptid, false);
+ set_running (this, event_ptid, false);
+ get_remote_thread_info (evthread)->set_not_resumed ();
}
/* "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. */
void
remote_target::start_remote (int from_tty, int extended_p)
{
+ REMOTE_SCOPED_DEBUG_ENTER_EXIT;
+
struct remote_state *rs = get_remote_state ();
struct packet_config *noack_config;
- char *wait_status = NULL;
/* Signal other parts that we're going through the initial setup,
and so things may not be stable yet. E.g., we don't try to
if (!target_is_non_stop_p ())
{
+ char *wait_status = NULL;
+
if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
{
if (!extended_p)
/* 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
thread. */
- add_current_inferior_and_thread (wait_status);
+ thread_info *tp = add_current_inferior_and_thread (wait_status);
+ get_remote_thread_info (tp)->set_resumed ();
}
else
{
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"
register in T stop reply?). Just pick the first
thread in the thread list then. */
-
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "warning: couldn't determine remote "
- "current thread; picking first in list.\n");
- inferior_ptid = inferior_list->thread_list->ptid;
+ remote_debug_printf ("warning: couldn't determine remote "
+ "current thread; picking first in list.");
+
+ 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
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?)"));
return;
}
- /* In non-stop mode, any cached wait status will be stored in
- the stop reply queue. */
- gdb_assert (wait_status == NULL);
-
/* Report all signals during attach/startup. */
pass_signals ({});
}
/* If we connected to a live target, do some additional setup. */
- if (target_has_execution)
+ if (target_has_execution ())
{
- if (symfile_objfile) /* No use without a symbol-file. */
+ /* No use without a symbol-file. */
+ if (current_program_space->symfile_object_file)
remote_check_symbols ();
}
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. */
but our current inferior is not running, we should not invite the
remote target to request symbol lookups related to its
(unrelated) current process. */
- if (!target_has_execution)
+ if (!target_has_execution ())
return;
if (packet_support (PACKET_qSymbol) == PACKET_DISABLE)
/* If this is a function address, return the start of code
instead of any data function descriptor. */
- sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
- sym_addr,
- current_top_target ());
+ sym_addr = gdbarch_convert_from_func_ptr_addr
+ (target_gdbarch (), sym_addr, current_inferior ()->top_target ());
xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol:%s:%s",
phex_nz (sym_addr, addr_size), &reply[8]);
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,
{ "vContSupported", PACKET_DISABLE, remote_supported_packet, PACKET_vContSupported },
{ "QThreadEvents", PACKET_DISABLE, remote_supported_packet, PACKET_QThreadEvents },
{ "no-resumed", PACKET_DISABLE, remote_supported_packet, PACKET_no_resumed },
+ { "memory-tagging", PACKET_DISABLE, remote_supported_packet,
+ PACKET_memory_tagging_feature },
};
static char *remote_support_xml;
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,
if (packet_set_cmd_state (PACKET_no_resumed) != AUTO_BOOLEAN_FALSE)
remote_query_supported_append (&q, "no-resumed+");
+ if (packet_set_cmd_state (PACKET_memory_tagging_feature)
+ != AUTO_BOOLEAN_FALSE)
+ remote_query_supported_append (&q, "memory-tagging+");
+
/* Keep this one last to work around a gdbserver <= 7.10 bug in
the qSupported:xmlRegisters=i386 handling. */
if (remote_support_xml != NULL
{
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 ();
+ current_inferior ()->push_target (std::move (target_holder));
/* Register extra event sources in the event loop. */
rs->remote_async_inferior_event_token
- = create_async_event_handler (remote_async_inferior_event_handler,
- remote);
+ = create_async_event_handler (remote_async_inferior_event_handler, nullptr,
+ "remote");
rs->notif_state = remote_notif_state_allocate (remote);
/* Reset the target state; these things will be queried either by
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);
struct remote_state *rs = get_remote_state ();
int is_fork_parent;
- if (!target_has_execution)
+ if (!target_has_execution ())
error (_("No process to detach from."));
target_announce_detach (from_tty);
+ if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
+ {
+ /* If we're in breakpoints-always-inserted mode, or the inferior
+ is running, we have to remove breakpoints before detaching.
+ We don't do this in common code instead because not all
+ targets support removing breakpoints while the target is
+ running. The remote target / gdbserver does, though. */
+ remove_breakpoints_inf (current_inferior ());
+ }
+
/* Tell the remote target to detach. */
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. */
}
else
{
- inferior_ptid = null_ptid;
+ switch_to_no_thread ();
detach_inferior (current_inferior ());
}
}
it is named remote_follow_fork in anticipation of using it for the
remote target as well. */
-int
-remote_target::follow_fork (int follow_child, int detach_fork)
+void
+remote_target::follow_fork (bool follow_child, bool detach_fork)
{
struct remote_state *rs = get_remote_state ();
enum target_waitkind kind = inferior_thread ()->pending_follow.kind;
remote_detach_pid (child_pid);
}
}
- return 0;
}
/* Target follow-exec function for remote targets. Save EXECD_PATHNAME
- in the program space of the new inferior. On entry and at return the
- current inferior is the exec'ing inferior. INF is the new exec'd
- inferior, which may be the same as the exec'ing inferior unless
- follow-exec-mode is "new". */
+ in the program space of the new inferior. */
void
-remote_target::follow_exec (struct inferior *inf, char *execd_pathname)
+remote_target::follow_exec (inferior *follow_inf, ptid_t ptid,
+ const char *execd_pathname)
{
+ process_stratum_target::follow_exec (follow_inf, ptid, 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. */
if (is_target_filename (execd_pathname))
execd_pathname += strlen (TARGET_SYSROOT_PREFIX);
- set_pspace_remote_exec_file (inf->pspace, execd_pathname);
+ set_pspace_remote_exec_file (follow_inf->pspace, execd_pathname);
}
/* Same as remote_detach, but don't send the "D" packet; just disconnect. */
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.data (), get_remote_packet_size (), "vAttach;%x", pid);
}
else if (strcmp (rs->buf.data (), "OK") != 0)
error (_("Attaching to %s failed with: %s"),
- target_pid_to_str (ptid_t (pid)),
+ 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));
+ switch_to_inferior_no_thread (remote_add_inferior (false, pid, 1, 0));
inferior_ptid = ptid_t (pid);
if (target_is_non_stop_p ())
{
- struct thread_info *thread;
-
/* Get list of threads. */
update_thread_list ();
- thread = first_thread_of_inferior (current_inferior ());
- if (thread)
- inferior_ptid = thread->ptid;
- else
- inferior_ptid = ptid_t (pid);
+ thread_info *thread = first_thread_of_inferior (current_inferior ());
+ if (thread != nullptr)
+ switch_to_thread (thread);
/* Invalidate our notion of the remote current thread. */
record_currthread (rs, minus_one_ptid);
}
else
{
- /* Now, if we have thread information, update inferior_ptid. */
- inferior_ptid = remote_current_thread (inferior_ptid);
+ /* Now, if we have thread information, update the main thread's
+ ptid. */
+ ptid_t curr_ptid = remote_current_thread (ptid_t (pid));
/* Add the main thread to the thread list. */
- thread_info *thr = add_thread_silent (inferior_ptid);
+ thread_info *thr = add_thread_silent (this, curr_ptid);
+
+ switch_to_thread (thr);
+
/* 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);
+ {
+ gdb_assert (wait_status == NULL);
+
+ gdb_assert (target_can_async_p ());
+ target_async (1);
+ }
}
/* Implementation of the to_post_attach method. */
binary is not using shared libraries, the vsyscall page is not
present (on Linux) and the binary itself hadn't changed since the
debugging process was started. */
- if (symfile_objfile != NULL)
+ if (current_program_space->symfile_object_file != NULL)
remote_check_symbols();
}
}
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.data ();
individually. Resuming remote threads directly in target_resume
would thus result in sending one packet per thread. Instead, to
minimize roundtrip latency, here we just store the resume
- request; the actual remote resumption will be done in
- target_commit_resume / remote_commit_resume, where we'll be able
- to do vCont action coalescing. */
+ request (put the thread in RESUMED_PENDING_VCONT state); the actual remote
+ resumption will be done in remote_target::commit_resume, where we'll be
+ able to do vCont action coalescing. */
if (target_is_non_stop_p () && ::execution_direction != EXEC_REVERSE)
{
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;
+ /* We don't expect the core to ask to resume an already resumed (from
+ its point of view) thread. */
+ gdb_assert (remote_thr->get_resume_state () == resume_state::NOT_RESUMED);
+
+ remote_thr->set_resumed_pending_vcont (step, siggnal);
return;
}
if (!remote_resume_with_vcont (ptid, step, siggnal))
remote_resume_with_hc (ptid, step, siggnal);
+ /* Update resumed state tracked by the remote target. */
+ for (thread_info *tp : all_non_exited_threads (this, ptid))
+ get_remote_thread_info (tp)->set_resumed ();
+
/* We are about to start executing the inferior, let's register it
with the event loop. NOTE: this is the one place where all the
execution commands end up. We could alternatively do this in each
return static_cast<remote_inferior *> (inf->priv.get ());
}
+struct stop_reply : public notif_event
+{
+ ~stop_reply ();
+
+ /* The identifier of the thread about this event */
+ ptid_t ptid;
+
+ /* The remote state this event is associated with. When the remote
+ connection, represented by a remote_state object, is closed,
+ all the associated stop_reply events should be released. */
+ struct remote_state *rs;
+
+ struct target_waitstatus ws;
+
+ /* The architecture associated with the expedited registers. */
+ gdbarch *arch;
+
+ /* Expedited registers. This makes remote debugging a bit more
+ efficient for those targets that provide critical registers as
+ part of their normal status mechanism (as another roundtrip to
+ fetch them is avoided). */
+ std::vector<cached_reg_t> regcache;
+
+ enum target_stop_reason stop_reason;
+
+ CORE_ADDR watch_data_address;
+
+ int core;
+};
+
/* Class used to track the construction of a vCont packet in the
outgoing packet buffer. This is used to send multiple vCont
packets if we have more actions than would fit a single packet. */
/* to_commit_resume implementation. */
void
-remote_target::commit_resume ()
+remote_target::commit_resumed ()
{
- int any_process_wildcard;
- int may_global_wildcard_vcont;
-
/* If connected in all-stop mode, we'd send the remote resume
request directly from remote_resume. Likewise if
reverse-debugging, as there are no defined vCont actions for
(vCont;c). We can still send process-wide wildcards though. */
/* Start by assuming a global wildcard (vCont;c) is possible. */
- may_global_wildcard_vcont = 1;
+ bool may_global_wildcard_vcont = true;
/* 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 ())
+ bool any_pending_vcont_resume = false;
+
+ for (thread_info *tp : all_non_exited_threads (this))
{
+ remote_thread_info *priv = get_remote_thread_info (tp);
+
/* If a thread of a process is not meant to be resumed, then we
can't wildcard that process. */
- if (!tp->executing)
+ if (priv->get_resume_state () == resume_state::NOT_RESUMED)
{
get_remote_inferior (tp->inf)->may_wildcard_vcont = false;
/* And if we can't wildcard a process, we can't wildcard
everything either. */
- may_global_wildcard_vcont = 0;
+ may_global_wildcard_vcont = false;
continue;
}
+ if (priv->get_resume_state () == resume_state::RESUMED_PENDING_VCONT)
+ any_pending_vcont_resume = true;
+
/* If a thread is the parent of an unfollowed fork, then we
can't do a global wildcard, as that would resume the fork
child. */
if (is_pending_fork_parent_thread (tp))
- may_global_wildcard_vcont = 0;
+ may_global_wildcard_vcont = false;
}
+ /* We didn't have any resumed thread pending a vCont resume, so nothing to
+ do. */
+ if (!any_pending_vcont_resume)
+ return;
+
/* Now let's build the vCont packet(s). Actions must be appended
from narrower to wider scopes (thread -> process -> global). If
we end up with too many actions for a single packet vcont_builder
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);
- if (!tp->executing || remote_thr->vcont_resumed)
+ /* If the thread was previously vCont-resumed, no need to send a specific
+ action for it. If we didn't receive a resume request for it, don't
+ send an action for it either. */
+ if (remote_thr->get_resume_state () != resume_state::RESUMED_PENDING_VCONT)
continue;
gdb_assert (!thread_is_in_step_over_chain (tp));
- if (!remote_thr->last_resume_step
- && remote_thr->last_resume_sig == GDB_SIGNAL_0
- && get_remote_inferior (tp->inf)->may_wildcard_vcont)
- {
- /* We'll send a wildcard resume instead. */
- remote_thr->vcont_resumed = 1;
- continue;
- }
+ /* We should never be commit-resuming a thread that has a stop reply.
+ Otherwise, we would end up reporting a stop event for a thread while
+ it is running on the remote target. */
+ remote_state *rs = get_remote_state ();
+ for (const auto &stop_reply : rs->stop_reply_queue)
+ gdb_assert (stop_reply->ptid != tp->ptid);
- vcont_builder.push_action (tp->ptid,
- remote_thr->last_resume_step,
- remote_thr->last_resume_sig);
- remote_thr->vcont_resumed = 1;
+ const resumed_pending_vcont_info &info
+ = remote_thr->resumed_pending_vcont_info ();
+
+ /* Check if we need to send a specific action for this thread. If not,
+ it will be included in a wildcard resume instead. */
+ if (info.step || info.sig != GDB_SIGNAL_0
+ || !get_remote_inferior (tp->inf)->may_wildcard_vcont)
+ vcont_builder.push_action (tp->ptid, info.step, info.sig);
+
+ remote_thr->set_resumed ();
}
/* Now check whether we can send any process-wide wildcard. This is
to avoid sending a global wildcard in the case nothing is
supposed to be resumed. */
- any_process_wildcard = 0;
+ bool any_process_wildcard = false;
- for (inferior *inf : all_non_exited_inferiors ())
+ for (inferior *inf : all_non_exited_inferiors (this))
{
if (get_remote_inferior (inf)->may_wildcard_vcont)
{
- any_process_wildcard = 1;
+ any_process_wildcard = true;
break;
}
}
}
else
{
- for (inferior *inf : all_non_exited_inferiors ())
+ for (inferior *inf : all_non_exited_inferiors (this))
{
if (get_remote_inferior (inf)->may_wildcard_vcont)
{
vcont_builder.flush ();
}
+/* Implementation of target_has_pending_events. */
+
+bool
+remote_target::has_pending_events ()
+{
+ if (target_can_async_p ())
+ {
+ remote_state *rs = get_remote_state ();
+
+ if (async_event_handler_marked (rs->remote_async_inferior_event_token))
+ return true;
+
+ /* Note that BUFCNT can be negative, indicating sticky
+ error. */
+ if (rs->remote_desc->bufcnt != 0)
+ return true;
+ }
+ return false;
+}
+
\f
/* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
char *p = rs->buf.data ();
char *endp = p + get_remote_packet_size ();
- if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
+ /* If any thread that needs to stop was resumed but pending a vCont
+ resume, generate a phony stop_reply. However, first check
+ whether the thread wasn't resumed with a signal. Generating a
+ phony stop in that case would result in losing the signal. */
+ bool needs_commit = false;
+ for (thread_info *tp : all_non_exited_threads (this, ptid))
+ {
+ remote_thread_info *remote_thr = get_remote_thread_info (tp);
+
+ if (remote_thr->get_resume_state ()
+ == resume_state::RESUMED_PENDING_VCONT)
+ {
+ const resumed_pending_vcont_info &info
+ = remote_thr->resumed_pending_vcont_info ();
+ if (info.sig != GDB_SIGNAL_0)
+ {
+ /* This signal must be forwarded to the inferior. We
+ could commit-resume just this thread, but its simpler
+ to just commit-resume everything. */
+ needs_commit = true;
+ break;
+ }
+ }
+ }
+
+ if (needs_commit)
+ commit_resumed ();
+ else
+ for (thread_info *tp : all_non_exited_threads (this, ptid))
+ {
+ remote_thread_info *remote_thr = get_remote_thread_info (tp);
+
+ if (remote_thr->get_resume_state ()
+ == resume_state::RESUMED_PENDING_VCONT)
+ {
+ remote_debug_printf ("Enqueueing phony stop reply for thread pending "
+ "vCont-resume (%d, %ld, %ld)", tp->ptid.pid(),
+ tp->ptid.lwp (), tp->ptid.tid ());
+
+ /* Check that the thread wasn't resumed with a signal.
+ Generating a phony stop would result in losing the
+ signal. */
+ const resumed_pending_vcont_info &info
+ = remote_thr->resumed_pending_vcont_info ();
+ gdb_assert (info.sig == GDB_SIGNAL_0);
+
+ stop_reply *sr = new stop_reply ();
+ sr->ptid = tp->ptid;
+ sr->rs = rs;
+ sr->ws.kind = TARGET_WAITKIND_STOPPED;
+ sr->ws.value.sig = GDB_SIGNAL_0;
+ sr->arch = tp->inf->gdbarch;
+ sr->stop_reason = TARGET_STOPPED_BY_NO_REASON;
+ sr->watch_data_address = 0;
+ sr->core = 0;
+ this->push_stop_reply (sr);
+
+ /* Pretend that this thread was actually resumed on the
+ remote target, then stopped. If we leave it in the
+ RESUMED_PENDING_VCONT state and the commit_resumed
+ method is called while the stop reply is still in the
+ queue, we'll end up reporting a stop event to the core
+ for that thread while it is running on the remote
+ target... that would be bad. */
+ remote_thr->set_resumed ();
+ }
+ }
+
+ /* 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)
putpkt (rs->buf);
getpkt (&rs->buf, 0);
if (strcmp (rs->buf.data (), "OK") != 0)
- error (_("Stopping %s failed: %s"), target_pid_to_str (ptid),
+ error (_("Stopping %s failed: %s"), target_pid_to_str (ptid).c_str (),
rs->buf.data ());
}
void
remote_target::stop (ptid_t ptid)
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
+ REMOTE_SCOPED_DEBUG_ENTER_EXIT;
if (target_is_non_stop_p ())
remote_stop_ns (ptid);
void
remote_target::interrupt ()
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
+ REMOTE_SCOPED_DEBUG_ENTER_EXIT;
if (target_is_non_stop_p ())
remote_interrupt_ns ();
void
remote_target::pass_ctrlc ()
{
- struct remote_state *rs = get_remote_state ();
+ REMOTE_SCOPED_DEBUG_ENTER_EXIT;
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "remote_pass_ctrlc called\n");
+ struct remote_state *rs = get_remote_state ();
/* If we're starting up, we're not fully synced yet. Quit
immediately. */
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."));
}
}
tb[0] = c;
tb[1] = 0;
- fputs_unfiltered (tb, gdb_stdtarg);
+ gdb_stdtarg->puts (tb);
}
- gdb_flush (gdb_stdtarg);
-}
-
-DEF_VEC_O(cached_reg_t);
-
-typedef struct stop_reply
-{
- struct notif_event base;
-
- /* The identifier of the thread about this event */
- ptid_t ptid;
-
- /* The remote state this event is associated with. When the remote
- connection, represented by a remote_state object, is closed,
- all the associated stop_reply events should be released. */
- struct remote_state *rs;
-
- struct target_waitstatus ws;
-
- /* The architecture associated with the expedited registers. */
- gdbarch *arch;
-
- /* Expedited registers. This makes remote debugging a bit more
- 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;
-
- 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);
+ gdb_stdtarg->flush ();
}
/* 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, const char *buf,
struct notif_event *event)
/* acknowledge */
putpkt (remote, self->ack_command);
- if (stop_reply->ws.kind == TARGET_WAITKIND_IGNORE)
- {
- /* We got an unknown stop reply. */
- error (_("Unknown stop reply"));
- }
-
- remote->push_stop_reply (stop_reply);
+ /* Kind can be TARGET_WAITKIND_IGNORE if we have meanwhile discarded
+ the notification. It was left in the queue because we need to
+ acknowledge it and pull the rest of the notifications out. */
+ if (stop_reply->ws.kind != TARGET_WAITKIND_IGNORE)
+ remote->push_stop_reply (stop_reply);
}
static int
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);
context->remove_thread (event->ws.value.related_pid);
}
-/* Check whether any event pending in the vStopped queue would prevent
- a global or process wildcard vCont action. Clear
- *may_global_wildcard if we can't do a global wildcard (vCont;c),
- and clear the event inferior's may_wildcard_vcont flag if we can't
- do a process-wide wildcard resume (vCont;c:pPID.-1). */
+/* Check whether any event pending in the vStopped queue would prevent a
+ global or process wildcard vCont action. Set *may_global_wildcard to
+ false if we can't do a global wildcard (vCont;c), and clear the event
+ inferior's may_wildcard_vcont flag if we can't do a process-wide
+ wildcard resume (vCont;c:pPID.-1). */
void
remote_target::check_pending_events_prevent_wildcard_vcont
- (int *may_global_wildcard)
+ (bool *may_global_wildcard)
{
struct notif_client *notif = ¬if_client_stop;
if (event->ws.kind == TARGET_WAITKIND_FORKED
|| event->ws.kind == TARGET_WAITKIND_VFORKED)
- *may_global_wildcard = 0;
-
- struct inferior *inf = find_inferior_ptid (event->ptid);
+ *may_global_wildcard = false;
/* This may be the first time we heard about this process.
Regardless, we must not do a global wildcard resume, otherwise
we'd resume this process too. */
- *may_global_wildcard = 0;
- if (inf != NULL)
- get_remote_inferior (inf)->may_wildcard_vcont = false;
+ *may_global_wildcard = false;
+ if (event->ptid != null_ptid)
+ {
+ inferior *inf = find_inferior_ptid (this, event->ptid);
+ if (inf != NULL)
+ get_remote_inferior (inf)->may_wildcard_vcont = false;
+ }
}
}
/* Discard the in-flight notification. */
if (reply != NULL && reply->ptid.pid () == inf->pid)
{
- stop_reply_xfree (reply);
- rns->pending_event[notif_client_stop.id] = NULL;
+ /* Leave the notification pending, since the server expects that
+ we acknowledge it with vStopped. But clear its contents, so
+ that later on when we acknowledge it, we also discard it. */
+ reply->ws.kind = TARGET_WAITKIND_IGNORE;
+
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stdlog,
+ "discarded in-flight notification\n");
}
/* Discard the stop replies we have already pulled with
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);
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
reported expedited registers. */
if (event->ptid == null_ptid)
{
+ /* If there is no thread-id information then leave
+ the event->ptid as null_ptid. Later in
+ process_stop_reply we will pick a suitable
+ thread. */
const char *thr = strstr (p1 + 1, ";thread:");
if (thr != NULL)
event->ptid = read_ptid (thr + strlen (";thread:"),
NULL);
- else
- {
- /* Either the current thread hasn't changed,
- or the inferior is not multi-threaded.
- The event must be for the thread we last
- set as (or learned as being) current. */
- event->ptid = event->rs->general_thread;
- }
}
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 == ';')
event->ptid = minus_one_ptid;
break;
}
-
- if (target_is_non_stop_p () && event->ptid == null_ptid)
- error (_("No process or thread specified in stop reply: %s"), buf);
}
/* When the stub wants to tell GDB about a new notification reply, it
<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
}
}
-/* Wrapper around remote_target::remote_notif_get_pending_events to
- avoid having to export the whole remote_target class. */
+/* Wrapper around remote_target::remote_notif_get_pending_events to
+ avoid having to export the whole remote_target class. */
+
+void
+remote_notif_get_pending_events (remote_target *remote, notif_client *nc)
+{
+ remote->remote_notif_get_pending_events (nc);
+}
+
+/* Called from process_stop_reply when the stop packet we are responding
+ to didn't include a process-id or thread-id. STATUS is the stop event
+ we are responding to.
+
+ It is the task of this function to select a suitable thread (or process)
+ and return its ptid, this is the thread (or process) we will assume the
+ stop event came from.
+
+ In some cases there isn't really any choice about which thread (or
+ process) is selected, a basic remote with a single process containing a
+ single thread might choose not to send any process-id or thread-id in
+ its stop packets, this function will select and return the one and only
+ thread.
+
+ However, if a target supports multiple threads (or processes) and still
+ doesn't include a thread-id (or process-id) in its stop packet then
+ first, this is a badly behaving target, and second, we're going to have
+ to select a thread (or process) at random and use that. This function
+ will print a warning to the user if it detects that there is the
+ possibility that GDB is guessing which thread (or process) to
+ report.
+
+ Note that this is called before GDB fetches the updated thread list from the
+ target. So it's possible for the stop reply to be ambiguous and for GDB to
+ not realize it. For example, if there's initially one thread, the target
+ spawns a second thread, and then sends a stop reply without an id that
+ concerns the first thread. GDB will assume the stop reply is about the
+ first thread - the only thread it knows about - without printing a warning.
+ Anyway, if the remote meant for the stop reply to be about the second thread,
+ then it would be really broken, because GDB doesn't know about that thread
+ yet. */
+
+ptid_t
+remote_target::select_thread_for_ambiguous_stop_reply
+ (const struct target_waitstatus *status)
+{
+ REMOTE_SCOPED_DEBUG_ENTER_EXIT;
+
+ /* Some stop events apply to all threads in an inferior, while others
+ only apply to a single thread. */
+ bool process_wide_stop
+ = (status->kind == TARGET_WAITKIND_EXITED
+ || status->kind == TARGET_WAITKIND_SIGNALLED);
+
+ remote_debug_printf ("process_wide_stop = %d", process_wide_stop);
+
+ thread_info *first_resumed_thread = nullptr;
+ bool ambiguous = false;
+
+ /* Consider all non-exited threads of the target, find the first resumed
+ one. */
+ for (thread_info *thr : all_non_exited_threads (this))
+ {
+ remote_thread_info *remote_thr = get_remote_thread_info (thr);
+
+ if (remote_thr->get_resume_state () != resume_state::RESUMED)
+ continue;
+
+ if (first_resumed_thread == nullptr)
+ first_resumed_thread = thr;
+ else if (!process_wide_stop
+ || first_resumed_thread->ptid.pid () != thr->ptid.pid ())
+ ambiguous = true;
+ }
+
+ remote_debug_printf ("first resumed thread is %s",
+ pid_to_str (first_resumed_thread->ptid).c_str ());
+ remote_debug_printf ("is this guess ambiguous? = %d", ambiguous);
+
+ gdb_assert (first_resumed_thread != nullptr);
+
+ /* Warn if the remote target is sending ambiguous stop replies. */
+ if (ambiguous)
+ {
+ static bool warned = false;
+
+ if (!warned)
+ {
+ /* If you are seeing this warning then the remote target has
+ stopped without specifying a thread-id, but the target
+ does have multiple threads (or inferiors), and so GDB is
+ having to guess which thread stopped.
+
+ Examples of what might cause this are the target sending
+ and 'S' stop packet, or a 'T' stop packet and not
+ including a thread-id.
-void
-remote_notif_get_pending_events (remote_target *remote, notif_client *nc)
-{
- remote->remote_notif_get_pending_events (nc);
+ Additionally, the target might send a 'W' or 'X packet
+ without including a process-id, when the target has
+ multiple running inferiors. */
+ if (process_wide_stop)
+ warning (_("multi-inferior target stopped without "
+ "sending a process-id, using first "
+ "non-exited inferior"));
+ else
+ warning (_("multi-threaded target stopped without "
+ "sending a thread-id, using first "
+ "non-exited thread"));
+ warned = true;
+ }
+ }
+
+ /* If this is a stop for all threads then don't use a particular threads
+ ptid, instead create a new ptid where only the pid field is set. */
+ if (process_wide_stop)
+ return ptid_t (first_resumed_thread->ptid.pid ());
+ else
+ return first_resumed_thread->ptid;
}
/* Called when it is decided that STOP_REPLY holds the info of the
remote_target::process_stop_reply (struct stop_reply *stop_reply,
struct target_waitstatus *status)
{
- ptid_t ptid;
-
*status = stop_reply->ws;
- ptid = stop_reply->ptid;
+ ptid_t ptid = stop_reply->ptid;
- /* If no thread/process was reported by the stub, assume the current
- inferior. */
+ /* If no thread/process was reported by the stub then select a suitable
+ thread/process. */
if (ptid == null_ptid)
- ptid = inferior_ptid;
+ ptid = select_thread_for_ambiguous_stop_reply (status);
+ gdb_assert (ptid != null_ptid);
if (status->kind != TARGET_WAITKIND_EXITED
&& status->kind != TARGET_WAITKIND_SIGNALLED
&& 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_notice_new_inferior (ptid, false);
+ 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;
+
+ if (target_is_non_stop_p ())
+ {
+ /* If the target works in non-stop mode, a stop-reply indicates that
+ only this thread stopped. */
+ remote_thr->set_not_resumed ();
+ }
+ else
+ {
+ /* If the target works in all-stop mode, a stop-reply indicates that
+ all the target's threads stopped. */
+ for (thread_info *tp : all_non_exited_threads (this))
+ get_remote_thread_info (tp)->set_not_resumed ();
+ }
}
- stop_reply_xfree (stop_reply);
+ delete stop_reply;
return ptid;
}
/* The non-stop mode version of target_wait. */
ptid_t
-remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int options)
+remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status,
+ target_wait_flags options)
{
struct remote_state *rs = get_remote_state ();
struct stop_reply *stop_reply;
}
}
+/* 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. */
ptid_t
-remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options)
+remote_target::wait_as (ptid_t ptid, target_waitstatus *status,
+ target_wait_flags options)
{
struct remote_state *rs = get_remote_state ();
ptid_t event_ptid = null_ptid;
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;
}
STATUS just as `wait' would. */
ptid_t
-remote_target::wait (ptid_t ptid, struct target_waitstatus *status, int options)
+remote_target::wait (ptid_t ptid, struct target_waitstatus *status,
+ target_wait_flags options)
{
+ REMOTE_SCOPED_DEBUG_ENTER_EXIT;
+
+ remote_state *rs = get_remote_state ();
+
+ /* Start by clearing the flag that asks for our wait method to be called,
+ we'll mark it again at the end if needed. */
+ if (target_is_async_p ())
+ clear_async_event_handler (rs->remote_async_inferior_event_token);
+
ptid_t event_ptid;
if (target_is_non_stop_p ())
if (target_is_async_p ())
{
- remote_state *rs = get_remote_state ();
-
- /* If there are are events left in the queue tell the event loop
- to return here. */
- if (!rs->stop_reply_queue.empty ())
+ /* If there are events left in the queue, or unacknowledged
+ notifications, then tell the event loop to call us again. */
+ if (!rs->stop_reply_queue.empty ()
+ || rs->notif_state->pending_event[notif_client_stop.id] != nullptr)
mark_async_event_handler (rs->remote_async_inferior_event_token);
}
getpkt (&rs->buf, 0);
if (packet_check_result (rs->buf) == PACKET_ERROR)
error (_("Could not read registers; remote failure reply '%s'"),
- rs->buf.data ());
+ 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
&& (rs->buf[0] < 'a' || rs->buf[0] > 'f')
&& rs->buf[0] != 'x') /* New: unavailable register value. */
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "Bad register packet; fetching a new packet\n");
+ remote_debug_printf ("Bad register packet; fetching a new packet");
getpkt (&rs->buf, 0);
}
}
/* Looks valid enough, we can assume this is the correct length
- for a 'g' packet. It's important not to adjust
- rsa->sizeof_g_packet if we have truncated registers otherwise
- this "if" won't be run the next time the method is called
- with a packet of the same size and one of the internal errors
- below will trigger instead. */
+ for a 'g' packet. It's important not to adjust
+ rsa->sizeof_g_packet if we have truncated registers otherwise
+ this "if" won't be run the next time the method is called
+ with a packet of the same size and one of the internal errors
+ below will trigger instead. */
rsa->sizeof_g_packet = sizeof_g_packet;
}
&& address_size < (sizeof (ULONGEST) * 8))
{
/* Only create a mask when that mask can safely be constructed
- in a ULONGEST variable. */
+ in a ULONGEST variable. */
ULONGEST mask = 1;
mask = (mask << address_size) - 1;
if (rs->buf[0] == '\0')
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "binary downloading NOT "
- "supported by target\n");
+ remote_debug_printf ("binary downloading NOT supported by target");
remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
}
else
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "binary downloading supported by target\n");
+ remote_debug_printf ("binary downloading supported by target");
remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
}
break;
*p++ = ',';
/* Append the length and retain its location and size. It may need to be
- adjusted once the packet body has been created. */
+ adjusted once the packet body has been created. */
plen = p;
plenlen = hexnumstr (p, (ULONGEST) todo_units);
p += plenlen;
int unit_size,
ULONGEST *xfered_len)
{
- struct target_section *secp;
- struct target_section_table *table;
+ const struct target_section *secp;
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;
- table = target_get_section_table (this);
-
- for (p = table->sections; p < table->sections_end; p++)
+ const target_section_table *table = target_get_section_table (this);
+ for (const target_section &p : *table)
{
- if (memaddr >= p->addr)
+ if (memaddr >= p.addr)
{
- if (memend <= p->endaddr)
+ if (memend <= p.endaddr)
{
/* Entire transfer is within this section. */
return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
xfered_len);
}
- else if (memaddr >= p->endaddr)
+ else if (memaddr >= p.endaddr)
{
/* This section ends before the transfer starts. */
continue;
else
{
/* This section overlaps the transfer. Just do half. */
- len = p->endaddr - memaddr;
+ len = p.endaddr - memaddr;
return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
xfered_len);
}
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)
while (1)
{
- int started_error_output = 0;
-
if (remote_debug)
{
*p = '\0';
int len = (int) (p - buf2);
+ int max_chars;
- std::string str
- = escape_buffer (buf2, std::min (len, REMOTE_DEBUG_MAX_CHAR));
-
- fprintf_unfiltered (gdb_stdlog, "Sending packet: %s", str.c_str ());
-
- if (len > REMOTE_DEBUG_MAX_CHAR)
- fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
- len - REMOTE_DEBUG_MAX_CHAR);
+ if (remote_packet_max_chars < 0)
+ max_chars = len;
+ else
+ max_chars = remote_packet_max_chars;
- fprintf_unfiltered (gdb_stdlog, "...");
+ std::string str
+ = escape_buffer (buf2, std::min (len, max_chars));
- gdb_flush (gdb_stdlog);
+ if (len > max_chars)
+ remote_debug_printf_nofunc
+ ("Sending packet: %s [%d bytes omitted]", str.c_str (),
+ len - max_chars);
+ else
+ remote_debug_printf_nofunc ("Sending packet: %s", str.c_str ());
}
remote_serial_write (buf2, p - buf2);
/* If this is a no acks version of the remote protocol, send the
packet and move on. */
if (rs->noack_mode)
- break;
+ break;
/* Read until either a timeout occurs (-2) or '+' is read.
Handle any notification that arrives in the mean time. */
{
ch = readchar (remote_timeout);
- if (remote_debug)
- {
- switch (ch)
- {
- case '+':
- case '-':
- case SERIAL_TIMEOUT:
- case '$':
- case '%':
- if (started_error_output)
- {
- putchar_unfiltered ('\n');
- started_error_output = 0;
- }
- }
- }
-
switch (ch)
{
case '+':
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "Ack\n");
+ remote_debug_printf_nofunc ("Received Ack");
return 1;
case '-':
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "Nak\n");
+ remote_debug_printf_nofunc ("Received Nak");
/* FALLTHROUGH */
case SERIAL_TIMEOUT:
tcount++;
break; /* Retransmit buffer. */
case '$':
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "Packet instead of Ack, ignoring it\n");
+ remote_debug_printf ("Packet instead of Ack, ignoring it");
/* It's probably an old response sent because an ACK
was lost. Gobble up the packet and ack it so it
doesn't get retransmitted when we resend this
val = read_frame (&rs->buf);
if (val >= 0)
{
- if (remote_debug)
- {
- std::string str = escape_buffer (rs->buf.data (), val);
+ remote_debug_printf_nofunc
+ (" Notification received: %s",
+ escape_buffer (rs->buf.data (), val).c_str ());
- fprintf_unfiltered (gdb_stdlog,
- " Notification received: %s\n",
- str.c_str ());
- }
handle_notification (rs->notif_state, rs->buf.data ());
/* We're in sync now, rewait for the ack. */
tcount = 0;
}
else
- {
- if (remote_debug)
- {
- if (!started_error_output)
- {
- started_error_output = 1;
- fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
- }
- fputc_unfiltered (ch & 0177, gdb_stdlog);
- fprintf_unfiltered (gdb_stdlog, "%s", rs->buf.data ());
- }
- }
+ remote_debug_printf_nofunc ("Junk: %c%s", ch & 0177,
+ rs->buf.data ());
continue;
}
/* fall-through */
default:
- if (remote_debug)
- {
- if (!started_error_output)
- {
- started_error_output = 1;
- fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
- }
- fputc_unfiltered (ch & 0177, gdb_stdlog);
- }
+ remote_debug_printf_nofunc ("Junk: %c%s", ch & 0177,
+ rs->buf.data ());
continue;
}
break; /* Here to retransmit. */
#if 0
/* This is wrong. If doing a long backtrace, the user should be
- able to get out next time we call QUIT, without anything as
- violent as interrupt_query. If we want to provide a way out of
- here without getting to the next QUIT, it should be based on
- hitting ^C twice as in remote_wait. */
+ able to get out next time we call QUIT, without anything as
+ violent as interrupt_query. If we want to provide a way out of
+ here without getting to the next QUIT, it should be based on
+ hitting ^C twice as in remote_wait. */
if (quit_flag)
{
quit_flag = 0;
switch (c)
{
case SERIAL_TIMEOUT:
- if (remote_debug)
- fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
+ remote_debug_printf ("Timeout in mid-packet, retrying");
return -1;
+
case '$':
- if (remote_debug)
- fputs_filtered ("Saw new packet start in middle of old one\n",
- gdb_stdlog);
+ remote_debug_printf ("Saw new packet start in middle of old one");
return -1; /* Start a new packet, count retries. */
+
case '#':
{
unsigned char pktcsum;
if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
{
- if (remote_debug)
- fputs_filtered ("Timeout in checksum, retrying\n",
- gdb_stdlog);
+ remote_debug_printf ("Timeout in checksum, retrying");
return -1;
}
else if (check_0 < 0 || check_1 < 0)
{
- if (remote_debug)
- fputs_filtered ("Communication error in checksum\n",
- gdb_stdlog);
+ remote_debug_printf ("Communication error in checksum");
return -1;
}
pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
if (csum == pktcsum)
- return bc;
+ return bc;
- if (remote_debug)
- {
- std::string str = escape_buffer (buf, bc);
+ remote_debug_printf
+ ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s",
+ pktcsum, csum, escape_buffer (buf, bc).c_str ());
- fprintf_unfiltered (gdb_stdlog,
- "Bad checksum, sentsum=0x%x, "
- "csum=0x%x, buf=%s\n",
- pktcsum, csum, str.c_str ());
- }
/* Number of characters in buffer ignoring trailing
- NULL. */
+ NULL. */
return -1;
}
case '*': /* Run length encoding. */
- {
+ {
int repeat;
- csum += c;
+ csum += c;
c = readchar (remote_timeout);
csum += c;
repeat = c - ' ' + 3; /* Compute repeat count. */
}
}
+/* 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 if necessary to hold the result. If
FOREVER, wait forever rather than timing out; this is used (in
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."));
}
- if (remote_debug)
- fputs_filtered ("Timed out.\n", gdb_stdlog);
+
+ remote_debug_printf ("Timed out.");
}
else
{
{
if (remote_debug)
{
- std::string str
- = escape_buffer (buf->data (),
- std::min (val, REMOTE_DEBUG_MAX_CHAR));
+ int max_chars;
- fprintf_unfiltered (gdb_stdlog, "Packet received: %s",
- str.c_str ());
+ if (remote_packet_max_chars < 0)
+ max_chars = val;
+ else
+ max_chars = remote_packet_max_chars;
- if (val > REMOTE_DEBUG_MAX_CHAR)
- fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
- val - REMOTE_DEBUG_MAX_CHAR);
+ std::string str
+ = escape_buffer (buf->data (),
+ std::min (val, max_chars));
- fprintf_unfiltered (gdb_stdlog, "\n");
+ if (val > max_chars)
+ remote_debug_printf_nofunc
+ ("Packet received: %s [%d bytes omitted]", str.c_str (),
+ val - max_chars);
+ else
+ remote_debug_printf_nofunc ("Packet received: %s",
+ str.c_str ());
}
/* Skip the ack char if we're in no-ack mode. */
{
gdb_assert (c == '%');
- if (remote_debug)
- {
- std::string str = escape_buffer (buf->data (), val);
+ remote_debug_printf_nofunc
+ (" Notification received: %s",
+ escape_buffer (buf->data (), val).c_str ());
- fprintf_unfiltered (gdb_stdlog,
- " Notification received: %s\n",
- str.c_str ());
- }
if (is_notif != NULL)
*is_notif = 1;
/* 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 ();
{
/* 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, 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
}
-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)
{
case PACKET_ERROR:
if (rs->buf[1] == '.')
- {
- message = strchr (&rs->buf[2], '.');
- if (message)
- error (_("Remote failure reply: %s"), message + 1);
- }
+ {
+ message = strchr (&rs->buf[2], '.');
+ if (message)
+ error (_("Remote failure reply: %s"), message + 1);
+ }
return -1;
case PACKET_UNKNOWN:
return -1;
/* It doesn't make sense to use qCRC if the remote target is
connected but not running. */
- if (target_has_execution && packet_support (PACKET_qCRC) != PACKET_DISABLE)
+ if (target_has_execution ()
+ && packet_support (PACKET_qCRC) != PACKET_DISABLE)
{
enum packet_result result;
int res;
int read_only = 0;
- if (!exec_bfd)
+ if (!current_program_space->exec_bfd ())
error (_("command cannot be used without an exec file"));
if (args != NULL && strcmp (args, "-r") == 0)
args = NULL;
}
- for (s = exec_bfd->sections; s; s = s->next)
+ for (s = current_program_space->exec_bfd ()->sections; s; s = s->next)
{
if (!(s->flags & SEC_LOAD))
continue; /* Skip non-loadable section. */
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. */
lma = s->lma;
gdb::byte_vector sectdata (size);
- bfd_get_section_contents (exec_bfd, s, sectdata.data (), 0, size);
+ bfd_get_section_contents (current_program_space->exec_bfd (), s,
+ sectdata.data (), 0, size);
res = target_verify_memory (sectdata.data (), lma, size);
/* If the remote target is connected but not running, we should
pass this request down to a lower stratum (e.g. the executable
file). */
- if (!target_has_execution)
+ if (!target_has_execution ())
return TARGET_XFER_EOF;
if (writebuf != NULL)
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 (rs->remote_desc);
return remote_read_qxfer
("osdata", annex, readbuf, offset, len, xfered_len,
- &remote_protocol_packets[PACKET_qXfer_osdata]);
+ &remote_protocol_packets[PACKET_qXfer_osdata]);
case TARGET_OBJECT_THREADS:
gdb_assert (annex == NULL);
case TARGET_OBJECT_BTRACE:
return remote_read_qxfer ("btrace", annex, readbuf, offset, len,
xfered_len,
- &remote_protocol_packets[PACKET_qXfer_btrace]);
+ &remote_protocol_packets[PACKET_qXfer_btrace]);
case TARGET_OBJECT_BTRACE_CONF:
return remote_read_qxfer ("btrace-conf", annex, readbuf, offset,
int found;
ULONGEST found_addr;
+ auto read_memory = [=] (CORE_ADDR addr, gdb_byte *result, size_t len)
+ {
+ return (target_read (this, TARGET_OBJECT_MEMORY, NULL, result, addr, len)
+ == len);
+ };
+
/* Don't go to the target if we don't have to. This is done before
checking packet_config_support to avoid the possibility that a
success for this edge case means the facility works in
{
/* Target doesn't provided special support, fall back and use the
standard support (copy memory and do the search here). */
- return simple_search_memory (this, start_addr, search_space_len,
+ return simple_search_memory (read_memory, start_addr, search_space_len,
pattern, pattern_len, found_addrp);
}
supported. If so, fall back to the simple way. */
if (packet_config_support (packet) == PACKET_DISABLE)
{
- return simple_search_memory (this, start_addr, search_space_len,
+ return simple_search_memory (read_memory, start_addr, search_space_len,
pattern, pattern_len, found_addrp);
}
return -1;
QUIT; /* Allow user to bail out with ^C. */
rs->buf[0] = '\0';
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
- is still executing the (long) monitor command.
- If needed, the user can interrupt gdb using C-c, obtaining
- an effect similar to stop on timeout. */
- continue;
- }
+ {
+ /* Timeout. Continue to (try to) read responses.
+ This is better than stopping with an error, assuming the stub
+ is still executing the (long) monitor command.
+ If needed, the user can interrupt gdb using C-c, obtaining
+ an effect similar to stop on timeout. */
+ continue;
+ }
buf = rs->buf.data ();
if (buf[0] == '\0')
error (_("Target does not support this command."));
{
std::vector<mem_region> result;
gdb::optional<gdb::char_vector> text
- = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP, NULL);
+ = target_read_stralloc (current_inferior ()->top_target (),
+ TARGET_OBJECT_MEMORY_MAP, NULL);
if (text)
result = parse_memory_map (text->data ());
{
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 ());
}
}
/* Do not try this during initial connection, when we do not know
whether there is a running but stopped thread. */
- if (!target_has_execution || inferior_ptid == null_ptid)
+ if (!target_has_execution () || inferior_ptid == null_ptid)
return beneath ()->read_description ();
if (!data->guesses.empty ())
-1 is returned, the other variables may not be initialized. */
static int
-remote_hostio_parse_result (char *buffer, int *retcode,
- int *remote_errno, char **attachment)
+remote_hostio_parse_result (const char *buffer, int *retcode,
+ int *remote_errno, const char **attachment)
{
char *p, *p2;
int
remote_target::remote_hostio_send_command (int command_bytes, int which_packet,
- int *remote_errno, char **attachment,
+ int *remote_errno, const char **attachment,
int *attachment_len)
{
struct remote_state *rs = get_remote_state ();
int ret, bytes_read;
- char *attachment_tmp;
+ const char *attachment_tmp;
if (packet_support (which_packet) == PACKET_DISABLE)
{
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf.data ();
- char *attachment;
+ const char *attachment;
int left = get_remote_packet_size ();
int ret, attachment_len;
int read_len;
{
cache->hit_count++;
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "readahead cache hit %s\n",
- pulongest (cache->hit_count));
+ remote_debug_printf ("readahead cache hit %s",
+ pulongest (cache->hit_count));
return ret;
}
cache->miss_count++;
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "readahead cache miss %s\n",
- pulongest (cache->miss_count));
+
+ remote_debug_printf ("readahead cache miss %s",
+ pulongest (cache->miss_count));
cache->fd = fd;
cache->offset = offset;
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf.data ();
- char *attachment;
+ const char *attachment;
int left = get_remote_packet_size ();
int len, attachment_len;
int read_len;
char *p = rs->buf.data ();
int left = get_remote_packet_size ();
int attachment_len, ret;
- char *attachment;
+ const char *attachment;
struct fio_stat fst;
int read_len;
switch (errnum)
{
case FILEIO_EPERM:
- return EPERM;
+ return EPERM;
case FILEIO_ENOENT:
- return ENOENT;
+ return ENOENT;
case FILEIO_EINTR:
- return EINTR;
+ return EINTR;
case FILEIO_EIO:
- return EIO;
+ return EIO;
case FILEIO_EBADF:
- return EBADF;
+ return EBADF;
case FILEIO_EACCES:
- return EACCES;
+ return EACCES;
case FILEIO_EFAULT:
- return EFAULT;
+ return EFAULT;
case FILEIO_EBUSY:
- return EBUSY;
+ return EBUSY;
case FILEIO_EEXIST:
- return EEXIST;
+ return EEXIST;
case FILEIO_ENODEV:
- return ENODEV;
+ return ENODEV;
case FILEIO_ENOTDIR:
- return ENOTDIR;
+ return ENOTDIR;
case FILEIO_EISDIR:
- return EISDIR;
+ return EISDIR;
case FILEIO_EINVAL:
- return EINVAL;
+ return EINVAL;
case FILEIO_ENFILE:
- return ENFILE;
+ return ENFILE;
case FILEIO_EMFILE:
- return EMFILE;
+ return EMFILE;
case FILEIO_EFBIG:
- return EFBIG;
+ return EFBIG;
case FILEIO_ENOSPC:
- return ENOSPC;
+ return ENOSPC;
case FILEIO_ESPIPE:
- return ESPIPE;
+ return ESPIPE;
case FILEIO_EROFS:
- return EROFS;
+ return EROFS;
case FILEIO_ENOSYS:
- return ENOSYS;
+ return ENOSYS;
case FILEIO_ENAMETOOLONG:
- return ENAMETOOLONG;
+ return ENAMETOOLONG;
}
return -1;
}
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;
remote_file_delete (argv[0], from_tty);
}
-static void
-remote_command (const char *args, int from_tty)
-{
- help_list (remote_cmdlist, "remote ", all_commands, gdb_stdout);
-}
-
bool
remote_target::can_execute_reverse ()
{
encode_actions_rsp (loc, &tdp_actions, &stepping_actions);
tpaddr = loc->address;
- sprintf_vma (addrbuf, tpaddr);
+ strcpy (addrbuf, phex (tpaddr, sizeof (CORE_ADDR)));
ret = snprintf (buf.data (), buf.size (), "QTDP:%x:%s:%c:%lx:%x",
b->number, addrbuf, /* address */
(b->enable_state == bp_enabled ? 'E' : 'D'),
remote_target::enable_tracepoint (struct bp_location *location)
{
struct remote_state *rs = get_remote_state ();
- char addr_buf[40];
- sprintf_vma (addr_buf, location->address);
xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTEnable:%x:%s",
- location->owner->number, addr_buf);
+ location->owner->number,
+ phex (location->address, sizeof (CORE_ADDR)));
putpkt (rs->buf);
remote_get_noisy_reply ();
if (rs->buf[0] == '\0')
remote_target::disable_tracepoint (struct bp_location *location)
{
struct remote_state *rs = get_remote_state ();
- char addr_buf[40];
- sprintf_vma (addr_buf, location->address);
xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDisable:%x:%s",
- location->owner->number, addr_buf);
+ location->owner->number,
+ phex (location->address, sizeof (CORE_ADDR)));
putpkt (rs->buf);
remote_get_noisy_reply ();
if (rs->buf[0] == '\0')
remote_target::trace_set_readonly_regions ()
{
asection *s;
- bfd *abfd = NULL;
bfd_size_type size;
bfd_vma vma;
int anysecs = 0;
int offset = 0;
- if (!exec_bfd)
+ if (!current_program_space->exec_bfd ())
return; /* No information to give. */
struct remote_state *rs = get_remote_state ();
strcpy (rs->buf.data (), "QTro");
offset = strlen (rs->buf.data ());
- for (s = exec_bfd->sections; s; s = s->next)
+ for (s = current_program_space->exec_bfd ()->sections; s; s = s->next)
{
char tmp1[40], tmp2[40];
int sec_length;
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);
{
/* 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]);
{
struct remote_state *rs = get_remote_state ();
char *reply;
- struct bp_location *loc;
struct tracepoint *tp = (struct tracepoint *) bp;
size_t size = get_remote_packet_size ();
{
tp->hit_count = 0;
tp->traceframe_usage = 0;
- for (loc = tp->loc; loc; loc = loc->next)
+ for (bp_location *loc : tp->locations ())
{
/* If the tracepoint was never downloaded, don't go asking for
any status. */
if (*reply == '\0')
error (_("Target does not support this command."));
if (strcmp (reply, "OK") != 0)
- error (_("Bogus reply from target: %s"), reply);
+ error (_("Bogus reply from target: %s"), reply);
}
else if (val)
warning (_("Target does not support disconnected tracing."));
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;
remote_target::traceframe_info ()
{
gdb::optional<gdb::char_vector> text
- = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO,
+ = target_read_stralloc (current_inferior ()->top_target (),
+ TARGET_OBJECT_TRACEFRAME_INFO,
NULL);
if (text)
return parse_traceframe_info (text->data ());
/* If we're not debugging a process yet, the IPA can't be
loaded. */
- if (!target_has_execution)
+ if (!target_has_execution ())
return 0;
/* Make sure the remote is pointing at the right process. */
if (val < 0)
{
*buf++ = '-';
- buf += hexnumstr (buf, (ULONGEST) -val);
+ buf += hexnumstr (buf, (ULONGEST) -val);
}
else
buf += hexnumstr (buf, (ULONGEST) val);
{
pos = buf;
pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
- conf->bts.size);
+ conf->bts.size);
putpkt (buf);
getpkt (&rs->buf, 0);
{
pos = buf;
pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
- conf->pt.size);
+ conf->pt.size);
putpkt (buf);
getpkt (&rs->buf, 0);
btrace_read_config (struct btrace_config *conf)
{
gdb::optional<gdb::char_vector> xml
- = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF, "");
+ = target_read_stralloc (current_inferior ()->top_target (),
+ TARGET_OBJECT_BTRACE_CONF, "");
if (xml)
parse_xml_btrace_conf (conf, xml->data ());
}
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);
{
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;
}
{
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);
}
gdb::optional<gdb::char_vector> xml
- = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE, annex);
+ = target_read_stralloc (current_inferior ()->top_target (),
+ TARGET_OBJECT_BTRACE, annex);
if (!xml)
return BTRACE_ERR_UNKNOWN;
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);
xsnprintf (annex, annex_size, "%x", pid);
}
- filename = target_read_stralloc (current_top_target (),
+ filename = target_read_stralloc (current_inferior ()->top_target (),
TARGET_OBJECT_EXEC_FILE, annex);
return filename ? filename->data () : nullptr;
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);
if (tp->inf == inf && priv != NULL)
- {
+ {
if (handle_len != priv->thread_handle.size ())
error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
- handle_len, priv->thread_handle.size ());
+ handle_len, priv->thread_handle.size ());
if (memcmp (thread_handle, priv->thread_handle.data (),
- handle_len) == 0)
+ handle_len) == 0)
return 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 ()
{
{
/* Don't propogate error information up to the client. Instead let
the client find out about the error by querying the target. */
- inferior_event_handler (INF_REG_EVENT, NULL);
+ inferior_event_handler (INF_REG_EVENT);
}
static void
remote_async_inferior_event_handler (gdb_client_data data)
{
- inferior_event_handler (INF_REG_EVENT, data);
+ inferior_event_handler (INF_REG_EVENT);
+}
+
+int
+remote_target::async_wait_fd ()
+{
+ struct remote_state *rs = get_remote_state ();
+ return rs->remote_desc->fd;
}
void
}
}
-static void
-set_remote_cmd (const char *args, int from_tty)
-{
- help_list (remote_set_cmdlist, "set remote ", all_commands, gdb_stdout);
-}
-
static void
show_remote_cmd (const char *args, int from_tty)
{
{
remote_target *remote = get_current_remote_target ();
- if (remote != NULL) /* Have a remote connection. */
- remote->remote_check_symbols ();
+ /* First, check whether the current inferior's process target is a remote
+ target. */
+ if (remote == nullptr)
+ return;
+
+ /* When we are attaching or handling a fork child and the shared library
+ subsystem reads the list of loaded libraries, we receive new objfile
+ events in between each found library. The libraries are read in an
+ undefined order, so if we gave the remote side a chance to look up
+ symbols between each objfile, we might give it an inconsistent picture
+ of the inferior. It could appear that a library A appears loaded but
+ a library B does not, even though library A requires library B. That
+ would present a state that couldn't normally exist in the inferior.
+
+ So, skip these events, we'll give the remote a chance to look up symbols
+ once all the loaded libraries and their symbols are known to GDB. */
+ if (current_inferior ()->in_initial_library_scan)
+ return;
+
+ remote->remote_check_symbols ();
}
/* Pull all the tracepoints defined on the target and create local
}
}
-void
-_initialize_remote (void)
+static void
+show_remote_debug (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Debugging of remote protocol is %s.\n"),
+ value);
+}
+
+static void
+show_remote_timeout (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file,
+ _("Timeout limit to wait for target to respond is %s.\n"),
+ value);
+}
+
+/* Implement the "supports_memory_tagging" target_ops method. */
+
+bool
+remote_target::supports_memory_tagging ()
+{
+ return remote_memory_tagging_p ();
+}
+
+/* Create the qMemTags packet given ADDRESS, LEN and TYPE. */
+
+static void
+create_fetch_memtags_request (gdb::char_vector &packet, CORE_ADDR address,
+ size_t len, int type)
+{
+ int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
+
+ std::string request = string_printf ("qMemTags:%s,%s:%s",
+ phex_nz (address, addr_size),
+ phex_nz (len, sizeof (len)),
+ phex_nz (type, sizeof (type)));
+
+ strcpy (packet.data (), request.c_str ());
+}
+
+/* Parse the qMemTags packet reply into TAGS.
+
+ Return true if successful, false otherwise. */
+
+static bool
+parse_fetch_memtags_reply (const gdb::char_vector &reply,
+ gdb::byte_vector &tags)
+{
+ if (reply.empty () || reply[0] == 'E' || reply[0] != 'm')
+ return false;
+
+ /* Copy the tag data. */
+ tags = hex2bin (reply.data () + 1);
+
+ return true;
+}
+
+/* Create the QMemTags packet given ADDRESS, LEN, TYPE and TAGS. */
+
+static void
+create_store_memtags_request (gdb::char_vector &packet, CORE_ADDR address,
+ size_t len, int type,
+ const gdb::byte_vector &tags)
+{
+ int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
+
+ /* Put together the main packet, address and length. */
+ std::string request = string_printf ("QMemTags:%s,%s:%s:",
+ phex_nz (address, addr_size),
+ phex_nz (len, sizeof (len)),
+ phex_nz (type, sizeof (type)));
+ request += bin2hex (tags.data (), tags.size ());
+
+ /* Check if we have exceeded the maximum packet size. */
+ if (packet.size () < request.length ())
+ error (_("Contents too big for packet QMemTags."));
+
+ strcpy (packet.data (), request.c_str ());
+}
+
+/* Implement the "fetch_memtags" target_ops method. */
+
+bool
+remote_target::fetch_memtags (CORE_ADDR address, size_t len,
+ gdb::byte_vector &tags, int type)
+{
+ /* Make sure the qMemTags packet is supported. */
+ if (!remote_memory_tagging_p ())
+ gdb_assert_not_reached ("remote fetch_memtags called with packet disabled");
+
+ struct remote_state *rs = get_remote_state ();
+
+ create_fetch_memtags_request (rs->buf, address, len, type);
+
+ putpkt (rs->buf);
+ getpkt (&rs->buf, 0);
+
+ return parse_fetch_memtags_reply (rs->buf, tags);
+}
+
+/* Implement the "store_memtags" target_ops method. */
+
+bool
+remote_target::store_memtags (CORE_ADDR address, size_t len,
+ const gdb::byte_vector &tags, int type)
+{
+ /* Make sure the QMemTags packet is supported. */
+ if (!remote_memory_tagging_p ())
+ gdb_assert_not_reached ("remote store_memtags called with packet disabled");
+
+ struct remote_state *rs = get_remote_state ();
+
+ create_store_memtags_request (rs->buf, address, len, type, tags);
+
+ putpkt (rs->buf);
+ getpkt (&rs->buf, 0);
+
+ /* Verify if the request was successful. */
+ return packet_check_result (rs->buf.data ()) == PACKET_OK;
+}
+
+/* Return true if remote target T is non-stop. */
+
+bool
+remote_target_is_non_stop_p (remote_target *t)
+{
+ scoped_restore_current_thread restore_thread;
+ switch_to_target_no_thread (t);
+
+ return target_is_non_stop_p ();
+}
+
+#if GDB_SELF_TEST
+
+namespace selftests {
+
+static void
+test_memory_tagging_functions ()
{
- struct cmd_list_element *cmd;
- const char *cmd_name;
+ remote_target remote;
+
+ struct packet_config *config
+ = &remote_protocol_packets[PACKET_memory_tagging_feature];
+
+ scoped_restore restore_memtag_support_
+ = make_scoped_restore (&config->support);
+
+ /* Test memory tagging packet support. */
+ config->support = PACKET_SUPPORT_UNKNOWN;
+ SELF_CHECK (remote.supports_memory_tagging () == false);
+ config->support = PACKET_DISABLE;
+ SELF_CHECK (remote.supports_memory_tagging () == false);
+ config->support = PACKET_ENABLE;
+ SELF_CHECK (remote.supports_memory_tagging () == true);
+
+ /* Setup testing. */
+ gdb::char_vector packet;
+ gdb::byte_vector tags, bv;
+ std::string expected, reply;
+ packet.resize (32000);
+
+ /* Test creating a qMemTags request. */
+
+ expected = "qMemTags:0,0:0";
+ create_fetch_memtags_request (packet, 0x0, 0x0, 0);
+ SELF_CHECK (strcmp (packet.data (), expected.c_str ()) == 0);
+
+ expected = "qMemTags:deadbeef,10:1";
+ create_fetch_memtags_request (packet, 0xdeadbeef, 16, 1);
+ SELF_CHECK (strcmp (packet.data (), expected.c_str ()) == 0);
+
+ /* Test parsing a qMemTags reply. */
+
+ /* Error reply, tags vector unmodified. */
+ reply = "E00";
+ strcpy (packet.data (), reply.c_str ());
+ tags.resize (0);
+ SELF_CHECK (parse_fetch_memtags_reply (packet, tags) == false);
+ SELF_CHECK (tags.size () == 0);
+
+ /* Valid reply, tags vector updated. */
+ tags.resize (0);
+ bv.resize (0);
+
+ for (int i = 0; i < 5; i++)
+ bv.push_back (i);
+
+ reply = "m" + bin2hex (bv.data (), bv.size ());
+ strcpy (packet.data (), reply.c_str ());
+ SELF_CHECK (parse_fetch_memtags_reply (packet, tags) == true);
+ SELF_CHECK (tags.size () == 5);
+
+ for (int i = 0; i < 5; i++)
+ SELF_CHECK (tags[i] == i);
+
+ /* Test creating a QMemTags request. */
+
+ /* Empty tag data. */
+ tags.resize (0);
+ expected = "QMemTags:0,0:0:";
+ create_store_memtags_request (packet, 0x0, 0x0, 0, tags);
+ SELF_CHECK (memcmp (packet.data (), expected.c_str (),
+ expected.length ()) == 0);
+
+ /* Non-empty tag data. */
+ tags.resize (0);
+ for (int i = 0; i < 5; i++)
+ tags.push_back (i);
+ expected = "QMemTags:deadbeef,ff:1:0001020304";
+ create_store_memtags_request (packet, 0xdeadbeef, 255, 1, tags);
+ SELF_CHECK (memcmp (packet.data (), expected.c_str (),
+ expected.length ()) == 0);
+}
+
+} // namespace selftests
+#endif /* GDB_SELF_TEST */
+
+void _initialize_remote ();
+void
+_initialize_remote ()
+{
/* architecture specific data */
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);
/* Hook into new objfile notification. */
- gdb::observers::new_objfile.attach (remote_new_objfile);
+ gdb::observers::new_objfile.attach (remote_new_objfile, "remote");
#if 0
init_remote_threadtests ();
/* set/show remote ... */
- add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
-Remote protocol specific variables\n\
+ add_basic_prefix_cmd ("remote", class_maintenance, _("\
+Remote protocol specific variables.\n\
Configure various remote-protocol specific variables such as\n\
-the packets being used"),
- &remote_set_cmdlist, "set remote ",
- 0 /* allow-unknown */, &setlist);
+the packets being used."),
+ &remote_set_cmdlist,
+ 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"),
- &remote_show_cmdlist, "show remote ",
+the packets being used."),
+ &remote_show_cmdlist,
0 /* allow-unknown */, &showlist);
add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
terminating `#' character and checksum."),
&maintenancelist);
- add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
+ set_show_commands remotebreak_cmds
+ = add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
Set whether to send break if interrupted."), _("\
Show whether to send break if interrupted."), _("\
If set, a break, instead of a cntrl-c, is sent to the remote target."),
- set_remotebreak, show_remotebreak,
- &setlist, &showlist);
- cmd_name = "remotebreak";
- cmd = lookup_cmd (&cmd_name, setlist, "", -1, 1);
- deprecate_cmd (cmd, "set remote interrupt-sequence");
- cmd_name = "remotebreak"; /* needed because lookup_cmd updates the pointer */
- cmd = lookup_cmd (&cmd_name, showlist, "", -1, 1);
- deprecate_cmd (cmd, "show remote interrupt-sequence");
+ set_remotebreak, show_remotebreak,
+ &setlist, &showlist);
+ deprecate_cmd (remotebreak_cmds.set, "set remote interrupt-sequence");
+ deprecate_cmd (remotebreak_cmds.show, "show remote interrupt-sequence");
add_setshow_enum_cmd ("interrupt-sequence", class_support,
interrupt_sequence_modes, &interrupt_sequence_mode,
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);
+ "qXfer:osdata:read", "osdata", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads],
"qXfer:threads:read", "threads", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read],
- "qXfer:siginfo:read", "read-siginfo-object", 0);
+ "qXfer:siginfo:read", "read-siginfo-object", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write],
- "qXfer:siginfo:write", "write-siginfo-object", 0);
+ "qXfer:siginfo:write", "write-siginfo-object", 0);
add_packet_config_cmd
(&remote_protocol_packets[PACKET_qXfer_traceframe_info],
"InstallInTrace", "install-in-trace", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read],
- "qXfer:statictrace:read", "read-sdata-object", 0);
+ "qXfer:statictrace:read", "read-sdata-object", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic],
"qXfer:fdpic:read", "read-fdpic-loadmap", 0);
"multiprocess-feature", "multiprocess-feature", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_swbreak_feature],
- "swbreak-feature", "swbreak-feature", 0);
+ "swbreak-feature", "swbreak-feature", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature],
- "hwbreak-feature", "hwbreak-feature", 0);
+ "hwbreak-feature", "hwbreak-feature", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_fork_event_feature],
"fork-event-feature", "fork-event-feature", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_no_resumed],
"N stop reply", "no-resumed-stop-reply", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_memory_tagging_feature],
+ "memory-tagging-feature", "memory-tagging-feature", 0);
+
/* Assert that we've registered "set remote foo-packet" commands
for all packet configs. */
{
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,
`Z' packets is %s. */
&remote_set_cmdlist, &remote_show_cmdlist);
- add_prefix_cmd ("remote", class_files, remote_command, _("\
-Manipulate files on the remote system\n\
+ add_basic_prefix_cmd ("remote", class_files, _("\
+Manipulate files on the remote system.\n\
Transfer files to and from the remote target system."),
- &remote_cmdlist, "remote ",
- 0 /* allow-unknown */, &cmdlist);
+ &remote_cmdlist,
+ 0 /* allow-unknown */, &cmdlist);
add_cmd ("put", class_files, remote_put_command,
_("Copy a local file to the remote system."),
add_setshow_string_noescape_cmd ("exec-file", class_files,
&remote_exec_file_var, _("\
-Set the remote pathname for \"run\""), _("\
-Show the remote pathname for \"run\""), NULL,
+Set the remote pathname for \"run\"."), _("\
+Show the remote pathname for \"run\"."), NULL,
set_remote_exec_file,
show_remote_exec_file,
&remote_set_cmdlist,
&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);
+
+ add_setshow_boolean_cmd ("remote", no_class, &remote_debug,
+ _("Set debugging of remote protocol."),
+ _("Show debugging of remote protocol."),
+ _("\
+When enabled, each packet sent or received with the remote target\n\
+is displayed."),
+ NULL,
+ show_remote_debug,
+ &setdebuglist, &showdebuglist);
+
+ add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class,
+ &remote_timeout, _("\
+Set timeout limit to wait for target to respond."), _("\
+Show timeout limit to wait for target to respond."), _("\
+This value is used to set the time limit for gdb to wait for a response\n\
+from the target."),
+ NULL,
+ show_remote_timeout,
+ &setlist, &showlist);
+
/* Eventually initialize fileio. See fileio.c */
- initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
+ 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);
+#if GDB_SELF_TEST
+ selftests::register_test ("remote_memory_tagging",
+ selftests::test_memory_tagging_functions);
+#endif
}
projects / deliverable / binutils-gdb.git / blobdiff