Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
- 2010 Free Software Foundation, Inc.
+ 2010, 2011 Free Software Foundation, Inc.
This file is part of GDB.
#include "ax.h"
#include "ax-gdb.h"
-/* temp hacks for tracepoint encoding migration */
+/* Temp hacks for tracepoint encoding migration. */
static char *target_buf;
static long target_buf_size;
/*static*/ void
/* 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 can continue running a trace while GDB is
disconnected. */
int disconnected_tracing;
{
char *buf;
- QUIT; /* allow user to bail out with ^C */
+ QUIT; /* Allow user to bail out with ^C. */
getpkt (buf_p, sizeof_buf, 0);
buf = *buf_p;
if (buf[0] == 'E')
else if (buf[0] == 'O' && buf[1] != 'K')
remote_console_output (buf + 1); /* 'O' message from stub */
else
- return buf; /* here's the actual reply */
+ return buf; /* Here's the actual reply. */
}
while (1);
}
to be smaller. */
rsa->sizeof_g_packet = offset;
- /* Default maximum number of characters in a packet body. Many
+ /* Default maximum number of characters in a packet body. Many
remote stubs have a hardwired buffer size of 400 bytes
(c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
as the maximum packet-size to ensure that the packet and an extra
rsa->actual_register_packet_size = 0;
/* Should rsa->sizeof_g_packet needs more space than the
- default, adjust the size accordingly. Remember that each byte is
- encoded as two characters. 32 is the overhead for the packet
- header / footer. NOTE: cagney/1999-10-26: I suspect that 8
+ default, adjust the size accordingly. Remember that each byte is
+ encoded as two characters. 32 is the overhead for the packet
+ header / footer. NOTE: cagney/1999-10-26: I suspect that 8
(``$NN:G...#NN'') is a better guess, the below has been padded a
little. */
if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
/* This variable sets the number of bits in an address that are to be
sent in a memory ("M" or "m") packet. Normally, after stripping
- leading zeros, the entire address would be sent. This variable
+ leading zeros, the entire address would be sent. This variable
restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
initial implementation of remote.c restricted the address sent in
memory packets to ``host::sizeof long'' bytes - (typically 32
return what_they_get;
}
-/* Update the size of a read/write packet. If they user wants
+/* Update the size of a read/write packet. If they user wants
something really big then do a sanity check. */
static void
\f
/* Generic configuration support for packets the stub optionally
- supports. Allows the user to specify the use of the packet as well
+ supports. Allows the user to specify the use of the packet as well
as allowing GDB to auto-detect support in the remote stub. */
enum packet_support
switch (config->detect)
{
case AUTO_BOOLEAN_AUTO:
- printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
+ printf_filtered (_("Support for the `%s' packet "
+ "is auto-detected, currently %s.\n"),
config->name, support);
break;
case AUTO_BOOLEAN_TRUE:
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 protocol `%s' (%s) packet",
+ show_doc = xstrprintf ("Show current use of remote "
+ "protocol `%s' (%s) packet",
name, title);
/* set/show TITLE-packet {auto,on,off} */
cmd_name = xstrprintf ("%s-packet", title);
add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
- &config->detect, set_doc, show_doc, NULL, /* help_doc */
+ &config->detect, set_doc,
+ show_doc, NULL, /* help_doc */
set_remote_protocol_packet_cmd,
show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist);
PACKET_qXfer_spu_write,
PACKET_qXfer_osdata,
PACKET_qXfer_threads,
+ PACKET_qXfer_statictrace_read,
PACKET_qGetTIBAddr,
PACKET_qGetTLSAddr,
PACKET_qSupported,
PACKET_qAttached,
PACKET_ConditionalTracepoints,
PACKET_FastTracepoints,
+ PACKET_StaticTracepoints,
PACKET_bc,
PACKET_bs,
PACKET_TracepointSource,
return;
}
}
- internal_error (__FILE__, __LINE__, "Could not find config for %s",
+ internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
c->name);
}
return;
}
}
- internal_error (__FILE__, __LINE__, "Could not find config for %s",
+ internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
c->name);
}
/* Call this function as a result of
1) A halt indication (T packet) containing a thread id
2) A direct query of currthread
- 3) Successful execution of set thread
- */
+ 3) Successful execution of set thread */
static void
record_currthread (ptid_t currthread)
typedef unsigned char threadref[OPAQUETHREADBYTES];
/* WARNING: This threadref data structure comes from the remote O.S.,
- libstub protocol encoding, and remote.c. it is not particularly
+ libstub protocol encoding, and remote.c. It is not particularly
changable. */
/* Right now, the internal structure is int. We want it to be bigger.
- Plan to fix this.
- */
+ Plan to fix this. */
typedef int gdb_threadref; /* Internal GDB thread reference. */
/* The volume of remote transfers can be limited by submitting
a mask containing bits specifying the desired information.
Use a union of these values as the 'selection' parameter to
- get_thread_info. FIXME: Make these TAG names more thread specific.
- */
+ get_thread_info. FIXME: Make these TAG names more thread specific. */
#define TAG_THREADID 1
#define TAG_EXISTS 2
}
/* Externally, threadrefs are 64 bits but internally, they are still
- ints. This is due to a mismatch of specifications. We would like
+ ints. This is due to a mismatch of specifications. We would like
to use 64bit thread references internally. This is an adapter
function. */
int result = 1;
/* Trancate result limit to be smaller than the packet size. */
- if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= get_remote_packet_size ())
+ if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10)
+ >= get_remote_packet_size ())
result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
getpkt (&rs->buf, &rs->buf_size, 0);
if (*rs->buf == '\0')
- *result_count = 0;
+ return 0;
else
*result_count =
parse_threadlist_response (rs->buf + 2, result_limit, &echo_nextthread,
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");
+ context.items = NULL;
+ make_cleanup (clear_threads_parsing_context, &context);
- clear_parsing_context
- = 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;
- for (i = 0; VEC_iterate (thread_item_t, context.items, i, item); ++i)
+ for (i = 0;
+ VEC_iterate (thread_item_t, context.items, i, item);
+ ++i)
{
if (!ptid_equal (item->ptid, null_ptid))
{
}
}
}
-
- do_cleanups (clear_parsing_context);
}
do_cleanups (back_to);
}
\f
+static int
+remote_static_tracepoint_marker_at (CORE_ADDR addr,
+ struct static_tracepoint_marker *marker)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *p = rs->buf;
+
+ sprintf (p, "qTSTMat:");
+ p += strlen (p);
+ p += hexnumstr (p, addr);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ p = rs->buf;
+
+ if (*p == 'E')
+ error (_("Remote failure reply: %s"), p);
+
+ if (*p++ == 'm')
+ {
+ parse_static_tracepoint_marker_definition (p, &p, marker);
+ return 1;
+ }
+
+ return 0;
+}
+
+static void
+free_current_marker (void *arg)
+{
+ struct static_tracepoint_marker **marker_p = arg;
+
+ if (*marker_p != NULL)
+ {
+ release_static_tracepoint_marker (*marker_p);
+ xfree (*marker_p);
+ }
+ else
+ *marker_p = NULL;
+}
+
+static VEC(static_tracepoint_marker_p) *
+remote_static_tracepoint_markers_by_strid (const char *strid)
+{
+ struct remote_state *rs = get_remote_state ();
+ VEC(static_tracepoint_marker_p) *markers = NULL;
+ struct static_tracepoint_marker *marker = NULL;
+ struct cleanup *old_chain;
+ char *p;
+
+ /* Ask for a first packet of static tracepoint marker
+ definition. */
+ putpkt ("qTfSTM");
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ p = rs->buf;
+ if (*p == 'E')
+ error (_("Remote failure reply: %s"), p);
+
+ old_chain = make_cleanup (free_current_marker, &marker);
+
+ while (*p++ == 'm')
+ {
+ if (marker == NULL)
+ marker = XCNEW (struct static_tracepoint_marker);
+
+ do
+ {
+ parse_static_tracepoint_marker_definition (p, &p, marker);
+
+ if (strid == NULL || strcmp (strid, marker->str_id) == 0)
+ {
+ VEC_safe_push (static_tracepoint_marker_p,
+ markers, marker);
+ marker = NULL;
+ }
+ else
+ {
+ release_static_tracepoint_marker (marker);
+ memset (marker, 0, sizeof (*marker));
+ }
+ }
+ while (*p++ == ','); /* comma-separated list */
+ /* Ask for another packet of static tracepoint definition. */
+ putpkt ("qTsSTM");
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ p = rs->buf;
+ }
+
+ do_cleanups (old_chain);
+ return markers;
+}
+
+\f
/* Implement the to_get_ada_task_ptid function for the remote targets. */
static ptid_t
offs, num_segments, segments);
if (ret == 0 && !do_sections)
- error (_("Can not handle qOffsets TextSeg response with this symbol file"));
+ error (_("Can not handle qOffsets TextSeg "
+ "response with this symbol file"));
if (ret > 0)
do_sections = 0;
{
offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
- /* This is a temporary kludge to force data and bss to use the same offsets
- because that's what nlmconv does now. The real solution requires changes
- to the stub and remote.c that I don't have time to do right now. */
+ /* This is a temporary kludge to force data and bss to use the
+ same offsets because that's what nlmconv does now. The real
+ solution requires changes to the stub and remote.c that I
+ don't have time to do right now. */
offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
if (non_stop)
{
if (!rs->non_stop_aware)
- error (_("Non-stop mode requested, but remote does not support non-stop"));
+ error (_("Non-stop mode requested, but remote "
+ "does not support non-stop"));
putpkt ("QNonStop:1");
getpkt (&rs->buf, &rs->buf_size, 0);
if (strcmp (rs->buf, "OK") != 0)
- error ("Remote refused setting non-stop mode with: %s", rs->buf);
+ error (_("Remote refused setting non-stop mode with: %s"), rs->buf);
/* Find about threads and processes the stub is already
controlling. We default to adding them in the running state.
getpkt (&rs->buf, &rs->buf_size, 0);
if (strcmp (rs->buf, "OK") != 0)
- error ("Remote refused setting all-stop mode with: %s", rs->buf);
+ error (_("Remote refused setting all-stop mode with: %s"), rs->buf);
}
/* Check whether the target is running now. */
to be. */
if (!udp_warning && strncmp (name, "udp:", 4) == 0)
{
- warning (_("\
-The remote protocol may be unreliable over UDP.\n\
-Some events may be lost, rendering further debugging impossible."));
+ warning (_("The remote protocol may be unreliable over UDP.\n"
+ "Some events may be lost, rendering further debugging "
+ "impossible."));
udp_warning = 1;
}
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_disconnected_tracing_feature (const struct protocol_feature *feature,
enum packet_support support,
PACKET_ConditionalTracepoints },
{ "FastTracepoints", PACKET_DISABLE, remote_fast_tracepoint_feature,
PACKET_FastTracepoints },
+ { "StaticTracepoints", PACKET_DISABLE, remote_static_tracepoint_feature,
+ PACKET_StaticTracepoints },
{ "DisconnectedTracing", PACKET_DISABLE, remote_disconnected_tracing_feature,
-1 },
{ "ReverseContinue", PACKET_DISABLE, remote_supported_packet,
break;
default:
- warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p);
+ warning (_("unrecognized item \"%s\" "
+ "in \"qSupported\" response"), p);
continue;
}
end[-1] = '\0';
static void
-remote_open_1 (char *name, int from_tty, struct target_ops *target, int extended_p)
+remote_open_1 (char *name, int from_tty,
+ struct target_ops *target, int extended_p)
{
struct remote_state *rs = get_remote_state ();
/* FIXME: cagney/1999-09-23: During the initial connection it is
assumed that the target is already ready and able to respond to
- requests. Unfortunately remote_start_remote() eventually calls
+ requests. Unfortunately remote_start_remote() eventually calls
wait_for_inferior() with no timeout. wait_forever_enabled_p gets
- around this. Eventually a mechanism that allows
+ around this. Eventually a mechanism that allows
wait_for_inferior() to expect/get timeouts will be
implemented. */
wait_forever_enabled_p = 0;
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vAttach]) == PACKET_OK)
+ if (packet_ok (rs->buf,
+ &remote_protocol_packets[PACKET_vAttach]) == PACKET_OK)
{
if (from_tty)
printf_unfiltered (_("Attached to %s\n"),
done:
/* We are about to start executing the inferior, let's register it
- with the event loop. NOTE: this is the one place where all the
- execution commands end up. We could alternatively do this in each
+ with the event loop. NOTE: this is the one place where all the
+ execution commands end up. We could alternatively do this in each
of the execution commands in infcmd.c. */
/* FIXME: ezannoni 1999-09-28: We may need to move this out of here
into infcmd.c in order to allow inferior function calls to work
target_stop (inferior_ptid);
}
-/* Perform interrupt, if the first attempt did not succeed. Just give
+/* Perform interrupt, if the first attempt did not succeed. Just give
up on the target alltogether. */
void
async_remote_interrupt_twice (gdb_client_data arg)
packet. */
static void (*ofunc) (int);
-/* The command line interface's stop routine. This function is installed
- as a signal handler for SIGINT. The first time a user requests a
- stop, we call remote_stop to send a break or ^C. If there is no
+/* The command line interface's stop routine. This function is installed
+ as a signal handler for SIGINT. The first time a user requests a
+ stop, we call remote_stop to send a break or ^C. If there is no
response from the target (it didn't stop when the user requested it),
we ask the user if he'd like to detach from the target. */
static void
send_interrupt_sequence ();
}
-/* This is the generic stop called via the target vector. When a target
+/* This is the generic stop called via the target vector. When a target
interrupt is requested, either by the command line or the GUI, we
will eventually end up here. */
if (p[0] == 0 || p[1] == 0)
/* This shouldn't happen - we adjusted sizeof_g_packet above. */
internal_error (__FILE__, __LINE__,
- "unexpected end of 'g' packet reply");
+ _("unexpected end of 'g' packet reply"));
if (p[0] == 'x' && p[1] == 'x')
regs[i] = 0; /* 'x' */
if (r->offset * 2 >= strlen (rs->buf))
/* This shouldn't happen - we adjusted in_g_packet above. */
internal_error (__FILE__, __LINE__,
- "unexpected end of 'g' packet reply");
+ _("unexpected end of 'g' packet reply"));
else if (rs->buf[r->offset * 2] == 'x')
{
gdb_assert (r->offset * 2 < strlen (rs->buf));
/* For now, don't complain if we have no way to write the
register. GDB loses track of unavailable registers too
easily. Some day, this may be an error. We don't have
- any way to read the register, either... */
+ any way to read the register, either... */
if (!reg->in_g_packet)
return;
remote_write_bytes.
NOTE: This can still lose if the serial line is not eight-bit
- clean. In cases like this, the user should clear "remote
+ clean. In cases like this, the user should clear "remote
X-packet". */
static void
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog,
- "binary downloading NOT suppported by target\n");
+ "binary downloading NOT "
+ "supported by target\n");
remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
}
else
if (packet_format != 'X' && packet_format != 'M')
internal_error (__FILE__, __LINE__,
- "remote_write_bytes_aux: bad packet format");
+ _("remote_write_bytes_aux: bad packet format"));
if (len <= 0)
return 0;
rs->buf[0] = '\0';
/* Compute the size of the actual payload by subtracting out the
- packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
- */
+ packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
+
payload_size -= strlen ("$,:#NN");
if (!use_length)
- /* The comma won't be used. */
+ /* The comma won't be used. */
payload_size += 1;
header_length = strlen (header);
payload_size -= header_length;
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);
+ /* Number if bytes that will fit. */
+ todo = min (len, max_buf_size / 2);
- 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. */
-
- 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
rs->buf[0] = '\0';
if (vsnprintf (rs->buf, max_size, format, ap) >= max_size)
- internal_error (__FILE__, __LINE__, "Too long remote packet.");
+ internal_error (__FILE__, __LINE__, _("Too long remote packet."));
if (putpkt (rs->buf) < 0)
error (_("Communication problem with target."));
error (_("Remote connection closed"));
/* no return */
case SERIAL_ERROR:
- perror_with_name (_("Remote communication error"));
+ pop_target ();
+ perror_with_name (_("Remote communication error. "
+ "Target disconnected."));
/* no return */
case SERIAL_TIMEOUT:
break;
str = escape_buffer (buf, bc);
old_chain = make_cleanup (xfree, str);
fprintf_unfiltered (gdb_stdlog,
- "\
-Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
+ "Bad checksum, sentsum=0x%x, "
+ "csum=0x%x, buf=%s\n",
pktcsum, csum, str);
do_cleanups (old_chain);
}
if (rs->buf[0] == 'S' || rs->buf[0] == 'T')
{
- /* Assume that the target has been restarted. Set inferior_ptid
- so that bits of core GDB realizes there's something here, e.g.,
- so that the user can say "kill" again. */
+ /* Assume that the target has been restarted. Set
+ inferior_ptid so that bits of core GDB realizes
+ there's something here, e.g., so that the user can
+ say "kill" again. */
inferior_ptid = magic_null_ptid;
}
}
}
static int
-remote_insert_watchpoint (CORE_ADDR addr, int len, int type)
+remote_insert_watchpoint (CORE_ADDR addr, int len, int type,
+ struct expression *cond)
{
struct remote_state *rs = get_remote_state ();
char *p;
static int
-remote_remove_watchpoint (CORE_ADDR addr, int len, int type)
+remote_remove_watchpoint (CORE_ADDR addr, int len, int type,
+ struct expression *cond)
{
struct remote_state *rs = get_remote_state ();
char *p;
for (s = exec_bfd->sections; s; s = s->next)
{
if (!(s->flags & SEC_LOAD))
- continue; /* skip non-loadable section */
+ continue; /* Skip non-loadable section. */
size = bfd_get_section_size (s);
if (size == 0)
- continue; /* skip zero-length section */
+ continue; /* Skip zero-length section. */
sectname = bfd_get_section_name (exec_bfd, s);
if (args && strcmp (args, sectname) != 0)
- continue; /* not the section selected by user */
+ continue; /* Not the section selected by user. */
- matched = 1; /* do this section */
+ matched = 1; /* Do this section. */
lma = s->lma;
sectdata = xmalloc (size);
return -1;
}
- /* Handle SPU memory using qxfer packets. */
+ /* Handle SPU memory using qxfer packets. */
if (object == TARGET_OBJECT_SPU)
{
if (readbuf)
&remote_protocol_packets
[PACKET_qXfer_siginfo_read]);
else
- return remote_write_qxfer (ops, "siginfo", annex, writebuf, offset, len,
+ return remote_write_qxfer (ops, "siginfo", annex,
+ writebuf, offset, len,
&remote_protocol_packets
[PACKET_qXfer_siginfo_write]);
}
+ if (object == TARGET_OBJECT_STATIC_TRACE_DATA)
+ {
+ if (readbuf)
+ return remote_read_qxfer (ops, "statictrace", annex,
+ readbuf, offset, len,
+ &remote_protocol_packets
+ [PACKET_qXfer_statictrace_read]);
+ else
+ return -1;
+ }
+
/* Only handle flash writes. */
if (writebuf != NULL)
{
buffer size. */
if (offset == 0 && len == 0)
return (get_remote_packet_size ());
- /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
+ /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
large enough let the caller deal with it. */
if (len < get_remote_packet_size ())
return -1;
int max_size = get_memory_write_packet_size ();
struct packet_config *packet =
&remote_protocol_packets[PACKET_qSearch_memory];
- /* number of packet bytes used to encode the pattern,
- this could be more than PATTERN_LEN due to escape characters */
+ /* Number of packet bytes used to encode the pattern;
+ this could be more than PATTERN_LEN due to escape characters. */
int escaped_pattern_len;
- /* amount of pattern that was encodable in the packet */
+ /* Amount of pattern that was encodable in the packet. */
int used_pattern_len;
int i;
int found;
/* Bail if the pattern is too large. */
if (used_pattern_len != pattern_len)
- error ("Pattern is too large to transmit to remote target.");
+ error (_("Pattern is too large to transmit to remote target."));
if (putpkt_binary (rs->buf, i + escaped_pattern_len) < 0
|| getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
strcpy (rs->buf, "qRcmd,");
p = strchr (rs->buf, '\0');
- if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ())
+ if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/)
+ > get_remote_packet_size ())
error (_("\"monitor\" command ``%s'' is too long."), command);
/* Encode the actual command. */
static void
init_remote_threadtests (void)
{
- add_com ("tlist", class_obscure, threadlist_test_cmd, _("\
-Fetch and print the remote list of thread identifiers, one pkt only"));
+ add_com ("tlist", class_obscure, threadlist_test_cmd,
+ _("Fetch and print the remote list of "
+ "thread identifiers, one pkt only"));
add_com ("tinfo", class_obscure, threadinfo_test_cmd,
_("Fetch and display info about one thread"));
add_com ("tset", class_obscure, threadset_test_cmd,
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_qGetTLSAddr]);
+ result = packet_ok (rs->buf,
+ &remote_protocol_packets[PACKET_qGetTLSAddr]);
if (result == PACKET_OK)
{
ULONGEST result;
ix++)
if (guess->bytes == bytes)
internal_error (__FILE__, __LINE__,
- "Duplicate g packet description added for size %d",
+ _("Duplicate g packet description added for size %d"),
bytes);
new_guess.bytes = bytes;
{
if (!saw_eof)
{
- bytes = fread (buffer + bytes_in_buffer, 1, io_size - bytes_in_buffer,
+ bytes = fread (buffer + bytes_in_buffer, 1,
+ io_size - bytes_in_buffer,
file);
if (bytes == 0)
{
bytes += bytes_in_buffer;
bytes_in_buffer = 0;
- retcode = remote_hostio_pwrite (fd, buffer, bytes, offset, &remote_errno);
+ retcode = remote_hostio_pwrite (fd, buffer, bytes,
+ offset, &remote_errno);
if (retcode < 0)
remote_hostio_error (remote_errno);
return rs->fast_tracepoints;
}
+static int
+remote_supports_static_tracepoints (void)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ return rs->static_tracepoints;
+}
+
static void
remote_trace_init (void)
{
for (cmd = cmds; cmd; cmd = cmd->next)
{
- QUIT; /* allow user to bail out with ^C */
+ QUIT; /* Allow user to bail out with ^C. */
strcpy (rs->buf, "QTDPsrc:");
encode_source_string (num, addr, "cmd", cmd->line,
rs->buf + strlen (rs->buf),
{
remote_download_command_source (num, addr, *cmd->body_list);
- QUIT; /* allow user to bail out with ^C */
+ QUIT; /* Allow user to bail out with ^C. */
strcpy (rs->buf, "QTDPsrc:");
encode_source_string (num, addr, "cmd", "end",
rs->buf + strlen (rs->buf),
encode_actions (t, loc, &tdp_actions, &stepping_actions);
old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
tdp_actions);
- (void) make_cleanup (free_actions_list_cleanup_wrapper, stepping_actions);
+ (void) make_cleanup (free_actions_list_cleanup_wrapper,
+ stepping_actions);
tpaddr = loc->address;
sprintf_vma (addrbuf, tpaddr);
/* If it passed validation at definition but fails now,
something is very wrong. */
internal_error (__FILE__, __LINE__,
- "Fast tracepoint not valid during download");
+ _("Fast tracepoint not "
+ "valid during download"));
}
else
/* Fast tracepoints are functionally identical to regular
tracepoints, so don't take lack of support as a reason to
give up on the trace run. */
- warning (_("Target does not support fast tracepoints, downloading %d as regular tracepoint"), t->number);
+ warning (_("Target does not support fast tracepoints, "
+ "downloading %d as regular tracepoint"), t->number);
+ }
+ else if (t->type == bp_static_tracepoint)
+ {
+ /* Only test for support at download time; we may not know
+ target capabilities at definition time. */
+ if (remote_supports_static_tracepoints ())
+ {
+ struct static_tracepoint_marker marker;
+
+ if (target_static_tracepoint_marker_at (tpaddr, &marker))
+ strcat (buf, ":S");
+ else
+ error (_("Static tracepoint not valid during download"));
+ }
+ else
+ /* Fast tracepoints are functionally identical to regular
+ tracepoints, so don't take lack of support as a reason
+ to give up on the trace run. */
+ error (_("Target does not support static tracepoints"));
}
/* If the tracepoint has a conditional, make it into an agent
expression and append to the definition. */
do_cleanups (aexpr_chain);
}
else
- warning (_("Target does not support conditional tracepoints, ignoring tp %d cond"), t->number);
+ warning (_("Target does not support conditional tracepoints, "
+ "ignoring tp %d cond"), t->number);
}
if (t->commands || *default_collect)
{
for (ndx = 0; tdp_actions[ndx]; ndx++)
{
- QUIT; /* allow user to bail out with ^C */
+ QUIT; /* Allow user to bail out with ^C. */
sprintf (buf, "QTDP:-%x:%s:%s%c",
t->number, addrbuf, /* address */
tdp_actions[ndx],
{
for (ndx = 0; stepping_actions[ndx]; ndx++)
{
- QUIT; /* allow user to bail out with ^C */
+ QUIT; /* Allow user to bail out with ^C. */
sprintf (buf, "QTDP:-%x:%s:%s%s%s",
t->number, addrbuf, /* address */
((ndx == 0) ? "S" : ""),
}
}
- if (remote_protocol_packets[PACKET_TracepointSource].support == PACKET_ENABLE)
+ if (remote_protocol_packets[PACKET_TracepointSource].support
+ == PACKET_ENABLE)
{
if (t->addr_string)
{
{
asection *s;
bfd_size_type size;
- bfd_vma lma;
+ bfd_vma vma;
int anysecs = 0;
if (!exec_bfd)
char tmp1[40], tmp2[40];
if ((s->flags & SEC_LOAD) == 0 ||
- /* (s->flags & SEC_CODE) == 0 || */
+ /* (s->flags & SEC_CODE) == 0 || */
(s->flags & SEC_READONLY) == 0)
continue;
anysecs = 1;
- lma = s->lma;
+ vma = bfd_get_section_vma (,s);
size = bfd_get_section_size (s);
- sprintf_vma (tmp1, lma);
- sprintf_vma (tmp2, lma + size);
+ sprintf_vma (tmp1, vma);
+ sprintf_vma (tmp2, vma + size);
sprintf (target_buf + strlen (target_buf),
":%s,%s", tmp1, tmp2);
}
remote_get_trace_status (struct trace_status *ts)
{
char *p;
- /* FIXME we need to get register block size some other way */
+ /* FIXME we need to get register block size some other way. */
extern int trace_regblock_size;
trace_regblock_size = get_remote_arch_state ()->sizeof_g_packet;
sprintf (p, "outside:%s:%s", phex_nz (addr1, 0), phex_nz (addr2, 0));
break;
default:
- error ("Unknown trace find type %d", type);
+ error (_("Unknown trace find type %d"), type);
}
putpkt (rs->buf);
remote_ops.to_has_stack = default_child_has_stack;
remote_ops.to_has_registers = default_child_has_registers;
remote_ops.to_has_execution = default_child_has_execution;
- remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
+ remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
remote_ops.to_can_execute_reverse = remote_can_execute_reverse;
remote_ops.to_magic = OPS_MAGIC;
remote_ops.to_memory_map = remote_memory_map;
remote_ops.to_supports_multi_process = remote_supports_multi_process;
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_download_trace_state_variable
+ = remote_download_trace_state_variable;
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_ops.to_trace_stop = remote_trace_stop;
remote_ops.to_trace_find = remote_trace_find;
- remote_ops.to_get_trace_state_variable_value = remote_get_trace_state_variable_value;
+ remote_ops.to_get_trace_state_variable_value
+ = remote_get_trace_state_variable_value;
remote_ops.to_save_trace_data = remote_save_trace_data;
remote_ops.to_upload_tracepoints = remote_upload_tracepoints;
- remote_ops.to_upload_trace_state_variables = remote_upload_trace_state_variables;
+ remote_ops.to_upload_trace_state_variables
+ = remote_upload_trace_state_variables;
remote_ops.to_get_raw_trace_data = remote_get_raw_trace_data;
remote_ops.to_set_disconnected_tracing = remote_set_disconnected_tracing;
remote_ops.to_set_circular_trace_buffer = remote_set_circular_trace_buffer;
remote_ops.to_verify_memory = remote_verify_memory;
remote_ops.to_get_tib_address = remote_get_tib_address;
remote_ops.to_set_permissions = remote_set_permissions;
+ remote_ops.to_static_tracepoint_marker_at
+ = remote_static_tracepoint_marker_at;
+ remote_ops.to_static_tracepoint_markers_by_strid
+ = remote_static_tracepoint_markers_by_strid;
}
/* Set up the extended remote vector by making a copy of the standard
deprecate_cmd (cmd, "show remote interrupt-sequence");
add_setshow_enum_cmd ("interrupt-sequence", class_support,
- interrupt_sequence_modes, &interrupt_sequence_mode, _("\
+ interrupt_sequence_modes, &interrupt_sequence_mode,
+ _("\
Set interrupt sequence to remote target."), _("\
Show interrupt sequence to remote target."), _("\
Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
Set the maximum number of target hardware watchpoints."), _("\
Show the maximum number of target hardware watchpoints."), _("\
Specify a negative limit for unlimited."),
- NULL, NULL, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
+ NULL, NULL, /* FIXME: i18n: The maximum
+ number of target hardware
+ watchpoints is %s. */
&remote_set_cmdlist, &remote_show_cmdlist);
add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class,
&remote_hw_breakpoint_limit, _("\
Set the maximum number of target hardware breakpoints."), _("\
Show the maximum number of target hardware breakpoints."), _("\
Specify a negative limit for unlimited."),
- NULL, NULL, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
+ NULL, NULL, /* FIXME: i18n: The maximum
+ number of target hardware
+ breakpoints is %s. */
&remote_set_cmdlist, &remote_show_cmdlist);
add_setshow_integer_cmd ("remoteaddresssize", class_obscure,
"qAttached", "query-attached", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints],
- "ConditionalTracepoints", "conditional-tracepoints", 0);
+ "ConditionalTracepoints",
+ "conditional-tracepoints", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints],
"FastTracepoints", "fast-tracepoints", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow],
"QAllow", "allow", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints],
+ "StaticTracepoints", "static-tracepoints", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read],
+ "qXfer:statictrace:read", "read-sdata-object", 0);
+
/* 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
When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
packets."),
set_remote_protocol_Z_packet_cmd,
- show_remote_protocol_Z_packet_cmd, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
+ show_remote_protocol_Z_packet_cmd,
+ /* FIXME: i18n: Use of remote protocol
+ `Z' packets is %s. */
&remote_set_cmdlist, &remote_show_cmdlist);
add_prefix_cmd ("remote", class_files, remote_command, _("\