static void remote_async (void (*callback) (enum inferior_event_type event_type,
void *context), void *context);
-static int remote_async_mask (int new_mask);
-
static void remote_detach (struct target_ops *ops, char *args, int from_tty);
static void remote_interrupt (int signo);
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;
+
/* Nonzero if the user has pressed Ctrl-C, but the target hasn't
responded to that. */
int ctrlc_pending_p;
from = ul;
p = pp + 1;
- pp = unpack_varlen_hex (p, &ul);
+ unpack_varlen_hex (p, &ul);
to = ul;
org_to = to;
return 1;
}
-static void *
-init_remote_state (struct gdbarch *gdbarch)
+static int
+map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs)
{
int regnum, num_remote_regs, offset;
- struct remote_state *rs = get_remote_state_raw ();
- struct remote_arch_state *rsa;
struct packet_reg **remote_regs;
- rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
-
- /* Use the architecture to build a regnum<->pnum table, which will be
- 1:1 unless a feature set specifies otherwise. */
- rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,
- gdbarch_num_regs (gdbarch),
- struct packet_reg);
for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
{
- struct packet_reg *r = &rsa->regs[regnum];
+ struct packet_reg *r = ®s[regnum];
if (register_size (gdbarch, regnum) == 0)
/* Do not try to fetch zero-sized (placeholder) registers. */
number. */
remote_regs = alloca (gdbarch_num_regs (gdbarch)
- * sizeof (struct packet_reg *));
+ * sizeof (struct packet_reg *));
for (num_remote_regs = 0, regnum = 0;
regnum < gdbarch_num_regs (gdbarch);
regnum++)
- if (rsa->regs[regnum].pnum != -1)
- remote_regs[num_remote_regs++] = &rsa->regs[regnum];
+ if (regs[regnum].pnum != -1)
+ remote_regs[num_remote_regs++] = ®s[regnum];
qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
compare_pnums);
offset += register_size (gdbarch, remote_regs[regnum]->regnum);
}
+ return offset;
+}
+
+/* Given the architecture described by GDBARCH, return the remote
+ protocol register's number and the register's offset in the g/G
+ packets of GDB register REGNUM, in PNUM and POFFSET respectively.
+ If the target does not have a mapping for REGNUM, return false,
+ otherwise, return true. */
+
+int
+remote_register_number_and_offset (struct gdbarch *gdbarch, int regnum,
+ int *pnum, int *poffset)
+{
+ int sizeof_g_packet;
+ struct packet_reg *regs;
+ struct cleanup *old_chain;
+
+ gdb_assert (regnum < gdbarch_num_regs (gdbarch));
+
+ regs = xcalloc (gdbarch_num_regs (gdbarch), sizeof (struct packet_reg));
+ old_chain = make_cleanup (xfree, regs);
+
+ sizeof_g_packet = map_regcache_remote_table (gdbarch, regs);
+
+ *pnum = regs[regnum].pnum;
+ *poffset = regs[regnum].offset;
+
+ do_cleanups (old_chain);
+
+ return *pnum != -1;
+}
+
+static void *
+init_remote_state (struct gdbarch *gdbarch)
+{
+ struct remote_state *rs = get_remote_state_raw ();
+ struct remote_arch_state *rsa;
+
+ rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
+
+ /* Use the architecture to build a regnum<->pnum table, which will be
+ 1:1 unless a feature set specifies otherwise. */
+ rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,
+ gdbarch_num_regs (gdbarch),
+ struct packet_reg);
+
/* Record the maximum possible size of the g packet - it may turn out
to be smaller. */
- rsa->sizeof_g_packet = offset;
+ rsa->sizeof_g_packet = map_regcache_remote_table (gdbarch, rsa->regs);
/* Default maximum number of characters in a packet body. Many
remote stubs have a hardwired buffer size of 400 bytes
static struct target_ops extended_remote_ops;
-static int remote_async_mask_value = 1;
-
/* FIXME: cagney/1999-09-23: Even though getpkt was called with
``forever'' still use the normal timeout mechanism. This is
currently used by the ASYNC code to guarentee that target reads
PACKET_qXfer_osdata,
PACKET_qXfer_threads,
PACKET_qXfer_statictrace_read,
+ PACKET_qXfer_traceframe_info,
PACKET_qGetTIBAddr,
PACKET_qGetTLSAddr,
PACKET_qSupported,
static ptid_t general_thread;
static ptid_t continue_thread;
+/* This the traceframe which we last selected on the remote system.
+ It will be -1 if no traceframe is selected. */
+static int remote_traceframe_number = -1;
+
/* Find out if the stub attached to PID (and hence GDB should offer to
detach instead of killing it when bailing out). */
it can simply pass through to the inferior without reporting. */
static void
-remote_pass_signals (void)
+remote_pass_signals (int numsigs, unsigned char *pass_signals)
{
if (remote_protocol_packets[PACKET_QPassSignals].support != PACKET_DISABLE)
{
char *pass_packet, *p;
- int numsigs = (int) TARGET_SIGNAL_LAST;
int count = 0, i;
gdb_assert (numsigs < 256);
for (i = 0; i < numsigs; i++)
{
- if (signal_stop_state (i) == 0
- && signal_print_state (i) == 0
- && signal_pass_state (i) == 1)
+ if (pass_signals[i])
count++;
}
pass_packet = xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
p = pass_packet + strlen (pass_packet);
for (i = 0; i < numsigs; i++)
{
- if (signal_stop_state (i) == 0
- && signal_print_state (i) == 0
- && signal_pass_state (i) == 1)
+ if (pass_signals[i])
{
if (i >= 16)
*p++ = tohex (i >> 4);
}
}
-static void
-remote_notice_signals (ptid_t ptid)
-{
- /* Update the remote on signals to silently pass, if they've
- changed. */
- remote_pass_signals ();
-}
-
/* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
MINUS_ONE_PTID, set the thread to -1, so the stub returns the
thread. If GEN is set, set the general thread, if not, then set
/* Multi-process ptid. */
pp = unpack_varlen_hex (p + 1, &pid);
if (*pp != '.')
- error (_("invalid remote ptid: %s\n"), p);
+ error (_("invalid remote ptid: %s"), p);
p = pp;
pp = unpack_varlen_hex (p + 1, &tid);
struct thread_item item;
char *id;
+ struct gdb_xml_value *attr;
- id = VEC_index (gdb_xml_value_s, attributes, 0)->value;
+ id = xml_find_attribute (attributes, "id")->value;
item.ptid = read_ptid (id, NULL);
- if (VEC_length (gdb_xml_value_s, attributes) > 1)
- item.core = *(ULONGEST *) VEC_index (gdb_xml_value_s,
- attributes, 1)->value;
+ attr = xml_find_attribute (attributes, "core");
+ if (attr != NULL)
+ item.core = *(ULONGEST *) attr->value;
else
item.core = -1;
TARGET_OBJECT_THREADS, NULL);
struct cleanup *back_to = make_cleanup (xfree, xml);
+
if (xml && *xml)
{
- struct gdb_xml_parser *parser;
struct threads_parsing_context context;
- struct cleanup *clear_parsing_context;
-
- context.items = 0;
- /* Note: this parser cleanup is already guarded by BACK_TO
- above. */
- parser = gdb_xml_create_parser_and_cleanup (_("threads"),
- threads_elements,
- &context);
-
- gdb_xml_use_dtd (parser, "threads.dtd");
- clear_parsing_context
- = make_cleanup (clear_threads_parsing_context, &context);
+ context.items = NULL;
+ make_cleanup (clear_threads_parsing_context, &context);
- if (gdb_xml_parse (parser, xml) == 0)
+ if (gdb_xml_parse_quick (_("threads"), "threads.dtd",
+ threads_elements, xml, &context) == 0)
{
int i;
struct thread_item *item;
}
}
}
-
- do_cleanups (clear_parsing_context);
}
do_cleanups (back_to);
remote_desc = NULL;
/* We don't have a connection to the remote stub anymore. Get rid
- of all the inferiors and their threads we were controlling. */
- discard_all_inferiors ();
+ of all the inferiors and their threads we were controlling.
+ Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
+ will be unable to find the thread corresponding to (pid, 0, 0). */
inferior_ptid = null_ptid;
+ discard_all_inferiors ();
/* We're no longer interested in any of these events. */
discard_pending_stop_replies (-1);
return 0;
}
-/* Stub for catch_exception. */
-
-struct start_remote_args
-{
- int from_tty;
-
- /* The current target. */
- struct target_ops *target;
-
- /* Non-zero if this is an extended-remote target. */
- int extended_p;
-};
-
/* Send interrupt_sequence to remote target. */
static void
-send_interrupt_sequence ()
+send_interrupt_sequence (void)
{
if (interrupt_sequence_mode == interrupt_sequence_control_c)
serial_write (remote_desc, "\x03", 1);
}
static void
-remote_start_remote (struct ui_out *uiout, void *opaque)
+remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
{
- struct start_remote_args *args = opaque;
struct remote_state *rs = get_remote_state ();
struct packet_config *noack_config;
char *wait_status = NULL;
immediate_quit++; /* Allow user to interrupt it. */
- /* Ack any packet which the remote side has already sent. */
- serial_write (remote_desc, "+", 1);
-
if (interrupt_on_connect)
send_interrupt_sequence ();
+ /* Ack any packet which the remote side has already sent. */
+ serial_write (remote_desc, "+", 1);
+
/* The first packet we send to the target is the optional "supported
packets" request. If the target can answer this, it will tell us
which later probes to skip. */
rs->noack_mode = 1;
}
- if (args->extended_p)
+ if (extended_p)
{
/* Tell the remote that we are using the extended protocol. */
putpkt ("!");
/* On OSs where the list of libraries is global to all
processes, we fetch them early. */
if (gdbarch_has_global_solist (target_gdbarch))
- solib_add (NULL, args->from_tty, args->target, auto_solib_add);
+ solib_add (NULL, from_tty, target, auto_solib_add);
if (non_stop)
{
controlling. We default to adding them in the running state.
The '?' query below will then tell us about which threads are
stopped. */
- remote_threads_info (args->target);
+ remote_threads_info (target);
}
else if (rs->non_stop_aware)
{
{
if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
{
- if (!args->extended_p)
+ if (!extended_p)
error (_("The target is not running (try extended-remote?)"));
/* We're connected, but not running. Drop out before we
how to do it some other way, try again. This is not
supported for non-stop; it could be, but it is tricky if
there are no stopped threads when we connect. */
- if (remote_read_description_p (args->target)
+ if (remote_read_description_p (target)
&& gdbarch_target_desc (target_gdbarch) == NULL)
{
target_clear_description ();
rs->cached_wait_status = 1;
immediate_quit--;
- start_remote (args->from_tty); /* Initialize gdb process mechanisms. */
+ start_remote (from_tty); /* Initialize gdb process mechanisms. */
}
else
{
if (thread_count () == 0)
{
- if (!args->extended_p)
+ if (!extended_p)
error (_("The target is not running (try extended-remote?)"));
/* We're connected, but not running. Drop out before we
the stop reply queue. */
gdb_assert (wait_status == NULL);
- /* Update the remote on signals to silently pass, or more
- importantly, which to not ignore, in case a previous session
- had set some different set of signals to be ignored. */
- remote_pass_signals ();
+ /* Report all signals during attach/startup. */
+ remote_pass_signals (0, NULL);
}
/* If we connected to a live target, do some additional setup. */
struct minimal_symbol *sym;
int end;
+ /* The remote side has no concept of inferiors that aren't running
+ yet, it only knows about running processes. If we're connected
+ but our current inferior is not running, we should not invite the
+ remote target to request symbol lookups related to its
+ (unrelated) current process. */
+ if (!target_has_execution)
+ return;
+
if (remote_protocol_packets[PACKET_qSymbol].support == PACKET_DISABLE)
return;
- /* Make sure the remote is pointing at the right process. */
+ /* Make sure the remote is pointing at the right process. Note
+ there's no way to select "no process". */
set_general_process ();
/* Allocate a message buffer. We can't reuse the input buffer in RS,
/* If the target didn't like the packet, warn the user. Do not try
to undo the user's settings, that would just be maddening. */
if (strcmp (rs->buf, "OK") != 0)
- warning ("Remote refused setting permissions with: %s", rs->buf);
+ warning (_("Remote refused setting permissions with: %s"), rs->buf);
}
/* This type describes each known response to the qSupported
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 struct protocol_feature remote_protocol_features[] = {
{ "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
{ "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_osdata },
{ "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_threads },
+ { "qXfer:traceframe-info:read", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_traceframe_info },
{ "QPassSignals", PACKET_DISABLE, remote_supported_packet,
PACKET_QPassSignals },
{ "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet,
PACKET_TracepointSource },
{ "QAllow", PACKET_DISABLE, remote_supported_packet,
PACKET_QAllow },
+ { "EnableDisableTracepoints", PACKET_DISABLE,
+ remote_enable_disable_tracepoint_feature, -1 },
};
static char *remote_support_xml;
general_thread = not_sent_ptid;
continue_thread = not_sent_ptid;
+ remote_traceframe_number = -1;
/* Probe for ability to use "ThreadInfo" query, as required. */
use_threadinfo_query = 1;
all the ``target ....'' commands to share a common callback
function. See cli-dump.c. */
{
- struct gdb_exception ex;
- struct start_remote_args args;
-
- args.from_tty = from_tty;
- args.target = target;
- args.extended_p = extended_p;
+ volatile struct gdb_exception ex;
- ex = catch_exception (uiout, remote_start_remote, &args, RETURN_MASK_ALL);
+ TRY_CATCH (ex, RETURN_MASK_ALL)
+ {
+ remote_start_remote (from_tty, target, extended_p);
+ }
if (ex.reason < 0)
{
/* Pop the partially set up target - unless something else did
so we don't have any TID numbers the inferior will
understand. Make sure to only send forms that do not specify
a TID. */
- p = append_resumption (p, endp, minus_one_ptid, step, siggnal);
+ append_resumption (p, endp, minus_one_ptid, step, siggnal);
}
else if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
{
}
/* And continue others without a signal. */
- p = append_resumption (p, endp, ptid, /*step=*/ 0, TARGET_SIGNAL_0);
+ append_resumption (p, endp, ptid, /*step=*/ 0, TARGET_SIGNAL_0);
}
else
{
/* Scheduler locking; resume only PTID. */
- p = append_resumption (p, endp, ptid, step, siggnal);
+ append_resumption (p, endp, ptid, step, siggnal);
}
gdb_assert (strlen (rs->buf) < get_remote_packet_size ());
last_sent_signal = siggnal;
last_sent_step = step;
- /* Update the inferior on signals to silently pass, if they've changed. */
- remote_pass_signals ();
-
/* The vCont packet doesn't need to specify threads via Hc. */
/* No reverse support (yet) for vCont. */
if (execution_direction != EXEC_REVERSE)
{
/* We don't pass signals to the target in reverse exec mode. */
if (info_verbose && siggnal != TARGET_SIGNAL_0)
- warning (" - Can't pass signal %d to target in reverse: ignored.\n",
+ warning (_(" - Can't pass signal %d to target in reverse: ignored."),
siggnal);
if (step
nptid = ptid;
}
- p = write_ptid (p, endp, nptid);
+ write_ptid (p, endp, nptid);
}
/* In non-stop, we get an immediate OK reply. The stop reply will
process_g_packet (regcache);
}
+/* Make the remote selected traceframe match GDB's selected
+ traceframe. */
+
+static void
+set_remote_traceframe (void)
+{
+ int newnum;
+
+ if (remote_traceframe_number == get_traceframe_number ())
+ return;
+
+ /* Avoid recursion, remote_trace_find calls us again. */
+ remote_traceframe_number = get_traceframe_number ();
+
+ newnum = target_trace_find (tfind_number,
+ get_traceframe_number (), 0, 0, NULL);
+
+ /* Should not happen. If it does, all bets are off. */
+ if (newnum != get_traceframe_number ())
+ warning (_("could not set remote traceframe"));
+}
+
static void
remote_fetch_registers (struct target_ops *ops,
struct regcache *regcache, int regnum)
struct remote_arch_state *rsa = get_remote_arch_state ();
int i;
+ set_remote_traceframe ();
set_general_thread (inferior_ptid);
if (regnum >= 0)
struct remote_arch_state *rsa = get_remote_arch_state ();
int i;
+ set_remote_traceframe ();
set_general_thread (inferior_ptid);
if (regnum >= 0)
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog,
- "binary downloading suppported by target\n");
+ "binary downloading supported by target\n");
remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
}
break;
Returns number of bytes transferred, or 0 (setting errno) for
error. Only transfer a single packet. */
-int
+static int
remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
{
char *packet_format = 0;
Returns number of bytes transferred, or 0 for error. */
-/* NOTE: cagney/1999-10-18: This function (and its siblings in other
- remote targets) shouldn't attempt to read the entire buffer.
- Instead it should read a single packet worth of data and then
- return the byte size of that packet to the caller. The caller (its
- caller and its callers caller ;-) already contains code for
- handling partial reads. */
-
-int
+static int
remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
{
struct remote_state *rs = get_remote_state ();
int max_buf_size; /* Max size of packet output buffer. */
- int origlen;
+ char *p;
+ int todo;
+ int i;
if (len <= 0)
return 0;
/* The packet buffer will be large enough for the payload;
get_memory_packet_size ensures this. */
- origlen = len;
- while (len > 0)
- {
- char *p;
- int todo;
- int i;
-
- todo = min (len, max_buf_size / 2); /* num bytes that will fit. */
-
- /* construct "m"<memaddr>","<len>" */
- /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
- memaddr = remote_address_masked (memaddr);
- p = rs->buf;
- *p++ = 'm';
- p += hexnumstr (p, (ULONGEST) memaddr);
- *p++ = ',';
- p += hexnumstr (p, (ULONGEST) todo);
- *p = '\0';
-
- putpkt (rs->buf);
- getpkt (&rs->buf, &rs->buf_size, 0);
-
- if (rs->buf[0] == 'E'
- && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
- && rs->buf[3] == '\0')
- {
- /* There is no correspondance between what the remote
- protocol uses for errors and errno codes. We would like
- a cleaner way of representing errors (big enough to
- include errno codes, bfd_error codes, and others). But
- for now just return EIO. */
- errno = EIO;
- return 0;
- }
-
- /* Reply describes memory byte by byte,
- each byte encoded as two hex characters. */
+ /* Number if bytes that will fit. */
+ todo = min (len, max_buf_size / 2);
- p = rs->buf;
- if ((i = hex2bin (p, myaddr, todo)) < todo)
- {
- /* Reply is short. This means that we were able to read
- only part of what we wanted to. */
- return i + (origlen - len);
- }
- myaddr += todo;
- memaddr += todo;
- len -= todo;
+ /* Construct "m"<memaddr>","<len>". */
+ memaddr = remote_address_masked (memaddr);
+ p = rs->buf;
+ *p++ = 'm';
+ p += hexnumstr (p, (ULONGEST) memaddr);
+ *p++ = ',';
+ p += hexnumstr (p, (ULONGEST) todo);
+ *p = '\0';
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ if (rs->buf[0] == 'E'
+ && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
+ && rs->buf[3] == '\0')
+ {
+ /* There is no correspondance between what the remote protocol
+ uses for errors and errno codes. We would like a cleaner way
+ of representing errors (big enough to include errno codes,
+ bfd_error codes, and others). But for now just return
+ EIO. */
+ errno = EIO;
+ return 0;
}
- return origlen;
+ /* Reply describes memory byte by byte, each byte encoded as two hex
+ characters. */
+ p = rs->buf;
+ i = hex2bin (p, myaddr, todo);
+ /* Return what we have. Let higher layers handle partial reads. */
+ return i;
}
\f
{
int res;
+ set_remote_traceframe ();
set_general_thread (inferior_ptid);
if (should_write)
case '-':
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "Nak\n");
+ /* FALLTHROUGH */
case SERIAL_TIMEOUT:
tcount++;
if (tcount > 3)
char *p2;
char query_type;
+ set_remote_traceframe ();
set_general_thread (inferior_ptid);
rs = get_remote_state ();
return remote_read_qxfer (ops, "threads", annex, readbuf, offset, len,
&remote_protocol_packets[PACKET_qXfer_threads]);
+ case TARGET_OBJECT_TRACEFRAME_INFO:
+ gdb_assert (annex == NULL);
+ return remote_read_qxfer
+ (ops, "traceframe-info", annex, readbuf, offset, len,
+ &remote_protocol_packets[PACKET_qXfer_traceframe_info]);
default:
return -1;
}
return rs->static_tracepoints;
}
+static int
+remote_supports_enable_disable_tracepoint (void)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ return rs->enable_disable_tracepoints;
+}
+
static void
remote_trace_init (void)
{
error (_("Error on target while downloading trace state variable."));
}
+static void
+remote_enable_tracepoint (struct bp_location *location)
+{
+ struct remote_state *rs = get_remote_state ();
+ char addr_buf[40];
+
+ sprintf_vma (addr_buf, location->address);
+ sprintf (rs->buf, "QTEnable:%x:%s", location->owner->number, addr_buf);
+ putpkt (rs->buf);
+ remote_get_noisy_reply (&rs->buf, &rs->buf_size);
+ if (*rs->buf == '\0')
+ error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
+ if (strcmp (rs->buf, "OK") != 0)
+ error (_("Error on target while enabling tracepoint."));
+}
+
+static void
+remote_disable_tracepoint (struct bp_location *location)
+{
+ struct remote_state *rs = get_remote_state ();
+ char addr_buf[40];
+
+ sprintf_vma (addr_buf, location->address);
+ sprintf (rs->buf, "QTDisable:%x:%s", location->owner->number, addr_buf);
+ putpkt (rs->buf);
+ remote_get_noisy_reply (&rs->buf, &rs->buf_size);
+ if (*rs->buf == '\0')
+ error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
+ if (strcmp (rs->buf, "OK") != 0)
+ error (_("Error on target while disabling tracepoint."));
+}
+
static void
remote_trace_set_readonly_regions (void)
{
char *p, *reply;
int target_frameno = -1, target_tracept = -1;
+ /* Lookups other than by absolute frame number depend on the current
+ trace selected, so make sure it is correct on the remote end
+ first. */
+ if (type != tfind_number)
+ set_remote_traceframe ();
+
p = rs->buf;
strcpy (p, "QTFrame:");
p = strchr (p, '\0');
target_frameno = (int) strtol (p, &reply, 16);
if (reply == p)
error (_("Unable to parse trace frame number"));
+ /* Don't update our remote traceframe number cache on failure
+ to select a remote traceframe. */
if (target_frameno == -1)
return -1;
break;
}
if (tpp)
*tpp = target_tracept;
+
+ remote_traceframe_number = target_frameno;
return target_frameno;
}
char *reply;
ULONGEST uval;
+ set_remote_traceframe ();
+
sprintf (rs->buf, "qTV:%x", tsvnum);
putpkt (rs->buf);
reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
error (_("Bogus reply from target: %s"), reply);
}
+static struct traceframe_info *
+remote_traceframe_info (void)
+{
+ char *text;
+
+ text = target_read_stralloc (¤t_target,
+ TARGET_OBJECT_TRACEFRAME_INFO, NULL);
+ if (text != NULL)
+ {
+ struct traceframe_info *info;
+ struct cleanup *back_to = make_cleanup (xfree, text);
+
+ info = parse_traceframe_info (text);
+ do_cleanups (back_to);
+ return info;
+ }
+
+ return NULL;
+}
+
static void
init_remote_ops (void)
{
remote_ops.to_kill = remote_kill;
remote_ops.to_load = generic_load;
remote_ops.to_mourn_inferior = remote_mourn;
- remote_ops.to_notice_signals = remote_notice_signals;
+ remote_ops.to_pass_signals = remote_pass_signals;
remote_ops.to_thread_alive = remote_thread_alive;
remote_ops.to_find_new_threads = remote_threads_info;
remote_ops.to_pid_to_str = remote_pid_to_str;
remote_ops.to_can_async_p = remote_can_async_p;
remote_ops.to_is_async_p = remote_is_async_p;
remote_ops.to_async = remote_async;
- remote_ops.to_async_mask = remote_async_mask;
remote_ops.to_terminal_inferior = remote_terminal_inferior;
remote_ops.to_terminal_ours = remote_terminal_ours;
remote_ops.to_supports_non_stop = remote_supports_non_stop;
remote_ops.to_supports_multi_process = remote_supports_multi_process;
+ remote_ops.to_supports_enable_disable_tracepoint = remote_supports_enable_disable_tracepoint;
remote_ops.to_trace_init = remote_trace_init;
remote_ops.to_download_tracepoint = remote_download_tracepoint;
remote_ops.to_download_trace_state_variable
= remote_download_trace_state_variable;
+ remote_ops.to_enable_tracepoint = remote_enable_tracepoint;
+ remote_ops.to_disable_tracepoint = remote_disable_tracepoint;
remote_ops.to_trace_set_readonly_regions = remote_trace_set_readonly_regions;
remote_ops.to_trace_start = remote_trace_start;
remote_ops.to_get_trace_status = remote_get_trace_status;
= remote_static_tracepoint_marker_at;
remote_ops.to_static_tracepoint_markers_by_strid
= remote_static_tracepoint_markers_by_strid;
+ remote_ops.to_traceframe_info = remote_traceframe_info;
}
/* Set up the extended remote vector by making a copy of the standard
return 0;
/* We're async whenever the serial device is. */
- return remote_async_mask_value && serial_can_async_p (remote_desc);
+ return serial_can_async_p (remote_desc);
}
static int
return 0;
/* We're async whenever the serial device is. */
- return remote_async_mask_value && serial_is_async_p (remote_desc);
+ return serial_is_async_p (remote_desc);
}
/* Pass the SERIAL event on and up to the client. One day this code
remote_async (void (*callback) (enum inferior_event_type event_type,
void *context), void *context)
{
- if (remote_async_mask_value == 0)
- internal_error (__FILE__, __LINE__,
- _("Calling remote_async when async is masked"));
-
if (callback != NULL)
{
serial_async (remote_desc, remote_async_serial_handler, NULL);
serial_async (remote_desc, NULL, NULL);
}
-static int
-remote_async_mask (int new_mask)
-{
- int curr_mask = remote_async_mask_value;
-
- remote_async_mask_value = new_mask;
- return curr_mask;
-}
-
static void
set_remote_cmd (char *args, int from_tty)
{
sigint_remote_token =
create_async_signal_handler (async_remote_interrupt, NULL);
sigint_remote_twice_token =
- create_async_signal_handler (inferior_event_handler_wrapper, NULL);
+ create_async_signal_handler (async_remote_interrupt_twice, NULL);
#if 0
init_remote_threadtests ();
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write],
"qXfer:siginfo:write", "write-siginfo-object", 0);
+ add_packet_config_cmd
+ (&remote_protocol_packets[PACKET_qXfer_traceframe_info],
+ "qXfer:trace-frame-info:read", "traceframe-info", 0);
+
add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
"qGetTLSAddr", "get-thread-local-storage-address",
0);
projects / deliverable / binutils-gdb.git / blobdiff