#include <ctype.h>
#include <fcntl.h>
#include "inferior.h"
+#include "infrun.h"
#include "bfd.h"
#include "symfile.h"
#include "exceptions.h"
static void init_extended_remote_ops (void);
-static void remote_stop (ptid_t);
+static void remote_stop (struct target_ops *self, ptid_t);
static int stubhex (int ch);
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,
static char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
static ptid_t read_ptid (char *buf, char **obuf);
-static void remote_set_permissions (void);
+static void remote_set_permissions (struct target_ops *self);
struct remote_state;
-static int remote_get_trace_status (struct trace_status *ts);
+static int remote_get_trace_status (struct target_ops *self,
+ struct trace_status *ts);
-static int remote_upload_tracepoints (struct uploaded_tp **utpp);
+static int remote_upload_tracepoints (struct target_ops *self,
+ struct uploaded_tp **utpp);
-static int remote_upload_trace_state_variables (struct uploaded_tsv **utsvp);
+static int remote_upload_trace_state_variables (struct target_ops *self,
+ struct uploaded_tsv **utsvp);
static void remote_query_supported (void);
static void remote_async_inferior_event_handler (gdb_client_data);
-static void remote_terminal_ours (void);
+static void remote_terminal_ours (struct target_ops *self);
static int remote_read_description_p (struct target_ops *target);
static void remote_console_output (char *msg);
-static int remote_supports_cond_breakpoints (void);
+static int remote_supports_cond_breakpoints (struct target_ops *self);
-static int remote_can_run_breakpoint_commands (void);
+static int remote_can_run_breakpoint_commands (struct target_ops *self);
/* For "remote". */
/* 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))
it can simply pass through to the inferior without reporting. */
static void
-remote_pass_signals (int numsigs, unsigned char *pass_signals)
+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;
signals it should pass through to the inferior when detaching. */
static void
-remote_program_signals (int numsigs, unsigned char *signals)
+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);
*/
static char *
-remote_threads_extra_info (struct thread_info *tp)
+remote_threads_extra_info (struct target_ops *self, struct thread_info *tp)
{
struct remote_state *rs = get_remote_state ();
int result;
_("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)
{
\f
static int
-remote_static_tracepoint_marker_at (CORE_ADDR addr,
+remote_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR addr,
struct static_tracepoint_marker *marker)
{
struct remote_state *rs = get_remote_state ();
}
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;
/* Implement the to_get_ada_task_ptid function for the remote targets. */
static ptid_t
-remote_get_ada_task_ptid (long lwp, long thread)
+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
/* Make sure we leave stdin registered in the event loop, and we
don't leave the async SIGINT signal handler installed. */
- remote_terminal_ours ();
+ remote_terminal_ours (self);
serial_close (rs->remote_desc);
rs->remote_desc = NULL;
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)
- remote_set_permissions ();
+ 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. */
/* Upload TSVs regardless of whether the target is running or not. The
remote stub, such as GDBserver, may have some predefined or builtin
TSVs, even if the target is not running. */
- if (remote_get_trace_status (current_trace_status ()) != -1)
+ if (remote_get_trace_status (target, current_trace_status ()) != -1)
{
struct uploaded_tsv *uploaded_tsvs = NULL;
- remote_upload_trace_state_variables (&uploaded_tsvs);
+ remote_upload_trace_state_variables (target, &uploaded_tsvs);
merge_uploaded_trace_state_variables (&uploaded_tsvs);
}
gdb_assert (wait_status == NULL);
/* Report all signals during attach/startup. */
- remote_pass_signals (0, NULL);
+ remote_pass_signals (target, 0, NULL);
}
/* If we connected to a live target, do some additional setup. */
/* Possibly the target has been engaged in a trace run started
previously; find out where things are at. */
- if (remote_get_trace_status (current_trace_status ()) != -1)
+ if (remote_get_trace_status (target, current_trace_status ()) != -1)
{
struct uploaded_tp *uploaded_tps = NULL;
if (current_trace_status ()->running)
printf_filtered (_("Trace is already running on the target.\n"));
- remote_upload_tracepoints (&uploaded_tps);
+ remote_upload_tracepoints (target, &uploaded_tps);
merge_uploaded_tracepoints (&uploaded_tps);
}
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. */
permissions. */
void
-remote_set_permissions (void)
+remote_set_permissions (struct target_ops *self)
{
struct remote_state *rs = get_remote_state ();
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;
/* 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));
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
will eventually end up here. */
static void
-remote_stop (ptid_t ptid)
+remote_stop (struct target_ops *self, ptid_t ptid)
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
is required. */
static void
-remote_terminal_inferior (void)
+remote_terminal_inferior (struct target_ops *self)
{
if (!target_async_permitted)
/* Nothing to do. */
}
static void
-remote_terminal_ours (void)
+remote_terminal_ours (struct target_ops *self)
{
if (!target_async_permitted)
/* Nothing to do. */
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 (void)
+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"));
}
}
target_async (inferior_event_handler, 0);
/* Disable address space randomization if requested (and supported). */
- if (extended_remote_supports_disable_randomization ())
+ if (extended_remote_supports_disable_randomization (ops))
extended_remote_disable_randomization (disable_randomization);
/* Now restart the remote server. */
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;
p += hexnumstr (p, addr);
xsnprintf (p, endbuf - p, ",%d", bpsize);
- if (remote_supports_cond_breakpoints ())
+ if (remote_supports_cond_breakpoints (ops))
remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
- if (remote_can_run_breakpoint_commands ())
+ if (remote_can_run_breakpoint_commands (ops))
remote_add_target_side_commands (gdbarch, bp_tgt, p);
putpkt (rs->buf);
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
int remote_hw_breakpoint_limit = -1;
static int
-remote_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
+remote_region_ok_for_hw_watchpoint (struct target_ops *self,
+ CORE_ADDR addr, int len)
{
if (remote_hw_watchpoint_length_limit == 0)
return 0;
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
p += hexnumstr (p, (ULONGEST) addr);
xsnprintf (p, endbuf - p, ",%x", bp_tgt->placed_size);
- if (remote_supports_cond_breakpoints ())
+ if (remote_supports_cond_breakpoints (self))
remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
- if (remote_can_run_breakpoint_commands ())
+ if (remote_can_run_breakpoint_commands (self))
remote_add_target_side_commands (gdbarch, bp_tgt, p);
putpkt (rs->buf);
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). */
}
static void
-remote_rcmd (char *command,
+remote_rcmd (struct target_ops *self, char *command,
struct ui_file *outbuf)
{
struct remote_state *rs = get_remote_state ();
{
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;
Returns 1 if ptid is found and thread_local_base is non zero. */
static int
-remote_get_tib_address (ptid_t ptid, CORE_ADDR *addr)
+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;
*REMOTE_ERRNO). */
static int
-remote_hostio_open (const char *filename, int flags, int mode,
+remote_hostio_open (struct target_ops *self,
+ const char *filename, int flags, int mode,
int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
set *REMOTE_ERRNO). */
static int
-remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
+remote_hostio_pwrite (struct target_ops *self,
+ int fd, const gdb_byte *write_buf, int len,
ULONGEST offset, int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
set *REMOTE_ERRNO). */
static int
-remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
+remote_hostio_pread (struct target_ops *self,
+ int fd, gdb_byte *read_buf, int len,
ULONGEST offset, int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
(and set *REMOTE_ERRNO). */
static int
-remote_hostio_close (int fd, int *remote_errno)
+remote_hostio_close (struct target_ops *self, int fd, int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
occurs (and set *REMOTE_ERRNO). */
static int
-remote_hostio_unlink (const char *filename, int *remote_errno)
+remote_hostio_unlink (struct target_ops *self,
+ const char *filename, int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
occurs (and set *REMOTE_ERRNO). */
static char *
-remote_hostio_readlink (const char *filename, int *remote_errno)
+remote_hostio_readlink (struct target_ops *self,
+ const char *filename, int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
int fd = *(int *) opaque;
int remote_errno;
- remote_hostio_close (fd, &remote_errno);
+ remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno);
}
gdb_assert (remote_filename_p (filename));
- fd = remote_hostio_open (filename + 7, FILEIO_O_RDONLY, 0, &remote_errno);
+ fd = remote_hostio_open (find_target_at (process_stratum),
+ filename + 7, FILEIO_O_RDONLY, 0, &remote_errno);
if (fd == -1)
{
errno = remote_fileio_errno_to_host (remote_errno);
/* Ignore errors on close; these may happen if the remote
connection was already torn down. */
- remote_hostio_close (fd, &remote_errno);
+ remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno);
/* Zero means success. */
return 0;
pos = 0;
while (nbytes > pos)
{
- bytes = remote_hostio_pread (fd, (gdb_byte *) buf + pos, nbytes - pos,
+ bytes = remote_hostio_pread (find_target_at (process_stratum),
+ fd, (gdb_byte *) buf + pos, nbytes - pos,
offset + pos, &remote_errno);
if (bytes == 0)
/* Success, but no bytes, means end-of-file. */
perror_with_name (local_file);
back_to = make_cleanup_fclose (file);
- fd = remote_hostio_open (remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
+ fd = remote_hostio_open (find_target_at (process_stratum),
+ remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
| FILEIO_O_TRUNC),
0700, &remote_errno);
if (fd == -1)
bytes += bytes_in_buffer;
bytes_in_buffer = 0;
- retcode = remote_hostio_pwrite (fd, buffer, bytes,
+ retcode = remote_hostio_pwrite (find_target_at (process_stratum),
+ fd, buffer, bytes,
offset, &remote_errno);
if (retcode < 0)
}
discard_cleanups (close_cleanup);
- if (remote_hostio_close (fd, &remote_errno))
+ if (remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno))
remote_hostio_error (remote_errno);
if (from_tty)
if (!rs->remote_desc)
error (_("command can only be used with remote target"));
- fd = remote_hostio_open (remote_file, FILEIO_O_RDONLY, 0, &remote_errno);
+ fd = remote_hostio_open (find_target_at (process_stratum),
+ remote_file, FILEIO_O_RDONLY, 0, &remote_errno);
if (fd == -1)
remote_hostio_error (remote_errno);
offset = 0;
while (1)
{
- bytes = remote_hostio_pread (fd, buffer, io_size, offset, &remote_errno);
+ bytes = remote_hostio_pread (find_target_at (process_stratum),
+ fd, buffer, io_size, offset, &remote_errno);
if (bytes == 0)
/* Success, but no bytes, means end-of-file. */
break;
}
discard_cleanups (close_cleanup);
- if (remote_hostio_close (fd, &remote_errno))
+ if (remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno))
remote_hostio_error (remote_errno);
if (from_tty)
if (!rs->remote_desc)
error (_("command can only be used with remote target"));
- retcode = remote_hostio_unlink (remote_file, &remote_errno);
+ retcode = remote_hostio_unlink (find_target_at (process_stratum),
+ remote_file, &remote_errno);
if (retcode == -1)
remote_hostio_error (remote_errno);
}
static int
-remote_can_execute_reverse (void)
+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_non_stop (void)
+remote_supports_non_stop (struct target_ops *self)
{
return 1;
}
static int
-remote_supports_disable_randomization (void)
+remote_supports_disable_randomization (struct target_ops *self)
{
/* Only supported in extended mode. */
return 0;
}
static int
-remote_supports_multi_process (void)
+remote_supports_multi_process (struct target_ops *self)
{
struct remote_state *rs = get_remote_state ();
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 (void)
+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 (void)
+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 (void)
+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 (void)
+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
-remote_trace_init (void)
+remote_trace_init (struct target_ops *self)
{
putpkt ("QTinit");
remote_get_noisy_reply (&target_buf, &target_buf_size);
}
static void
-remote_download_tracepoint (struct bp_location *loc)
+remote_download_tracepoint (struct target_ops *self, struct bp_location *loc)
{
#define BUF_SIZE 2048
}
}
- if (remote_protocol_packets[PACKET_TracepointSource].support
- == PACKET_ENABLE)
+ if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE)
{
if (b->addr_string)
{
}
static int
-remote_can_download_tracepoint (void)
+remote_can_download_tracepoint (struct target_ops *self)
{
struct remote_state *rs = get_remote_state ();
struct trace_status *ts;
return 0;
ts = current_trace_status ();
- status = remote_get_trace_status (ts);
+ status = remote_get_trace_status (self, ts);
if (status == -1 || !ts->running_known || !ts->running)
return 0;
static void
-remote_download_trace_state_variable (struct trace_state_variable *tsv)
+remote_download_trace_state_variable (struct target_ops *self,
+ struct trace_state_variable *tsv)
{
struct remote_state *rs = get_remote_state ();
char *p;
}
static void
-remote_enable_tracepoint (struct bp_location *location)
+remote_enable_tracepoint (struct target_ops *self,
+ struct bp_location *location)
{
struct remote_state *rs = get_remote_state ();
char addr_buf[40];
}
static void
-remote_disable_tracepoint (struct bp_location *location)
+remote_disable_tracepoint (struct target_ops *self,
+ struct bp_location *location)
{
struct remote_state *rs = get_remote_state ();
char addr_buf[40];
}
static void
-remote_trace_set_readonly_regions (void)
+remote_trace_set_readonly_regions (struct target_ops *self)
{
asection *s;
bfd *abfd = NULL;
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;
}
static void
-remote_trace_start (void)
+remote_trace_start (struct target_ops *self)
{
putpkt ("QTStart");
remote_get_noisy_reply (&target_buf, &target_buf_size);
}
static int
-remote_get_trace_status (struct trace_status *ts)
+remote_get_trace_status (struct target_ops *self, struct trace_status *ts)
{
/* Initialize it just to avoid a GCC false warning. */
char *p = NULL;
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;
}
static void
-remote_get_tracepoint_status (struct breakpoint *bp,
+remote_get_tracepoint_status (struct target_ops *self, struct breakpoint *bp,
struct uploaded_tp *utp)
{
struct remote_state *rs = get_remote_state ();
}
static void
-remote_trace_stop (void)
+remote_trace_stop (struct target_ops *self)
{
putpkt ("QTStop");
remote_get_noisy_reply (&target_buf, &target_buf_size);
}
static int
-remote_trace_find (enum trace_find_type type, int num,
+remote_trace_find (struct target_ops *self,
+ enum trace_find_type type, int num,
CORE_ADDR addr1, CORE_ADDR addr2,
int *tpp)
{
}
static int
-remote_get_trace_state_variable_value (int tsvnum, LONGEST *val)
+remote_get_trace_state_variable_value (struct target_ops *self,
+ int tsvnum, LONGEST *val)
{
struct remote_state *rs = get_remote_state ();
char *reply;
}
static int
-remote_save_trace_data (const char *filename)
+remote_save_trace_data (struct target_ops *self, const char *filename)
{
struct remote_state *rs = get_remote_state ();
char *p, *reply;
not be unhappy if we don't get as much as we ask for. */
static LONGEST
-remote_get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len)
+remote_get_raw_trace_data (struct target_ops *self,
+ gdb_byte *buf, ULONGEST offset, LONGEST len)
{
struct remote_state *rs = get_remote_state ();
char *reply;
}
static void
-remote_set_disconnected_tracing (int val)
+remote_set_disconnected_tracing (struct target_ops *self, int val)
{
struct remote_state *rs = get_remote_state ();
- if (rs->disconnected_tracing)
+ if (packet_support (PACKET_DisconnectedTracing_feature) == PACKET_ENABLE)
{
char *reply;
}
static void
-remote_set_circular_trace_buffer (int val)
+remote_set_circular_trace_buffer (struct target_ops *self, int val)
{
struct remote_state *rs = get_remote_state ();
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)
length is unknown. */
static int
-remote_get_min_fast_tracepoint_insn_len (void)
+remote_get_min_fast_tracepoint_insn_len (struct target_ops *self)
{
struct remote_state *rs = get_remote_state ();
char *reply;
}
static void
-remote_set_trace_buffer_size (LONGEST val)
+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_set_trace_notes (const char *user, const char *notes,
+remote_set_trace_notes (struct target_ops *self,
+ const char *user, const char *notes,
const char *stop_notes)
{
struct remote_state *rs = get_remote_state ();
}
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. */
static void
-remote_load (char *name, int from_tty)
+remote_load (struct target_ops *self, char *name, int from_tty)
{
generic_load (name, from_tty);
}
collection. */
static int
-remote_upload_tracepoints (struct uploaded_tp **utpp)
+remote_upload_tracepoints (struct target_ops *self, struct uploaded_tp **utpp)
{
struct remote_state *rs = get_remote_state ();
char *p;
}
static int
-remote_upload_trace_state_variables (struct uploaded_tsv **utsvp)
+remote_upload_trace_state_variables (struct target_ops *self,
+ struct uploaded_tsv **utsvp)
{
struct remote_state *rs = get_remote_state ();
char *p;
{
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);