#include "remote-fileio.h"
+#include "memory-map.h"
+
/* The size to align memory write packets, when practical. The protocol
does not guarantee any alignment, and gdb will generate short
writes and unaligned writes, but even as a best-effort attempt this
static struct remote_state remote_state;
static struct remote_state *
-get_remote_state (void)
+get_remote_state_raw (void)
{
return &remote_state;
}
long regnum; /* GDB's internal register number. */
LONGEST pnum; /* Remote protocol register number. */
int in_g_packet; /* Always part of G packet. */
- /* long size in bytes; == register_size (current_gdbarch, regnum);
+ /* long size in bytes; == register_size (current_gdbarch, regnum);
at present. */
/* char *name; == REGISTER_NAME (regnum); at present. */
};
return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
}
+/* Fetch the global remote target state. */
+
+static struct remote_state *
+get_remote_state (void)
+{
+ /* Make sure that the remote architecture state has been
+ initialized, because doing so might reallocate rs->buf. Any
+ function which calls getpkt also needs to be mindful of changes
+ to rs->buf, but this call limits the number of places which run
+ into trouble. */
+ get_remote_arch_state ();
+
+ return get_remote_state_raw ();
+}
+
static void *
init_remote_state (struct gdbarch *gdbarch)
{
int regnum;
- struct remote_state *rs = get_remote_state ();
+ struct remote_state *rs = get_remote_state_raw ();
struct remote_arch_state *rsa;
rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
}
static enum packet_result
-packet_ok (const char *buf, struct packet_config *config)
+packet_check_result (const char *buf)
{
if (buf[0] != '\0')
{
/* The stub recognized the packet request. Check that the
operation succeeded. */
+ if (buf[0] == 'E'
+ && isxdigit (buf[1]) && isxdigit (buf[2])
+ && buf[3] == '\0')
+ /* "Enn" - definitly an error. */
+ return PACKET_ERROR;
+
+ /* Always treat "E." as an error. This will be used for
+ more verbose error messages, such as E.memtypes. */
+ if (buf[0] == 'E' && buf[1] == '.')
+ return PACKET_ERROR;
+
+ /* The packet may or may not be OK. Just assume it is. */
+ return PACKET_OK;
+ }
+ else
+ /* The stub does not support the packet. */
+ return PACKET_UNKNOWN;
+}
+
+static enum packet_result
+packet_ok (const char *buf, struct packet_config *config)
+{
+ enum packet_result result;
+
+ result = packet_check_result (buf);
+ switch (result)
+ {
+ case PACKET_OK:
+ case PACKET_ERROR:
+ /* The stub recognized the packet request. */
switch (config->support)
{
case PACKET_SUPPORT_UNKNOWN:
case PACKET_ENABLE:
break;
}
- if (buf[0] == 'O' && buf[1] == 'K' && buf[2] == '\0')
- /* "OK" - definitly OK. */
- return PACKET_OK;
- if (buf[0] == 'E'
- && isxdigit (buf[1]) && isxdigit (buf[2])
- && buf[3] == '\0')
- /* "Enn" - definitly an error. */
- return PACKET_ERROR;
- /* The packet may or may not be OK. Just assume it is. */
- return PACKET_OK;
- }
- else
- {
+ break;
+ case PACKET_UNKNOWN:
/* The stub does not support the packet. */
switch (config->support)
{
case PACKET_DISABLE:
break;
}
- return PACKET_UNKNOWN;
+ break;
}
+
+ return result;
}
enum {
PACKET_Z3,
PACKET_Z4,
PACKET_qXfer_auxv,
+ PACKET_qXfer_memory_map,
PACKET_qGetTLSAddr,
PACKET_qSupported,
PACKET_MAX
{
struct remote_state *rs = get_remote_state ();
int tid = PIDGET (ptid);
- char *buf = rs->buf;
if (tid < 0)
- xsnprintf (buf, get_remote_packet_size (), "T-%08x", -tid);
+ xsnprintf (rs->buf, get_remote_packet_size (), "T-%08x", -tid);
else
- xsnprintf (buf, get_remote_packet_size (), "T%08x", tid);
- putpkt (buf);
+ xsnprintf (rs->buf, get_remote_packet_size (), "T%08x", tid);
+ putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- return (buf[0] == 'O' && buf[1] == 'K');
+ return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
}
/* About these extended threadlist and threadinfo packets. They are
struct gdb_ext_thread_info
{
threadref threadid; /* External form of thread reference. */
- int active; /* Has state interesting to GDB?
+ int active; /* Has state interesting to GDB?
regs, stack. */
- char display[256]; /* Brief state display, name,
+ char display[256]; /* Brief state display, name,
blocked/suspended. */
char shortname[32]; /* To be used to name threads. */
- char more_display[256]; /* Long info, statistics, queue depth,
+ char more_display[256]; /* Long info, statistics, queue depth,
whatever. */
};
static int threadmatch (threadref *dest, threadref *src);
-static char *pack_threadinfo_request (char *pkt, int mode,
+static char *pack_threadinfo_request (char *pkt, int mode,
threadref *id);
static int remote_unpack_thread_info_response (char *pkt,
*info);
-static int remote_get_threadinfo (threadref *threadid,
+static int remote_get_threadinfo (threadref *threadid,
int fieldset, /*TAG mask */
struct gdb_ext_thread_info *info);
static int parse_threadlist_response (char *pkt,
int result_limit,
threadref *original_echo,
- threadref *resultlist,
+ threadref *resultlist,
int *doneflag);
static int remote_get_threadlist (int startflag,
threadref *nextthread,
int result_limit,
int *done,
- int *result_count,
+ int *result_count,
threadref *threadlist);
typedef int (*rmt_thread_action) (threadref *ref, void *context);
ULONGEST *result)
{
int nibble;
- int retval = 0;
+ ULONGEST retval = 0;
while (ishex (*buff, &nibble))
{
{
struct remote_state *rs = get_remote_state ();
int result;
- char *threadinfo_pkt = rs->buf;
- pack_threadinfo_request (threadinfo_pkt, fieldset, threadid);
- putpkt (threadinfo_pkt);
+ pack_threadinfo_request (rs->buf, fieldset, threadid);
+ putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- result = remote_unpack_thread_info_response (threadinfo_pkt + 2,
+ result = remote_unpack_thread_info_response (rs->buf + 2,
threadid, info);
return result;
}
{
struct remote_state *rs = get_remote_state ();
static threadref echo_nextthread;
- char *threadlist_packet = rs->buf;
int result = 1;
/* Trancate result limit to be smaller than the packet size. */
remote_current_thread (ptid_t oldpid)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf;
putpkt ("qC");
getpkt (&rs->buf, &rs->buf_size, 0);
- if (buf[0] == 'Q' && buf[1] == 'C')
+ if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
/* Use strtoul here, so we'll correctly parse values whose highest
bit is set. The protocol carries them as a simple series of
hex digits; in the absence of a sign, strtol will see such
values as positive numbers out of range for signed 'long', and
return LONG_MAX to indicate an overflow. */
- return pid_to_ptid (strtoul (&buf[2], NULL, 16));
+ return pid_to_ptid (strtoul (&rs->buf[2], NULL, 16));
else
return oldpid;
}
if (use_threadinfo_query)
{
putpkt ("qfThreadInfo");
- bufp = rs->buf;
getpkt (&rs->buf, &rs->buf_size, 0);
+ bufp = rs->buf;
if (bufp[0] != '\0') /* q packet recognized */
{
while (*bufp++ == 'm') /* reply contains one or more TID */
}
while (*bufp++ == ','); /* comma-separated list */
putpkt ("qsThreadInfo");
- bufp = rs->buf;
getpkt (&rs->buf, &rs->buf_size, 0);
+ bufp = rs->buf;
}
return; /* done */
}
if (use_threadextra_query)
{
- char *bufp = rs->buf;
-
- xsnprintf (bufp, get_remote_packet_size (), "qThreadExtraInfo,%x",
+ xsnprintf (rs->buf, get_remote_packet_size (), "qThreadExtraInfo,%x",
PIDGET (tp->ptid));
- putpkt (bufp);
+ putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- if (bufp[0] != 0)
+ if (rs->buf[0] != 0)
{
- n = min (strlen (bufp) / 2, sizeof (display_buf));
- result = hex2bin (bufp, (gdb_byte *) display_buf, n);
+ n = min (strlen (rs->buf) / 2, sizeof (display_buf));
+ result = hex2bin (rs->buf, (gdb_byte *) display_buf, n);
display_buf [result] = '\0';
return display_buf;
}
if (threadinfo.active)
{
if (*threadinfo.shortname)
- n += xsnprintf (&display_buf[0], sizeof (display_buf) - n,
+ n += xsnprintf (&display_buf[0], sizeof (display_buf) - n,
" Name: %s,", threadinfo.shortname);
if (*threadinfo.display)
- n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
+ n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
" State: %s,", threadinfo.display);
if (*threadinfo.more_display)
- n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
+ n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
" Priority: %s", threadinfo.more_display);
if (n > 0)
putpkt (rs->buf);
remote_fileio_reset ();
-
+
/* Now query for status so this looks just like we restarted
gdbserver from scratch. */
putpkt ("?");
get_offsets (void)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf;
+ char *buf;
char *ptr;
int lose;
CORE_ADDR text_addr, data_addr, bss_addr;
putpkt ("qOffsets");
getpkt (&rs->buf, &rs->buf_size, 0);
+ buf = rs->buf;
if (buf[0] == '\000')
return; /* Return silently. Stub doesn't support
because we need both at the same time. */
msg = alloca (get_remote_packet_size ());
- reply = rs->buf;
-
/* Invite target to request symbol lookups. */
putpkt ("qSymbol::");
getpkt (&rs->buf, &rs->buf_size, 0);
packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]);
+ reply = rs->buf;
while (strncmp (reply, "qSymbol:", 8) == 0)
{
&reply[8]);
putpkt (msg);
getpkt (&rs->buf, &rs->buf_size, 0);
+ reply = rs->buf;
}
}
static struct protocol_feature remote_protocol_features[] = {
{ "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
- { "qPart:auxv:read", PACKET_DISABLE, remote_supported_packet,
- PACKET_qXfer_auxv }
+ { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_auxv },
+ { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_memory_map }
};
static void
static void
remote_vcont_probe (struct remote_state *rs)
{
- char *buf = rs->buf;
+ char *buf;
- strcpy (buf, "vCont?");
- putpkt (buf);
+ strcpy (rs->buf, "vCont?");
+ putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
+ buf = rs->buf;
/* Make sure that the features we assume are supported. */
if (strncmp (buf, "vCont", 5) == 0)
remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf;
+ char *buf;
int pid = PIDGET (ptid);
last_sent_signal = siggnal;
else
set_thread (pid, 0); /* Run this thread. */
+ buf = rs->buf;
if (siggnal != TARGET_SIGNAL_0)
{
buf[0] = step ? 'S' : 'C';
{
signal (SIGINT, handle_sigint);
if (sigint_remote_twice_token)
- delete_async_signal_handler ((struct async_signal_handler **)
+ delete_async_signal_handler ((struct async_signal_handler **)
&sigint_remote_twice_token);
if (sigint_remote_token)
- delete_async_signal_handler ((struct async_signal_handler **)
+ delete_async_signal_handler ((struct async_signal_handler **)
&sigint_remote_token);
}
{
struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
- char *buf = rs->buf;
ULONGEST thread_num = -1;
ULONGEST addr;
while (1)
{
- char *p;
+ char *buf, *p;
ofunc = signal (SIGINT, remote_interrupt);
getpkt (&rs->buf, &rs->buf_size, 1);
signal (SIGINT, ofunc);
+ buf = rs->buf;
+
/* This is a hook for when we need to do something (perhaps the
collection of trace data) every time the target stops. */
if (deprecated_target_wait_loop_hook)
phex_nz (pnum, 0), p, buf);
fieldsize = hex2bin (p, regs,
- register_size (current_gdbarch,
+ register_size (current_gdbarch,
reg->regnum));
p += 2 * fieldsize;
- if (fieldsize < register_size (current_gdbarch,
+ if (fieldsize < register_size (current_gdbarch,
reg->regnum))
warning (_("Remote reply is too short: %s"), buf);
- regcache_raw_supply (current_regcache,
+ regcache_raw_supply (current_regcache,
reg->regnum, regs);
}
if (*p++ != ';')
- error (_("Remote register badly formatted: %s\nhere: %s"),
+ error (_("Remote register badly formatted: %s\nhere: %s"),
buf, p);
}
}
{
struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
- char *buf = rs->buf;
ULONGEST thread_num = -1;
ULONGEST addr;
while (1)
{
- char *p;
+ char *buf, *p;
if (!target_is_async_p ())
ofunc = signal (SIGINT, remote_interrupt);
if (!target_is_async_p ())
signal (SIGINT, ofunc);
+ buf = rs->buf;
+
/* This is a hook for when we need to do something (perhaps the
collection of trace data) every time the target stops. */
if (deprecated_target_wait_loop_hook)
pnum, p, buf);
fieldsize = hex2bin (p, regs,
- register_size (current_gdbarch,
+ register_size (current_gdbarch,
reg->regnum));
p += 2 * fieldsize;
- if (fieldsize < register_size (current_gdbarch,
+ if (fieldsize < register_size (current_gdbarch,
reg->regnum))
warning (_("Remote reply is too short: %s"), buf);
regcache_raw_supply (current_regcache, reg->regnum, regs);
fetch_register_using_p (int regnum)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf, *p;
+ char *buf, *p;
char regp[MAX_REGISTER_SIZE];
int i;
- p = buf;
+ p = rs->buf;
*p++ = 'p';
p += hexnumstr (p, regnum);
*p++ = '\0';
remote_send (&rs->buf, &rs->buf_size);
+ buf = rs->buf;
+
/* If the stub didn't recognize the packet, or if we got an error,
tell our caller. */
if (buf[0] == '\0' || buf[0] == 'E')
{
struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
- char *buf = rs->buf;
+ char *buf;
int i;
char *p;
char *regs = alloca (rsa->sizeof_g_packet);
}
}
- sprintf (buf, "g");
+ sprintf (rs->buf, "g");
remote_send (&rs->buf, &rs->buf_size);
+ buf = rs->buf;
/* Save the size of the packet sent to us by the target. Its used
as a heuristic when determining the max size of packets that the
fprintf_unfiltered (gdb_stdlog,
"Bad register packet; fetching a new packet\n");
getpkt (&rs->buf, &rs->buf_size, 0);
+ buf = rs->buf;
}
/* Reply describes registers byte by byte, each byte encoded as two
bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
remote_send (&rs->buf, &rs->buf_size);
- return buf[0] != '\0';
+ return rs->buf[0] != '\0';
}
break;
case PACKET_SUPPORT_UNKNOWN:
{
- char *buf = rs->buf;
char *p;
- p = buf;
+ p = rs->buf;
*p++ = 'X';
p += hexnumstr (p, (ULONGEST) addr);
*p++ = ',';
*p++ = ':';
*p = '\0';
- putpkt_binary (buf, (int) (p - buf));
+ putpkt_binary (rs->buf, (int) (p - rs->buf));
getpkt (&rs->buf, &rs->buf_size, 0);
- if (buf[0] == '\0')
+ if (rs->buf[0] == '\0')
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog,
/* Write memory data directly to the remote machine.
This does not inform the data cache; the data cache uses this.
+ HEADER is the starting part of the packet.
MEMADDR is the address in the remote memory space.
MYADDR is the address of the buffer in our space.
LEN is the number of bytes.
+ PACKET_FORMAT should be either 'X' or 'M', and indicates if we
+ should send data as binary ('X'), or hex-encoded ('M').
- Returns number of bytes transferred, or 0 (setting errno) for
+ The function creates packet of the form
+ <HEADER><ADDRESS>,<LENGTH>:<DATA>
+
+ where encoding of <DATA> is termined by PACKET_FORMAT.
+
+ If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
+ are omitted.
+
+ Returns the number of bytes transferred, or 0 (setting errno) for
error. Only transfer a single packet. */
-int
-remote_write_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
+static int
+remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
+ const gdb_byte *myaddr, int len,
+ char packet_format, int use_length)
{
struct remote_state *rs = get_remote_state ();
- char *buf;
char *p;
- char *plen;
- int plenlen;
+ char *plen = NULL;
+ int plenlen = 0;
int todo;
int nr_bytes;
int payload_size;
int payload_length;
+ int header_length;
- /* Verify that the target can support a binary download. */
- check_binary_download (memaddr);
+ if (packet_format != 'X' && packet_format != 'M')
+ internal_error (__FILE__, __LINE__,
+ "remote_write_bytes_aux: bad packet format");
+
+ /* Should this be the selected frame? */
+ gdbarch_remote_translate_xfer_address (current_gdbarch,
+ current_regcache,
+ memaddr, len,
+ &memaddr, &len);
+
+ if (len <= 0)
+ return 0;
payload_size = get_memory_write_packet_size ();
-
+
/* The packet buffer will be large enough for the payload;
get_memory_packet_size ensures this. */
- buf = rs->buf;
+ rs->buf[0] = '\0';
/* Compute the size of the actual payload by subtracting out the
packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
*/
- payload_size -= strlen ("$M,:#NN");
+ payload_size -= strlen ("$,:#NN");
+ if (!use_length)
+ /* The comma won't be used. */
+ payload_size += 1;
+ header_length = strlen (header);
+ payload_size -= header_length;
payload_size -= hexnumlen (memaddr);
- /* Construct the packet header: "[MX]<memaddr>,<len>:". */
+ /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
- /* Append "[XM]". Compute a best guess of the number of bytes
- actually transfered. */
- p = buf;
- switch (remote_protocol_packets[PACKET_X].support)
+ strcat (rs->buf, header);
+ p = rs->buf + strlen (header);
+
+ /* Compute a best guess of the number of bytes actually transfered. */
+ if (packet_format == 'X')
{
- case PACKET_ENABLE:
- *p++ = 'X';
/* Best guess at number of bytes that will fit. */
todo = min (len, payload_size);
- payload_size -= hexnumlen (todo);
+ if (use_length)
+ payload_size -= hexnumlen (todo);
todo = min (todo, payload_size);
- break;
- case PACKET_DISABLE:
- *p++ = 'M';
+ }
+ else
+ {
/* Num bytes that will fit. */
todo = min (len, payload_size / 2);
- payload_size -= hexnumlen (todo);
+ if (use_length)
+ payload_size -= hexnumlen (todo);
todo = min (todo, payload_size / 2);
- break;
- case PACKET_SUPPORT_UNKNOWN:
- internal_error (__FILE__, __LINE__,
- _("remote_write_bytes: bad internal state"));
- default:
- internal_error (__FILE__, __LINE__, _("bad switch"));
}
+
if (todo <= 0)
internal_error (__FILE__, __LINE__,
_("minumum packet size too small to write data"));
memaddr = remote_address_masked (memaddr);
p += hexnumstr (p, (ULONGEST) memaddr);
- /* Append ",". */
- *p++ = ',';
+ if (use_length)
+ {
+ /* Append ",". */
+ *p++ = ',';
- /* Append <len>. Retain the location/size of <len>. It may need to
- be adjusted once the packet body has been created. */
- plen = p;
- plenlen = hexnumstr (p, (ULONGEST) todo);
- p += plenlen;
+ /* Append <len>. Retain the location/size of <len>. It may need to
+ be adjusted once the packet body has been created. */
+ plen = p;
+ plenlen = hexnumstr (p, (ULONGEST) todo);
+ p += plenlen;
+ }
/* Append ":". */
*p++ = ':';
*p = '\0';
/* Append the packet body. */
- switch (remote_protocol_packets[PACKET_X].support)
+ if (packet_format == 'X')
{
- case PACKET_ENABLE:
/* Binary mode. Send target system values byte by byte, in
increasing byte addresses. Only escape certain critical
characters. */
payload_size);
/* If not all TODO bytes fit, then we'll need another packet. Make
- a second try to keep the end of the packet aligned. */
- if (nr_bytes < todo)
+ a second try to keep the end of the packet aligned. Don't do
+ this if the packet is tiny. */
+ if (nr_bytes < todo && nr_bytes > 2 * REMOTE_ALIGN_WRITES)
{
int new_nr_bytes;
}
p += payload_length;
- if (nr_bytes < todo)
+ if (use_length && nr_bytes < todo)
{
/* Escape chars have filled up the buffer prematurely,
and we have actually sent fewer bytes than planned.
plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
*plen = ':'; /* overwrite \0 from hexnumnstr() */
}
- break;
- case PACKET_DISABLE:
+ }
+ else
+ {
/* Normal mode: Send target system values byte by byte, in
increasing byte addresses. Each byte is encoded as a two hex
value. */
nr_bytes = bin2hex (myaddr, p, todo);
p += 2 * nr_bytes;
- break;
- case PACKET_SUPPORT_UNKNOWN:
- internal_error (__FILE__, __LINE__,
- _("remote_write_bytes: bad internal state"));
- default:
- internal_error (__FILE__, __LINE__, _("bad switch"));
}
- putpkt_binary (buf, (int) (p - buf));
+ putpkt_binary (rs->buf, (int) (p - rs->buf));
getpkt (&rs->buf, &rs->buf_size, 0);
- if (buf[0] == 'E')
+ if (rs->buf[0] == 'E')
{
/* There is no correspondance between what the remote protocol
uses for errors and errno codes. We would like a cleaner way
return nr_bytes;
}
+/* Write memory data directly to the remote machine.
+ This does not inform the data cache; the data cache uses this.
+ MEMADDR is the address in the remote memory space.
+ MYADDR is the address of the buffer in our space.
+ LEN is the number of bytes.
+
+ Returns number of bytes transferred, or 0 (setting errno) for
+ error. Only transfer a single packet. */
+
+int
+remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
+{
+ char *packet_format = 0;
+
+ /* Check whether the target supports binary download. */
+ check_binary_download (memaddr);
+
+ switch (remote_protocol_packets[PACKET_X].support)
+ {
+ case PACKET_ENABLE:
+ packet_format = "X";
+ break;
+ case PACKET_DISABLE:
+ packet_format = "M";
+ break;
+ case PACKET_SUPPORT_UNKNOWN:
+ internal_error (__FILE__, __LINE__,
+ _("remote_write_bytes: bad internal state"));
+ default:
+ internal_error (__FILE__, __LINE__, _("bad switch"));
+ }
+
+ return remote_write_bytes_aux (packet_format,
+ memaddr, myaddr, len, packet_format[0], 1);
+}
+
/* Read memory data directly from the remote machine.
This does not use the data cache; the data cache uses this.
MEMADDR is the address in the remote memory space.
remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
{
struct remote_state *rs = get_remote_state ();
- char *buf;
int max_buf_size; /* Max size of packet output buffer. */
int origlen;
+ /* Should this be the selected frame? */
+ gdbarch_remote_translate_xfer_address (current_gdbarch,
+ current_regcache,
+ memaddr, len,
+ &memaddr, &len);
+
+ 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. */
- buf = rs->buf;
origlen = len;
while (len > 0)
todo = min (len, max_buf_size / 2); /* num bytes that will fit */
/* construct "m"<memaddr>","<len>" */
- /* sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); */
+ /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
memaddr = remote_address_masked (memaddr);
- p = buf;
+ p = rs->buf;
*p++ = 'm';
p += hexnumstr (p, (ULONGEST) memaddr);
*p++ = ',';
p += hexnumstr (p, (ULONGEST) todo);
*p = '\0';
- putpkt (buf);
+ putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
- if (buf[0] == 'E'
- && isxdigit (buf[1]) && isxdigit (buf[2])
- && buf[3] == '\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
/* Reply describes memory byte by byte,
each byte encoded as two hex characters. */
- p = buf;
+ p = rs->buf;
if ((i = hex2bin (p, myaddr, todo)) < todo)
{
/* Reply is short. This means that we were able to read
int should_write, struct mem_attrib *attrib,
struct target_ops *target)
{
- CORE_ADDR targ_addr;
- int targ_len;
int res;
- /* Should this be the selected frame? */
- gdbarch_remote_translate_xfer_address (current_gdbarch,
- current_regcache,
- mem_addr, mem_len,
- &targ_addr, &targ_len);
- if (targ_len <= 0)
- return 0;
-
if (should_write)
- res = remote_write_bytes (targ_addr, buffer, targ_len);
+ res = remote_write_bytes (mem_addr, buffer, mem_len);
else
- res = remote_read_bytes (targ_addr, buffer, targ_len);
+ res = remote_read_bytes (mem_addr, buffer, mem_len);
return res;
}
+/* Sends a packet with content determined by the printf format string
+ FORMAT and the remaining arguments, then gets the reply. Returns
+ whether the packet was a success, a failure, or unknown. */
+
+enum packet_result
+remote_send_printf (const char *format, ...)
+{
+ struct remote_state *rs = get_remote_state ();
+ int max_size = get_remote_packet_size ();
+
+ va_list ap;
+ va_start (ap, format);
+
+ rs->buf[0] = '\0';
+ if (vsnprintf (rs->buf, max_size, format, ap) >= max_size)
+ internal_error (__FILE__, __LINE__, "Too long remote packet.");
+
+ if (putpkt (rs->buf) < 0)
+ error (_("Communication problem with target."));
+
+ rs->buf[0] = '\0';
+ getpkt (&rs->buf, &rs->buf_size, 0);
+
+ return packet_check_result (rs->buf);
+}
+
+static void
+restore_remote_timeout (void *p)
+{
+ int value = *(int *)p;
+ remote_timeout = value;
+}
+
+/* Flash writing can take quite some time. We'll set
+ effectively infinite timeout for flash operations.
+ In future, we'll need to decide on a better approach. */
+static const int remote_flash_timeout = 1000;
+
+static void
+remote_flash_erase (struct target_ops *ops,
+ ULONGEST address, LONGEST length)
+{
+ int saved_remote_timeout = remote_timeout;
+ enum packet_result ret;
+
+ struct cleanup *back_to = make_cleanup (restore_remote_timeout,
+ &saved_remote_timeout);
+ remote_timeout = remote_flash_timeout;
+
+ ret = remote_send_printf ("vFlashErase:%s,%s",
+ paddr (address),
+ phex (length, 4));
+ switch (ret)
+ {
+ case PACKET_UNKNOWN:
+ error (_("Remote target does not support flash erase"));
+ case PACKET_ERROR:
+ error (_("Error erasing flash with vFlashErase packet"));
+ default:
+ break;
+ }
+
+ do_cleanups (back_to);
+}
+
+static LONGEST
+remote_flash_write (struct target_ops *ops,
+ ULONGEST address, LONGEST length,
+ const gdb_byte *data)
+{
+ int saved_remote_timeout = remote_timeout;
+ int ret;
+ struct cleanup *back_to = make_cleanup (restore_remote_timeout,
+ &saved_remote_timeout);
+
+ remote_timeout = remote_flash_timeout;
+ ret = remote_write_bytes_aux ("vFlashWrite:", address, data, length, 'X', 0);
+ do_cleanups (back_to);
+
+ return ret;
+}
+
+static void
+remote_flash_done (struct target_ops *ops)
+{
+ int saved_remote_timeout = remote_timeout;
+ int ret;
+ struct cleanup *back_to = make_cleanup (restore_remote_timeout,
+ &saved_remote_timeout);
+
+ remote_timeout = remote_flash_timeout;
+ ret = remote_send_printf ("vFlashDone");
+ do_cleanups (back_to);
+
+ switch (ret)
+ {
+ case PACKET_UNKNOWN:
+ error (_("Remote target does not support vFlashDone"));
+ case PACKET_ERROR:
+ error (_("Error finishing flash operation"));
+ default:
+ break;
+ }
+}
+
static void
remote_files_info (struct target_ops *ignore)
{
case '$':
{
if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
+ fprintf_unfiltered (gdb_stdlog,
"Packet instead of Ack, ignoring it\n");
/* It's probably an old response sent because an ACK
was lost. Gobble up the packet and ack it so it
if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
{
if (remote_debug)
- fputs_filtered ("Timeout in checksum, retrying\n",
+ fputs_filtered ("Timeout in checksum, retrying\n",
gdb_stdlog);
return -1;
}
else if (check_0 < 0 || check_1 < 0)
{
if (remote_debug)
- fputs_filtered ("Communication error in checksum\n",
+ fputs_filtered ("Communication error in checksum\n",
gdb_stdlog);
return -1;
}
serial_write (remote_desc, "-", 1);
}
- /* We have tried hard enough, and just can't receive the packet.
+ /* We have tried hard enough, and just can't receive the packet.
Give up. */
printf_unfiltered (_("Ignoring packet error, continuing...\n"));
if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
return -1;
-
+
*(p++) = 'Z';
*(p++) = '1';
*(p++) = ',';
char *p2;
char query_type;
- /* Handle memory using remote_xfer_memory. */
+ /* Handle memory using the standard memory routines. */
if (object == TARGET_OBJECT_MEMORY)
{
int xfered;
errno = 0;
if (writebuf != NULL)
- {
- void *buffer = xmalloc (len);
- struct cleanup *cleanup = make_cleanup (xfree, buffer);
- memcpy (buffer, writebuf, len);
- xfered = remote_xfer_memory (offset, buffer, len, 1, NULL, ops);
- do_cleanups (cleanup);
- }
+ xfered = remote_write_bytes (offset, writebuf, len);
else
- xfered = remote_xfer_memory (offset, readbuf, len, 0, NULL, ops);
+ xfered = remote_read_bytes (offset, readbuf, len);
if (xfered > 0)
return xfered;
return -1;
}
- /* Only handle reads. */
- if (writebuf != NULL || readbuf == NULL)
- return -1;
+ /* Only handle flash writes. */
+ if (writebuf != NULL)
+ {
+ LONGEST xfered;
+
+ switch (object)
+ {
+ case TARGET_OBJECT_FLASH:
+ xfered = remote_flash_write (ops, offset, len, writebuf);
+
+ if (xfered > 0)
+ return xfered;
+ else if (xfered == 0 && errno == 0)
+ return 0;
+ else
+ return -1;
+
+ default:
+ return -1;
+ }
+ }
/* Map pre-existing objects onto letters. DO NOT do this for new
objects!!! Instead specify new query packets. */
return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
&remote_protocol_packets[PACKET_qXfer_auxv]);
+ case TARGET_OBJECT_MEMORY_MAP:
+ gdb_assert (annex == NULL);
+ return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len,
+ &remote_protocol_packets[PACKET_qXfer_memory_map]);
+
default:
return -1;
}
struct ui_file *outbuf)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf;
- char *p = buf;
+ char *p = rs->buf;
if (!remote_desc)
error (_("remote rcmd is only available after target open"));
command = "";
/* The query prefix. */
- strcpy (buf, "qRcmd,");
- p = strchr (buf, '\0');
+ strcpy (rs->buf, "qRcmd,");
+ p = strchr (rs->buf, '\0');
- if ((strlen (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. */
/* get/display the response */
while (1)
{
+ char *buf;
+
/* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
- buf[0] = '\0';
+ rs->buf[0] = '\0';
getpkt (&rs->buf, &rs->buf_size, 0);
+ buf = rs->buf;
if (buf[0] == '\0')
error (_("Target does not support this command."));
if (buf[0] == 'O' && buf[1] != 'K')
}
}
+static VEC(mem_region_s) *
+remote_memory_map (struct target_ops *ops)
+{
+ VEC(mem_region_s) *result = NULL;
+ char *text = target_read_stralloc (¤t_target,
+ TARGET_OBJECT_MEMORY_MAP, NULL);
+
+ if (text)
+ {
+ struct cleanup *back_to = make_cleanup (xfree, text);
+ result = parse_memory_map (text);
+ do_cleanups (back_to);
+ }
+
+ return result;
+}
+
static void
packet_command (char *args, int from_tty)
{
remote_ops.to_has_execution = 1;
remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
remote_ops.to_magic = OPS_MAGIC;
+ remote_ops.to_memory_map = remote_memory_map;
+ remote_ops.to_flash_erase = remote_flash_erase;
+ remote_ops.to_flash_done = remote_flash_done;
}
/* Set up the extended remote vector by making a copy of the standard
will be able to delay notifying the client of an event until the
point where an entire packet has been received. */
-static void (*async_client_callback) (enum inferior_event_type event_type,
+static void (*async_client_callback) (enum inferior_event_type event_type,
void *context);
static void *async_client_context;
static serial_event_ftype remote_async_serial_handler;
}
static void
-remote_async (void (*callback) (enum inferior_event_type event_type,
+remote_async (void (*callback) (enum inferior_event_type event_type,
void *context), void *context)
{
if (current_target.to_async_mask_value == 0)
init_remote_async_ops (void)
{
remote_async_ops.to_shortname = "async";
- remote_async_ops.to_longname =
+ remote_async_ops.to_longname =
"Remote serial target in async version of the gdb-specific protocol";
remote_async_ops.to_doc =
"Use a remote computer via a serial line, using a gdb-specific protocol.\n\
remote_async_ops.to_async = remote_async;
remote_async_ops.to_async_mask_value = 1;
remote_async_ops.to_magic = OPS_MAGIC;
+ remote_async_ops.to_memory_map = remote_memory_map;
+ remote_async_ops.to_flash_erase = remote_flash_erase;
+ remote_async_ops.to_flash_done = remote_flash_done;
}
/* Set up the async extended remote vector by making a copy of the standard
struct remote_state *rs;
/* architecture specific data */
- remote_gdbarch_data_handle =
+ remote_gdbarch_data_handle =
gdbarch_data_register_post_init (init_remote_state);
/* Old tacky stuff. NOTE: This comes after the remote protocol so
of these, not one per target. Only one target is active at a
time. The default buffer size is unimportant; it will be expanded
whenever a larger buffer is needed. */
- rs = get_remote_state ();
+ rs = get_remote_state_raw ();
rs->buf_size = 400;
rs->buf = xmalloc (rs->buf_size);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
"qXfer:auxv:read", "read-aux-vector", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
+ "qXfer:memory-map:read", "memory-map", 0);
+
add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
"qGetTLSAddr", "get-thread-local-storage-address",
0);