/* Remote target communications for serial-line targets in custom GDB protocol
- Copyright (C) 1988-2022 Free Software Foundation, Inc.
+ Copyright (C) 1988-2023 Free Software Foundation, Inc.
This file is part of GDB.
#include "process-stratum-target.h"
#include "gdbcmd.h"
#include "objfiles.h"
-#include "gdb-stabs.h"
#include "gdbthread.h"
#include "remote.h"
#include "remote-notif.h"
#include "gdbsupport/agent.h"
#include "btrace.h"
#include "record-btrace.h"
-#include <algorithm>
#include "gdbsupport/scoped_restore.h"
#include "gdbsupport/environ.h"
#include "gdbsupport/byte-vector.h"
#include "gdbsupport/search.h"
#include <algorithm>
+#include <iterator>
#include <unordered_map>
#include "async-event.h"
#include "gdbsupport/selftest.h"
PACKET_DISABLE
};
+/* Convert the packet support auto_boolean to a name used for gdb printing. */
+
+static const char *
+get_packet_support_name (auto_boolean support)
+{
+ switch (support)
+ {
+ case AUTO_BOOLEAN_TRUE:
+ return "on";
+ case AUTO_BOOLEAN_FALSE:
+ return "off";
+ case AUTO_BOOLEAN_AUTO:
+ return "auto";
+ default:
+ gdb_assert_not_reached ("invalid var_auto_boolean");
+ }
+}
+
+/* Convert the target type (future remote target or currently connected target)
+ to a name used for gdb printing. */
+
+static const char *
+get_target_type_name (bool target_connected)
+{
+ if (target_connected)
+ return _("on the current remote target");
+ else
+ return _("on future remote targets");
+}
+
/* Analyze a packet's return value and update the packet config
accordingly. */
PACKET_UNKNOWN
};
+/* Enumeration of packets for a remote target. */
+
+enum {
+ PACKET_vCont = 0,
+ PACKET_X,
+ PACKET_qSymbol,
+ PACKET_P,
+ PACKET_p,
+ PACKET_Z0,
+ PACKET_Z1,
+ PACKET_Z2,
+ PACKET_Z3,
+ PACKET_Z4,
+ PACKET_vFile_setfs,
+ PACKET_vFile_open,
+ PACKET_vFile_pread,
+ PACKET_vFile_pwrite,
+ PACKET_vFile_close,
+ PACKET_vFile_unlink,
+ PACKET_vFile_readlink,
+ PACKET_vFile_fstat,
+ PACKET_qXfer_auxv,
+ PACKET_qXfer_features,
+ PACKET_qXfer_exec_file,
+ PACKET_qXfer_libraries,
+ PACKET_qXfer_libraries_svr4,
+ PACKET_qXfer_memory_map,
+ PACKET_qXfer_osdata,
+ PACKET_qXfer_threads,
+ PACKET_qXfer_statictrace_read,
+ PACKET_qXfer_traceframe_info,
+ PACKET_qXfer_uib,
+ PACKET_qGetTIBAddr,
+ PACKET_qGetTLSAddr,
+ PACKET_qSupported,
+ PACKET_qTStatus,
+ PACKET_QPassSignals,
+ PACKET_QCatchSyscalls,
+ PACKET_QProgramSignals,
+ PACKET_QSetWorkingDir,
+ PACKET_QStartupWithShell,
+ PACKET_QEnvironmentHexEncoded,
+ PACKET_QEnvironmentReset,
+ PACKET_QEnvironmentUnset,
+ PACKET_qCRC,
+ PACKET_qSearch_memory,
+ PACKET_vAttach,
+ PACKET_vRun,
+ PACKET_QStartNoAckMode,
+ PACKET_vKill,
+ PACKET_qXfer_siginfo_read,
+ PACKET_qXfer_siginfo_write,
+ PACKET_qAttached,
+
+ /* Support for conditional tracepoints. */
+ PACKET_ConditionalTracepoints,
+
+ /* Support for target-side breakpoint conditions. */
+ PACKET_ConditionalBreakpoints,
+
+ /* Support for target-side breakpoint commands. */
+ PACKET_BreakpointCommands,
+
+ /* Support for fast tracepoints. */
+ PACKET_FastTracepoints,
+
+ /* Support for static tracepoints. */
+ PACKET_StaticTracepoints,
+
+ /* Support for installing tracepoints while a trace experiment is
+ running. */
+ PACKET_InstallInTrace,
+
+ PACKET_bc,
+ PACKET_bs,
+ PACKET_TracepointSource,
+ PACKET_QAllow,
+ PACKET_qXfer_fdpic,
+ PACKET_QDisableRandomization,
+ PACKET_QAgent,
+ PACKET_QTBuffer_size,
+ PACKET_Qbtrace_off,
+ PACKET_Qbtrace_bts,
+ PACKET_Qbtrace_pt,
+ PACKET_qXfer_btrace,
+
+ /* Support for the QNonStop packet. */
+ PACKET_QNonStop,
+
+ /* Support for the QThreadEvents packet. */
+ PACKET_QThreadEvents,
+
+ /* Support for multi-process extensions. */
+ PACKET_multiprocess_feature,
+
+ /* Support for enabling and disabling tracepoints while a trace
+ experiment is running. */
+ PACKET_EnableDisableTracepoints_feature,
+
+ /* Support for collecting strings using the tracenz bytecode. */
+ PACKET_tracenz_feature,
+
+ /* Support for continuing to run a trace experiment while GDB is
+ disconnected. */
+ PACKET_DisconnectedTracing_feature,
+
+ /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
+ PACKET_augmented_libraries_svr4_read_feature,
+
+ /* Support for the qXfer:btrace-conf:read packet. */
+ PACKET_qXfer_btrace_conf,
+
+ /* Support for the Qbtrace-conf:bts:size packet. */
+ PACKET_Qbtrace_conf_bts_size,
+
+ /* Support for swbreak+ feature. */
+ PACKET_swbreak_feature,
+
+ /* Support for hwbreak+ feature. */
+ PACKET_hwbreak_feature,
+
+ /* Support for fork events. */
+ PACKET_fork_event_feature,
+
+ /* Support for vfork events. */
+ PACKET_vfork_event_feature,
+
+ /* Support for the Qbtrace-conf:pt:size packet. */
+ PACKET_Qbtrace_conf_pt_size,
+
+ /* Support for exec events. */
+ PACKET_exec_event_feature,
+
+ /* Support for query supported vCont actions. */
+ PACKET_vContSupported,
+
+ /* Support remote CTRL-C. */
+ PACKET_vCtrlC,
+
+ /* 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
+};
+
struct threads_listing_context;
/* Stub vCont actions support.
ULONGEST offset = 0;
/* The buffer holding the cache contents. */
- gdb_byte *buf = nullptr;
- /* The buffer's size. We try to read as much as fits into a packet
- at a time. */
- size_t bufsize = 0;
+ gdb::byte_vector buf;
/* Cache hit and miss counters. */
ULONGEST hit_count = 0;
long regnum; /* GDB's internal register number. */
LONGEST pnum; /* Remote protocol register number. */
int in_g_packet; /* Always part of G packet. */
- /* long size in bytes; == register_size (target_gdbarch (), regnum);
+ /* long size in bytes; == register_size (arch, regnum);
at present. */
- /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
+ /* char *name; == gdbarch_register_name (arch, regnum);
at present. */
};
/* Get the remote arch state for GDBARCH. */
struct remote_arch_state *get_remote_arch_state (struct gdbarch *gdbarch);
+ void create_async_event_handler ()
+ {
+ gdb_assert (m_async_event_handler_token == nullptr);
+ m_async_event_handler_token
+ = ::create_async_event_handler ([] (gdb_client_data data)
+ {
+ inferior_event_handler (INF_REG_EVENT);
+ },
+ nullptr, "remote");
+ }
+
+ void mark_async_event_handler ()
+ {
+ gdb_assert (this->is_async_p ());
+ ::mark_async_event_handler (m_async_event_handler_token);
+ }
+
+ void clear_async_event_handler ()
+ { ::clear_async_event_handler (m_async_event_handler_token); }
+
+ bool async_event_handler_marked () const
+ { return ::async_event_handler_marked (m_async_event_handler_token); }
+
+ void delete_async_event_handler ()
+ {
+ if (m_async_event_handler_token != nullptr)
+ ::delete_async_event_handler (&m_async_event_handler_token);
+ }
+
+ bool is_async_p () const
+ {
+ /* We're async whenever the serial device is. */
+ gdb_assert (this->remote_desc != nullptr);
+ return serial_is_async_p (this->remote_desc);
+ }
+
+ bool can_async_p () const
+ {
+ /* We can async whenever the serial device can. */
+ gdb_assert (this->remote_desc != nullptr);
+ return serial_can_async_p (this->remote_desc);
+ }
+
public: /* data */
/* A buffer to use for incoming packets, and its current size. The
/* 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. */
immediately, so queue is not needed for them. */
std::vector<stop_reply_up> stop_reply_queue;
- /* Asynchronous signal handle registered as event loop source for
- when we have pending events ready to be passed to the core. */
- struct async_event_handler *remote_async_inferior_event_token = nullptr;
-
/* FIXME: cagney/1999-09-23: Even though getpkt was called with
``forever'' still use the normal timeout mechanism. This is
currently used by the ASYNC code to guarentee that target reads
modified to return a timeout indication and, in turn
remote_wait()/wait_for_inferior() have gained a timeout parameter
this can go away. */
- int wait_forever_enabled_p = 1;
+ bool wait_forever_enabled_p = true;
private:
+ /* Asynchronous signal handle registered as event loop source for
+ when we have pending events ready to be passed to the core. */
+ async_event_handler *m_async_event_handler_token = nullptr;
+
/* Mapping of remote protocol data for each gdbarch. Usually there
is only one entry here, though we may see more with stubs that
support multi-process. */
remote_doc
};
+/* Description of a remote packet. */
+
+struct packet_description
+{
+ /* Name of the packet used for gdb output. */
+ const char *name;
+
+ /* Title of the packet, used by the set/show remote name-packet
+ commands to identify the individual packages and gdb output. */
+ const char *title;
+};
+
+/* Configuration of a remote packet. */
+
+struct packet_config
+{
+ /* If auto, GDB auto-detects support for this packet or feature,
+ either through qSupported, or by trying the packet and looking
+ at the response. If true, GDB assumes the target supports this
+ packet. If false, the packet is disabled. Configs that don't
+ have an associated command always have this set to auto. */
+ enum auto_boolean detect;
+
+ /* Does the target support this packet? */
+ enum packet_support support;
+};
+
+/* User configurable variables for the number of characters in a
+ memory read/write packet. MIN (rsa->remote_packet_size,
+ rsa->sizeof_g_packet) is the default. Some targets need smaller
+ values (fifo overruns, et.al.) and some users need larger values
+ (speed up transfers). The variables ``preferred_*'' (the user
+ request), ``current_*'' (what was actually set) and ``forced_*''
+ (Positive - a soft limit, negative - a hard limit). */
+
+struct memory_packet_config
+{
+ const char *name;
+ long size;
+ int fixed_p;
+};
+
+/* These global variables contain the default configuration for every new
+ remote_feature object. */
+static memory_packet_config memory_read_packet_config =
+{
+ "memory-read-packet-size",
+};
+static memory_packet_config memory_write_packet_config =
+{
+ "memory-write-packet-size",
+};
+
+/* This global array contains packet descriptions (name and title). */
+static packet_description packets_descriptions[PACKET_MAX];
+/* This global array contains the default configuration for every new
+ per-remote target array. */
+static packet_config remote_protocol_packets[PACKET_MAX];
+
+/* Description of a remote target's features. It stores the configuration
+ and provides functions to determine supported features of the target. */
+
+struct remote_features
+{
+ remote_features ()
+ {
+ m_memory_read_packet_config = memory_read_packet_config;
+ m_memory_write_packet_config = memory_write_packet_config;
+
+ std::copy (std::begin (remote_protocol_packets),
+ std::end (remote_protocol_packets),
+ std::begin (m_protocol_packets));
+ }
+ ~remote_features () = default;
+
+ DISABLE_COPY_AND_ASSIGN (remote_features);
+
+ /* Returns whether a given packet defined by its enum value is supported. */
+ enum packet_support packet_support (int) const;
+
+ /* Returns the packet's corresponding "set remote foo-packet" command
+ state. See struct packet_config for more details. */
+ enum auto_boolean packet_set_cmd_state (int packet) const
+ { return m_protocol_packets[packet].detect; }
+
+ /* Returns true if the multi-process extensions are in effect. */
+ int remote_multi_process_p () const
+ { return packet_support (PACKET_multiprocess_feature) == PACKET_ENABLE; }
+
+ /* Returns true if fork events are supported. */
+ int remote_fork_event_p () const
+ { return packet_support (PACKET_fork_event_feature) == PACKET_ENABLE; }
+
+ /* Returns true if vfork events are supported. */
+ int remote_vfork_event_p () const
+ { return packet_support (PACKET_vfork_event_feature) == PACKET_ENABLE; }
+
+ /* Returns true if exec events are supported. */
+ int remote_exec_event_p () const
+ { return packet_support (PACKET_exec_event_feature) == PACKET_ENABLE; }
+
+ /* Returns true if memory tagging is supported, false otherwise. */
+ bool remote_memory_tagging_p () const
+ { return packet_support (PACKET_memory_tagging_feature) == PACKET_ENABLE; }
+
+ /* Reset all packets back to "unknown support". Called when opening a
+ new connection to a remote target. */
+ void reset_all_packet_configs_support ();
+
+/* Check result value in BUF for packet WHICH_PACKET and update the packet's
+ support configuration accordingly. */
+ packet_result packet_ok (const char *buf, const int which_packet);
+ packet_result packet_ok (const gdb::char_vector &buf, const int which_packet);
+
+ /* Configuration of a remote target's memory read packet. */
+ memory_packet_config m_memory_read_packet_config;
+ /* Configuration of a remote target's memory write packet. */
+ memory_packet_config m_memory_write_packet_config;
+
+ /* The per-remote target array which stores a remote's packet
+ configurations. */
+ packet_config m_protocol_packets[PACKET_MAX];
+};
+
class remote_target : public process_stratum_target
{
public:
int handle_len,
inferior *inf) override;
- gdb::byte_vector thread_info_to_thread_handle (struct thread_info *tp)
- override;
+ gdb::array_view<const gdb_byte> thread_info_to_thread_handle (struct thread_info *tp)
+ override;
void stop (ptid_t) override;
bool supports_string_tracing () override;
+ int remote_supports_cond_tracepoints ();
+
bool supports_evaluation_of_breakpoint_conditions () override;
+ int remote_supports_fast_tracepoints ();
+
+ int remote_supports_static_tracepoints ();
+
+ int remote_supports_install_in_trace ();
+
bool can_run_breakpoint_commands () override;
void trace_init () override;
int get_trace_status (struct trace_status *ts) override;
- void get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
+ void get_tracepoint_status (tracepoint *tp, struct uploaded_tp *utp)
override;
void trace_stop () override;
void send_interrupt_sequence ();
void interrupt_query ();
- void remote_notif_get_pending_events (notif_client *nc);
+ void remote_notif_get_pending_events (const notif_client *nc);
int fetch_register_using_p (struct regcache *regcache,
packet_reg *reg);
void skip_frame ();
long read_frame (gdb::char_vector *buf_p);
- void getpkt (gdb::char_vector *buf, int forever);
- int getpkt_or_notif_sane_1 (gdb::char_vector *buf, int forever,
- int expecting_notif, int *is_notif);
- int getpkt_sane (gdb::char_vector *buf, int forever);
- int getpkt_or_notif_sane (gdb::char_vector *buf, int forever,
- int *is_notif);
+ int getpkt (gdb::char_vector *buf, bool forever = false,
+ bool *is_notif = nullptr);
int remote_vkill (int pid);
void remote_kill_k ();
const gdb_byte *writebuf,
ULONGEST offset, LONGEST len,
ULONGEST *xfered_len,
- struct packet_config *packet);
+ const unsigned int which_packet);
target_xfer_status remote_read_qxfer (const char *object_name,
const char *annex,
gdb_byte *readbuf, ULONGEST offset,
LONGEST len,
ULONGEST *xfered_len,
- struct packet_config *packet);
+ const unsigned int which_packet);
void push_stop_reply (struct stop_reply *new_event);
bool vcont_r_supported ();
+ remote_features m_features;
+
private:
bool start_remote_1 (int from_tty, int extended_p);
/* The variable registered as the control variable used by the
remote exec-file commands. While the remote exec-file setting is
- per-program-space, the set/show machinery uses this as the
+ per-program-space, the set/show machinery uses this as the
location of the remote exec-file value. */
static std::string remote_exec_file_var;
static int stub_unpack_int (const char *buff, int fieldlength);
-struct packet_config;
+static void set_remote_protocol_packet_cmd (const char *args, int from_tty,
+ cmd_list_element *c);
+
+static void show_packet_config_cmd (ui_file *file,
+ const unsigned int which_packet,
+ remote_target *remote);
static void show_remote_protocol_packet_cmd (struct ui_file *file,
int from_tty,
static ptid_t read_ptid (const char *buf, const char **obuf);
-static void remote_async_inferior_event_handler (gdb_client_data);
-
static bool remote_read_description_p (struct target_ops *target);
static void remote_console_output (const char *msg);
char *buf;
QUIT; /* Allow user to bail out with ^C. */
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
buf = rs->buf.data ();
if (buf[0] == 'E')
trace_error (buf);
try
{
- gdbarch_relocate_instruction (target_gdbarch (), &to, from);
+ gdbarch_relocate_instruction (current_inferior ()->arch (),
+ &to, from);
relocated = 1;
}
catch (const gdb_exception &ex)
function which calls getpkt also needs to be mindful of changes
to rs->buf, but this call limits the number of places which run
into trouble. */
- m_remote_state.get_remote_arch_state (target_gdbarch ());
+ m_remote_state.get_remote_arch_state (current_inferior ()->arch ());
return &m_remote_state;
}
remote_target::get_remote_packet_size ()
{
struct remote_state *rs = get_remote_state ();
- remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ());
+ remote_arch_state *rsa
+ = rs->get_remote_arch_state (current_inferior ()->arch ());
if (rs->explicit_packet_size)
return rs->explicit_packet_size;
static unsigned int remote_address_size;
\f
-/* User configurable variables for the number of characters in a
- memory read/write packet. MIN (rsa->remote_packet_size,
- rsa->sizeof_g_packet) is the default. Some targets need smaller
- values (fifo overruns, et.al.) and some users need larger values
- (speed up transfers). The variables ``preferred_*'' (the user
- request), ``current_*'' (what was actually set) and ``forced_*''
- (Positive - a soft limit, negative - a hard limit). */
-
-struct memory_packet_config
-{
- const char *name;
- long size;
- int fixed_p;
-};
-
/* The default max memory-write-packet-size, when the setting is
"fixed". The 16k is historical. (It came from older GDB's using
alloca for buffers and the knowledge (folklore?) that some hosts
remote_target::get_memory_packet_size (struct memory_packet_config *config)
{
struct remote_state *rs = get_remote_state ();
- remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ());
+ remote_arch_state *rsa
+ = rs->get_remote_arch_state (current_inferior ()->arch ());
long what_they_get;
if (config->fixed_p)
something really big then do a sanity check. */
static void
-set_memory_packet_size (const char *args, struct memory_packet_config *config)
+set_memory_packet_size (const char *args, struct memory_packet_config *config,
+ bool target_connected)
{
int fixed_p = config->fixed_p;
long size = config->size;
if (args == NULL)
- error (_("Argument required (integer, `fixed' or `limited')."));
+ error (_("Argument required (integer, \"fixed\" or \"limit\")."));
else if (strcmp (args, "hard") == 0
|| strcmp (args, "fixed") == 0)
fixed_p = 1;
? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
: size);
- if (! query (_("The target may not be able to correctly handle a %s\n"
- "of %ld bytes. Change the packet size? "),
- config->name, query_size))
+ if (target_connected
+ && !query (_("The target may not be able to correctly handle a %s\n"
+ "of %ld bytes. Change the packet size? "),
+ config->name, query_size))
+ error (_("Packet size not changed."));
+ else if (!target_connected
+ && !query (_("Future remote targets may not be able to "
+ "correctly handle a %s\nof %ld bytes. Change the "
+ "packet size for future remote targets? "),
+ config->name, query_size))
error (_("Packet size not changed."));
}
/* Update the config. */
config->fixed_p = fixed_p;
config->size = size;
+
+ const char *target_type = get_target_type_name (target_connected);
+ gdb_printf (_("The %s %s is set to \"%s\".\n"), config->name, target_type,
+ args);
+
}
+/* Show the memory-read or write-packet size configuration CONFIG of the
+ target REMOTE. If REMOTE is nullptr, the default configuration for future
+ remote targets should be passed in CONFIG. */
+
static void
-show_memory_packet_size (struct memory_packet_config *config)
+show_memory_packet_size (memory_packet_config *config, remote_target *remote)
{
+ const char *target_type = get_target_type_name (remote != nullptr);
+
if (config->size == 0)
- gdb_printf (_("The %s is 0 (default). "), config->name);
+ gdb_printf (_("The %s %s is 0 (default). "), config->name, target_type);
else
- gdb_printf (_("The %s is %ld. "), config->name, config->size);
+ gdb_printf (_("The %s %s is %ld. "), config->name, target_type,
+ config->size);
+
if (config->fixed_p)
gdb_printf (_("Packets are fixed at %ld bytes.\n"),
get_fixed_memory_packet_size (config));
else
{
- remote_target *remote = get_current_remote_target ();
-
- if (remote != NULL)
+ if (remote != nullptr)
gdb_printf (_("Packets are limited to %ld bytes.\n"),
remote->get_memory_packet_size (config));
else
}
}
-/* FIXME: needs to be per-remote-target. */
-static struct memory_packet_config memory_write_packet_config =
-{
- "memory-write-packet-size",
-};
+/* Configure the memory-write-packet size of the currently selected target. If
+ no target is available, the default configuration for future remote targets
+ is configured. */
static void
set_memory_write_packet_size (const char *args, int from_tty)
{
- set_memory_packet_size (args, &memory_write_packet_config);
+ remote_target *remote = get_current_remote_target ();
+ if (remote != nullptr)
+ {
+ set_memory_packet_size
+ (args, &remote->m_features.m_memory_write_packet_config, true);
+ }
+ else
+ {
+ memory_packet_config* config = &memory_write_packet_config;
+ set_memory_packet_size (args, config, false);
+ }
}
+/* Display the memory-write-packet size of the currently selected target. If
+ no target is available, the default configuration for future remote targets
+ is shown. */
+
static void
show_memory_write_packet_size (const char *args, int from_tty)
{
- show_memory_packet_size (&memory_write_packet_config);
+ remote_target *remote = get_current_remote_target ();
+ if (remote != nullptr)
+ show_memory_packet_size (&remote->m_features.m_memory_write_packet_config,
+ remote);
+ else
+ show_memory_packet_size (&memory_write_packet_config, nullptr);
}
/* Show the number of hardware watchpoints that can be used. */
long
remote_target::get_memory_write_packet_size ()
{
- return get_memory_packet_size (&memory_write_packet_config);
+ return get_memory_packet_size (&m_features.m_memory_write_packet_config);
}
-/* FIXME: needs to be per-remote-target. */
-static struct memory_packet_config memory_read_packet_config =
-{
- "memory-read-packet-size",
-};
+/* Configure the memory-read-packet size of the currently selected target. If
+ no target is available, the default configuration for future remote targets
+ is adapted. */
static void
set_memory_read_packet_size (const char *args, int from_tty)
{
- set_memory_packet_size (args, &memory_read_packet_config);
+ remote_target *remote = get_current_remote_target ();
+ if (remote != nullptr)
+ set_memory_packet_size
+ (args, &remote->m_features.m_memory_read_packet_config, true);
+ else
+ {
+ memory_packet_config* config = &memory_read_packet_config;
+ set_memory_packet_size (args, config, false);
+ }
+
}
+/* Display the memory-read-packet size of the currently selected target. If
+ no target is available, the default configuration for future remote targets
+ is shown. */
+
static void
show_memory_read_packet_size (const char *args, int from_tty)
{
- show_memory_packet_size (&memory_read_packet_config);
+ remote_target *remote = get_current_remote_target ();
+ if (remote != nullptr)
+ show_memory_packet_size (&remote->m_features.m_memory_read_packet_config,
+ remote);
+ else
+ show_memory_packet_size (&memory_read_packet_config, nullptr);
}
long
remote_target::get_memory_read_packet_size ()
{
- long size = get_memory_packet_size (&memory_read_packet_config);
+ long size = get_memory_packet_size (&m_features.m_memory_read_packet_config);
/* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
extra buffer size argument before the memory read size can be
return size;
}
-\f
+static enum packet_support packet_config_support (const packet_config *config);
-struct packet_config
- {
- const char *name;
- const char *title;
- /* If auto, GDB auto-detects support for this packet or feature,
- either through qSupported, or by trying the packet and looking
- at the response. If true, GDB assumes the target supports this
- packet. If false, the packet is disabled. Configs that don't
- have an associated command always have this set to auto. */
- enum auto_boolean detect;
+static void
+set_remote_protocol_packet_cmd (const char *args, int from_tty,
+ cmd_list_element *c)
+{
+ remote_target *remote = get_current_remote_target ();
+ gdb_assert (c->var.has_value ());
- /* The "show remote foo-packet" command created for this packet. */
- cmd_list_element *show_cmd;
+ auto *default_config = static_cast<packet_config *> (c->context ());
+ const int packet_idx = std::distance (remote_protocol_packets,
+ default_config);
- /* Does the target support this packet? */
- enum packet_support support;
- };
+ if (packet_idx >= 0 && packet_idx < PACKET_MAX)
+ {
+ const char *name = packets_descriptions[packet_idx].name;
+ const auto_boolean value = c->var->get<auto_boolean> ();
+ const char *support = get_packet_support_name (value);
+ const char *target_type = get_target_type_name (remote != nullptr);
-static enum packet_support packet_config_support (struct packet_config *config);
-static enum packet_support packet_support (int packet);
+ if (remote != nullptr)
+ remote->m_features.m_protocol_packets[packet_idx].detect = value;
+ else
+ remote_protocol_packets[packet_idx].detect = value;
+
+ gdb_printf (_("Support for the '%s' packet %s is set to \"%s\".\n"), name,
+ target_type, support);
+ return;
+ }
+
+ internal_error (_("Could not find config for %s"), c->name);
+}
static void
-show_packet_config_cmd (ui_file *file, struct packet_config *config)
+show_packet_config_cmd (ui_file *file, const unsigned int which_packet,
+ remote_target *remote)
{
const char *support = "internal-error";
+ const char *target_type = get_target_type_name (remote != nullptr);
+
+ packet_config *config;
+ if (remote != nullptr)
+ config = &remote->m_features.m_protocol_packets[which_packet];
+ else
+ config = &remote_protocol_packets[which_packet];
switch (packet_config_support (config))
{
{
case AUTO_BOOLEAN_AUTO:
gdb_printf (file,
- _("Support for the `%s' packet "
- "is auto-detected, currently %s.\n"),
- config->name, support);
+ _("Support for the '%s' packet %s is \"auto\", "
+ "currently %s.\n"),
+ packets_descriptions[which_packet].name, target_type,
+ support);
break;
case AUTO_BOOLEAN_TRUE:
case AUTO_BOOLEAN_FALSE:
gdb_printf (file,
- _("Support for the `%s' packet is currently %s.\n"),
- config->name, support);
+ _("Support for the '%s' packet %s is \"%s\".\n"),
+ packets_descriptions[which_packet].name, target_type,
+ get_packet_support_name (config->detect));
break;
}
}
static void
-add_packet_config_cmd (struct packet_config *config, const char *name,
+add_packet_config_cmd (const unsigned int which_packet, const char *name,
const char *title, int legacy)
{
- config->name = name;
- config->title = title;
+ packets_descriptions[which_packet].name = name;
+ packets_descriptions[which_packet].title = title;
+
+ packet_config *config = &remote_protocol_packets[which_packet];
+
gdb::unique_xmalloc_ptr<char> set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
name, title);
= add_setshow_auto_boolean_cmd (cmd_name.release (), class_obscure,
&config->detect, set_doc.get (),
show_doc.get (), NULL, /* help_doc */
- NULL,
+ set_remote_protocol_packet_cmd,
show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist);
- config->show_cmd = cmds.show;
+ cmds.show->set_context (config);
+ cmds.set->set_context (config);
/* set/show remote NAME-packet {auto,on,off} -- legacy. */
if (legacy)
return packet_check_result (buf.data ());
}
-static enum packet_result
-packet_ok (const char *buf, struct packet_config *config)
+packet_result
+remote_features::packet_ok (const char *buf, const int which_packet)
{
+ packet_config *config = &m_protocol_packets[which_packet];
+ packet_description *descr = &packets_descriptions[which_packet];
+
enum packet_result result;
if (config->detect != AUTO_BOOLEAN_TRUE
if (config->support == PACKET_SUPPORT_UNKNOWN)
{
remote_debug_printf ("Packet %s (%s) is supported",
- config->name, config->title);
+ descr->name, descr->title);
config->support = PACKET_ENABLE;
}
break;
/* If the stub previously indicated that the packet was
supported then there is a protocol error. */
error (_("Protocol error: %s (%s) conflicting enabled responses."),
- config->name, config->title);
+ descr->name, descr->title);
}
else if (config->detect == AUTO_BOOLEAN_TRUE)
{
/* The user set it wrong. */
error (_("Enabled packet %s (%s) not recognized by stub"),
- config->name, config->title);
+ descr->name, descr->title);
}
- remote_debug_printf ("Packet %s (%s) is NOT supported",
- config->name, config->title);
+ remote_debug_printf ("Packet %s (%s) is NOT supported", descr->name,
+ descr->title);
config->support = PACKET_DISABLE;
break;
}
return result;
}
-static enum packet_result
-packet_ok (const gdb::char_vector &buf, struct packet_config *config)
-{
- return packet_ok (buf.data (), config);
-}
-
-enum {
- PACKET_vCont = 0,
- PACKET_X,
- PACKET_qSymbol,
- PACKET_P,
- PACKET_p,
- PACKET_Z0,
- PACKET_Z1,
- PACKET_Z2,
- PACKET_Z3,
- PACKET_Z4,
- PACKET_vFile_setfs,
- PACKET_vFile_open,
- PACKET_vFile_pread,
- PACKET_vFile_pwrite,
- PACKET_vFile_close,
- PACKET_vFile_unlink,
- PACKET_vFile_readlink,
- PACKET_vFile_fstat,
- PACKET_qXfer_auxv,
- PACKET_qXfer_features,
- PACKET_qXfer_exec_file,
- PACKET_qXfer_libraries,
- PACKET_qXfer_libraries_svr4,
- PACKET_qXfer_memory_map,
- PACKET_qXfer_osdata,
- PACKET_qXfer_threads,
- PACKET_qXfer_statictrace_read,
- PACKET_qXfer_traceframe_info,
- PACKET_qXfer_uib,
- PACKET_qGetTIBAddr,
- PACKET_qGetTLSAddr,
- PACKET_qSupported,
- PACKET_qTStatus,
- PACKET_QPassSignals,
- PACKET_QCatchSyscalls,
- PACKET_QProgramSignals,
- PACKET_QSetWorkingDir,
- PACKET_QStartupWithShell,
- PACKET_QEnvironmentHexEncoded,
- PACKET_QEnvironmentReset,
- PACKET_QEnvironmentUnset,
- PACKET_qCRC,
- PACKET_qSearch_memory,
- PACKET_vAttach,
- PACKET_vRun,
- PACKET_QStartNoAckMode,
- PACKET_vKill,
- PACKET_qXfer_siginfo_read,
- PACKET_qXfer_siginfo_write,
- PACKET_qAttached,
-
- /* Support for conditional tracepoints. */
- PACKET_ConditionalTracepoints,
-
- /* Support for target-side breakpoint conditions. */
- PACKET_ConditionalBreakpoints,
-
- /* Support for target-side breakpoint commands. */
- PACKET_BreakpointCommands,
-
- /* Support for fast tracepoints. */
- PACKET_FastTracepoints,
-
- /* Support for static tracepoints. */
- PACKET_StaticTracepoints,
-
- /* Support for installing tracepoints while a trace experiment is
- running. */
- PACKET_InstallInTrace,
-
- PACKET_bc,
- PACKET_bs,
- PACKET_TracepointSource,
- PACKET_QAllow,
- PACKET_qXfer_fdpic,
- PACKET_QDisableRandomization,
- PACKET_QAgent,
- PACKET_QTBuffer_size,
- PACKET_Qbtrace_off,
- PACKET_Qbtrace_bts,
- PACKET_Qbtrace_pt,
- PACKET_qXfer_btrace,
-
- /* Support for the QNonStop packet. */
- PACKET_QNonStop,
-
- /* Support for the QThreadEvents packet. */
- PACKET_QThreadEvents,
-
- /* Support for multi-process extensions. */
- PACKET_multiprocess_feature,
-
- /* Support for enabling and disabling tracepoints while a trace
- experiment is running. */
- PACKET_EnableDisableTracepoints_feature,
-
- /* Support for collecting strings using the tracenz bytecode. */
- PACKET_tracenz_feature,
-
- /* Support for continuing to run a trace experiment while GDB is
- disconnected. */
- PACKET_DisconnectedTracing_feature,
-
- /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
- PACKET_augmented_libraries_svr4_read_feature,
-
- /* Support for the qXfer:btrace-conf:read packet. */
- PACKET_qXfer_btrace_conf,
-
- /* Support for the Qbtrace-conf:bts:size packet. */
- PACKET_Qbtrace_conf_bts_size,
-
- /* Support for swbreak+ feature. */
- PACKET_swbreak_feature,
-
- /* Support for hwbreak+ feature. */
- PACKET_hwbreak_feature,
-
- /* Support for fork events. */
- PACKET_fork_event_feature,
-
- /* Support for vfork events. */
- PACKET_vfork_event_feature,
-
- /* Support for the Qbtrace-conf:pt:size packet. */
- PACKET_Qbtrace_conf_pt_size,
-
- /* Support for exec events. */
- PACKET_exec_event_feature,
-
- /* Support for query supported vCont actions. */
- PACKET_vContSupported,
-
- /* Support remote CTRL-C. */
- PACKET_vCtrlC,
-
- /* 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
- state. See struct packet_config for more details. */
-
-static enum auto_boolean
-packet_set_cmd_state (int packet)
+packet_result
+remote_features::packet_ok (const gdb::char_vector &buf, const int which_packet)
{
- return remote_protocol_packets[packet].detect;
+ return packet_ok (buf.data (), which_packet);
}
/* Returns whether a given packet or feature is supported. This takes
command, which may be used to bypass auto-detection. */
static enum packet_support
-packet_config_support (struct packet_config *config)
+packet_config_support (const packet_config *config)
{
switch (config->detect)
{
}
}
-/* Same as packet_config_support, but takes the packet's enum value as
- argument. */
-
-static enum packet_support
-packet_support (int packet)
+packet_support
+remote_features::packet_support (int packet) const
{
- struct packet_config *config = &remote_protocol_packets[packet];
-
+ const packet_config *config = &m_protocol_packets[packet];
return packet_config_support (config);
}
struct cmd_list_element *c,
const char *value)
{
- struct packet_config *packet;
+ remote_target *remote = get_current_remote_target ();
gdb_assert (c->var.has_value ());
- for (packet = remote_protocol_packets;
- packet < &remote_protocol_packets[PACKET_MAX];
- packet++)
+ auto *default_config = static_cast<packet_config *> (c->context ());
+ const int packet_idx = std::distance (remote_protocol_packets,
+ default_config);
+
+ if (packet_idx >= 0 && packet_idx < PACKET_MAX)
{
- if (c == packet->show_cmd)
- {
- show_packet_config_cmd (file, packet);
- return;
- }
+ show_packet_config_cmd (file, packet_idx, remote);
+ return;
}
- internal_error (_("Could not find config for %s"),
- c->name);
+ internal_error (_("Could not find config for %s"), c->name);
}
/* Should we try one of the 'Z' requests? */
set_remote_protocol_Z_packet_cmd (const char *args, int from_tty,
struct cmd_list_element *c)
{
+ remote_target *remote = get_current_remote_target ();
int i;
for (i = 0; i < NR_Z_PACKET_TYPES; i++)
- remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
+ {
+ if (remote != nullptr)
+ remote->m_features.m_protocol_packets[PACKET_Z0 + i].detect
+ = remote_Z_packet_detect;
+ else
+ remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
+ }
+
+ const char *support = get_packet_support_name (remote_Z_packet_detect);
+ const char *target_type = get_target_type_name (remote != nullptr);
+ gdb_printf (_("Use of Z packets %s is set to \"%s\".\n"), target_type,
+ support);
+
}
static void
struct cmd_list_element *c,
const char *value)
{
+ remote_target *remote = get_current_remote_target ();
int i;
for (i = 0; i < NR_Z_PACKET_TYPES; i++)
- {
- show_packet_config_cmd (file, &remote_protocol_packets[PACKET_Z0 + i]);
- }
-}
-
-/* Returns true if the multi-process extensions are in effect. */
-
-static int
-remote_multi_process_p (struct remote_state *rs)
-{
- return packet_support (PACKET_multiprocess_feature) == PACKET_ENABLE;
-}
-
-/* Returns true if fork events are supported. */
-
-static int
-remote_fork_event_p (struct remote_state *rs)
-{
- return packet_support (PACKET_fork_event_feature) == PACKET_ENABLE;
-}
-
-/* Returns true if vfork events are supported. */
-
-static int
-remote_vfork_event_p (struct remote_state *rs)
-{
- return packet_support (PACKET_vfork_event_feature) == PACKET_ENABLE;
-}
-
-/* Returns true if exec events are supported. */
-
-static int
-remote_exec_event_p (struct remote_state *rs)
-{
- 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;
+ show_packet_config_cmd (file, PACKET_Z0 + i, remote);
}
/* Insert fork catchpoint target routine. If fork events are enabled
int
remote_target::insert_fork_catchpoint (int pid)
{
- struct remote_state *rs = get_remote_state ();
-
- return !remote_fork_event_p (rs);
+ return !m_features.remote_fork_event_p ();
}
/* Remove fork catchpoint target routine. Nothing to do, just
int
remote_target::insert_vfork_catchpoint (int pid)
{
- struct remote_state *rs = get_remote_state ();
-
- return !remote_vfork_event_p (rs);
+ return !m_features.remote_vfork_event_p ();
}
/* Remove vfork catchpoint target routine. Nothing to do, just
int
remote_target::insert_exec_catchpoint (int pid)
-{
- struct remote_state *rs = get_remote_state ();
-
- return !remote_exec_event_p (rs);
+{
+ return !m_features.remote_exec_event_p ();
}
/* Remove exec catchpoint target routine. Nothing to do, just
struct remote_state *rs = get_remote_state ();
size_t size = get_remote_packet_size ();
- if (packet_support (PACKET_qAttached) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_qAttached) == PACKET_DISABLE)
return 0;
- if (remote_multi_process_p (rs))
+ if (m_features.remote_multi_process_p ())
xsnprintf (rs->buf.data (), size, "qAttached:%x", pid);
else
xsnprintf (rs->buf.data (), size, "qAttached");
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- switch (packet_ok (rs->buf,
- &remote_protocol_packets[PACKET_qAttached]))
+ switch (m_features.packet_ok (rs->buf, PACKET_qAttached))
{
case PACKET_OK:
if (strcmp (rs->buf.data (), "1") == 0)
if (attached == -1)
attached = remote_query_attached (pid);
- if (gdbarch_has_global_solist (target_gdbarch ()))
+ if (gdbarch_has_global_solist (current_inferior ()->arch ()))
{
/* If the target shares code across all inferiors, then every
attach adds a new inferior. */
/* 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 (this, currthread);
+ thread_info *tp = this->find_thread (currthread);
if (tp != NULL && tp->state == THREAD_EXITED)
{
/* We're seeing an event on a thread id we knew had exited.
thread, so notifications are emitted in a sensible order. */
if (find_inferior_pid (this, currthread.pid ()) == NULL)
{
- struct remote_state *rs = get_remote_state ();
- bool fake_pid_p = !remote_multi_process_p (rs);
+ bool fake_pid_p = !m_features.remote_multi_process_p ();
inf = remote_add_inferior (fake_pid_p,
currthread.pid (), -1, 1);
static remote_thread_info *
get_remote_thread_info (remote_target *target, ptid_t ptid)
{
- thread_info *thr = find_thread_ptid (target, ptid);
+ thread_info *thr = target->find_thread (ptid);
return get_remote_thread_info (thr);
}
void
remote_target::pass_signals (gdb::array_view<const unsigned char> pass_signals)
{
- if (packet_support (PACKET_QPassSignals) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_QPassSignals) != PACKET_DISABLE)
{
char *pass_packet, *p;
int count = 0;
if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet))
{
putpkt (pass_packet);
- getpkt (&rs->buf, 0);
- packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]);
+ getpkt (&rs->buf);
+ m_features.packet_ok (rs->buf, PACKET_QPassSignals);
xfree (rs->last_pass_packet);
rs->last_pass_packet = pass_packet;
}
enum packet_result result;
int n_sysno = 0;
- if (packet_support (PACKET_QCatchSyscalls) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_QCatchSyscalls) == PACKET_DISABLE)
{
/* Not supported. */
return 1;
struct remote_state *rs = get_remote_state ();
putpkt (catch_packet);
- getpkt (&rs->buf, 0);
- result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_QCatchSyscalls]);
+ getpkt (&rs->buf);
+ result = m_features.packet_ok (rs->buf, PACKET_QCatchSyscalls);
if (result == PACKET_OK)
return 0;
else
void
remote_target::program_signals (gdb::array_view<const unsigned char> signals)
{
- if (packet_support (PACKET_QProgramSignals) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_QProgramSignals) != PACKET_DISABLE)
{
char *packet, *p;
int count = 0;
|| strcmp (rs->last_program_signals_packet, packet) != 0)
{
putpkt (packet);
- getpkt (&rs->buf, 0);
- packet_ok (rs->buf, &remote_protocol_packets[PACKET_QProgramSignals]);
+ getpkt (&rs->buf);
+ m_features.packet_ok (rs->buf, PACKET_QProgramSignals);
xfree (rs->last_program_signals_packet);
rs->last_program_signals_packet = packet;
}
else
write_ptid (buf, endbuf, ptid);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (gen)
rs->general_thread = ptid;
else
void
remote_target::set_general_process ()
{
- struct remote_state *rs = get_remote_state ();
-
/* If the remote can't handle multiple processes, don't bother. */
- if (!remote_multi_process_p (rs))
+ if (!m_features.remote_multi_process_p ())
return;
+ remote_state *rs = get_remote_state ();
+
/* We only need to change the remote current thread if it's pointing
at some other process. */
if (rs->general_thread.pid () != inferior_ptid.pid ())
write_ptid (p, endp, ptid);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
}
/* WARNING: This threadref data structure comes from the remote O.S.,
libstub protocol encoding, and remote.c. It is not particularly
- changable. */
+ changeable. */
/* Right now, the internal structure is int. We want it to be bigger.
Plan to fix this. */
remote_target::write_ptid (char *buf, const char *endbuf, ptid_t ptid)
{
int pid, tid;
- struct remote_state *rs = get_remote_state ();
- if (remote_multi_process_p (rs))
+ if (m_features.remote_multi_process_p ())
{
pid = ptid.pid ();
if (pid < 0)
pack_threadinfo_request (rs->buf.data (), fieldset, threadid);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (rs->buf[0] == '\0')
return 0;
pack_threadlist_request (rs->buf.data (), startflag, result_limit,
nextthread);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (rs->buf[0] == '\0')
{
/* Packet not supported. */
struct remote_state *rs = get_remote_state ();
putpkt ("qC");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
{
const char *obuf;
remote_target::remote_get_threads_with_qxfer (threads_listing_context *context)
{
#if defined(HAVE_LIBEXPAT)
- if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
{
gdb::optional<gdb::char_vector> xml
= target_read_stralloc (this, TARGET_OBJECT_THREADS, NULL);
const char *bufp;
putpkt ("qfThreadInfo");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
bufp = rs->buf.data ();
if (bufp[0] != '\0') /* q packet recognized */
{
}
while (*bufp++ == ','); /* comma-separated list */
putpkt ("qsThreadInfo");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
bufp = rs->buf.data ();
}
return 1;
remote_notice_new_inferior (item.ptid, executing);
- thread_info *tp = find_thread_ptid (this, item.ptid);
+ thread_info *tp = this->find_thread (item.ptid);
remote_thread_info *info = get_remote_thread_info (tp);
info->core = item.core;
info->extra = std::move (item.extra);
if (!extra.empty ())
return extra.c_str ();
- if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
{
/* If we're using qXfer:threads:read, then the extra info is
included in the XML. So if we didn't have anything cached,
write_ptid (b, endb, tp->ptid);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (rs->buf[0] != 0)
{
extra.resize (strlen (rs->buf.data ()) / 2);
p += strlen (p);
p += hexnumstr (p, addr);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
p = rs->buf.data ();
if (*p == 'E')
/* Ask for a first packet of static tracepoint marker
definition. */
putpkt ("qTfSTM");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
p = rs->buf.data ();
if (*p == 'E')
error (_("Remote failure reply: %s"), p);
while (*p++ == ','); /* comma-separated list */
/* Ask for another packet of static tracepoint definition. */
putpkt ("qTsSTM");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
p = rs->buf.data ();
}
everything of this target. */
discard_pending_stop_replies_in_queue ();
- if (rs->remote_async_inferior_event_token)
- delete_async_event_handler (&rs->remote_async_inferior_event_token);
+ rs->delete_async_event_handler ();
delete rs->notif_state;
}
return;
putpkt ("qOffsets");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
buf = rs->buf.data ();
if (buf[0] == '\000')
thread_info *
remote_target::add_current_inferior_and_thread (const char *wait_status)
{
- struct remote_state *rs = get_remote_state ();
bool fake_pid_p = false;
switch_to_no_thread ();
if (curr_ptid != null_ptid)
{
- if (!remote_multi_process_p (rs))
+ if (!m_features.remote_multi_process_p ())
fake_pid_p = true;
}
else
enum gdb_signal sig = ws.sig ();
if (signal_print_state (sig))
- gdb::observers::signal_received.notify (sig);
+ notify_signal_received (sig);
}
- gdb::observers::normal_stop.notify (NULL, 1);
+
+ notify_normal_stop (nullptr, 1);
}
/* Process all initial stop replies the remote side sent in response
if (ignore_event)
continue;
- thread_info *evthread = find_thread_ptid (this, event_ptid);
+ thread_info *evthread = this->find_thread (event_ptid);
if (ws.kind () == TARGET_WAITKIND_STOPPED)
{
}
}
-/* Mark a remote_target as marking (by setting the starting_up flag within
+/* Mark a remote_target as starting (by setting the starting_up flag within
its remote_state) for the lifetime of this object. The reference count
on the remote target is temporarily incremented, to prevent the target
being deleted under our feet. */
/* Constructor, TARGET is the target to be marked as starting, its
reference count will be incremented. */
scoped_mark_target_starting (remote_target *target)
- : m_remote_target (target)
- {
- m_remote_target->incref ();
- remote_state *rs = m_remote_target->get_remote_state ();
- rs->starting_up = true;
- }
+ : m_remote_target (remote_target_ref::new_reference (target)),
+ m_restore_starting_up (set_starting_up_flag (target))
+ { /* Nothing. */ }
+
+private:
- /* Destructor, mark the target being worked on as no longer starting, and
- decrement the reference count. */
- ~scoped_mark_target_starting ()
+ /* Helper function, set the starting_up flag on TARGET and return an
+ object which, when it goes out of scope, will restore the previous
+ value of the starting_up flag. */
+ static scoped_restore_tmpl<bool>
+ set_starting_up_flag (remote_target *target)
{
- remote_state *rs = m_remote_target->get_remote_state ();
- rs->starting_up = false;
- decref_target (m_remote_target);
+ remote_state *rs = target->get_remote_state ();
+ gdb_assert (!rs->starting_up);
+ return make_scoped_restore (&rs->starting_up, true);
}
-private:
+ /* A gdb::ref_ptr pointer to a remote_target. */
+ using remote_target_ref = gdb::ref_ptr<remote_target, target_ops_ref_policy>;
- /* The target on which we are operating. */
- remote_target *m_remote_target;
+ /* A reference to the target on which we are operating. */
+ remote_target_ref m_remote_target;
+
+ /* An object which restores the previous value of the starting_up flag
+ when it goes out of scope. */
+ scoped_restore_tmpl<bool> m_restore_starting_up;
};
/* Helper for remote_target::start_remote, start the remote connection and
REMOTE_SCOPED_DEBUG_ENTER_EXIT;
struct remote_state *rs = get_remote_state ();
- struct packet_config *noack_config;
/* 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
which later probes to skip. */
remote_query_supported ();
+ /* Check vCont support and set the remote state's vCont_action_support
+ attribute. */
+ remote_vcont_probe ();
+
/* If the stub wants to get a QAllow, compose one and send it. */
- if (packet_support (PACKET_QAllow) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_QAllow) != PACKET_DISABLE)
set_permissions ();
/* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
const char v_mustreplyempty[] = "vMustReplyEmpty";
putpkt (v_mustreplyempty);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (strcmp (rs->buf.data (), "OK") == 0)
- remote_protocol_packets[PACKET_vFile_setfs].support = PACKET_DISABLE;
+ {
+ m_features.m_protocol_packets[PACKET_vFile_setfs].support
+ = PACKET_DISABLE;
+ }
else if (strcmp (rs->buf.data (), "") != 0)
error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty,
rs->buf.data ());
If FALSE, then don't activate noack mode, regardless of what the
stub claimed should be the default with qSupported. */
- noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode];
- if (packet_config_support (noack_config) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_QStartNoAckMode) != PACKET_DISABLE)
{
putpkt ("QStartNoAckMode");
- getpkt (&rs->buf, 0);
- if (packet_ok (rs->buf, noack_config) == PACKET_OK)
+ getpkt (&rs->buf);
+ if (m_features.packet_ok (rs->buf, PACKET_QStartNoAckMode) == PACKET_OK)
rs->noack_mode = 1;
}
{
/* Tell the remote that we are using the extended protocol. */
putpkt ("!");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
}
/* Let the target know which signals it is allowed to pass down to
/* On OSs where the list of libraries is global to all
processes, we fetch them early. */
- if (gdbarch_has_global_solist (target_gdbarch ()))
+ if (gdbarch_has_global_solist (current_inferior ()->arch ()))
solib_add (NULL, from_tty, auto_solib_add);
if (target_is_non_stop_p ())
{
- if (packet_support (PACKET_QNonStop) != PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_QNonStop) != PACKET_ENABLE)
error (_("Non-stop mode requested, but remote "
"does not support non-stop"));
putpkt ("QNonStop:1");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (strcmp (rs->buf.data (), "OK") != 0)
error (_("Remote refused setting non-stop mode with: %s"),
stopped. */
this->update_thread_list ();
}
- else if (packet_support (PACKET_QNonStop) == PACKET_ENABLE)
+ else if (m_features.packet_support (PACKET_QNonStop) == PACKET_ENABLE)
{
/* Don't assume that the stub can operate in all-stop mode.
Request it explicitly. */
putpkt ("QNonStop:0");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (strcmp (rs->buf.data (), "OK") != 0)
error (_("Remote refused setting all-stop mode with: %s"),
/* Check whether the target is running now. */
putpkt ("?");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (!target_is_non_stop_p ())
{
}
}
else
- switch_to_thread (find_thread_ptid (this, curr_thread));
+ switch_to_thread (this->find_thread (curr_thread));
}
/* init_wait_for_inferior should be called before get_offsets in order
supported for non-stop; it could be, but it is tricky if
there are no stopped threads when we connect. */
if (remote_read_description_p (this)
- && gdbarch_target_desc (target_gdbarch ()) == NULL)
+ && gdbarch_target_desc (current_inferior ()->arch ()) == NULL)
{
target_clear_description ();
target_find_description ();
mechanism. */
if (strcmp (rs->buf.data (), "OK") != 0)
{
- struct notif_client *notif = ¬if_client_stop;
+ const notif_client *notif = ¬if_client_stop;
/* remote_notif_get_pending_replies acks this one, and gets
the rest out. */
continue;
/* Need to switch to a specific thread, because remote_check_symbols
- uses INFERIOR_PTID to set the general thread. */
+ uses INFERIOR_PTID to set the general thread. */
scoped_restore_current_thread restore_thread;
thread_info *thread = any_thread_of_inferior (inf);
switch_to_thread (thread);
open_1 (name, from_tty, 1 /*extended_p */);
}
-/* Reset all packets back to "unknown support". Called when opening a
- new connection to a remote target. */
-
-static void
-reset_all_packet_configs_support (void)
+void
+remote_features::reset_all_packet_configs_support ()
{
int i;
for (i = 0; i < PACKET_MAX; i++)
- remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
+ m_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
}
/* Initialize all packet configs. */
inferiors without execution. */
gdb_assert (target_has_execution ());
- if (packet_support (PACKET_qSymbol) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_qSymbol) == PACKET_DISABLE)
return;
/* Make sure the remote is pointing at the right process. Note
/* Invite target to request symbol lookups. */
putpkt ("qSymbol::");
- getpkt (&reply, 0);
- packet_ok (reply, &remote_protocol_packets[PACKET_qSymbol]);
+ getpkt (&reply);
+ m_features.packet_ok (reply, PACKET_qSymbol);
while (startswith (reply.data (), "qSymbol:"))
{
&reply[8]);
else
{
- int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
+ int addr_size = gdbarch_addr_bit (current_inferior ()->arch ()) / 8;
CORE_ADDR sym_addr = sym.value_address ();
/* 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_inferior ()->top_target ());
+ (current_inferior ()->arch (), sym_addr,
+ current_inferior ()->top_target ());
xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol:%s:%s",
phex_nz (sym_addr, addr_size), &reply[8]);
}
putpkt (msg.data ());
- getpkt (&reply, 0);
+ getpkt (&reply);
}
}
may_insert_breakpoints, may_insert_tracepoints,
may_insert_fast_tracepoints, may_stop);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
/* If the target didn't like the packet, warn the user. Do not try
to undo the user's settings, that would just be maddening. */
return;
}
- remote_protocol_packets[feature->packet].support = support;
+ remote->m_features.m_protocol_packets[feature->packet].support = support;
}
void
containing no features. */
rs->buf[0] = 0;
- if (packet_support (PACKET_qSupported) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_qSupported) != PACKET_DISABLE)
{
std::string q;
- if (packet_set_cmd_state (PACKET_multiprocess_feature) != AUTO_BOOLEAN_FALSE)
+ if (m_features.packet_set_cmd_state (PACKET_multiprocess_feature)
+ != AUTO_BOOLEAN_FALSE)
remote_query_supported_append (&q, "multiprocess+");
- if (packet_set_cmd_state (PACKET_swbreak_feature) != AUTO_BOOLEAN_FALSE)
+ if (m_features.packet_set_cmd_state (PACKET_swbreak_feature)
+ != AUTO_BOOLEAN_FALSE)
remote_query_supported_append (&q, "swbreak+");
- if (packet_set_cmd_state (PACKET_hwbreak_feature) != AUTO_BOOLEAN_FALSE)
+
+ if (m_features.packet_set_cmd_state (PACKET_hwbreak_feature)
+ != AUTO_BOOLEAN_FALSE)
remote_query_supported_append (&q, "hwbreak+");
remote_query_supported_append (&q, "qRelocInsn+");
- if (packet_set_cmd_state (PACKET_fork_event_feature)
+ if (m_features.packet_set_cmd_state (PACKET_fork_event_feature)
!= AUTO_BOOLEAN_FALSE)
remote_query_supported_append (&q, "fork-events+");
- if (packet_set_cmd_state (PACKET_vfork_event_feature)
+
+ if (m_features.packet_set_cmd_state (PACKET_vfork_event_feature)
!= AUTO_BOOLEAN_FALSE)
remote_query_supported_append (&q, "vfork-events+");
- if (packet_set_cmd_state (PACKET_exec_event_feature)
+
+ if (m_features.packet_set_cmd_state (PACKET_exec_event_feature)
!= AUTO_BOOLEAN_FALSE)
remote_query_supported_append (&q, "exec-events+");
- if (packet_set_cmd_state (PACKET_vContSupported) != AUTO_BOOLEAN_FALSE)
+ if (m_features.packet_set_cmd_state (PACKET_vContSupported)
+ != AUTO_BOOLEAN_FALSE)
remote_query_supported_append (&q, "vContSupported+");
- if (packet_set_cmd_state (PACKET_QThreadEvents) != AUTO_BOOLEAN_FALSE)
+ if (m_features.packet_set_cmd_state (PACKET_QThreadEvents)
+ != AUTO_BOOLEAN_FALSE)
remote_query_supported_append (&q, "QThreadEvents+");
- if (packet_set_cmd_state (PACKET_no_resumed) != AUTO_BOOLEAN_FALSE)
+ if (m_features.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)
+ if (m_features.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
- && packet_support (PACKET_qXfer_features) != PACKET_DISABLE)
+ && (m_features.packet_support (PACKET_qXfer_features)
+ != PACKET_DISABLE))
remote_query_supported_append (&q, remote_support_xml);
q = "qSupported:" + q;
putpkt (q.c_str ());
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- /* If an error occured, warn, but do not return - just reset the
+ /* If an error occurred, warn, but do not return - just reset the
buffer to empty and go on to disable features. */
- if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
- == PACKET_ERROR)
+ if (m_features.packet_ok (rs->buf, PACKET_qSupported) == PACKET_ERROR)
{
warning (_("Remote failure reply: %s"), rs->buf.data ());
rs->buf[0] = 0;
for (inferior *inf : all_inferiors (target))
{
switch_to_inferior_no_thread (inf);
- pop_all_targets_at_and_above (process_stratum);
+ inf->pop_all_targets_at_and_above (process_stratum);
generic_mourn_inferior ();
}
/* See FIXME above. */
if (!target_async_permitted)
- rs->wait_forever_enabled_p = 1;
+ rs->wait_forever_enabled_p = true;
rs->remote_desc = remote_serial_open (name);
if (!rs->remote_desc)
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, nullptr,
- "remote");
+ rs->create_async_event_handler ();
+
rs->notif_state = remote_notif_state_allocate (remote);
/* Reset the target state; these things will be queried either by
remote_query_supported or as they are needed. */
- reset_all_packet_configs_support ();
+ remote->m_features.reset_all_packet_configs_support ();
rs->explicit_packet_size = 0;
rs->noack_mode = 0;
rs->extended = extended_p;
around this. Eventually a mechanism that allows
wait_for_inferior() to expect/get timeouts will be
implemented. */
- rs->wait_forever_enabled_p = 0;
+ rs->wait_forever_enabled_p = false;
}
/* First delete any symbols previously loaded from shared libraries. */
remote_btrace_reset (rs);
if (target_async_permitted)
- rs->wait_forever_enabled_p = 1;
+ rs->wait_forever_enabled_p = true;
}
/* Determine if WS represents a fork status. */
GDBserver to select GDB's current process. */
set_general_process ();
- if (remote_multi_process_p (rs))
+ if (m_features.remote_multi_process_p ())
xsnprintf (rs->buf.data (), get_remote_packet_size (), "D;%x", pid);
else
strcpy (rs->buf.data (), "D");
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (rs->buf[0] == 'O' && rs->buf[1] == 'K')
;
target_announce_detach (from_tty);
- if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
+ if (!gdbarch_has_global_breakpoints (current_inferior ()->arch ()))
{
/* If we're in breakpoints-always-inserted mode, or the inferior
is running, we have to remove breakpoints before detaching.
remote_detach_pid (reply->ws.child_ptid ().pid ());
}
- thread_info *tp = find_thread_ptid (this, inferior_ptid);
+ thread_info *tp = this->find_thread (inferior_ptid);
/* Check to see if we are detaching a fork parent. Note that if we
are detaching a fork child, tp == NULL. */
process_stratum_target::follow_fork (child_inf, child_ptid,
fork_kind, follow_child, detach_fork);
- struct remote_state *rs = get_remote_state ();
-
- if ((fork_kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs))
- || (fork_kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs)))
+ if ((fork_kind == TARGET_WAITKIND_FORKED
+ && m_features.remote_fork_event_p ())
+ || (fork_kind == TARGET_WAITKIND_VFORKED
+ && m_features.remote_vfork_event_p ()))
{
/* When following the parent and detaching the child, we detach
the child here. For the case of following the child and
/* Remote PID can be freely equal to getpid, do not check it here the same
way as in other targets. */
- if (packet_support (PACKET_vAttach) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_vAttach) == PACKET_DISABLE)
error (_("This target does not support attaching to a process"));
target_announce_attach (from_tty, pid);
xsnprintf (rs->buf.data (), get_remote_packet_size (), "vAttach;%x", pid);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- switch (packet_ok (rs->buf,
- &remote_protocol_packets[PACKET_vAttach]))
+ switch (m_features.packet_ok (rs->buf, PACKET_vAttach))
{
case PACKET_OK:
if (!target_is_non_stop_p ())
strcpy (rs->buf.data (), "vCont?");
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
buf = rs->buf.data ();
/* Make sure that the features we assume are supported. */
buf[0] = 0;
}
- packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCont]);
- rs->supports_vCont_probed = true;
+ m_features.packet_ok (rs->buf, PACKET_vCont);
}
/* Helper function for building "vCont" resumptions. Write a
threads with a wildcard (though the protocol allows it,
so stubs shouldn't make an active effort to forbid
it). */
- && !(remote_multi_process_p (rs) && ptid.is_pid ()))
+ && !(m_features.remote_multi_process_p () && ptid.is_pid ()))
{
struct thread_info *tp;
{
/* If we don't know about the target thread's tid, then
we're resuming magic_null_ptid (see caller). */
- tp = find_thread_ptid (this, magic_null_ptid);
+ tp = this->find_thread (magic_null_ptid);
}
else
- tp = find_thread_ptid (this, ptid);
+ tp = this->find_thread (ptid);
gdb_assert (tp != NULL);
if (tp->control.may_range_step)
{
- int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
+ int addr_size = gdbarch_addr_bit (current_inferior ()->arch ()) / 8;
p += xsnprintf (p, endp - p, ";r%s,%s",
phex_nz (tp->control.step_range_start,
else
p += xsnprintf (p, endp - p, ";c");
- if (remote_multi_process_p (rs) && ptid.is_pid ())
+ if (m_features.remote_multi_process_p () && ptid.is_pid ())
{
ptid_t nptid;
warning (_(" - Can't pass signal %d to target in reverse: ignored."),
siggnal);
- if (step && packet_support (PACKET_bs) == PACKET_DISABLE)
+ if (step && m_features.packet_support (PACKET_bs) == PACKET_DISABLE)
error (_("Remote reverse-step not supported."));
- if (!step && packet_support (PACKET_bc) == PACKET_DISABLE)
+ if (!step && m_features.packet_support (PACKET_bc) == PACKET_DISABLE)
error (_("Remote reverse-continue not supported."));
strcpy (buf, step ? "bs" : "bc");
if (::execution_direction == EXEC_REVERSE)
return 0;
- if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
- remote_vcont_probe ();
-
- if (packet_support (PACKET_vCont) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_vCont) == PACKET_DISABLE)
return 0;
p = rs->buf.data ();
/* In non-stop, the stub replies to vCont with "OK". The stop
reply will be reported asynchronously by means of a `%Stop'
notification. */
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (strcmp (rs->buf.data (), "OK") != 0)
error (_("Unexpected vCont reply in non-stop mode: %s"),
rs->buf.data ());
= get_remote_thread_info (inferior_thread ());
/* We don't expect the core to ask to resume an already resumed (from
- its point of view) thread. */
+ its point of view) thread. */
gdb_assert (remote_thr->get_resume_state () == resume_state::NOT_RESUMED);
remote_thr->set_resumed_pending_vcont (step, siggnal);
rs = m_remote->get_remote_state ();
m_remote->putpkt (rs->buf);
- m_remote->getpkt (&rs->buf, 0);
+ m_remote->getpkt (&rs->buf);
if (strcmp (rs->buf.data (), "OK") != 0)
error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf.data ());
}
gdb_assert (!thread_is_in_step_over_chain (tp));
/* 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
+ 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)
= 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. */
+ 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_state *rs = get_remote_state ();
- if (async_event_handler_marked (rs->remote_async_inferior_event_token))
+ if (rs->async_event_handler_marked ())
return true;
/* Note that BUFCNT can be negative, indicating sticky
sr->ptid = tp->ptid;
sr->rs = rs;
sr->ws.set_stopped (GDB_SIGNAL_0);
- sr->arch = tp->inf->gdbarch;
+ sr->arch = tp->inf->arch ();
sr->stop_reason = TARGET_STOPPED_BY_NO_REASON;
sr->watch_data_address = 0;
sr->core = 0;
}
}
- /* 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)
error (_("Remote server does not support stopping threads"));
if (ptid == minus_one_ptid
- || (!remote_multi_process_p (rs) && ptid.is_pid ()))
+ || (!m_features.remote_multi_process_p () && ptid.is_pid ()))
p += xsnprintf (p, endp - p, "vCont;t");
else
{
/* In non-stop, we get an immediate OK reply. The stop reply will
come in asynchronously by notification. */
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (strcmp (rs->buf.data (), "OK") != 0)
error (_("Stopping %s failed: %s"), target_pid_to_str (ptid).c_str (),
rs->buf.data ());
/* In non-stop, we get an immediate OK reply. The stop reply will
come in asynchronously by notification. */
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCtrlC]))
+ switch (m_features.packet_ok (rs->buf, PACKET_vCtrlC))
{
case PACKET_OK:
break;
static void
remote_notif_stop_parse (remote_target *remote,
- struct notif_client *self, const char *buf,
+ const notif_client *self, const char *buf,
struct notif_event *event)
{
remote->remote_parse_stop_reply (buf, (struct stop_reply *) event);
static void
remote_notif_stop_ack (remote_target *remote,
- struct notif_client *self, const char *buf,
+ const notif_client *self, const char *buf,
struct notif_event *event)
{
struct stop_reply *stop_reply = (struct stop_reply *) event;
static int
remote_notif_stop_can_get_pending_events (remote_target *remote,
- struct notif_client *self)
+ const notif_client *self)
{
/* We can't get pending events in remote_notif_process for
notification stop, and we have to do this in remote_wait_ns
may exit and we have no chance to process them back in
remote_wait_ns. */
remote_state *rs = remote->get_remote_state ();
- mark_async_event_handler (rs->remote_async_inferior_event_token);
+ rs->mark_async_event_handler ();
return 0;
}
/* A client of notification Stop. */
-struct notif_client notif_client_stop =
+const notif_client notif_client_stop =
{
"Stop",
"vStopped",
void
remote_target::remove_new_fork_children (threads_listing_context *context)
{
- struct notif_client *notif = ¬if_client_stop;
+ const notif_client *notif = ¬if_client_stop;
/* For any threads stopped at a fork event, remove the corresponding
fork child threads from the CONTEXT list. */
remote_target::check_pending_events_prevent_wildcard_vcont
(bool *may_global_wildcard)
{
- struct notif_client *notif = ¬if_client_stop;
+ const notif_client *notif = ¬if_client_stop;
remote_notif_get_pending_events (notif);
for (auto &event : get_remote_state ()->stop_reply_queue)
for (auto it = iter; it != rs->stop_reply_queue.end (); ++it)
remote_debug_printf
("discarding queued stop reply: ptid: %s, ws: %s\n",
- reply->ptid.to_string().c_str(),
- reply->ws.to_string ().c_str ());
+ (*it)->ptid.to_string().c_str(),
+ (*it)->ws.to_string ().c_str ());
rs->stop_reply_queue.erase (iter, rs->stop_reply_queue.end ());
}
if (!rs->stop_reply_queue.empty () && target_can_async_p ())
{
/* There's still at least an event left. */
- mark_async_event_handler (rs->remote_async_inferior_event_token);
+ rs->mark_async_event_handler ();
}
return r;
enabled, and there are events in this queue, we will mark the event
token at that point, see remote_target::async. */
if (target_is_async_p ())
- mark_async_event_handler (rs->remote_async_inferior_event_token);
+ rs->mark_async_event_handler ();
}
/* Returns true if we have a stop reply for PTID. */
/* Make sure the stub doesn't forget to indicate support
with qSupported. */
- if (packet_support (PACKET_swbreak_feature) != PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_swbreak_feature)
+ != PACKET_ENABLE)
error (_("Unexpected swbreak stop reason"));
/* The value part is documented as "must be empty",
/* Make sure the stub doesn't forget to indicate support
with qSupported. */
- if (packet_support (PACKET_hwbreak_feature) != PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_hwbreak_feature)
+ != PACKET_ENABLE)
error (_("Unexpected hwbreak stop reason"));
/* See above. */
continue;
}
- event->arch = inf->gdbarch;
+ event->arch = inf->arch ();
rsa = event->rs->get_remote_arch_state (event->arch);
}
*/
void
-remote_target::remote_notif_get_pending_events (notif_client *nc)
+remote_target::remote_notif_get_pending_events (const notif_client *nc)
{
struct remote_state *rs = get_remote_state ();
while (1)
{
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (strcmp (rs->buf.data (), "OK") == 0)
break;
else
avoid having to export the whole remote_target class. */
void
-remote_notif_get_pending_events (remote_target *remote, notif_client *nc)
+remote_notif_get_pending_events (remote_target *remote, const notif_client *nc)
{
remote->remote_notif_get_pending_events (nc);
}
struct remote_state *rs = get_remote_state ();
struct stop_reply *stop_reply;
int ret;
- int is_notif = 0;
+ bool is_notif = false;
/* If in non-stop mode, get out of getpkt even if a
notification is received. */
- ret = getpkt_or_notif_sane (&rs->buf, 0 /* forever */, &is_notif);
+ ret = getpkt (&rs->buf, false /* forever */, &is_notif);
while (1)
{
if (ret != -1 && !is_notif)
}
/* Otherwise do a blocking wait. */
- ret = getpkt_or_notif_sane (&rs->buf, 1 /* forever */, &is_notif);
+ ret = getpkt (&rs->buf, true /* forever */, &is_notif);
}
}
}
else
{
- int forever = ((options & TARGET_WNOHANG) == 0
- && rs->wait_forever_enabled_p);
+ bool forever = ((options & TARGET_WNOHANG) == 0
+ && rs->wait_forever_enabled_p);
if (!rs->waiting_for_stop_reply)
{
_never_ wait for ever -> test on target_is_async_p().
However, before we do that we need to ensure that the caller
knows how to take the target into/out of async mode. */
- int is_notif;
- int ret = getpkt_or_notif_sane (&rs->buf, forever, &is_notif);
+ bool is_notif;
+ int ret = getpkt (&rs->buf, forever, &is_notif);
/* GDB gets a notification. Return to core as this event is
not interesting. */
we'll mark it again at the end if needed. If the target is not in
async mode then the async token should not be marked. */
if (target_is_async_p ())
- clear_async_event_handler (rs->remote_async_inferior_event_token);
+ rs->clear_async_event_handler ();
else
- gdb_assert (!async_event_handler_marked
- (rs->remote_async_inferior_event_token));
+ gdb_assert (!rs->async_event_handler_marked ());
ptid_t event_ptid;
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);
+ rs->mark_async_event_handler ();
}
return event_ptid;
gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum));
int i;
- if (packet_support (PACKET_p) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_p) == PACKET_DISABLE)
return 0;
if (reg->pnum == -1)
p += hexnumstr (p, reg->pnum);
*p++ = '\0';
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
buf = rs->buf.data ();
- switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_p]))
+ switch (m_features.packet_ok (rs->buf, PACKET_p))
{
case PACKET_OK:
break;
return 0;
case PACKET_ERROR:
error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
- gdbarch_register_name (regcache->arch (),
- reg->regnum),
+ gdbarch_register_name (regcache->arch (), reg->regnum),
buf);
}
xsnprintf (rs->buf.data (), get_remote_packet_size (), "g");
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (packet_check_result (rs->buf) == PACKET_ERROR)
error (_("Could not read registers; remote failure reply '%s'"),
rs->buf.data ());
&& rs->buf[0] != 'x') /* New: unavailable register value. */
{
remote_debug_printf ("Bad register packet; fetching a new packet");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
}
buf_len = strlen (rs->buf.data ());
int i;
/* Make sure the entire registers array is valid. */
- switch (packet_support (PACKET_P))
+ switch (m_features.packet_support (PACKET_P))
{
case PACKET_DISABLE:
case PACKET_SUPPORT_UNKNOWN:
gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum));
char *p;
- if (packet_support (PACKET_P) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_P) == PACKET_DISABLE)
return 0;
if (reg->pnum == -1)
regcache->raw_collect (reg->regnum, regp);
bin2hex (regp, p, register_size (gdbarch, reg->regnum));
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
+ switch (m_features.packet_ok (rs->buf, PACKET_P))
{
case PACKET_OK:
return 1;
*p++ = 'G';
bin2hex (regs, p, rsa->sizeof_g_packet);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (packet_check_result (rs->buf) == PACKET_ERROR)
- error (_("Could not write registers; remote failure reply '%s'"),
+ error (_("Could not write registers; remote failure reply '%s'"),
rs->buf.data ());
}
/* If "remoteaddresssize" was not set, default to target address size. */
if (!address_size)
- address_size = gdbarch_addr_bit (target_gdbarch ());
+ address_size = gdbarch_addr_bit (current_inferior ()->arch ());
if (address_size > 0
&& address_size < (sizeof (ULONGEST) * 8))
{
struct remote_state *rs = get_remote_state ();
- switch (packet_support (PACKET_X))
+ switch (m_features.packet_support (PACKET_X))
{
case PACKET_DISABLE:
break;
*p = '\0';
putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ()));
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (rs->buf[0] == '\0')
{
remote_debug_printf ("binary downloading NOT supported by target");
- remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
+ m_features.m_protocol_packets[PACKET_X].support = PACKET_DISABLE;
}
else
{
remote_debug_printf ("binary downloading supported by target");
- remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
+ m_features.m_protocol_packets[PACKET_X].support = PACKET_ENABLE;
}
break;
}
}
putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ()));
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (rs->buf[0] == 'E')
return TARGET_XFER_E_IO;
/* Check whether the target supports binary download. */
check_binary_download (memaddr);
- switch (packet_support (PACKET_X))
+ switch (m_features.packet_support (PACKET_X))
{
case PACKET_ENABLE:
packet_format = "X";
p += hexnumstr (p, (ULONGEST) todo_units);
*p = '\0';
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (rs->buf[0] == 'E'
&& isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
&& rs->buf[3] == '\0')
{
ULONGEST memend = memaddr + len;
- const target_section_table *table = target_get_section_table (this);
+ const std::vector<target_section> *table
+ = target_get_section_table (this);
for (const target_section &p : *table)
{
if (memaddr >= p.addr)
error (_("Communication problem with target."));
rs->buf[0] = '\0';
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
return packet_check_result (rs->buf);
}
void
remote_target::flash_erase (ULONGEST address, LONGEST length)
{
- int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
+ int addr_size = gdbarch_addr_bit (current_inferior ()->arch ()) / 8;
enum packet_result ret;
scoped_restore restore_timeout
= make_scoped_restore (&remote_timeout, remote_flash_timeout);
/* no return */
case SERIAL_ERROR:
unpush_and_perror (this, _("Remote communication error. "
- "Target disconnected."));
+ "Target disconnected"));
/* no return */
case SERIAL_TIMEOUT:
break;
if (serial_write (rs->remote_desc, str, len))
{
unpush_and_perror (this, _("Remote communication error. "
- "Target disconnected."));
+ "Target disconnected"));
}
if (rs->got_ctrlc_during_io)
store it in *BUF. Resize *BUF if necessary to hold the result. If
FOREVER, wait forever rather than timing out; this is used (in
synchronous mode) to wait for a target that is is executing user
- code to stop. */
-/* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
- don't have to change all the calls to getpkt to deal with the
- return value, because at the moment I don't know what the right
- thing to do it for those. */
-
-void
-remote_target::getpkt (gdb::char_vector *buf, int forever)
-{
- getpkt_sane (buf, forever);
-}
-
-
-/* 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
- synchronous mode) to wait for a target that is is executing user
- code to stop. If FOREVER == 0, this function is allowed to time
+ code to stop. If FOREVER == false, this function is allowed to time
out gracefully and return an indication of this to the caller.
- Otherwise return the number of bytes read. If EXPECTING_NOTIF,
- consider receiving a notification enough reason to return to the
- caller. *IS_NOTIF is an output boolean that indicates whether *BUF
- holds a notification or not (a regular packet). */
+ Otherwise return the number of bytes read. If IS_NOTIF is not
+ NULL, then consider receiving a notification enough reason to
+ return to the caller. In this case, *IS_NOTIF is an output boolean
+ that indicates whether *BUF holds a notification or not (a regular
+ packet). */
int
-remote_target::getpkt_or_notif_sane_1 (gdb::char_vector *buf,
- int forever, int expecting_notif,
- int *is_notif)
+remote_target::getpkt (gdb::char_vector *buf, bool forever, bool *is_notif)
{
struct remote_state *rs = get_remote_state ();
int c;
if (forever)
timeout = watchdog > 0 ? watchdog : -1;
- else if (expecting_notif)
+ else if (is_notif != nullptr)
timeout = 0; /* There should already be a char in the buffer. If
not, bail out. */
else
if (c == SERIAL_TIMEOUT)
{
- if (expecting_notif)
+ if (is_notif != nullptr)
return -1; /* Don't complain, it's normal to not get
anything in this case. */
if (!rs->noack_mode)
remote_serial_write ("+", 1);
if (is_notif != NULL)
- *is_notif = 0;
+ *is_notif = false;
return val;
}
escape_buffer (buf->data (), val).c_str ());
if (is_notif != NULL)
- *is_notif = 1;
+ *is_notif = true;
handle_notification (rs->notif_state, buf->data ());
/* Notifications require no acknowledgement. */
- if (expecting_notif)
+ if (is_notif != nullptr)
return val;
}
}
}
-int
-remote_target::getpkt_sane (gdb::char_vector *buf, int forever)
-{
- return getpkt_or_notif_sane_1 (buf, forever, 0, NULL);
-}
-
-int
-remote_target::getpkt_or_notif_sane (gdb::char_vector *buf, int forever,
- int *is_notif)
-{
- return getpkt_or_notif_sane_1 (buf, forever, 1, is_notif);
-}
-
/* Kill any new fork children of inferior INF that haven't been
processed by follow_fork. */
remote_target::kill_new_fork_children (inferior *inf)
{
remote_state *rs = get_remote_state ();
- struct notif_client *notif = ¬if_client_stop;
+ const notif_client *notif = ¬if_client_stop;
/* Kill the fork child threads of any threads in inferior INF that are stopped
at a fork event. */
{
int res = -1;
inferior *inf = find_inferior_pid (this, inferior_ptid.pid ());
- struct remote_state *rs = get_remote_state ();
gdb_assert (inf != nullptr);
- if (packet_support (PACKET_vKill) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_vKill) != PACKET_DISABLE)
{
/* If we're stopped while forking and we haven't followed yet,
kill the child task. We need to do this before killing the
/* If we are in 'target remote' mode and we are killing the only
inferior, then we will tell gdbserver to exit and unpush the
target. */
- if (res == -1 && !remote_multi_process_p (rs)
+ if (res == -1 && !m_features.remote_multi_process_p ()
&& number_of_live_inferiors (this) == 1)
{
remote_kill_k ();
int
remote_target::remote_vkill (int pid)
{
- if (packet_support (PACKET_vKill) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_vKill) == PACKET_DISABLE)
return -1;
remote_state *rs = get_remote_state ();
/* Tell the remote target to detach. */
xsnprintf (rs->buf.data (), get_remote_packet_size (), "vKill;%x", pid);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- switch (packet_ok (rs->buf,
- &remote_protocol_packets[PACKET_vKill]))
+ switch (m_features.packet_ok (rs->buf, PACKET_vKill))
{
case PACKET_OK:
return 0;
bool
extended_remote_target::supports_disable_randomization ()
{
- return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE;
+ return (m_features.packet_support (PACKET_QDisableRandomization)
+ == PACKET_ENABLE);
}
void
/* If the user has disabled vRun support, or we have detected that
support is not available, do not try it. */
- if (packet_support (PACKET_vRun) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_vRun) == PACKET_DISABLE)
return -1;
strcpy (rs->buf.data (), "vRun;");
rs->buf[len++] = '\0';
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun]))
+ switch (m_features.packet_ok (rs->buf, PACKET_vRun))
{
case PACKET_OK:
/* We have a wait response. All is well. */
"%s:%s", packet, encoded_value.c_str ());
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (strcmp (rs->buf.data (), "OK") != 0)
warning (_("Unable to %s environment variable '%s' on remote."),
action, value);
{
remote_state *rs = get_remote_state ();
- if (packet_support (PACKET_QEnvironmentReset) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_QEnvironmentReset) != PACKET_DISABLE)
{
putpkt ("QEnvironmentReset");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (strcmp (rs->buf.data (), "OK") != 0)
warning (_("Unable to reset environment on remote."));
}
gdb_environ *e = ¤t_inferior ()->environment;
- if (packet_support (PACKET_QEnvironmentHexEncoded) != PACKET_DISABLE)
- for (const std::string &el : e->user_set_env ())
- send_environment_packet ("set", "QEnvironmentHexEncoded",
- el.c_str ());
+ if (m_features.packet_support (PACKET_QEnvironmentHexEncoded)
+ != PACKET_DISABLE)
+ {
+ for (const std::string &el : e->user_set_env ())
+ send_environment_packet ("set", "QEnvironmentHexEncoded",
+ el.c_str ());
+ }
- if (packet_support (PACKET_QEnvironmentUnset) != PACKET_DISABLE)
+
+ if (m_features.packet_support (PACKET_QEnvironmentUnset) != PACKET_DISABLE)
for (const std::string &el : e->user_unset_env ())
send_environment_packet ("unset", "QEnvironmentUnset", el.c_str ());
}
void
remote_target::extended_remote_set_inferior_cwd ()
{
- if (packet_support (PACKET_QSetWorkingDir) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_QSetWorkingDir) != PACKET_DISABLE)
{
const std::string &inferior_cwd = current_inferior ()->cwd ();
remote_state *rs = get_remote_state ();
}
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
- if (packet_ok (rs->buf,
- &remote_protocol_packets[PACKET_QSetWorkingDir])
- != PACKET_OK)
+ getpkt (&rs->buf);
+ if (m_features.packet_ok (rs->buf, PACKET_QSetWorkingDir) != PACKET_OK)
error (_("\
Remote replied unexpectedly while setting the inferior's working\n\
directory: %s"),
/* If startup-with-shell is on, we inform gdbserver to start the
remote inferior using a shell. */
- if (packet_support (PACKET_QStartupWithShell) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_QStartupWithShell) != PACKET_DISABLE)
{
xsnprintf (rs->buf.data (), get_remote_packet_size (),
"QStartupWithShell:%d", startup_with_shell ? 1 : 0);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (strcmp (rs->buf.data (), "OK") != 0)
error (_("\
Remote replied unexpectedly while setting startup-with-shell: %s"),
/* Send conditions to the target. */
for (agent_expr *aexpr : bp_tgt->conditions)
{
- xsnprintf (buf, buf_end - buf, "X%x,", aexpr->len);
+ xsnprintf (buf, buf_end - buf, "X%x,", (int) aexpr->buf.size ());
buf += strlen (buf);
- for (int i = 0; i < aexpr->len; ++i)
+ for (int i = 0; i < aexpr->buf.size (); ++i)
buf = pack_hex_byte (buf, aexpr->buf[i]);
*buf = '\0';
}
cmds parameter. */
for (agent_expr *aexpr : bp_tgt->tcommands)
{
- sprintf (buf, "X%x,", aexpr->len);
+ sprintf (buf, "X%x,", (int) aexpr->buf.size ());
buf += strlen (buf);
- for (int i = 0; i < aexpr->len; ++i)
+ for (int i = 0; i < aexpr->buf.size (); ++i)
buf = pack_hex_byte (buf, aexpr->buf[i]);
*buf = '\0';
}
fails, and the user has explicitly requested the Z support then
report an error, otherwise, mark it disabled and go on. */
- if (packet_support (PACKET_Z0) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_Z0) != PACKET_DISABLE)
{
CORE_ADDR addr = bp_tgt->reqstd_address;
struct remote_state *rs;
/* Make sure the remote is pointing at the right process, if
necessary. */
- if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
+ if (!gdbarch_has_global_breakpoints (current_inferior ()->arch ()))
set_general_process ();
rs = get_remote_state ();
remote_add_target_side_commands (gdbarch, bp_tgt, p);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
+ switch (m_features.packet_ok (rs->buf, PACKET_Z0))
{
case PACKET_ERROR:
return -1;
CORE_ADDR addr = bp_tgt->placed_address;
struct remote_state *rs = get_remote_state ();
- if (packet_support (PACKET_Z0) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_Z0) != PACKET_DISABLE)
{
char *p = rs->buf.data ();
char *endbuf = p + get_remote_packet_size ();
/* Make sure the remote is pointing at the right process, if
necessary. */
- if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
+ if (!gdbarch_has_global_breakpoints (current_inferior ()->arch ()))
set_general_process ();
*(p++) = 'z';
xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
return (rs->buf[0] == 'E');
}
char *p;
enum Z_packet_type packet = watchpoint_to_Z_packet (type);
- if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
+ if (m_features.packet_support ((to_underlying (PACKET_Z0)
+ + to_underlying (packet))) == PACKET_DISABLE)
return 1;
/* Make sure the remote is pointing at the right process, if
necessary. */
- if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
+ if (!gdbarch_has_global_breakpoints (current_inferior ()->arch ()))
set_general_process ();
xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "Z%x,", packet);
xsnprintf (p, endbuf - p, ",%x", len);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
+ switch (m_features.packet_ok (rs->buf, (to_underlying (PACKET_Z0)
+ + to_underlying (packet))))
{
case PACKET_ERROR:
return -1;
char *p;
enum Z_packet_type packet = watchpoint_to_Z_packet (type);
- if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
+ if (m_features.packet_support ((to_underlying (PACKET_Z0)
+ + to_underlying (packet))) == PACKET_DISABLE)
return -1;
/* Make sure the remote is pointing at the right process, if
necessary. */
- if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
+ if (!gdbarch_has_global_breakpoints (current_inferior ()->arch ()))
set_general_process ();
xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "z%x,", packet);
p += hexnumstr (p, (ULONGEST) addr);
xsnprintf (p, endbuf - p, ",%x", len);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
+ switch (m_features.packet_ok (rs->buf, (to_underlying (PACKET_Z0)
+ + to_underlying (packet))))
{
case PACKET_ERROR:
case PACKET_UNKNOWN:
bool
remote_target::supports_stopped_by_sw_breakpoint ()
{
- return (packet_support (PACKET_swbreak_feature) == PACKET_ENABLE);
+ return (m_features.packet_support (PACKET_swbreak_feature) == PACKET_ENABLE);
}
/* The to_stopped_by_hw_breakpoint method of target remote. */
bool
remote_target::supports_stopped_by_hw_breakpoint ()
{
- return (packet_support (PACKET_hwbreak_feature) == PACKET_ENABLE);
+ return (m_features.packet_support (PACKET_hwbreak_feature) == PACKET_ENABLE);
}
bool
char *p, *endbuf;
char *message;
- if (packet_support (PACKET_Z1) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_Z1) == PACKET_DISABLE)
return -1;
/* Make sure the remote is pointing at the right process, if
necessary. */
- if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
+ if (!gdbarch_has_global_breakpoints (current_inferior ()->arch ()))
set_general_process ();
rs = get_remote_state ();
remote_add_target_side_commands (gdbarch, bp_tgt, p);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
+ switch (m_features.packet_ok (rs->buf, PACKET_Z1))
{
case PACKET_ERROR:
if (rs->buf[1] == '.')
char *p = rs->buf.data ();
char *endbuf = p + get_remote_packet_size ();
- if (packet_support (PACKET_Z1) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_Z1) == PACKET_DISABLE)
return -1;
/* Make sure the remote is pointing at the right process, if
necessary. */
- if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
+ if (!gdbarch_has_global_breakpoints (current_inferior ()->arch ()))
set_general_process ();
*(p++) = 'z';
xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
+ switch (m_features.packet_ok (rs->buf, PACKET_Z1))
{
case PACKET_ERROR:
case PACKET_UNKNOWN:
/* 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)
+ && m_features.packet_support (PACKET_qCRC) != PACKET_DISABLE)
{
enum packet_result result;
reply. */
host_crc = xcrc32 (data, size, 0xffffffff);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- result = packet_ok (rs->buf,
- &remote_protocol_packets[PACKET_qCRC]);
+ result = m_features.packet_ok (rs->buf, PACKET_qCRC);
if (result == PACKET_ERROR)
return -1;
else if (result == PACKET_OK)
if (res == -1)
error (_("target memory fault, section %s, range %s -- %s"), sectname,
- paddress (target_gdbarch (), lma),
- paddress (target_gdbarch (), lma + size));
+ paddress (current_inferior ()->arch (), lma),
+ paddress (current_inferior ()->arch (), lma + size));
gdb_printf ("Section %s, range %s -- %s: ", sectname,
- paddress (target_gdbarch (), lma),
- paddress (target_gdbarch (), lma + size));
+ paddress (current_inferior ()->arch (), lma),
+ paddress (current_inferior ()->arch (), lma + size));
if (res)
gdb_printf ("matched.\n");
else
}
}
if (mismatched > 0)
- warning (_("One or more sections of the target image does not match\n\
-the loaded file\n"));
+ warning (_("One or more sections of the target image does "
+ "not match the loaded file"));
if (args && !matched)
gdb_printf (_("No loaded section named '%s'.\n"), args);
}
const char *annex, const gdb_byte *writebuf,
ULONGEST offset, LONGEST len,
ULONGEST *xfered_len,
- struct packet_config *packet)
+ const unsigned int which_packet)
{
int i, buf_len;
ULONGEST n;
struct remote_state *rs = get_remote_state ();
- int max_size = get_memory_write_packet_size ();
+ int max_size = get_memory_write_packet_size ();
- if (packet_config_support (packet) == PACKET_DISABLE)
+ if (m_features.packet_support (which_packet) == PACKET_DISABLE)
return TARGET_XFER_E_IO;
/* Insert header. */
- i = snprintf (rs->buf.data (), max_size,
+ i = snprintf (rs->buf.data (), max_size,
"qXfer:%s:write:%s:%s:",
object_name, annex ? annex : "",
phex_nz (offset, sizeof offset));
max_size -= (i + 1);
/* Escape as much data as fits into rs->buf. */
- buf_len = remote_escape_output
+ buf_len = remote_escape_output
(writebuf, len, 1, (gdb_byte *) rs->buf.data () + i, &max_size, max_size);
if (putpkt_binary (rs->buf.data (), i + buf_len) < 0
- || getpkt_sane (&rs->buf, 0) < 0
- || packet_ok (rs->buf, packet) != PACKET_OK)
+ || getpkt (&rs->buf) < 0
+ || m_features.packet_ok (rs->buf, which_packet) != PACKET_OK)
return TARGET_XFER_E_IO;
unpack_varlen_hex (rs->buf.data (), &n);
gdb_byte *readbuf, ULONGEST offset,
LONGEST len,
ULONGEST *xfered_len,
- struct packet_config *packet)
+ const unsigned int which_packet)
{
struct remote_state *rs = get_remote_state ();
LONGEST i, n, packet_len;
- if (packet_config_support (packet) == PACKET_DISABLE)
+ if (m_features.packet_support (which_packet) == PACKET_DISABLE)
return TARGET_XFER_E_IO;
/* Check whether we've cached an end-of-object packet that matches
return TARGET_XFER_E_IO;
rs->buf[0] = '\0';
- packet_len = getpkt_sane (&rs->buf, 0);
- if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
+ packet_len = getpkt (&rs->buf);
+ if (packet_len < 0
+ || m_features.packet_ok (rs->buf, which_packet) != PACKET_OK)
return TARGET_XFER_E_IO;
if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
int i;
char *p2;
char query_type;
- int unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ());
+ int unit_size
+ = gdbarch_addressable_memory_unit_size (current_inferior ()->arch ());
set_remote_traceframe ();
set_general_thread (inferior_ptid);
{
if (readbuf)
return remote_read_qxfer ("siginfo", annex, readbuf, offset, len,
- xfered_len, &remote_protocol_packets
- [PACKET_qXfer_siginfo_read]);
+ xfered_len, PACKET_qXfer_siginfo_read);
else
- return remote_write_qxfer ("siginfo", annex,
- writebuf, offset, len, xfered_len,
- &remote_protocol_packets
- [PACKET_qXfer_siginfo_write]);
+ return remote_write_qxfer ("siginfo", annex, writebuf, offset, len,
+ xfered_len, PACKET_qXfer_siginfo_write);
}
if (object == TARGET_OBJECT_STATIC_TRACE_DATA)
if (readbuf)
return remote_read_qxfer ("statictrace", annex,
readbuf, offset, len, xfered_len,
- &remote_protocol_packets
- [PACKET_qXfer_statictrace_read]);
+ PACKET_qXfer_statictrace_read);
else
return TARGET_XFER_E_IO;
}
case TARGET_OBJECT_AUXV:
gdb_assert (annex == NULL);
- return remote_read_qxfer ("auxv", annex, readbuf, offset, len,
- xfered_len,
- &remote_protocol_packets[PACKET_qXfer_auxv]);
+ return remote_read_qxfer
+ ("auxv", annex, readbuf, offset, len, xfered_len, PACKET_qXfer_auxv);
case TARGET_OBJECT_AVAILABLE_FEATURES:
return remote_read_qxfer
("features", annex, readbuf, offset, len, xfered_len,
- &remote_protocol_packets[PACKET_qXfer_features]);
+ PACKET_qXfer_features);
case TARGET_OBJECT_LIBRARIES:
return remote_read_qxfer
("libraries", annex, readbuf, offset, len, xfered_len,
- &remote_protocol_packets[PACKET_qXfer_libraries]);
+ PACKET_qXfer_libraries);
case TARGET_OBJECT_LIBRARIES_SVR4:
return remote_read_qxfer
("libraries-svr4", annex, readbuf, offset, len, xfered_len,
- &remote_protocol_packets[PACKET_qXfer_libraries_svr4]);
+ PACKET_qXfer_libraries_svr4);
case TARGET_OBJECT_MEMORY_MAP:
gdb_assert (annex == NULL);
- return remote_read_qxfer ("memory-map", annex, readbuf, offset, len,
- xfered_len,
- &remote_protocol_packets[PACKET_qXfer_memory_map]);
+ return remote_read_qxfer
+ ("memory-map", annex, readbuf, offset, len, xfered_len,
+ PACKET_qXfer_memory_map);
case TARGET_OBJECT_OSDATA:
/* Should only get here if we're connected. */
gdb_assert (rs->remote_desc);
return remote_read_qxfer
("osdata", annex, readbuf, offset, len, xfered_len,
- &remote_protocol_packets[PACKET_qXfer_osdata]);
+ PACKET_qXfer_osdata);
case TARGET_OBJECT_THREADS:
gdb_assert (annex == NULL);
- return remote_read_qxfer ("threads", annex, readbuf, offset, len,
- xfered_len,
- &remote_protocol_packets[PACKET_qXfer_threads]);
+ return remote_read_qxfer
+ ("threads", annex, readbuf, offset, len, xfered_len,
+ PACKET_qXfer_threads);
case TARGET_OBJECT_TRACEFRAME_INFO:
gdb_assert (annex == NULL);
return remote_read_qxfer
("traceframe-info", annex, readbuf, offset, len, xfered_len,
- &remote_protocol_packets[PACKET_qXfer_traceframe_info]);
+ PACKET_qXfer_traceframe_info);
case TARGET_OBJECT_FDPIC:
- return remote_read_qxfer ("fdpic", annex, readbuf, offset, len,
- xfered_len,
- &remote_protocol_packets[PACKET_qXfer_fdpic]);
+ return remote_read_qxfer
+ ("fdpic", annex, readbuf, offset, len, xfered_len, PACKET_qXfer_fdpic);
case TARGET_OBJECT_OPENVMS_UIB:
- return remote_read_qxfer ("uib", annex, readbuf, offset, len,
- xfered_len,
- &remote_protocol_packets[PACKET_qXfer_uib]);
+ return remote_read_qxfer
+ ("uib", annex, readbuf, offset, len, xfered_len, PACKET_qXfer_uib);
case TARGET_OBJECT_BTRACE:
- return remote_read_qxfer ("btrace", annex, readbuf, offset, len,
- xfered_len,
- &remote_protocol_packets[PACKET_qXfer_btrace]);
+ return remote_read_qxfer
+ ("btrace", annex, readbuf, offset, len, xfered_len,
+ PACKET_qXfer_btrace);
case TARGET_OBJECT_BTRACE_CONF:
- return remote_read_qxfer ("btrace-conf", annex, readbuf, offset,
- len, xfered_len,
- &remote_protocol_packets[PACKET_qXfer_btrace_conf]);
+ return remote_read_qxfer
+ ("btrace-conf", annex, readbuf, offset, len, xfered_len,
+ PACKET_qXfer_btrace_conf);
case TARGET_OBJECT_EXEC_FILE:
- return remote_read_qxfer ("exec-file", annex, readbuf, offset,
- len, xfered_len,
- &remote_protocol_packets[PACKET_qXfer_exec_file]);
+ return remote_read_qxfer
+ ("exec-file", annex, readbuf, offset, len, xfered_len,
+ PACKET_qXfer_exec_file);
default:
return TARGET_XFER_E_IO;
if (i < 0)
return TARGET_XFER_E_IO;
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
strcpy ((char *) readbuf, rs->buf.data ());
*xfered_len = strlen ((char *) readbuf);
const gdb_byte *pattern, ULONGEST pattern_len,
CORE_ADDR *found_addrp)
{
- int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
+ int addr_size = gdbarch_addr_bit (current_inferior ()->arch ()) / 8;
struct remote_state *rs = get_remote_state ();
int max_size = get_memory_write_packet_size ();
- struct packet_config *packet =
- &remote_protocol_packets[PACKET_qSearch_memory];
+
/* Number of packet bytes used to encode the pattern;
this could be more than PATTERN_LEN due to escape characters. */
int escaped_pattern_len;
int found;
ULONGEST found_addr;
- auto read_memory = [=] (CORE_ADDR addr, gdb_byte *result, size_t len)
+ auto read_memory = [this] (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
- general. */
+ checking packet_support to avoid the possibility that a success for this
+ edge case means the facility works in general. */
if (pattern_len > search_space_len)
return 0;
if (pattern_len == 0)
/* If we already know the packet isn't supported, fall back to the simple
way of searching memory. */
- if (packet_config_support (packet) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_qSearch_memory) == PACKET_DISABLE)
{
/* Target doesn't provided special support, fall back and use the
standard support (copy memory and do the search here). */
set_general_process ();
/* Insert header. */
- i = snprintf (rs->buf.data (), max_size,
+ i = snprintf (rs->buf.data (), max_size,
"qSearch:memory:%s;%s;",
phex_nz (start_addr, addr_size),
phex_nz (search_space_len, sizeof (search_space_len)));
error (_("Pattern is too large to transmit to remote target."));
if (putpkt_binary (rs->buf.data (), i + escaped_pattern_len) < 0
- || getpkt_sane (&rs->buf, 0) < 0
- || packet_ok (rs->buf, packet) != PACKET_OK)
+ || getpkt (&rs->buf) < 0
+ || m_features.packet_ok (rs->buf, PACKET_qSearch_memory) != PACKET_OK)
{
/* The request may not have worked because the command is not
supported. If so, fall back to the simple way. */
- if (packet_config_support (packet) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_qSearch_memory) == PACKET_DISABLE)
{
return simple_search_memory (read_memory, start_addr, search_space_len,
pattern, pattern_len, found_addrp);
/* XXX - see also remote_get_noisy_reply(). */
QUIT; /* Allow user to bail out with ^C. */
rs->buf[0] = '\0';
- if (getpkt_sane (&rs->buf, 0) == -1)
- {
+ if (getpkt (&rs->buf) == -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.
remote->putpkt_binary (buf.data (), buf.size ());
remote_state *rs = remote->get_remote_state ();
- int bytes = remote->getpkt_sane (&rs->buf, 0);
+ int bytes = remote->getpkt (&rs->buf);
if (bytes < 0)
error (_("error while fetching packet from remote target"));
std::string
remote_target::pid_to_str (ptid_t ptid)
{
- struct remote_state *rs = get_remote_state ();
-
if (ptid == null_ptid)
return normal_pid_to_str (ptid);
else if (ptid.is_pid ())
connecting with extended-remote and the stub already being
attached to a process, and reporting yes to qAttached, hence
no smart special casing here. */
- if (!remote_multi_process_p (rs))
+ if (!m_features.remote_multi_process_p ())
return "Remote target";
return normal_pid_to_str (ptid);
{
if (magic_null_ptid == ptid)
return "Thread <main>";
- else if (remote_multi_process_p (rs))
+ else if (m_features.remote_multi_process_p ())
if (ptid.lwp () == 0)
return normal_pid_to_str (ptid);
else
remote_target::get_thread_local_address (ptid_t ptid, CORE_ADDR lm,
CORE_ADDR offset)
{
- if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf.data ();
*p++ = '\0';
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
- result = packet_ok (rs->buf,
- &remote_protocol_packets[PACKET_qGetTLSAddr]);
+ getpkt (&rs->buf);
+ result = m_features.packet_ok (rs->buf, PACKET_qGetTLSAddr);
if (result == PACKET_OK)
{
ULONGEST addr;
bool
remote_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr)
{
- if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf.data ();
*p++ = '\0';
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
- result = packet_ok (rs->buf,
- &remote_protocol_packets[PACKET_qGetTIBAddr]);
+ getpkt (&rs->buf);
+ result = m_features.packet_ok (rs->buf, PACKET_qGetTIBAddr);
if (result == PACKET_OK)
{
ULONGEST val;
static bool
remote_read_description_p (struct target_ops *target)
{
- struct remote_g_packet_data *data = get_g_packet_data (target_gdbarch ());
+ remote_g_packet_data *data = get_g_packet_data (current_inferior ()->arch ());
return !data->guesses.empty ();
}
const struct target_desc *
remote_target::read_description ()
{
- struct remote_g_packet_data *data = get_g_packet_data (target_gdbarch ());
+ remote_g_packet_data *data = get_g_packet_data (current_inferior ()->arch ());
/* Do not try this during initial connection, when we do not know
whether there is a running but stopped thread. */
int ret, bytes_read;
const char *attachment_tmp;
- if (packet_support (which_packet) == PACKET_DISABLE)
+ if (m_features.packet_support (which_packet) == PACKET_DISABLE)
{
*remote_errno = FILEIO_ENOSYS;
return -1;
}
putpkt_binary (rs->buf.data (), command_bytes);
- bytes_read = getpkt_sane (&rs->buf, 0);
+ bytes_read = getpkt (&rs->buf);
/* If it timed out, something is wrong. Don't try to parse the
buffer. */
return -1;
}
- switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet]))
+ switch (m_features.packet_ok (rs->buf, which_packet))
{
case PACKET_ERROR:
*remote_errno = FILEIO_EINVAL;
char arg[9];
int ret;
- if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
return 0;
if (rs->fs_pid != -1 && required_pid == rs->fs_pid)
ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_setfs,
remote_errno, NULL, NULL);
- if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
return 0;
if (ret == 0)
{
if (this->fd == fd
&& this->offset <= offset
- && offset < this->offset + this->bufsize)
+ && offset < this->offset + this->buf.size ())
{
- ULONGEST max = this->offset + this->bufsize;
+ ULONGEST max = this->offset + this->buf.size ();
if (offset + len > max)
len = max - offset;
- memcpy (read_buf, this->buf + offset - this->offset, len);
+ memcpy (read_buf, &this->buf[offset - this->offset], len);
return len;
}
cache->fd = fd;
cache->offset = offset;
- cache->bufsize = get_remote_packet_size ();
- cache->buf = (gdb_byte *) xrealloc (cache->buf, cache->bufsize);
+ cache->buf.resize (get_remote_packet_size ());
- ret = remote_hostio_pread_vFile (cache->fd, cache->buf, cache->bufsize,
+ ret = remote_hostio_pread_vFile (cache->fd, &cache->buf[0],
+ cache->buf.size (),
cache->offset, remote_errno);
if (ret <= 0)
{
return ret;
}
- cache->bufsize = ret;
+ cache->buf.resize (ret);
return cache->pread (fd, read_buf, len, offset);
}
does not support vFile:open. */
if (gdb_sysroot == TARGET_SYSROOT_PREFIX)
{
- enum packet_support ps = packet_support (PACKET_vFile_open);
+ packet_support ps = m_features.packet_support (PACKET_vFile_open);
if (ps == PACKET_SUPPORT_UNKNOWN)
{
if (fd >= 0)
remote_hostio_close (fd, &remote_errno);
- ps = packet_support (PACKET_vFile_open);
+ ps = m_features.packet_support (PACKET_vFile_open);
}
if (ps == PACKET_DISABLE)
bool
remote_target::can_execute_reverse ()
{
- if (packet_support (PACKET_bs) == PACKET_ENABLE
- || packet_support (PACKET_bc) == PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_bs) == PACKET_ENABLE
+ || m_features.packet_support (PACKET_bc) == PACKET_ENABLE)
return true;
else
return false;
bool
remote_target::supports_multi_process ()
{
- struct remote_state *rs = get_remote_state ();
-
- return remote_multi_process_p (rs);
+ return m_features.remote_multi_process_p ();
}
-static int
-remote_supports_cond_tracepoints ()
+int
+remote_target::remote_supports_cond_tracepoints ()
{
- return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE;
+ return (m_features.packet_support (PACKET_ConditionalTracepoints)
+ == PACKET_ENABLE);
}
bool
remote_target::supports_evaluation_of_breakpoint_conditions ()
{
- return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE;
+ return (m_features.packet_support (PACKET_ConditionalBreakpoints)
+ == PACKET_ENABLE);
}
-static int
-remote_supports_fast_tracepoints ()
+int
+remote_target::remote_supports_fast_tracepoints ()
{
- return packet_support (PACKET_FastTracepoints) == PACKET_ENABLE;
+ return m_features.packet_support (PACKET_FastTracepoints) == PACKET_ENABLE;
}
-static int
-remote_supports_static_tracepoints ()
+int
+remote_target::remote_supports_static_tracepoints ()
{
- return packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE;
+ return m_features.packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE;
}
-static int
-remote_supports_install_in_trace ()
+int
+remote_target::remote_supports_install_in_trace ()
{
- return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE;
+ return m_features.packet_support (PACKET_InstallInTrace) == PACKET_ENABLE;
}
bool
remote_target::supports_enable_disable_tracepoint ()
{
- return (packet_support (PACKET_EnableDisableTracepoints_feature)
+ return (m_features.packet_support (PACKET_EnableDisableTracepoints_feature)
== PACKET_ENABLE);
}
bool
remote_target::supports_string_tracing ()
{
- return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE;
+ return m_features.packet_support (PACKET_tracenz_feature) == PACKET_ENABLE;
}
bool
remote_target::can_run_breakpoint_commands ()
{
- return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE;
+ return m_features.packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE;
}
void
std::vector<std::string> stepping_actions;
char *pkt;
struct breakpoint *b = loc->owner;
- struct tracepoint *t = (struct tracepoint *) b;
+ tracepoint *t = gdb::checked_static_cast<tracepoint *> (b);
struct remote_state *rs = get_remote_state ();
int ret;
const char *err_msg = _("Tracepoint packet too large for target.");
size_left = buf.size () - strlen (buf.data ());
ret = snprintf (buf.data () + strlen (buf.data ()),
- size_left, ":X%x,", aexpr->len);
+ size_left, ":X%x,", (int) aexpr->buf.size ());
if (ret < 0 || ret >= size_left)
error ("%s", err_msg);
/* Two bytes to encode each aexpr byte, plus the terminating
null byte. */
- if (aexpr->len * 2 + 1 > size_left)
+ if (aexpr->buf.size () * 2 + 1 > size_left)
error ("%s", err_msg);
pkt = buf.data () + strlen (buf.data ());
- for (int ndx = 0; ndx < aexpr->len; ++ndx)
+ for (int ndx = 0; ndx < aexpr->buf.size (); ++ndx)
pkt = pack_hex_byte (pkt, aexpr->buf[ndx]);
*pkt = '\0';
}
error (_("Error on target while setting tracepoints."));
}
- if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_TracepointSource) == PACKET_ENABLE)
{
if (b->locspec != nullptr)
{
sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2);
if (offset + sec_length + 1 > rs->buf.size ())
{
- if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_qXfer_traceframe_info)
+ != PACKET_ENABLE)
warning (_("\
Too many sections for read-only sections definition packet."));
break;
if (anysecs)
{
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
}
}
enum packet_result result;
struct remote_state *rs = get_remote_state ();
- if (packet_support (PACKET_qTStatus) == PACKET_DISABLE)
+ if (m_features.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;
+ = rs->get_remote_arch_state (current_inferior ()->arch ())->sizeof_g_packet;
putpkt ("qTStatus");
throw;
}
- result = packet_ok (p, &remote_protocol_packets[PACKET_qTStatus]);
+ result = m_features.packet_ok (p, PACKET_qTStatus);
/* If the remote target doesn't do tracing, flag it. */
if (result == PACKET_UNKNOWN)
}
void
-remote_target::get_tracepoint_status (struct breakpoint *bp,
+remote_target::get_tracepoint_status (tracepoint *tp,
struct uploaded_tp *utp)
{
struct remote_state *rs = get_remote_state ();
char *reply;
- struct tracepoint *tp = (struct tracepoint *) bp;
size_t size = get_remote_packet_size ();
if (tp)
{
tp->hit_count = 0;
tp->traceframe_usage = 0;
- for (bp_location *loc : tp->locations ())
+ for (bp_location &loc : tp->locations ())
{
/* If the tracepoint was never downloaded, don't go asking for
any status. */
if (tp->number_on_target == 0)
continue;
xsnprintf (rs->buf.data (), size, "qTP:%x:%s", tp->number_on_target,
- phex_nz (loc->address, 0));
+ phex_nz (loc.address, 0));
putpkt (rs->buf);
reply = remote_get_noisy_reply ();
if (reply && *reply)
{
if (*reply == 'V')
- parse_tracepoint_status (reply + 1, bp, utp);
+ parse_tracepoint_status (reply + 1, tp, utp);
}
}
}
if (reply && *reply)
{
if (*reply == 'V')
- parse_tracepoint_status (reply + 1, bp, utp);
+ parse_tracepoint_status (reply + 1, tp, utp);
}
}
}
{
struct remote_state *rs = get_remote_state ();
- if (packet_support (PACKET_DisconnectedTracing_feature) == PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_DisconnectedTracing_feature)
+ == PACKET_ENABLE)
{
char *reply;
int
remote_target::core_of_thread (ptid_t ptid)
{
- thread_info *info = find_thread_ptid (this, ptid);
+ thread_info *info = this->find_thread (ptid);
if (info != NULL && info->priv != NULL)
return get_remote_thread_info (info)->core;
void
remote_target::set_trace_buffer_size (LONGEST val)
{
- if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE)
{
struct remote_state *rs = get_remote_state ();
char *buf = rs->buf.data ();
putpkt (rs->buf);
remote_get_noisy_reply ();
- result = packet_ok (rs->buf,
- &remote_protocol_packets[PACKET_QTBuffer_size]);
+ result = m_features.packet_ok (rs->buf, PACKET_QTBuffer_size);
if (result != PACKET_OK)
warning (_("Bogus reply from target: %s"), rs->buf.data ());
bool
remote_target::use_agent (bool use)
{
- if (packet_support (PACKET_QAgent) != PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_QAgent) != PACKET_DISABLE)
{
struct remote_state *rs = get_remote_state ();
/* If the stub supports QAgent. */
xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAgent:%d", use);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
if (strcmp (rs->buf.data (), "OK") == 0)
{
bool
remote_target::can_use_agent ()
{
- return (packet_support (PACKET_QAgent) != PACKET_DISABLE);
+ return (m_features.packet_support (PACKET_QAgent) != PACKET_DISABLE);
}
-struct btrace_target_info
+#if defined (HAVE_LIBEXPAT)
+
+/* Check the btrace document version. */
+
+static void
+check_xml_btrace_version (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data,
+ std::vector<gdb_xml_value> &attributes)
{
- /* The ptid of the traced thread. */
- ptid_t ptid;
+ const char *version
+ = (const char *) xml_find_attribute (attributes, "version")->value.get ();
+
+ if (strcmp (version, "1.0") != 0)
+ gdb_xml_error (parser, _("Unsupported btrace version: \"%s\""), version);
+}
+
+/* Parse a btrace "block" xml record. */
+
+static void
+parse_xml_btrace_block (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data,
+ std::vector<gdb_xml_value> &attributes)
+{
+ struct btrace_data *btrace;
+ ULONGEST *begin, *end;
+
+ btrace = (struct btrace_data *) user_data;
+
+ switch (btrace->format)
+ {
+ case BTRACE_FORMAT_BTS:
+ break;
+
+ case BTRACE_FORMAT_NONE:
+ btrace->format = BTRACE_FORMAT_BTS;
+ btrace->variant.bts.blocks = new std::vector<btrace_block>;
+ break;
+
+ default:
+ gdb_xml_error (parser, _("Btrace format error."));
+ }
+
+ begin = (ULONGEST *) xml_find_attribute (attributes, "begin")->value.get ();
+ end = (ULONGEST *) xml_find_attribute (attributes, "end")->value.get ();
+ btrace->variant.bts.blocks->emplace_back (*begin, *end);
+}
+
+/* Parse a "raw" xml record. */
+
+static void
+parse_xml_raw (struct gdb_xml_parser *parser, const char *body_text,
+ gdb_byte **pdata, size_t *psize)
+{
+ gdb_byte *bin;
+ size_t len, size;
+
+ len = strlen (body_text);
+ if (len % 2 != 0)
+ gdb_xml_error (parser, _("Bad raw data size."));
+
+ size = len / 2;
+
+ gdb::unique_xmalloc_ptr<gdb_byte> data ((gdb_byte *) xmalloc (size));
+ bin = data.get ();
+
+ /* We use hex encoding - see gdbsupport/rsp-low.h. */
+ while (len > 0)
+ {
+ char hi, lo;
+
+ hi = *body_text++;
+ lo = *body_text++;
+
+ if (hi == 0 || lo == 0)
+ gdb_xml_error (parser, _("Bad hex encoding."));
+
+ *bin++ = fromhex (hi) * 16 + fromhex (lo);
+ len -= 2;
+ }
+
+ *pdata = data.release ();
+ *psize = size;
+}
+
+/* Parse a btrace pt-config "cpu" xml record. */
+
+static void
+parse_xml_btrace_pt_config_cpu (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data,
+ std::vector<gdb_xml_value> &attributes)
+{
+ struct btrace_data *btrace;
+ const char *vendor;
+ ULONGEST *family, *model, *stepping;
+
+ vendor
+ = (const char *) xml_find_attribute (attributes, "vendor")->value.get ();
+ family
+ = (ULONGEST *) xml_find_attribute (attributes, "family")->value.get ();
+ model
+ = (ULONGEST *) xml_find_attribute (attributes, "model")->value.get ();
+ stepping
+ = (ULONGEST *) xml_find_attribute (attributes, "stepping")->value.get ();
+
+ btrace = (struct btrace_data *) user_data;
+
+ if (strcmp (vendor, "GenuineIntel") == 0)
+ btrace->variant.pt.config.cpu.vendor = CV_INTEL;
+
+ btrace->variant.pt.config.cpu.family = *family;
+ btrace->variant.pt.config.cpu.model = *model;
+ btrace->variant.pt.config.cpu.stepping = *stepping;
+}
+
+/* Parse a btrace pt "raw" xml record. */
+
+static void
+parse_xml_btrace_pt_raw (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, const char *body_text)
+{
+ struct btrace_data *btrace;
+
+ btrace = (struct btrace_data *) user_data;
+ parse_xml_raw (parser, body_text, &btrace->variant.pt.data,
+ &btrace->variant.pt.size);
+}
+
+/* Parse a btrace "pt" xml record. */
+
+static void
+parse_xml_btrace_pt (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data,
+ std::vector<gdb_xml_value> &attributes)
+{
+ struct btrace_data *btrace;
+
+ btrace = (struct btrace_data *) user_data;
+ btrace->format = BTRACE_FORMAT_PT;
+ btrace->variant.pt.config.cpu.vendor = CV_UNKNOWN;
+ btrace->variant.pt.data = NULL;
+ btrace->variant.pt.size = 0;
+}
+
+static const struct gdb_xml_attribute block_attributes[] = {
+ { "begin", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
+ { "end", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_attribute btrace_pt_config_cpu_attributes[] = {
+ { "vendor", GDB_XML_AF_NONE, NULL, NULL },
+ { "family", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
+ { "model", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
+ { "stepping", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element btrace_pt_config_children[] = {
+ { "cpu", btrace_pt_config_cpu_attributes, NULL, GDB_XML_EF_OPTIONAL,
+ parse_xml_btrace_pt_config_cpu, NULL },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element btrace_pt_children[] = {
+ { "pt-config", NULL, btrace_pt_config_children, GDB_XML_EF_OPTIONAL, NULL,
+ NULL },
+ { "raw", NULL, NULL, GDB_XML_EF_OPTIONAL, NULL, parse_xml_btrace_pt_raw },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_attribute btrace_attributes[] = {
+ { "version", GDB_XML_AF_NONE, NULL, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element btrace_children[] = {
+ { "block", block_attributes, NULL,
+ GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL, parse_xml_btrace_block, NULL },
+ { "pt", NULL, btrace_pt_children, GDB_XML_EF_OPTIONAL, parse_xml_btrace_pt,
+ NULL },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element btrace_elements[] = {
+ { "btrace", btrace_attributes, btrace_children, GDB_XML_EF_NONE,
+ check_xml_btrace_version, NULL },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
+};
+
+#endif /* defined (HAVE_LIBEXPAT) */
+
+/* Parse a branch trace xml document XML into DATA. */
+
+static void
+parse_xml_btrace (struct btrace_data *btrace, const char *buffer)
+{
+#if defined (HAVE_LIBEXPAT)
+
+ int errcode;
+ btrace_data result;
+ result.format = BTRACE_FORMAT_NONE;
+
+ errcode = gdb_xml_parse_quick (_("btrace"), "btrace.dtd", btrace_elements,
+ buffer, &result);
+ if (errcode != 0)
+ error (_("Error parsing branch trace."));
+
+ /* Keep parse results. */
+ *btrace = std::move (result);
+
+#else /* !defined (HAVE_LIBEXPAT) */
+
+ error (_("Cannot process branch trace. XML support was disabled at "
+ "compile time."));
+
+#endif /* !defined (HAVE_LIBEXPAT) */
+}
+
+#if defined (HAVE_LIBEXPAT)
+
+/* Parse a btrace-conf "bts" xml record. */
+
+static void
+parse_xml_btrace_conf_bts (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data,
+ std::vector<gdb_xml_value> &attributes)
+{
+ struct btrace_config *conf;
+ struct gdb_xml_value *size;
+
+ conf = (struct btrace_config *) user_data;
+ conf->format = BTRACE_FORMAT_BTS;
+ conf->bts.size = 0;
+
+ size = xml_find_attribute (attributes, "size");
+ if (size != NULL)
+ conf->bts.size = (unsigned int) *(ULONGEST *) size->value.get ();
+}
+
+/* Parse a btrace-conf "pt" xml record. */
+
+static void
+parse_xml_btrace_conf_pt (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data,
+ std::vector<gdb_xml_value> &attributes)
+{
+ struct btrace_config *conf;
+ struct gdb_xml_value *size;
+
+ conf = (struct btrace_config *) user_data;
+ conf->format = BTRACE_FORMAT_PT;
+ conf->pt.size = 0;
+
+ size = xml_find_attribute (attributes, "size");
+ if (size != NULL)
+ conf->pt.size = (unsigned int) *(ULONGEST *) size->value.get ();
+}
+
+static const struct gdb_xml_attribute btrace_conf_pt_attributes[] = {
+ { "size", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
- /* The obtained branch trace configuration. */
- struct btrace_config conf;
+static const struct gdb_xml_attribute btrace_conf_bts_attributes[] = {
+ { "size", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element btrace_conf_children[] = {
+ { "bts", btrace_conf_bts_attributes, NULL, GDB_XML_EF_OPTIONAL,
+ parse_xml_btrace_conf_bts, NULL },
+ { "pt", btrace_conf_pt_attributes, NULL, GDB_XML_EF_OPTIONAL,
+ parse_xml_btrace_conf_pt, NULL },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_attribute btrace_conf_attributes[] = {
+ { "version", GDB_XML_AF_NONE, NULL, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element btrace_conf_elements[] = {
+ { "btrace-conf", btrace_conf_attributes, btrace_conf_children,
+ GDB_XML_EF_NONE, NULL, NULL },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
};
+#endif /* defined (HAVE_LIBEXPAT) */
+
+/* Parse a branch trace configuration xml document XML into CONF. */
+
+static void
+parse_xml_btrace_conf (struct btrace_config *conf, const char *xml)
+{
+#if defined (HAVE_LIBEXPAT)
+
+ int errcode;
+ errcode = gdb_xml_parse_quick (_("btrace-conf"), "btrace-conf.dtd",
+ btrace_conf_elements, xml, conf);
+ if (errcode != 0)
+ error (_("Error parsing branch trace configuration."));
+
+#else /* !defined (HAVE_LIBEXPAT) */
+
+ error (_("Cannot process the branch trace configuration. XML support "
+ "was disabled at compile time."));
+
+#endif /* !defined (HAVE_LIBEXPAT) */
+}
+
/* Reset our idea of our target's btrace configuration. */
static void
void
remote_target::btrace_sync_conf (const btrace_config *conf)
{
- struct packet_config *packet;
struct remote_state *rs;
char *buf, *pos, *endbuf;
buf = rs->buf.data ();
endbuf = buf + get_remote_packet_size ();
- packet = &remote_protocol_packets[PACKET_Qbtrace_conf_bts_size];
- if (packet_config_support (packet) == PACKET_ENABLE
+ if (m_features.packet_support (PACKET_Qbtrace_conf_bts_size) == PACKET_ENABLE
&& conf->bts.size != rs->btrace_config.bts.size)
{
pos = buf;
- pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
+ pos += xsnprintf (pos, endbuf - pos, "%s=0x%x",
+ packets_descriptions[PACKET_Qbtrace_conf_bts_size].name,
conf->bts.size);
putpkt (buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- if (packet_ok (buf, packet) == PACKET_ERROR)
+ if (m_features.packet_ok (buf, PACKET_Qbtrace_conf_bts_size)
+ == PACKET_ERROR)
{
if (buf[0] == 'E' && buf[1] == '.')
error (_("Failed to configure the BTS buffer size: %s"), buf + 2);
rs->btrace_config.bts.size = conf->bts.size;
}
- packet = &remote_protocol_packets[PACKET_Qbtrace_conf_pt_size];
- if (packet_config_support (packet) == PACKET_ENABLE
+ if (m_features.packet_support (PACKET_Qbtrace_conf_pt_size) == PACKET_ENABLE
&& conf->pt.size != rs->btrace_config.pt.size)
{
pos = buf;
- pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
+ pos += xsnprintf (pos, endbuf - pos, "%s=0x%x",
+ packets_descriptions[PACKET_Qbtrace_conf_pt_size].name,
conf->pt.size);
putpkt (buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- if (packet_ok (buf, packet) == PACKET_ERROR)
+ if (m_features.packet_ok (buf, PACKET_Qbtrace_conf_pt_size)
+ == PACKET_ERROR)
{
if (buf[0] == 'E' && buf[1] == '.')
error (_("Failed to configure the trace buffer size: %s"), buf + 2);
/* Read TP's btrace configuration from the target and store it into CONF. */
static void
-btrace_read_config (thread_info *tp, struct btrace_config *conf)
+btrace_read_config (thread_info *tp, btrace_config *conf)
{
/* target_read_stralloc relies on INFERIOR_PTID. */
scoped_restore_current_thread restore_thread;
/* 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)
+ if (m_features.packet_support (PACKET_qXfer_btrace_conf) != PACKET_ENABLE)
return;
for (thread_info *tp : all_non_exited_threads (this))
btrace_format_string (rs->btrace_config.format));
}
- tp->btrace.target = XCNEW (struct btrace_target_info);
- tp->btrace.target->ptid = tp->ptid;
- tp->btrace.target->conf = rs->btrace_config;
+ tp->btrace.target
+ = new btrace_target_info { tp->ptid, rs->btrace_config };
}
}
remote_target::enable_btrace (thread_info *tp,
const struct btrace_config *conf)
{
- struct btrace_target_info *tinfo = NULL;
struct packet_config *packet = NULL;
struct remote_state *rs = get_remote_state ();
char *buf = rs->buf.data ();
char *endbuf = buf + get_remote_packet_size ();
+ unsigned int which_packet;
switch (conf->format)
{
case BTRACE_FORMAT_BTS:
- packet = &remote_protocol_packets[PACKET_Qbtrace_bts];
+ which_packet = PACKET_Qbtrace_bts;
break;
-
case BTRACE_FORMAT_PT:
- packet = &remote_protocol_packets[PACKET_Qbtrace_pt];
+ which_packet = PACKET_Qbtrace_pt;
break;
+ default:
+ internal_error (_("Bad branch btrace format: %u."),
+ (unsigned int) conf->format);
}
+ packet = &m_features.m_protocol_packets[which_packet];
if (packet == NULL || packet_config_support (packet) != PACKET_ENABLE)
error (_("Target does not support branch tracing."));
ptid_t ptid = tp->ptid;
set_general_thread (ptid);
- buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
+ buf += xsnprintf (buf, endbuf - buf, "%s",
+ packets_descriptions[which_packet].name);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- if (packet_ok (rs->buf, packet) == PACKET_ERROR)
+ if (m_features.packet_ok (rs->buf, which_packet) == PACKET_ERROR)
{
if (rs->buf[0] == 'E' && rs->buf[1] == '.')
error (_("Could not enable branch tracing for %s: %s"),
target_pid_to_str (ptid).c_str ());
}
- tinfo = XCNEW (struct btrace_target_info);
- tinfo->ptid = ptid;
+ btrace_target_info *tinfo = new btrace_target_info { ptid };
/* If we fail to read the configuration, we lose some information, but the
tracing itself is not impacted. */
void
remote_target::disable_btrace (struct btrace_target_info *tinfo)
{
- struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off];
struct remote_state *rs = get_remote_state ();
char *buf = rs->buf.data ();
char *endbuf = buf + get_remote_packet_size ();
- if (packet_config_support (packet) != PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_Qbtrace_off) != PACKET_ENABLE)
error (_("Target does not support branch tracing."));
set_general_thread (tinfo->ptid);
- buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
+ buf += xsnprintf (buf, endbuf - buf, "%s",
+ packets_descriptions[PACKET_Qbtrace_off].name);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- if (packet_ok (rs->buf, packet) == PACKET_ERROR)
+ if (m_features.packet_ok (rs->buf, PACKET_Qbtrace_off) == PACKET_ERROR)
{
if (rs->buf[0] == 'E' && rs->buf[1] == '.')
error (_("Could not disable branch tracing for %s: %s"),
target_pid_to_str (tinfo->ptid).c_str ());
}
- xfree (tinfo);
+ delete tinfo;
}
/* Teardown branch tracing. */
remote_target::teardown_btrace (struct btrace_target_info *tinfo)
{
/* We must not talk to the target during teardown. */
- xfree (tinfo);
+ delete tinfo;
}
/* Read the branch trace. */
struct btrace_target_info *tinfo,
enum btrace_read_type type)
{
- struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace];
const char *annex;
- if (packet_config_support (packet) != PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_qXfer_btrace) != PACKET_ENABLE)
error (_("Target does not support branch tracing."));
#if !defined(HAVE_LIBEXPAT)
bool
remote_target::augmented_libraries_svr4_read ()
{
- return (packet_support (PACKET_augmented_libraries_svr4_read_feature)
- == PACKET_ENABLE);
+ return
+ (m_features.packet_support (PACKET_augmented_libraries_svr4_read_feature)
+ == PACKET_ENABLE);
}
/* Implementation of to_load. */
static gdb::optional<gdb::char_vector> filename;
char *annex = NULL;
- if (packet_support (PACKET_qXfer_exec_file) != PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_qXfer_exec_file) != PACKET_ENABLE)
return NULL;
inferior *inf = find_inferior_pid (this, pid);
feature. If the stub doesn't support vContSupported feature,
we have conservatively to think target doesn't supports single
step. */
- if (packet_support (PACKET_vContSupported) == PACKET_ENABLE)
+ if (m_features.packet_support (PACKET_vContSupported) == PACKET_ENABLE)
{
struct remote_state *rs = get_remote_state ();
- if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
- remote_vcont_probe ();
-
return rs->supports_vCont.s && rs->supports_vCont.S;
}
else
return NULL;
}
-gdb::byte_vector
+gdb::array_view<const gdb_byte>
remote_target::thread_info_to_thread_handle (struct thread_info *tp)
{
remote_thread_info *priv = get_remote_thread_info (tp);
gdb_assert (target_async_permitted);
/* We're async whenever the serial device can. */
- struct remote_state *rs = get_remote_state ();
- return serial_can_async_p (rs->remote_desc);
+ return get_remote_state ()->can_async_p ();
}
bool
remote_target::is_async_p ()
{
/* We're async whenever the serial device is. */
- struct remote_state *rs = get_remote_state ();
- return serial_is_async_p (rs->remote_desc);
+ return get_remote_state ()->is_async_p ();
}
/* Pass the SERIAL event on and up to the client. One day this code
inferior_event_handler (INF_REG_EVENT);
}
-static void
-remote_async_inferior_event_handler (gdb_client_data data)
-{
- inferior_event_handler (INF_REG_EVENT);
-}
-
int
remote_target::async_wait_fd ()
{
/* If there are pending events in the stop reply queue tell the
event loop to process them. */
if (!rs->stop_reply_queue.empty ())
- mark_async_event_handler (rs->remote_async_inferior_event_token);
+ rs->mark_async_event_handler ();
+
/* For simplicity, below we clear the pending events token
without remembering whether it is marked, so here we always
mark it. If there's actually no pending notification to
/* If the core is disabling async, it doesn't want to be
disturbed with target events. Clear all async event sources
too. */
- clear_async_event_handler (rs->remote_async_inferior_event_token);
+ rs->clear_async_event_handler ();
+
if (target_is_non_stop_p ())
clear_async_event_handler (rs->notif_state->get_pending_events_token);
}
struct remote_state *rs = get_remote_state ();
size_t size = get_remote_packet_size ();
- if (packet_support (PACKET_QThreadEvents) == PACKET_DISABLE)
+ if (m_features.packet_support (PACKET_QThreadEvents) == PACKET_DISABLE)
return;
xsnprintf (rs->buf.data (), size, "QThreadEvents:%x", enable ? 1 : 0);
putpkt (rs->buf);
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
- switch (packet_ok (rs->buf,
- &remote_protocol_packets[PACKET_QThreadEvents]))
+ switch (m_features.packet_ok (rs->buf, PACKET_QThreadEvents))
{
case PACKET_OK:
if (strcmp (rs->buf.data (), "OK") != 0)
}
}
+/* Some change happened in PSPACE's objfile list (obfiles added or removed),
+ offer all inferiors using that program space a change to look up symbols. */
-/* Function to be called whenever a new objfile (shlib) is detected. */
static void
-remote_new_objfile (struct objfile *objfile)
+remote_objfile_changed_check_symbols (program_space *pspace)
{
- /* The objfile change happened in that program space. */
- program_space *pspace = current_program_space;
-
/* The affected program space is possibly shared by multiple inferiors.
Consider sending a qSymbol packet for each of the inferiors using that
program space. */
continue;
/* Need to switch to a specific thread, because remote_check_symbols will
- set the general thread using INFERIOR_PTID.
+ set the general thread using INFERIOR_PTID.
It's possible to have inferiors with no thread here, because we are
called very early in the connection process, while the inferior is
}
}
+/* Function to be called whenever a new objfile (shlib) is detected. */
+
+static void
+remote_new_objfile (struct objfile *objfile)
+{
+ remote_objfile_changed_check_symbols (objfile->pspace);
+}
+
/* Pull all the tracepoints defined on the target and create local
data structures representing them. We don't want to create real
tracepoints yet, we don't want to mess up the user's existing
collection. */
-
+
int
remote_target::upload_tracepoints (struct uploaded_tp **utpp)
{
/* Ask for a first packet of tracepoint definition. */
putpkt ("qTfP");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
p = rs->buf.data ();
while (*p && *p != 'l')
{
parse_tracepoint_definition (p, utpp);
/* Ask for another packet of tracepoint definition. */
putpkt ("qTsP");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
p = rs->buf.data ();
}
return 0;
/* Ask for a first packet of variable definition. */
putpkt ("qTfV");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
p = rs->buf.data ();
while (*p && *p != 'l')
{
parse_tsv_definition (p, utsvp);
/* Ask for another packet of variable definition. */
putpkt ("qTsV");
- getpkt (&rs->buf, 0);
+ getpkt (&rs->buf);
p = rs->buf.data ();
}
return 0;
bool
remote_target::vcont_r_supported ()
{
- if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
- remote_vcont_probe ();
-
- return (packet_support (PACKET_vCont) == PACKET_ENABLE
+ return (m_features.packet_support (PACKET_vCont) == PACKET_ENABLE
&& get_remote_state ()->supports_vCont.r);
}
bool
remote_target::supports_memory_tagging ()
{
- return remote_memory_tagging_p ();
+ return m_features.remote_memory_tagging_p ();
}
/* Create the qMemTags packet given ADDRESS, LEN and TYPE. */
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;
+ int addr_size = gdbarch_addr_bit (current_inferior ()->arch ()) / 8;
std::string request = string_printf ("qMemTags:%s,%s:%s",
phex_nz (address, addr_size),
size_t len, int type,
const gdb::byte_vector &tags)
{
- int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
+ int addr_size = gdbarch_addr_bit (current_inferior ()->arch ()) / 8;
/* Put together the main packet, address and length. */
std::string request = string_printf ("QMemTags:%s,%s:%s:",
gdb::byte_vector &tags, int type)
{
/* Make sure the qMemTags packet is supported. */
- if (!remote_memory_tagging_p ())
+ if (!m_features.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);
+ getpkt (&rs->buf);
return parse_fetch_memtags_reply (rs->buf, tags);
}
const gdb::byte_vector &tags, int type)
{
/* Make sure the QMemTags packet is supported. */
- if (!remote_memory_tagging_p ())
+ if (!m_features.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);
+ getpkt (&rs->buf);
/* Verify if the request was successful. */
return packet_check_result (rs->buf.data ()) == PACKET_OK;
remote_target remote;
struct packet_config *config
- = &remote_protocol_packets[PACKET_memory_tagging_feature];
+ = &remote.m_features.m_protocol_packets[PACKET_memory_tagging_feature];
scoped_restore restore_memtag_support_
= make_scoped_restore (&config->support);
/* Hook into new objfile notification. */
gdb::observers::new_objfile.attach (remote_new_objfile, "remote");
+ gdb::observers::all_objfiles_removed.attach
+ (remote_objfile_changed_check_symbols, "remote");
#if 0
init_remote_threadtests ();
Set the maximum number of bytes per memory-write packet.\n\
Specify the number of bytes in a packet or 0 (zero) for the\n\
default packet size. The actual limit is further reduced\n\
-dependent on the target. Specify ``fixed'' to disable the\n\
-further restriction and ``limit'' to enable that restriction."),
+dependent on the target. Specify \"fixed\" to disable the\n\
+further restriction and \"limit\" to enable that restriction."),
&remote_set_cmdlist);
add_cmd ("memory-read-packet-size", no_class,
set_memory_read_packet_size, _("\
Set the maximum number of bytes per memory-read packet.\n\
Specify the number of bytes in a packet or 0 (zero) for the\n\
default packet size. The actual limit is further reduced\n\
-dependent on the target. Specify ``fixed'' to disable the\n\
-further restriction and ``limit'' to enable that restriction."),
+dependent on the target. Specify \"fixed\" to disable the\n\
+further restriction and \"limit\" to enable that restriction."),
&remote_set_cmdlist);
add_cmd ("memory-write-packet-size", no_class,
show_memory_write_packet_size,
init_all_packet_configs ();
- add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
- "X", "binary-download", 1);
+ add_packet_config_cmd (PACKET_X, "X", "binary-download", 1);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
- "vCont", "verbose-resume", 0);
+ add_packet_config_cmd (PACKET_vCont, "vCont", "verbose-resume", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals],
- "QPassSignals", "pass-signals", 0);
+ add_packet_config_cmd (PACKET_QPassSignals, "QPassSignals", "pass-signals",
+ 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QCatchSyscalls],
- "QCatchSyscalls", "catch-syscalls", 0);
+ add_packet_config_cmd (PACKET_QCatchSyscalls, "QCatchSyscalls",
+ "catch-syscalls", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QProgramSignals],
- "QProgramSignals", "program-signals", 0);
+ add_packet_config_cmd (PACKET_QProgramSignals, "QProgramSignals",
+ "program-signals", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QSetWorkingDir],
- "QSetWorkingDir", "set-working-dir", 0);
+ add_packet_config_cmd (PACKET_QSetWorkingDir, "QSetWorkingDir",
+ "set-working-dir", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartupWithShell],
- "QStartupWithShell", "startup-with-shell", 0);
+ add_packet_config_cmd (PACKET_QStartupWithShell, "QStartupWithShell",
+ "startup-with-shell", 0);
- add_packet_config_cmd (&remote_protocol_packets
- [PACKET_QEnvironmentHexEncoded],
- "QEnvironmentHexEncoded", "environment-hex-encoded",
- 0);
+ add_packet_config_cmd (PACKET_QEnvironmentHexEncoded,"QEnvironmentHexEncoded",
+ "environment-hex-encoded", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentReset],
- "QEnvironmentReset", "environment-reset",
- 0);
+ add_packet_config_cmd (PACKET_QEnvironmentReset, "QEnvironmentReset",
+ "environment-reset", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentUnset],
- "QEnvironmentUnset", "environment-unset",
- 0);
+ add_packet_config_cmd (PACKET_QEnvironmentUnset, "QEnvironmentUnset",
+ "environment-unset", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
- "qSymbol", "symbol-lookup", 0);
+ add_packet_config_cmd (PACKET_qSymbol, "qSymbol", "symbol-lookup", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
- "P", "set-register", 1);
+ add_packet_config_cmd (PACKET_P, "P", "set-register", 1);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
- "p", "fetch-register", 1);
+ add_packet_config_cmd (PACKET_p, "p", "fetch-register", 1);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
- "Z0", "software-breakpoint", 0);
+ add_packet_config_cmd (PACKET_Z0, "Z0", "software-breakpoint", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
- "Z1", "hardware-breakpoint", 0);
+ add_packet_config_cmd (PACKET_Z1, "Z1", "hardware-breakpoint", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
- "Z2", "write-watchpoint", 0);
+ add_packet_config_cmd (PACKET_Z2, "Z2", "write-watchpoint", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
- "Z3", "read-watchpoint", 0);
+ add_packet_config_cmd (PACKET_Z3, "Z3", "read-watchpoint", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
- "Z4", "access-watchpoint", 0);
+ add_packet_config_cmd (PACKET_Z4, "Z4", "access-watchpoint", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
- "qXfer:auxv:read", "read-aux-vector", 0);
+ add_packet_config_cmd (PACKET_qXfer_auxv, "qXfer:auxv:read",
+ "read-aux-vector", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_exec_file],
- "qXfer:exec-file:read", "pid-to-exec-file", 0);
+ add_packet_config_cmd (PACKET_qXfer_exec_file, "qXfer:exec-file:read",
+ "pid-to-exec-file", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features],
+ add_packet_config_cmd (PACKET_qXfer_features,
"qXfer:features:read", "target-features", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries],
- "qXfer:libraries:read", "library-info", 0);
+ add_packet_config_cmd (PACKET_qXfer_libraries, "qXfer:libraries:read",
+ "library-info", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries_svr4],
+ add_packet_config_cmd (PACKET_qXfer_libraries_svr4,
"qXfer:libraries-svr4:read", "library-info-svr4", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
- "qXfer:memory-map:read", "memory-map", 0);
+ add_packet_config_cmd (PACKET_qXfer_memory_map, "qXfer:memory-map:read",
+ "memory-map", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata],
- "qXfer:osdata:read", "osdata", 0);
+ add_packet_config_cmd (PACKET_qXfer_osdata, "qXfer:osdata:read", "osdata", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads],
- "qXfer:threads:read", "threads", 0);
+ add_packet_config_cmd (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);
+ add_packet_config_cmd (PACKET_qXfer_siginfo_read, "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);
+ add_packet_config_cmd (PACKET_qXfer_siginfo_write, "qXfer:siginfo:write",
+ "write-siginfo-object", 0);
- add_packet_config_cmd
- (&remote_protocol_packets[PACKET_qXfer_traceframe_info],
- "qXfer:traceframe-info:read", "traceframe-info", 0);
+ add_packet_config_cmd (PACKET_qXfer_traceframe_info,
+ "qXfer:traceframe-info:read", "traceframe-info", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_uib],
- "qXfer:uib:read", "unwind-info-block", 0);
+ add_packet_config_cmd (PACKET_qXfer_uib, "qXfer:uib:read",
+ "unwind-info-block", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
- "qGetTLSAddr", "get-thread-local-storage-address",
- 0);
+ add_packet_config_cmd (PACKET_qGetTLSAddr, "qGetTLSAddr",
+ "get-thread-local-storage-address", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTIBAddr],
- "qGetTIBAddr", "get-thread-information-block-address",
- 0);
+ add_packet_config_cmd (PACKET_qGetTIBAddr, "qGetTIBAddr",
+ "get-thread-information-block-address", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_bc],
- "bc", "reverse-continue", 0);
+ add_packet_config_cmd (PACKET_bc, "bc", "reverse-continue", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_bs],
- "bs", "reverse-step", 0);
+ add_packet_config_cmd (PACKET_bs, "bs", "reverse-step", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
- "qSupported", "supported-packets", 0);
+ add_packet_config_cmd (PACKET_qSupported, "qSupported", "supported-packets",
+ 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory],
- "qSearch:memory", "search-memory", 0);
+ add_packet_config_cmd (PACKET_qSearch_memory, "qSearch:memory",
+ "search-memory", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qTStatus],
- "qTStatus", "trace-status", 0);
+ add_packet_config_cmd (PACKET_qTStatus, "qTStatus", "trace-status", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_setfs],
- "vFile:setfs", "hostio-setfs", 0);
+ add_packet_config_cmd (PACKET_vFile_setfs, "vFile:setfs", "hostio-setfs", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open],
- "vFile:open", "hostio-open", 0);
+ add_packet_config_cmd (PACKET_vFile_open, "vFile:open", "hostio-open", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread],
- "vFile:pread", "hostio-pread", 0);
+ add_packet_config_cmd (PACKET_vFile_pread, "vFile:pread", "hostio-pread", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite],
- "vFile:pwrite", "hostio-pwrite", 0);
+ add_packet_config_cmd (PACKET_vFile_pwrite, "vFile:pwrite", "hostio-pwrite",
+ 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close],
- "vFile:close", "hostio-close", 0);
+ add_packet_config_cmd (PACKET_vFile_close, "vFile:close", "hostio-close", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink],
- "vFile:unlink", "hostio-unlink", 0);
+ add_packet_config_cmd (PACKET_vFile_unlink, "vFile:unlink", "hostio-unlink",
+ 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_readlink],
- "vFile:readlink", "hostio-readlink", 0);
+ add_packet_config_cmd (PACKET_vFile_readlink, "vFile:readlink",
+ "hostio-readlink", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_fstat],
- "vFile:fstat", "hostio-fstat", 0);
+ add_packet_config_cmd (PACKET_vFile_fstat, "vFile:fstat", "hostio-fstat", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach],
- "vAttach", "attach", 0);
+ add_packet_config_cmd (PACKET_vAttach, "vAttach", "attach", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun],
- "vRun", "run", 0);
+ add_packet_config_cmd (PACKET_vRun, "vRun", "run", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartNoAckMode],
- "QStartNoAckMode", "noack", 0);
+ add_packet_config_cmd (PACKET_QStartNoAckMode, "QStartNoAckMode", "noack", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill],
- "vKill", "kill", 0);
+ add_packet_config_cmd (PACKET_vKill, "vKill", "kill", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached],
- "qAttached", "query-attached", 0);
+ add_packet_config_cmd (PACKET_qAttached, "qAttached", "query-attached", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints],
- "ConditionalTracepoints",
- "conditional-tracepoints", 0);
+ add_packet_config_cmd (PACKET_ConditionalTracepoints,
+ "ConditionalTracepoints", "conditional-tracepoints",
+ 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalBreakpoints],
- "ConditionalBreakpoints",
- "conditional-breakpoints", 0);
+ add_packet_config_cmd (PACKET_ConditionalBreakpoints,
+ "ConditionalBreakpoints", "conditional-breakpoints",
+ 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_BreakpointCommands],
- "BreakpointCommands",
+ add_packet_config_cmd (PACKET_BreakpointCommands, "BreakpointCommands",
"breakpoint-commands", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints],
- "FastTracepoints", "fast-tracepoints", 0);
+ add_packet_config_cmd (PACKET_FastTracepoints, "FastTracepoints",
+ "fast-tracepoints", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_TracepointSource],
- "TracepointSource", "TracepointSource", 0);
+ add_packet_config_cmd (PACKET_TracepointSource, "TracepointSource",
+ "TracepointSource", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow],
- "QAllow", "allow", 0);
+ add_packet_config_cmd (PACKET_QAllow, "QAllow", "allow", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints],
- "StaticTracepoints", "static-tracepoints", 0);
+ add_packet_config_cmd (PACKET_StaticTracepoints, "StaticTracepoints",
+ "static-tracepoints", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_InstallInTrace],
- "InstallInTrace", "install-in-trace", 0);
+ add_packet_config_cmd (PACKET_InstallInTrace, "InstallInTrace",
+ "install-in-trace", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read],
+ add_packet_config_cmd (PACKET_qXfer_statictrace_read,
"qXfer:statictrace:read", "read-sdata-object", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic],
- "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
+ add_packet_config_cmd (PACKET_qXfer_fdpic, "qXfer:fdpic:read",
+ "read-fdpic-loadmap", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QDisableRandomization],
- "QDisableRandomization", "disable-randomization", 0);
+ add_packet_config_cmd (PACKET_QDisableRandomization, "QDisableRandomization",
+ "disable-randomization", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent],
- "QAgent", "agent", 0);
+ add_packet_config_cmd (PACKET_QAgent, "QAgent", "agent", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QTBuffer_size],
- "QTBuffer:size", "trace-buffer-size", 0);
+ add_packet_config_cmd (PACKET_QTBuffer_size, "QTBuffer:size",
+ "trace-buffer-size", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_off],
- "Qbtrace:off", "disable-btrace", 0);
+ add_packet_config_cmd (PACKET_Qbtrace_off, "Qbtrace:off", "disable-btrace",
+ 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_bts],
- "Qbtrace:bts", "enable-btrace-bts", 0);
+ add_packet_config_cmd (PACKET_Qbtrace_bts, "Qbtrace:bts", "enable-btrace-bts",
+ 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_pt],
- "Qbtrace:pt", "enable-btrace-pt", 0);
+ add_packet_config_cmd (PACKET_Qbtrace_pt, "Qbtrace:pt", "enable-btrace-pt",
+ 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace],
- "qXfer:btrace", "read-btrace", 0);
+ add_packet_config_cmd (PACKET_qXfer_btrace, "qXfer:btrace", "read-btrace", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace_conf],
- "qXfer:btrace-conf", "read-btrace-conf", 0);
+ add_packet_config_cmd (PACKET_qXfer_btrace_conf, "qXfer:btrace-conf",
+ "read-btrace-conf", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_bts_size],
- "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
+ add_packet_config_cmd (PACKET_Qbtrace_conf_bts_size, "Qbtrace-conf:bts:size",
+ "btrace-conf-bts-size", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_multiprocess_feature],
- "multiprocess-feature", "multiprocess-feature", 0);
+ add_packet_config_cmd (PACKET_multiprocess_feature, "multiprocess-feature",
+ "multiprocess-feature", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_swbreak_feature],
- "swbreak-feature", "swbreak-feature", 0);
+ add_packet_config_cmd (PACKET_swbreak_feature, "swbreak-feature",
+ "swbreak-feature", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature],
- "hwbreak-feature", "hwbreak-feature", 0);
+ add_packet_config_cmd (PACKET_hwbreak_feature, "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 (PACKET_fork_event_feature, "fork-event-feature",
+ "fork-event-feature", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vfork_event_feature],
- "vfork-event-feature", "vfork-event-feature", 0);
+ add_packet_config_cmd (PACKET_vfork_event_feature, "vfork-event-feature",
+ "vfork-event-feature", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_pt_size],
- "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
+ add_packet_config_cmd (PACKET_Qbtrace_conf_pt_size, "Qbtrace-conf:pt:size",
+ "btrace-conf-pt-size", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vContSupported],
- "vContSupported", "verbose-resume-supported", 0);
+ add_packet_config_cmd (PACKET_vContSupported, "vContSupported",
+ "verbose-resume-supported", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_exec_event_feature],
- "exec-event-feature", "exec-event-feature", 0);
+ add_packet_config_cmd (PACKET_exec_event_feature, "exec-event-feature",
+ "exec-event-feature", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_vCtrlC],
- "vCtrlC", "ctrl-c", 0);
+ add_packet_config_cmd (PACKET_vCtrlC, "vCtrlC", "ctrl-c", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_QThreadEvents],
- "QThreadEvents", "thread-events", 0);
+ add_packet_config_cmd (PACKET_QThreadEvents, "QThreadEvents", "thread-events",
+ 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_no_resumed],
- "N stop reply", "no-resumed-stop-reply", 0);
+ add_packet_config_cmd (PACKET_no_resumed, "N stop reply",
+ "no-resumed-stop-reply", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_memory_tagging_feature],
+ add_packet_config_cmd (PACKET_memory_tagging_feature,
"memory-tagging-feature", "memory-tagging-feature", 0);
/* Assert that we've registered "set remote foo-packet" commands
/* This catches both forgetting to add a config command, and
forgetting to remove a packet from the exception list. */
- gdb_assert (excepted == (remote_protocol_packets[i].name == NULL));
+ gdb_assert (excepted == (packets_descriptions[i].name == NULL));
}
}
projects / thirdparty / binutils-gdb.git / blobdiff