#include <ctype.h>
#include <fcntl.h>
#include "inferior.h"
+#include "infrun.h"
#include "bfd.h"
#include "symfile.h"
#include "exceptions.h"
static void show_packet_config_cmd (struct packet_config *config);
-static void update_packet_config (struct packet_config *config);
-
-static void set_remote_protocol_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c);
-
static void show_remote_protocol_packet_cmd (struct ui_file *file,
int from_tty,
struct cmd_list_element *c,
/* True if we're connected in extended remote mode. */
int extended;
- /* True if the stub reported support for multi-process
- extensions. */
- int multi_process_aware;
-
/* True if we resumed the target and we're waiting for the target to
stop. In the mean time, we can't start another command/query.
The remote server wouldn't be ready to process it, so we'd
because we allow GDB commands while the target is running. */
int waiting_for_stop_reply;
- /* True if the stub reports support for non-stop mode. */
- int non_stop_aware;
-
/* The status of the stub support for the various vCont actions. */
struct vCont_action_support supports_vCont;
- /* True if the stub reports support for conditional tracepoints. */
- int cond_tracepoints;
-
- /* True if the stub reports support for target-side breakpoint
- conditions. */
- int cond_breakpoints;
-
- /* True if the stub reports support for target-side breakpoint
- commands. */
- int breakpoint_commands;
-
- /* True if the stub reports support for fast tracepoints. */
- int fast_tracepoints;
-
- /* True if the stub reports support for static tracepoints. */
- int static_tracepoints;
-
- /* True if the stub reports support for installing tracepoint while
- tracing. */
- int install_in_trace;
-
- /* True if the stub can continue running a trace while GDB is
- disconnected. */
- int disconnected_tracing;
-
- /* True if the stub reports support for enabling and disabling
- tracepoints while a trace experiment is running. */
- int enable_disable_tracepoints;
-
- /* True if the stub can collect strings using tracenz bytecode. */
- int string_tracing;
-
- /* True if the stub supports qXfer:libraries-svr4:read with a
- non-empty annex. */
- int augmented_libraries_svr4_read;
-
/* Nonzero if the user has pressed Ctrl-C, but the target hasn't
responded to that. */
int ctrlc_pending_p;
xfree (info);
}
-/* Returns true if the multi-process extensions are in effect. */
-static int
-remote_multi_process_p (struct remote_state *rs)
-{
- return rs->multi_process_aware;
-}
-
/* This data could be associated with a target, but we do not always
have access to the current target when we need it, so for now it is
static. This will be fine for as long as only one target is in use
{
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;
+
+ /* Does the target support this packet? */
enum packet_support support;
};
PACKET_UNKNOWN
};
-static void
-update_packet_config (struct packet_config *config)
-{
- switch (config->detect)
- {
- case AUTO_BOOLEAN_TRUE:
- config->support = PACKET_ENABLE;
- break;
- case AUTO_BOOLEAN_FALSE:
- config->support = PACKET_DISABLE;
- break;
- case AUTO_BOOLEAN_AUTO:
- config->support = PACKET_SUPPORT_UNKNOWN;
- break;
- }
-}
+static enum packet_support packet_config_support (struct packet_config *config);
+static enum packet_support packet_support (int packet);
static void
show_packet_config_cmd (struct packet_config *config)
{
char *support = "internal-error";
- switch (config->support)
+ switch (packet_config_support (config))
{
case PACKET_ENABLE:
support = "enabled";
config->name = name;
config->title = title;
- config->detect = AUTO_BOOLEAN_AUTO;
- config->support = PACKET_SUPPORT_UNKNOWN;
set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
name, title);
show_doc = xstrprintf ("Show current use of remote "
add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
&config->detect, set_doc,
show_doc, NULL, /* help_doc */
- set_remote_protocol_packet_cmd,
+ NULL,
show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist);
/* The command code copies the documentation strings. */
{
enum packet_result result;
+ if (config->detect != AUTO_BOOLEAN_TRUE
+ && config->support == PACKET_DISABLE)
+ internal_error (__FILE__, __LINE__,
+ _("packet_ok: attempt to use a disabled packet"));
+
result = packet_check_result (buf);
switch (result)
{
case PACKET_OK:
case PACKET_ERROR:
/* The stub recognized the packet request. */
- switch (config->support)
+ if (config->support == PACKET_SUPPORT_UNKNOWN)
{
- case PACKET_SUPPORT_UNKNOWN:
if (remote_debug)
fprintf_unfiltered (gdb_stdlog,
- "Packet %s (%s) is supported\n",
- config->name, config->title);
+ "Packet %s (%s) is supported\n",
+ config->name, config->title);
config->support = PACKET_ENABLE;
- break;
- case PACKET_DISABLE:
- internal_error (__FILE__, __LINE__,
- _("packet_ok: attempt to use a disabled packet"));
- break;
- case PACKET_ENABLE:
- break;
}
break;
case PACKET_UNKNOWN:
/* The stub does not support the packet. */
- switch (config->support)
+ if (config->detect == AUTO_BOOLEAN_AUTO
+ && config->support == PACKET_ENABLE)
{
- case PACKET_ENABLE:
- if (config->detect == AUTO_BOOLEAN_AUTO)
- /* 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);
- else
- /* The user set it wrong. */
- error (_("Enabled packet %s (%s) not recognized by stub"),
- config->name, config->title);
- break;
- case PACKET_SUPPORT_UNKNOWN:
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "Packet %s (%s) is NOT supported\n",
- config->name, config->title);
- config->support = PACKET_DISABLE;
- break;
- case PACKET_DISABLE:
- 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);
}
+ 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);
+ }
+
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stdlog,
+ "Packet %s (%s) is NOT supported\n",
+ config->name, config->title);
+ config->support = PACKET_DISABLE;
break;
}
PACKET_qTStatus,
PACKET_QPassSignals,
PACKET_QProgramSignals,
+ PACKET_qCRC,
PACKET_qSearch_memory,
PACKET_vAttach,
PACKET_vRun,
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_Qbtrace_off,
PACKET_Qbtrace_bts,
PACKET_qXfer_btrace,
+
+ /* Support for the QNonStop packet. */
+ PACKET_QNonStop,
+
+ /* 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,
+
PACKET_MAX
};
static struct packet_config remote_protocol_packets[PACKET_MAX];
-static void
-set_remote_protocol_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- struct packet_config *packet;
+/* Returns whether a given packet or feature is supported. This takes
+ into account the state of the corresponding "set remote foo-packet"
+ command, which may be used to bypass auto-detection. */
- for (packet = remote_protocol_packets;
- packet < &remote_protocol_packets[PACKET_MAX];
- packet++)
+static enum packet_support
+packet_config_support (struct packet_config *config)
+{
+ switch (config->detect)
{
- if (&packet->detect == c->var)
- {
- update_packet_config (packet);
- return;
- }
+ case AUTO_BOOLEAN_TRUE:
+ return PACKET_ENABLE;
+ case AUTO_BOOLEAN_FALSE:
+ return PACKET_DISABLE;
+ case AUTO_BOOLEAN_AUTO:
+ return config->support;
+ default:
+ gdb_assert_not_reached (_("bad switch"));
}
- internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
- c->name);
+}
+
+/* Same as packet_config_support, but takes the packet's enum value as
+ argument. */
+
+static enum packet_support
+packet_support (int packet)
+{
+ struct packet_config *config = &remote_protocol_packets[packet];
+
+ return packet_config_support (config);
}
static void
int i;
for (i = 0; i < NR_Z_PACKET_TYPES; i++)
- {
- remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
- update_packet_config (&remote_protocol_packets[PACKET_Z0 + i]);
- }
+ remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
}
static void
}
}
+/* 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;
+}
+
/* Tokens for use by the asynchronous signal handlers for SIGINT. */
static struct async_signal_handler *async_sigint_remote_twice_token;
static struct async_signal_handler *async_sigint_remote_token;
struct remote_state *rs = get_remote_state ();
size_t size = get_remote_packet_size ();
- if (remote_protocol_packets[PACKET_qAttached].support == PACKET_DISABLE)
+ if (packet_support (PACKET_qAttached) == PACKET_DISABLE)
return 0;
if (remote_multi_process_p (rs))
remote_pass_signals (struct target_ops *self,
int numsigs, unsigned char *pass_signals)
{
- if (remote_protocol_packets[PACKET_QPassSignals].support != PACKET_DISABLE)
+ if (packet_support (PACKET_QPassSignals) != PACKET_DISABLE)
{
char *pass_packet, *p;
int count = 0, i;
remote_program_signals (struct target_ops *self,
int numsigs, unsigned char *signals)
{
- if (remote_protocol_packets[PACKET_QProgramSignals].support != PACKET_DISABLE)
+ if (packet_support (PACKET_QProgramSignals) != PACKET_DISABLE)
{
char *packet, *p;
int count = 0, i;
/* The main thread is always alive. */
return 1;
- if (ptid_get_pid (ptid) != 0 && ptid_get_tid (ptid) == 0)
+ if (ptid_get_pid (ptid) != 0 && ptid_get_lwp (ptid) == 0)
/* The main thread is always alive. This can happen after a
vAttach, if the remote side doesn't support
multi-threading. */
else
buf += xsnprintf (buf, endbuf - buf, "p%x.", pid);
}
- tid = ptid_get_tid (ptid);
+ tid = ptid_get_lwp (ptid);
if (tid < 0)
buf += xsnprintf (buf, endbuf - buf, "-%x", -tid);
else
pp = unpack_varlen_hex (p + 1, &tid);
if (obuf)
*obuf = pp;
- return ptid_build (pid, 0, tid);
+ return ptid_build (pid, tid, 0);
}
/* No multi-process. Just a tid. */
if (obuf)
*obuf = pp;
- return ptid_build (pid, 0, tid);
+ return ptid_build (pid, tid, 0);
}
static int
remote_newthread_step (threadref *ref, void *context)
{
int pid = ptid_get_pid (inferior_ptid);
- ptid_t ptid = ptid_build (pid, 0, threadref_to_int (ref));
+ ptid_t ptid = ptid_build (pid, threadref_to_int (ref), 0);
if (!in_thread_list (ptid))
add_thread (ptid);
error (_("Command can only be used when connected to the remote target."));
#if defined(HAVE_LIBEXPAT)
- if (remote_protocol_packets[PACKET_qXfer_threads].support == PACKET_ENABLE)
+ if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
{
char *xml = target_read_stralloc (¤t_target,
TARGET_OBJECT_THREADS, NULL);
_("remote_threads_extra_info"));
if (ptid_equal (tp->ptid, magic_null_ptid)
- || (ptid_get_pid (tp->ptid) != 0 && ptid_get_tid (tp->ptid) == 0))
+ || (ptid_get_pid (tp->ptid) != 0 && ptid_get_lwp (tp->ptid) == 0))
/* This is the main thread which was added by GDB. The remote
server doesn't know about it. */
return NULL;
- if (remote_protocol_packets[PACKET_qXfer_threads].support == PACKET_ENABLE)
+ if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
{
struct thread_info *info = find_thread_ptid (tp->ptid);
rs->use_threadextra_query = 0;
set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
| TAG_MOREDISPLAY | TAG_DISPLAY;
- int_to_threadref (&id, ptid_get_tid (tp->ptid));
+ int_to_threadref (&id, ptid_get_lwp (tp->ptid));
if (remote_get_threadinfo (&id, set, &threadinfo))
if (threadinfo.active)
{
}
static VEC(static_tracepoint_marker_p) *
-remote_static_tracepoint_markers_by_strid (const char *strid)
+remote_static_tracepoint_markers_by_strid (struct target_ops *self,
+ const char *strid)
{
struct remote_state *rs = get_remote_state ();
VEC(static_tracepoint_marker_p) *markers = NULL;
static ptid_t
remote_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
{
- return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
+ return ptid_build (ptid_get_pid (inferior_ptid), lwp, 0);
}
\f
remote_query_supported ();
/* If the stub wants to get a QAllow, compose one and send it. */
- if (remote_protocol_packets[PACKET_QAllow].support != PACKET_DISABLE)
+ if (packet_support (PACKET_QAllow) != PACKET_DISABLE)
remote_set_permissions (target);
/* Next, we possibly activate noack mode.
stub claimed should be the default with qSupported. */
noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode];
-
- if (noack_config->detect == AUTO_BOOLEAN_TRUE
- || (noack_config->detect == AUTO_BOOLEAN_AUTO
- && noack_config->support == PACKET_ENABLE))
+ if (packet_config_support (noack_config) != PACKET_DISABLE)
{
putpkt ("QStartNoAckMode");
getpkt (&rs->buf, &rs->buf_size, 0);
if (non_stop)
{
- if (!rs->non_stop_aware)
+ if (packet_support (PACKET_QNonStop) != PACKET_ENABLE)
error (_("Non-stop mode requested, but remote "
"does not support non-stop"));
stopped. */
remote_threads_info (target);
}
- else if (rs->non_stop_aware)
+ else if (packet_support (PACKET_QNonStop) == PACKET_ENABLE)
{
/* Don't assume that the stub can operate in all-stop mode.
Request it explicitly. */
remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */);
}
-/* Generic code for opening a connection to a remote target. */
+/* 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)
+{
+ int i;
+
+ for (i = 0; i < PACKET_MAX; i++)
+ remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
+}
+
+/* Initialize all packet configs. */
static void
init_all_packet_configs (void)
int i;
for (i = 0; i < PACKET_MAX; i++)
- update_packet_config (&remote_protocol_packets[i]);
+ {
+ remote_protocol_packets[i].detect = AUTO_BOOLEAN_AUTO;
+ remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
+ }
}
/* Symbol look-up. */
{
struct remote_state *rs = get_remote_state ();
char *msg, *reply, *tmp;
- struct minimal_symbol *sym;
+ struct bound_minimal_symbol sym;
int end;
/* The remote side has no concept of inferiors that aren't running
if (!target_has_execution)
return;
- if (remote_protocol_packets[PACKET_qSymbol].support == PACKET_DISABLE)
+ if (packet_support (PACKET_qSymbol) == PACKET_DISABLE)
return;
/* Make sure the remote is pointing at the right process. Note
while (strncmp (reply, "qSymbol:", 8) == 0)
{
+ struct bound_minimal_symbol sym;
+
tmp = &reply[8];
end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2);
msg[end] = '\0';
sym = lookup_minimal_symbol (msg, NULL, NULL);
- if (sym == NULL)
+ if (sym.minsym == NULL)
xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
else
{
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
- CORE_ADDR sym_addr = SYMBOL_VALUE_ADDRESS (sym);
+ CORE_ADDR sym_addr = BMSYMBOL_VALUE_ADDRESS (sym);
/* If this is a function address, return the start of code
instead of any data function descriptor. */
return;
}
- if (remote_protocol_packets[feature->packet].support
- == PACKET_SUPPORT_UNKNOWN)
- remote_protocol_packets[feature->packet].support = support;
+ remote_protocol_packets[feature->packet].support = support;
}
static void
rs->explicit_packet_size = packet_size;
}
-static void
-remote_multi_process_feature (const struct protocol_feature *feature,
- enum packet_support support, const char *value)
-{
- struct remote_state *rs = get_remote_state ();
-
- rs->multi_process_aware = (support == PACKET_ENABLE);
-}
-
-static void
-remote_non_stop_feature (const struct protocol_feature *feature,
- enum packet_support support, const char *value)
-{
- struct remote_state *rs = get_remote_state ();
-
- rs->non_stop_aware = (support == PACKET_ENABLE);
-}
-
-static void
-remote_cond_tracepoint_feature (const struct protocol_feature *feature,
- enum packet_support support,
- const char *value)
-{
- struct remote_state *rs = get_remote_state ();
-
- rs->cond_tracepoints = (support == PACKET_ENABLE);
-}
-
-static void
-remote_cond_breakpoint_feature (const struct protocol_feature *feature,
- enum packet_support support,
- const char *value)
-{
- struct remote_state *rs = get_remote_state ();
-
- rs->cond_breakpoints = (support == PACKET_ENABLE);
-}
-
-static void
-remote_breakpoint_commands_feature (const struct protocol_feature *feature,
- enum packet_support support,
- const char *value)
-{
- struct remote_state *rs = get_remote_state ();
-
- rs->breakpoint_commands = (support == PACKET_ENABLE);
-}
-
-static void
-remote_fast_tracepoint_feature (const struct protocol_feature *feature,
- enum packet_support support,
- const char *value)
-{
- struct remote_state *rs = get_remote_state ();
-
- rs->fast_tracepoints = (support == PACKET_ENABLE);
-}
-
-static void
-remote_static_tracepoint_feature (const struct protocol_feature *feature,
- enum packet_support support,
- const char *value)
-{
- struct remote_state *rs = get_remote_state ();
-
- rs->static_tracepoints = (support == PACKET_ENABLE);
-}
-
-static void
-remote_install_in_trace_feature (const struct protocol_feature *feature,
- enum packet_support support,
- const char *value)
-{
- struct remote_state *rs = get_remote_state ();
-
- rs->install_in_trace = (support == PACKET_ENABLE);
-}
-
-static void
-remote_disconnected_tracing_feature (const struct protocol_feature *feature,
- enum packet_support support,
- const char *value)
-{
- struct remote_state *rs = get_remote_state ();
-
- rs->disconnected_tracing = (support == PACKET_ENABLE);
-}
-
-static void
-remote_enable_disable_tracepoint_feature (const struct protocol_feature *feature,
- enum packet_support support,
- const char *value)
-{
- struct remote_state *rs = get_remote_state ();
-
- rs->enable_disable_tracepoints = (support == PACKET_ENABLE);
-}
-
-static void
-remote_string_tracing_feature (const struct protocol_feature *feature,
- enum packet_support support,
- const char *value)
-{
- struct remote_state *rs = get_remote_state ();
-
- rs->string_tracing = (support == PACKET_ENABLE);
-}
-
-static void
-remote_augmented_libraries_svr4_read_feature
- (const struct protocol_feature *feature,
- enum packet_support support, const char *value)
-{
- struct remote_state *rs = get_remote_state ();
-
- rs->augmented_libraries_svr4_read = (support == PACKET_ENABLE);
-}
-
static const struct protocol_feature remote_protocol_features[] = {
{ "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
{ "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
{ "qXfer:libraries-svr4:read", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_libraries_svr4 },
{ "augmented-libraries-svr4-read", PACKET_DISABLE,
- remote_augmented_libraries_svr4_read_feature, -1 },
+ remote_supported_packet, PACKET_augmented_libraries_svr4_read_feature },
{ "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_memory_map },
{ "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
PACKET_QProgramSignals },
{ "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet,
PACKET_QStartNoAckMode },
- { "multiprocess", PACKET_DISABLE, remote_multi_process_feature, -1 },
- { "QNonStop", PACKET_DISABLE, remote_non_stop_feature, -1 },
+ { "multiprocess", PACKET_DISABLE, remote_supported_packet,
+ PACKET_multiprocess_feature },
+ { "QNonStop", PACKET_DISABLE, remote_supported_packet, PACKET_QNonStop },
{ "qXfer:siginfo:read", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_siginfo_read },
{ "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_siginfo_write },
- { "ConditionalTracepoints", PACKET_DISABLE, remote_cond_tracepoint_feature,
+ { "ConditionalTracepoints", PACKET_DISABLE, remote_supported_packet,
PACKET_ConditionalTracepoints },
- { "ConditionalBreakpoints", PACKET_DISABLE, remote_cond_breakpoint_feature,
+ { "ConditionalBreakpoints", PACKET_DISABLE, remote_supported_packet,
PACKET_ConditionalBreakpoints },
- { "BreakpointCommands", PACKET_DISABLE, remote_breakpoint_commands_feature,
+ { "BreakpointCommands", PACKET_DISABLE, remote_supported_packet,
PACKET_BreakpointCommands },
- { "FastTracepoints", PACKET_DISABLE, remote_fast_tracepoint_feature,
+ { "FastTracepoints", PACKET_DISABLE, remote_supported_packet,
PACKET_FastTracepoints },
- { "StaticTracepoints", PACKET_DISABLE, remote_static_tracepoint_feature,
+ { "StaticTracepoints", PACKET_DISABLE, remote_supported_packet,
PACKET_StaticTracepoints },
- {"InstallInTrace", PACKET_DISABLE, remote_install_in_trace_feature,
+ {"InstallInTrace", PACKET_DISABLE, remote_supported_packet,
PACKET_InstallInTrace},
- { "DisconnectedTracing", PACKET_DISABLE, remote_disconnected_tracing_feature,
- -1 },
+ { "DisconnectedTracing", PACKET_DISABLE, remote_supported_packet,
+ PACKET_DisconnectedTracing_feature },
{ "ReverseContinue", PACKET_DISABLE, remote_supported_packet,
PACKET_bc },
{ "ReverseStep", PACKET_DISABLE, remote_supported_packet,
PACKET_TracepointSource },
{ "QAllow", PACKET_DISABLE, remote_supported_packet,
PACKET_QAllow },
- { "EnableDisableTracepoints", PACKET_DISABLE,
- remote_enable_disable_tracepoint_feature, -1 },
+ { "EnableDisableTracepoints", PACKET_DISABLE, remote_supported_packet,
+ PACKET_EnableDisableTracepoints_feature },
{ "qXfer:fdpic:read", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_fdpic },
{ "qXfer:uib:read", PACKET_DISABLE, remote_supported_packet,
{ "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent},
{ "QTBuffer:size", PACKET_DISABLE,
remote_supported_packet, PACKET_QTBuffer_size},
- { "tracenz", PACKET_DISABLE,
- remote_string_tracing_feature, -1 },
+ { "tracenz", PACKET_DISABLE, remote_supported_packet, PACKET_tracenz_feature },
{ "Qbtrace:off", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_off },
{ "Qbtrace:bts", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_bts },
{ "qXfer:btrace:read", PACKET_DISABLE, remote_supported_packet,
containing no features. */
rs->buf[0] = 0;
- if (remote_protocol_packets[PACKET_qSupported].support != PACKET_DISABLE)
+ if (packet_support (PACKET_qSupported) != PACKET_DISABLE)
{
char *q = NULL;
struct cleanup *old_chain = make_cleanup (free_current_contents, &q);
/* Reset the target state; these things will be queried either by
remote_query_supported or as they are needed. */
- init_all_packet_configs ();
+ reset_all_packet_configs_support ();
rs->cached_wait_status = 0;
rs->explicit_packet_size = 0;
rs->noack_mode = 0;
- rs->multi_process_aware = 0;
rs->extended = extended_p;
- rs->non_stop_aware = 0;
rs->waiting_for_stop_reply = 0;
rs->ctrlc_pending_p = 0;
be chatty about it. */
static void
-extended_remote_attach_1 (struct target_ops *target, char *args, int from_tty)
+extended_remote_attach_1 (struct target_ops *target, const char *args,
+ int from_tty)
{
struct remote_state *rs = get_remote_state ();
int pid;
/* Remote PID can be freely equal to getpid, do not check it here the same
way as in other targets. */
- if (remote_protocol_packets[PACKET_vAttach].support == PACKET_DISABLE)
+ if (packet_support (PACKET_vAttach) == PACKET_DISABLE)
error (_("This target does not support attaching to a process"));
if (from_tty)
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- if (packet_ok (rs->buf,
- &remote_protocol_packets[PACKET_vAttach]) == PACKET_OK)
+ switch (packet_ok (rs->buf,
+ &remote_protocol_packets[PACKET_vAttach]))
{
+ case PACKET_OK:
if (!non_stop)
{
/* Save the reply for later. */
error (_("Attaching to %s failed with: %s"),
target_pid_to_str (pid_to_ptid (pid)),
rs->buf);
+ break;
+ case PACKET_UNKNOWN:
+ error (_("This target does not support attaching to a process"));
+ default:
+ error (_("Attaching to %s failed"),
+ target_pid_to_str (pid_to_ptid (pid)));
}
- else if (remote_protocol_packets[PACKET_vAttach].support == PACKET_DISABLE)
- error (_("This target does not support attaching to a process"));
- else
- error (_("Attaching to %s failed"),
- target_pid_to_str (pid_to_ptid (pid)));
set_current_inferior (remote_add_inferior (0, pid, 1));
}
static void
-extended_remote_attach (struct target_ops *ops, char *args, int from_tty)
+extended_remote_attach (struct target_ops *ops, const char *args, int from_tty)
{
extended_remote_attach_1 (ops, args, from_tty);
}
ptid_t nptid;
/* All (-1) threads of process. */
- nptid = ptid_build (ptid_get_pid (ptid), 0, -1);
+ nptid = ptid_build (ptid_get_pid (ptid), -1, 0);
p += xsnprintf (p, endp - p, ":");
p = write_ptid (p, endp, nptid);
char *p;
char *endp;
- if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN)
+ if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
remote_vcont_probe (rs);
- if (remote_protocol_packets[PACKET_vCont].support == PACKET_DISABLE)
+ if (packet_support (PACKET_vCont) == PACKET_DISABLE)
return 0;
p = rs->buf;
warning (_(" - Can't pass signal %d to target in reverse: ignored."),
siggnal);
- if (step
- && remote_protocol_packets[PACKET_bs].support == PACKET_DISABLE)
+ if (step && packet_support (PACKET_bs) == PACKET_DISABLE)
error (_("Remote reverse-step not supported."));
- if (!step
- && remote_protocol_packets[PACKET_bc].support == PACKET_DISABLE)
+ if (!step && packet_support (PACKET_bc) == PACKET_DISABLE)
error (_("Remote reverse-continue not supported."));
strcpy (buf, step ? "bs" : "bc");
char *p = rs->buf;
char *endp = rs->buf + get_remote_packet_size ();
- if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN)
+ if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
remote_vcont_probe (rs);
if (!rs->supports_vCont.t)
if (ptid_is_pid (ptid))
/* All (-1) threads of process. */
- nptid = ptid_build (ptid_get_pid (ptid), 0, -1);
+ nptid = ptid_build (ptid_get_pid (ptid), -1, 0);
else
{
/* Small optimization: if we already have a stop reply for
char regp[MAX_REGISTER_SIZE];
int i;
- if (remote_protocol_packets[PACKET_p].support == PACKET_DISABLE)
+ if (packet_support (PACKET_p) == PACKET_DISABLE)
return 0;
if (reg->pnum == -1)
gdb_byte buf[MAX_REGISTER_SIZE];
/* Make sure the entire registers array is valid. */
- switch (remote_protocol_packets[PACKET_P].support)
+ switch (packet_support (PACKET_P))
{
case PACKET_DISABLE:
case PACKET_SUPPORT_UNKNOWN:
gdb_byte regp[MAX_REGISTER_SIZE];
char *p;
- if (remote_protocol_packets[PACKET_P].support == PACKET_DISABLE)
+ if (packet_support (PACKET_P) == PACKET_DISABLE)
return 0;
if (reg->pnum == -1)
{
struct remote_state *rs = get_remote_state ();
- switch (remote_protocol_packets[PACKET_X].support)
+ switch (packet_support (PACKET_X))
{
case PACKET_DISABLE:
break;
/* Check whether the target supports binary download. */
check_binary_download (memaddr);
- switch (remote_protocol_packets[PACKET_X].support)
+ switch (packet_support (PACKET_X))
{
case PACKET_ENABLE:
packet_format = "X";
transferred in *XFERED_LEN. */
static enum target_xfer_status
-remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len,
- ULONGEST *xfered_len)
+remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len,
+ ULONGEST *xfered_len)
{
struct remote_state *rs = get_remote_state ();
int max_buf_size; /* Max size of packet output buffer. */
int todo;
int i;
- if (len == 0)
- return 0;
-
max_buf_size = get_memory_read_packet_size ();
/* The packet buffer will be large enough for the payload;
get_memory_packet_size ensures this. */
return TARGET_XFER_OK;
}
+/* Using the set of read-only target sections of remote, read live
+ read-only memory.
+
+ For interface/parameters/return description see target.h,
+ to_xfer_partial. */
+
+static enum target_xfer_status
+remote_xfer_live_readonly_partial (struct target_ops *ops, gdb_byte *readbuf,
+ ULONGEST memaddr, ULONGEST len,
+ ULONGEST *xfered_len)
+{
+ struct target_section *secp;
+ struct target_section_table *table;
+
+ secp = target_section_by_addr (ops, memaddr);
+ if (secp != NULL
+ && (bfd_get_section_flags (secp->the_bfd_section->owner,
+ secp->the_bfd_section)
+ & SEC_READONLY))
+ {
+ struct target_section *p;
+ ULONGEST memend = memaddr + len;
+
+ table = target_get_section_table (ops);
+
+ for (p = table->sections; p < table->sections_end; p++)
+ {
+ if (memaddr >= p->addr)
+ {
+ if (memend <= p->endaddr)
+ {
+ /* Entire transfer is within this section. */
+ return remote_read_bytes_1 (memaddr, readbuf, len,
+ xfered_len);
+ }
+ else if (memaddr >= p->endaddr)
+ {
+ /* This section ends before the transfer starts. */
+ continue;
+ }
+ else
+ {
+ /* This section overlaps the transfer. Just do half. */
+ len = p->endaddr - memaddr;
+ return remote_read_bytes_1 (memaddr, readbuf, len,
+ xfered_len);
+ }
+ }
+ }
+ }
+
+ return TARGET_XFER_EOF;
+}
+
+/* Similar to remote_read_bytes_1, but it reads from the remote stub
+ first if the requested memory is unavailable in traceframe.
+ Otherwise, fall back to remote_read_bytes_1. */
+
+static enum target_xfer_status
+remote_read_bytes (struct target_ops *ops, CORE_ADDR memaddr,
+ gdb_byte *myaddr, ULONGEST len, ULONGEST *xfered_len)
+{
+ if (len == 0)
+ return 0;
+
+ if (get_traceframe_number () != -1)
+ {
+ VEC(mem_range_s) *available;
+
+ /* If we fail to get the set of available memory, then the
+ target does not support querying traceframe info, and so we
+ attempt reading from the traceframe anyway (assuming the
+ target implements the old QTro packet then). */
+ if (traceframe_available_memory (&available, memaddr, len))
+ {
+ struct cleanup *old_chain;
+
+ old_chain = make_cleanup (VEC_cleanup(mem_range_s), &available);
+
+ if (VEC_empty (mem_range_s, available)
+ || VEC_index (mem_range_s, available, 0)->start != memaddr)
+ {
+ enum target_xfer_status res;
+
+ /* Don't read into the traceframe's available
+ memory. */
+ if (!VEC_empty (mem_range_s, available))
+ {
+ LONGEST oldlen = len;
+
+ len = VEC_index (mem_range_s, available, 0)->start - memaddr;
+ gdb_assert (len <= oldlen);
+ }
+
+ do_cleanups (old_chain);
+
+ /* This goes through the topmost target again. */
+ res = remote_xfer_live_readonly_partial (ops, myaddr, memaddr,
+ len, xfered_len);
+ if (res == TARGET_XFER_OK)
+ return TARGET_XFER_OK;
+ else
+ {
+ /* No use trying further, we know some memory starting
+ at MEMADDR isn't available. */
+ *xfered_len = len;
+ return TARGET_XFER_UNAVAILABLE;
+ }
+ }
+
+ /* Don't try to read more than how much is available, in
+ case the target implements the deprecated QTro packet to
+ cater for older GDBs (the target's knowledge of read-only
+ sections may be outdated by now). */
+ len = VEC_index (mem_range_s, available, 0)->length;
+
+ do_cleanups (old_chain);
+ }
+ }
+
+ return remote_read_bytes_1 (memaddr, myaddr, len, xfered_len);
+}
+
\f
/* Sends a packet with content determined by the printf format string
static int
remote_vkill (int pid, struct remote_state *rs)
{
- if (remote_protocol_packets[PACKET_vKill].support == PACKET_DISABLE)
+ if (packet_support (PACKET_vKill) == PACKET_DISABLE)
return -1;
/* Tell the remote target to detach. */
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- if (packet_ok (rs->buf,
- &remote_protocol_packets[PACKET_vKill]) == PACKET_OK)
- return 0;
- else if (remote_protocol_packets[PACKET_vKill].support == PACKET_DISABLE)
- return -1;
- else
- return 1;
+ switch (packet_ok (rs->buf,
+ &remote_protocol_packets[PACKET_vKill]))
+ {
+ case PACKET_OK:
+ return 0;
+ case PACKET_ERROR:
+ return 1;
+ case PACKET_UNKNOWN:
+ return -1;
+ default:
+ internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
+ }
}
static void
static int
extended_remote_supports_disable_randomization (struct target_ops *self)
{
- return (remote_protocol_packets[PACKET_QDisableRandomization].support
- == PACKET_ENABLE);
+ return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE;
}
static void
/* If the user has disabled vRun support, or we have detected that
support is not available, do not try it. */
- if (remote_protocol_packets[PACKET_vRun].support == PACKET_DISABLE)
+ if (packet_support (PACKET_vRun) == PACKET_DISABLE)
return -1;
strcpy (rs->buf, "vRun;");
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun]) == PACKET_OK)
+ switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun]))
{
+ case PACKET_OK:
/* We have a wait response. All is well. */
return 0;
- }
- else if (remote_protocol_packets[PACKET_vRun].support == PACKET_DISABLE)
- /* It wasn't disabled before, but it is now. */
- return -1;
- else
- {
+ case PACKET_UNKNOWN:
+ return -1;
+ case PACKET_ERROR:
if (remote_exec_file[0] == '\0')
error (_("Running the default executable on the remote target failed; "
"try \"set remote exec-file\"?"));
else
error (_("Running \"%s\" on the remote target failed"),
remote_exec_file);
+ default:
+ gdb_assert_not_reached (_("bad switch"));
}
}
fails, and the user has explicitly requested the Z support then
report an error, otherwise, mark it disabled and go on. */
- if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
+ if (packet_support (PACKET_Z0) != PACKET_DISABLE)
{
CORE_ADDR addr = bp_tgt->placed_address;
struct remote_state *rs;
CORE_ADDR addr = bp_tgt->placed_address;
struct remote_state *rs = get_remote_state ();
- if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
+ if (packet_support (PACKET_Z0) != PACKET_DISABLE)
{
char *p = rs->buf;
char *endbuf = rs->buf + get_remote_packet_size ();
char *p;
enum Z_packet_type packet = watchpoint_to_Z_packet (type);
- if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
+ if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
return 1;
/* Make sure the remote is pointing at the right process, if
char *p;
enum Z_packet_type packet = watchpoint_to_Z_packet (type);
- if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
+ if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
return -1;
/* Make sure the remote is pointing at the right process, if
gdbarch_remote_breakpoint_from_pc
(gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
- if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
+ if (packet_support (PACKET_Z1) == PACKET_DISABLE)
return -1;
/* Make sure the remote is pointing at the right process, if
char *p = rs->buf;
char *endbuf = rs->buf + get_remote_packet_size ();
- if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
+ if (packet_support (PACKET_Z1) == PACKET_DISABLE)
return -1;
/* Make sure the remote is pointing at the right process, if
unsigned long host_crc, target_crc;
char *tmp;
- /* Make sure the remote is pointing at the right process. */
- set_general_process ();
+ /* 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)
+ {
+ enum packet_result result;
- /* FIXME: assumes lma can fit into long. */
- xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
- (long) lma, (long) size);
- putpkt (rs->buf);
+ /* Make sure the remote is pointing at the right process. */
+ set_general_process ();
- /* Be clever; compute the host_crc before waiting for target
- reply. */
- host_crc = xcrc32 (data, size, 0xffffffff);
+ /* FIXME: assumes lma can fit into long. */
+ xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
+ (long) lma, (long) size);
+ putpkt (rs->buf);
- getpkt (&rs->buf, &rs->buf_size, 0);
- if (rs->buf[0] == 'E')
- return -1;
+ /* Be clever; compute the host_crc before waiting for target
+ reply. */
+ host_crc = xcrc32 (data, size, 0xffffffff);
- if (rs->buf[0] != 'C')
- error (_("remote target does not support this operation"));
+ getpkt (&rs->buf, &rs->buf_size, 0);
+
+ result = packet_ok (rs->buf,
+ &remote_protocol_packets[PACKET_qCRC]);
+ if (result == PACKET_ERROR)
+ return -1;
+ else if (result == PACKET_OK)
+ {
+ for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
+ target_crc = target_crc * 16 + fromhex (*tmp);
- for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
- target_crc = target_crc * 16 + fromhex (*tmp);
+ return (host_crc == target_crc);
+ }
+ }
- return (host_crc == target_crc);
+ return simple_verify_memory (ops, data, lma, size);
}
/* compare-sections command
int matched = 0;
int mismatched = 0;
int res;
+ int read_only = 0;
if (!exec_bfd)
error (_("command cannot be used without an exec file"));
/* Make sure the remote is pointing at the right process. */
set_general_process ();
+ if (args != NULL && strcmp (args, "-r") == 0)
+ {
+ read_only = 1;
+ args = NULL;
+ }
+
for (s = exec_bfd->sections; s; s = s->next)
{
if (!(s->flags & SEC_LOAD))
continue; /* Skip non-loadable section. */
+ if (read_only && (s->flags & SEC_READONLY) == 0)
+ continue; /* Skip writeable sections */
+
size = bfd_get_section_size (s);
if (size == 0)
continue; /* Skip zero-length section. */
do_cleanups (old_chain);
}
if (mismatched > 0)
- warning (_("One or more sections of the remote executable does not match\n\
+ warning (_("One or more sections of the target image does not match\n\
the loaded file\n"));
if (args && !matched)
printf_filtered (_("No loaded section named '%s'.\n"), args);
if (writebuf != NULL)
return remote_write_bytes (offset, writebuf, len, xfered_len);
else
- return remote_read_bytes (offset, readbuf, len, xfered_len);
+ return remote_read_bytes (ops, offset, readbuf, len, xfered_len);
}
/* Handle SPU memory using qxfer packets. */
/* If we already know the packet isn't supported, fall back to the simple
way of searching memory. */
- if (packet->support == PACKET_DISABLE)
+ if (packet_config_support (packet) == PACKET_DISABLE)
{
/* Target doesn't provided special support, fall back and use the
standard support (copy memory and do the search here). */
{
int sample_thread = SAMPLE_THREAD;
int pid = ptid_get_pid (inferior_ptid);
- ptid_t ptid = ptid_build (pid, 0, sample_thread);
+ ptid_t ptid = ptid_build (pid, sample_thread, 0);
if (remote_thread_alive (ptid))
printf_filtered ("PASS: Thread alive test\n");
xsnprintf (buf, sizeof buf, "Thread <main>");
else if (rs->extended && remote_multi_process_p (rs))
xsnprintf (buf, sizeof buf, "Thread %d.%ld",
- ptid_get_pid (ptid), ptid_get_tid (ptid));
+ ptid_get_pid (ptid), ptid_get_lwp (ptid));
else
xsnprintf (buf, sizeof buf, "Thread %ld",
- ptid_get_tid (ptid));
+ ptid_get_lwp (ptid));
return buf;
}
}
remote_get_thread_local_address (struct target_ops *ops,
ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
{
- if (remote_protocol_packets[PACKET_qGetTLSAddr].support != PACKET_DISABLE)
+ if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
static int
remote_get_tib_address (struct target_ops *self, ptid_t ptid, CORE_ADDR *addr)
{
- if (remote_protocol_packets[PACKET_qGetTIBAddr].support != PACKET_DISABLE)
+ if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
/* Do not try this during initial connection, when we do not know
whether there is a running but stopped thread. */
if (!target_has_execution || ptid_equal (inferior_ptid, null_ptid))
- return NULL;
+ return target->beneath->to_read_description (target->beneath);
if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
{
an architecture, but it's too tricky to do safely. */
}
- return NULL;
+ return target->beneath->to_read_description (target->beneath);
}
/* Remote file transfer support. This is host-initiated I/O, not
char *attachment_tmp;
if (!rs->remote_desc
- || remote_protocol_packets[which_packet].support == PACKET_DISABLE)
+ || packet_support (which_packet) == PACKET_DISABLE)
{
*remote_errno = FILEIO_ENOSYS;
return -1;
static int
remote_can_execute_reverse (struct target_ops *self)
{
- if (remote_protocol_packets[PACKET_bs].support == PACKET_ENABLE
- || remote_protocol_packets[PACKET_bc].support == PACKET_ENABLE)
+ if (packet_support (PACKET_bs) == PACKET_ENABLE
+ || packet_support (PACKET_bc) == PACKET_ENABLE)
return 1;
else
return 0;
static int
remote_supports_cond_tracepoints (void)
{
- struct remote_state *rs = get_remote_state ();
-
- return rs->cond_tracepoints;
+ return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE;
}
static int
remote_supports_cond_breakpoints (struct target_ops *self)
{
- struct remote_state *rs = get_remote_state ();
-
- return rs->cond_breakpoints;
+ return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE;
}
static int
remote_supports_fast_tracepoints (void)
{
- struct remote_state *rs = get_remote_state ();
-
- return rs->fast_tracepoints;
+ return packet_support (PACKET_FastTracepoints) == PACKET_ENABLE;
}
static int
remote_supports_static_tracepoints (void)
{
- struct remote_state *rs = get_remote_state ();
-
- return rs->static_tracepoints;
+ return packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE;
}
static int
remote_supports_install_in_trace (void)
{
- struct remote_state *rs = get_remote_state ();
-
- return rs->install_in_trace;
+ return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE;
}
static int
remote_supports_enable_disable_tracepoint (struct target_ops *self)
{
- struct remote_state *rs = get_remote_state ();
-
- return rs->enable_disable_tracepoints;
+ return (packet_support (PACKET_EnableDisableTracepoints_feature)
+ == PACKET_ENABLE);
}
static int
remote_supports_string_tracing (struct target_ops *self)
{
- struct remote_state *rs = get_remote_state ();
-
- return rs->string_tracing;
+ return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE;
}
static int
remote_can_run_breakpoint_commands (struct target_ops *self)
{
- struct remote_state *rs = get_remote_state ();
-
- return rs->breakpoint_commands;
+ return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE;
}
static void
}
}
- if (remote_protocol_packets[PACKET_TracepointSource].support
- == PACKET_ENABLE)
+ if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE)
{
if (b->addr_string)
{
sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2);
if (offset + sec_length + 1 > target_buf_size)
{
- if (remote_protocol_packets[PACKET_qXfer_traceframe_info].support
- != PACKET_ENABLE)
+ if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE)
warning (_("\
Too many sections for read-only sections definition packet."));
break;
volatile struct gdb_exception ex;
enum packet_result result;
- if (remote_protocol_packets[PACKET_qTStatus].support == PACKET_DISABLE)
+ if (packet_support (PACKET_qTStatus) == PACKET_DISABLE)
return -1;
trace_regblock_size = get_remote_arch_state ()->sizeof_g_packet;
{
struct remote_state *rs = get_remote_state ();
- if (rs->disconnected_tracing)
+ if (packet_support (PACKET_DisconnectedTracing_feature) == PACKET_ENABLE)
{
char *reply;
}
static struct traceframe_info *
-remote_traceframe_info (void)
+remote_traceframe_info (struct target_ops *self)
{
char *text;
- /* If current traceframe is not selected, don't bother the remote
- stub. */
- if (get_traceframe_number () < 0)
- return NULL;
-
text = target_read_stralloc (¤t_target,
TARGET_OBJECT_TRACEFRAME_INFO, NULL);
if (text != NULL)
static void
remote_set_trace_buffer_size (struct target_ops *self, LONGEST val)
{
- if (remote_protocol_packets[PACKET_QTBuffer_size].support
- != PACKET_DISABLE)
+ if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE)
{
struct remote_state *rs = get_remote_state ();
char *buf = rs->buf;
}
static int
-remote_use_agent (int use)
+remote_use_agent (struct target_ops *self, int use)
{
- if (remote_protocol_packets[PACKET_QAgent].support != PACKET_DISABLE)
+ if (packet_support (PACKET_QAgent) != PACKET_DISABLE)
{
struct remote_state *rs = get_remote_state ();
}
static int
-remote_can_use_agent (void)
+remote_can_use_agent (struct target_ops *self)
{
- return (remote_protocol_packets[PACKET_QAgent].support != PACKET_DISABLE);
+ return (packet_support (PACKET_QAgent) != PACKET_DISABLE);
}
struct btrace_target_info
static int
remote_supports_btrace (struct target_ops *self)
{
- if (remote_protocol_packets[PACKET_Qbtrace_off].support != PACKET_ENABLE)
+ if (packet_support (PACKET_Qbtrace_off) != PACKET_ENABLE)
return 0;
- if (remote_protocol_packets[PACKET_Qbtrace_bts].support != PACKET_ENABLE)
+ if (packet_support (PACKET_Qbtrace_bts) != PACKET_ENABLE)
return 0;
- if (remote_protocol_packets[PACKET_qXfer_btrace].support != PACKET_ENABLE)
+ if (packet_support (PACKET_qXfer_btrace) != PACKET_ENABLE)
return 0;
return 1;
/* Enable branch tracing. */
static struct btrace_target_info *
-remote_enable_btrace (ptid_t ptid)
+remote_enable_btrace (struct target_ops *self, ptid_t ptid)
{
struct btrace_target_info *tinfo = NULL;
struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_bts];
char *buf = rs->buf;
char *endbuf = rs->buf + get_remote_packet_size ();
- if (packet->support != PACKET_ENABLE)
+ if (packet_config_support (packet) != PACKET_ENABLE)
error (_("Target does not support branch tracing."));
set_general_thread (ptid);
/* Disable branch tracing. */
static void
-remote_disable_btrace (struct btrace_target_info *tinfo)
+remote_disable_btrace (struct target_ops *self,
+ 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;
char *endbuf = rs->buf + get_remote_packet_size ();
- if (packet->support != PACKET_ENABLE)
+ if (packet_config_support (packet) != PACKET_ENABLE)
error (_("Target does not support branch tracing."));
set_general_thread (tinfo->ptid);
/* Teardown branch tracing. */
static void
-remote_teardown_btrace (struct btrace_target_info *tinfo)
+remote_teardown_btrace (struct target_ops *self,
+ struct btrace_target_info *tinfo)
{
/* We must not talk to the target during teardown. */
xfree (tinfo);
/* Read the branch trace. */
static enum btrace_error
-remote_read_btrace (VEC (btrace_block_s) **btrace,
+remote_read_btrace (struct target_ops *self,
+ VEC (btrace_block_s) **btrace,
struct btrace_target_info *tinfo,
enum btrace_read_type type)
{
const char *annex;
char *xml;
- if (packet->support != PACKET_ENABLE)
+ if (packet_config_support (packet) != PACKET_ENABLE)
error (_("Target does not support branch tracing."));
#if !defined(HAVE_LIBEXPAT)
}
static int
-remote_augmented_libraries_svr4_read (void)
+remote_augmented_libraries_svr4_read (struct target_ops *self)
{
- struct remote_state *rs = get_remote_state ();
-
- return rs->augmented_libraries_svr4_read;
+ return (packet_support (PACKET_augmented_libraries_svr4_read_feature)
+ == PACKET_ENABLE);
}
/* Implementation of to_load. */
{
if (rs->remote_desc != NULL)
{
- if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN)
+ if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
remote_vcont_probe (rs);
- if (remote_protocol_packets[PACKET_vCont].support == PACKET_ENABLE
+ if (packet_support (PACKET_vCont) == PACKET_ENABLE
&& rs->supports_vCont.r)
return;
}
add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
Compare section data on target to the exec file.\n\
-Argument is a single section name (default: all loaded sections)."),
+Argument is a single section name (default: all loaded sections).\n\
+To compare only read-only loaded sections, specify the -r option."),
&cmdlist);
add_cmd ("packet", class_maintenance, packet_command, _("\
NULL, /* FIXME: i18n: */
&setlist, &showlist);
+ init_all_packet_configs ();
+
add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
"X", "binary-download", 1);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace],
"qXfer:btrace", "read-btrace", 0);
+ /* Assert that we've registered commands for all packet configs. */
+ {
+ int i;
+
+ for (i = 0; i < PACKET_MAX; i++)
+ {
+ /* Ideally all configs would have a command associated. Some
+ still don't though. */
+ int excepted;
+
+ switch (i)
+ {
+ case PACKET_QNonStop:
+ case PACKET_multiprocess_feature:
+ case PACKET_EnableDisableTracepoints_feature:
+ case PACKET_tracenz_feature:
+ case PACKET_DisconnectedTracing_feature:
+ case PACKET_augmented_libraries_svr4_read_feature:
+ case PACKET_qCRC:
+ /* Additions to this list need to be well justified:
+ pre-existing packets are OK; new packets are not. */
+ excepted = 1;
+ break;
+ default:
+ excepted = 0;
+ break;
+ }
+
+ /* 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));
+ }
+ }
+
/* Keep the old ``set remote Z-packet ...'' working. Each individual
Z sub-packet has its own set and show commands, but users may
have sets to this variable in their .gdbinit files (or in their
/* Eventually initialize fileio. See fileio.c */
initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
- /* Take advantage of the fact that the LWP field is not used, to tag
+ /* Take advantage of the fact that the TID field is not used, to tag
special ptids with it set to != 0. */
- magic_null_ptid = ptid_build (42000, 1, -1);
- not_sent_ptid = ptid_build (42000, 1, -2);
- any_thread_ptid = ptid_build (42000, 1, 0);
+ magic_null_ptid = ptid_build (42000, -1, 1);
+ not_sent_ptid = ptid_build (42000, -2, 1);
+ any_thread_ptid = ptid_build (42000, 0, 1);
target_buf_size = 2048;
target_buf = xmalloc (target_buf_size);
projects / deliverable / binutils-gdb.git / blobdiff