/* Remote target communications for serial-line targets in custom GDB protocol
- Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
- 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+ 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
This file is part of GDB.
#include "solib.h"
#include "cli/cli-decode.h"
#include "cli/cli-setshow.h"
+#include "target-descriptions.h"
#include <ctype.h>
#include <sys/time.h>
#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
+ can improve bulk transfers. For instance, if a write is misaligned
+ relative to the target's data bus, the stub may need to make an extra
+ round trip fetching data from the target. This doesn't make a
+ huge difference, but it's easy to do, so we try to be helpful.
+
+ The alignment chosen is arbitrary; usually data bus width is
+ important here, not the possibly larger cache line size. */
+enum { REMOTE_ALIGN_WRITES = 16 };
+
/* Prototypes for local functions. */
static void cleanup_sigint_signal_handler (void *dummy);
static void initialize_sigint_signal_handler (void);
static void async_remote_interrupt (gdb_client_data);
void async_remote_interrupt_twice (gdb_client_data);
-static void build_remote_gdbarch_data (void);
-
static void remote_files_info (struct target_ops *ignore);
-static void remote_prepare_to_store (void);
+static void remote_prepare_to_store (struct regcache *regcache);
-static void remote_fetch_registers (int regno);
+static void remote_fetch_registers (struct regcache *regcache, int regno);
static void remote_resume (ptid_t ptid, int step,
enum target_signal siggnal);
static void remote_close (int quitting);
-static void remote_store_registers (int regno);
+static void remote_store_registers (struct regcache *regcache, int regno);
static void remote_mourn (void);
static void remote_async_mourn (void);
static long read_frame (char **buf_p, long *sizeof_buf);
-static int remote_insert_breakpoint (CORE_ADDR, bfd_byte *);
-
-static int remote_remove_breakpoint (CORE_ADDR, bfd_byte *);
-
static int hexnumlen (ULONGEST num);
static void init_remote_ops (void);
static void update_packet_config (struct packet_config *config);
+static void set_remote_protocol_packet_cmd (char *args, int from_tty,
+ struct cmd_list_element *c);
+
+static void show_remote_protocol_packet_cmd (struct ui_file *file,
+ int from_tty,
+ struct cmd_list_element *c,
+ const char *value);
+
void _initialize_remote (void);
-/* Description of the remote protocol. Strictly speaking, when the
- target is open()ed, remote.c should create a per-target description
- of the remote protocol using that target's architecture.
- Unfortunately, the target stack doesn't include local state. For
- the moment keep the information in the target's architecture
- object. Sigh.. */
+/* For "set remote" and "show remote". */
+
+static struct cmd_list_element *remote_set_cmdlist;
+static struct cmd_list_element *remote_show_cmdlist;
+
+/* Description of the remote protocol state for the currently
+ connected target. This is per-target state, and independent of the
+ selected architecture. */
+
+struct remote_state
+{
+ /* A buffer to use for incoming packets, and its current size. The
+ buffer is grown dynamically for larger incoming packets.
+ Outgoing packets may also be constructed in this buffer.
+ BUF_SIZE is always at least REMOTE_PACKET_SIZE;
+ REMOTE_PACKET_SIZE should be used to limit the length of outgoing
+ packets. */
+ char *buf;
+ long buf_size;
+
+ /* If we negotiated packet size explicitly (and thus can bypass
+ heuristics for the largest packet size that will not overflow
+ a buffer in the stub), this will be set to that packet size.
+ Otherwise zero, meaning to use the guessed size. */
+ long explicit_packet_size;
+};
+
+/* This data could be associated with a target, but we do not always
+ have access to the current target when we need it, so for now it is
+ static. This will be fine for as long as only one target is in use
+ at a time. */
+static struct remote_state remote_state;
+
+static struct remote_state *
+get_remote_state_raw (void)
+{
+ return &remote_state;
+}
+
+/* Description of the remote protocol for a given architecture. */
struct packet_reg
{
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; == gdbarch_register_name (current_gdbarch, regnum);
at present. */
- /* char *name; == REGISTER_NAME (regnum); at present. */
};
-struct remote_state
+struct remote_arch_state
{
/* Description of the remote protocol registers. */
long sizeof_g_packet;
/* Description of the remote protocol registers indexed by REGNUM
- (making an array of NUM_REGS + NUM_PSEUDO_REGS in size). */
+ (making an array gdbarch_num_regs in size). */
struct packet_reg *regs;
/* This is the size (in chars) of the first response to the ``g''
/* This is the maximum size (in chars) of a non read/write packet.
It is also used as a cap on the size of read/write packets. */
long remote_packet_size;
-
- /* A buffer to use for incoming packets, and its current size. The
- buffer is grown dynamically for larger incoming packets.
- Outgoing packets may also be constructed in this buffer.
- BUF_SIZE is always at least REMOTE_PACKET_SIZE;
- REMOTE_PACKET_SIZE should be used to limit the length of outgoing
- packets. */
- char *buf;
- long buf_size;
};
/* Handle for retreving the remote protocol data from gdbarch. */
static struct gdbarch_data *remote_gdbarch_data_handle;
+static struct remote_arch_state *
+get_remote_arch_state (void)
+{
+ return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
+}
+
+/* Fetch the global remote target state. */
+
static struct remote_state *
get_remote_state (void)
{
- return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
+ /* 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 int
+compare_pnums (const void *lhs_, const void *rhs_)
+{
+ const struct packet_reg * const *lhs = lhs_;
+ const struct packet_reg * const *rhs = rhs_;
+
+ if ((*lhs)->pnum < (*rhs)->pnum)
+ return -1;
+ else if ((*lhs)->pnum == (*rhs)->pnum)
+ return 0;
+ else
+ return 1;
}
static void *
init_remote_state (struct gdbarch *gdbarch)
{
- int regnum;
- struct remote_state *rs = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_state);
+ int regnum, num_remote_regs, offset;
+ struct remote_state *rs = get_remote_state_raw ();
+ struct remote_arch_state *rsa;
+ struct packet_reg **remote_regs;
- rs->sizeof_g_packet = 0;
+ rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
- /* Assume a 1:1 regnum<->pnum table. */
- rs->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, NUM_REGS + NUM_PSEUDO_REGS,
- struct packet_reg);
- for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
+ /* 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 (current_gdbarch),
+ struct packet_reg);
+ for (regnum = 0; regnum < gdbarch_num_regs (current_gdbarch); regnum++)
{
- struct packet_reg *r = &rs->regs[regnum];
- r->pnum = regnum;
+ struct packet_reg *r = &rsa->regs[regnum];
+
+ if (register_size (current_gdbarch, regnum) == 0)
+ /* Do not try to fetch zero-sized (placeholder) registers. */
+ r->pnum = -1;
+ else
+ r->pnum = gdbarch_remote_register_number (gdbarch, regnum);
+
r->regnum = regnum;
- r->offset = DEPRECATED_REGISTER_BYTE (regnum);
- r->in_g_packet = (regnum < NUM_REGS);
- /* ...name = REGISTER_NAME (regnum); */
+ }
+
+ /* Define the g/G packet format as the contents of each register
+ with a remote protocol number, in order of ascending protocol
+ number. */
+
+ remote_regs = alloca (gdbarch_num_regs (current_gdbarch)
+ * sizeof (struct packet_reg *));
+ for (num_remote_regs = 0, regnum = 0;
+ regnum < gdbarch_num_regs (current_gdbarch);
+ regnum++)
+ if (rsa->regs[regnum].pnum != -1)
+ remote_regs[num_remote_regs++] = &rsa->regs[regnum];
+
+ qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
+ compare_pnums);
- /* Compute packet size by accumulating the size of all registers. */
- if (regnum < NUM_REGS)
- rs->sizeof_g_packet += register_size (current_gdbarch, regnum);
+ for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
+ {
+ remote_regs[regnum]->in_g_packet = 1;
+ remote_regs[regnum]->offset = offset;
+ offset += register_size (current_gdbarch, remote_regs[regnum]->regnum);
}
+ /* Record the maximum possible size of the g packet - it may turn out
+ to be smaller. */
+ rsa->sizeof_g_packet = offset;
+
/* 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
NUL character can always fit in the buffer. This stops GDB
trashing stubs that try to squeeze an extra NUL into what is
- already a full buffer (As of 1999-12-04 that was most stubs. */
- rs->remote_packet_size = 400 - 1;
+ already a full buffer (As of 1999-12-04 that was most stubs). */
+ rsa->remote_packet_size = 400 - 1;
+
+ /* This one is filled in when a ``g'' packet is received. */
+ rsa->actual_register_packet_size = 0;
- /* Should rs->sizeof_g_packet needs more space than the
+ /* 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
(``$NN:G...#NN'') is a better guess, the below has been padded a
little. */
- if (rs->sizeof_g_packet > ((rs->remote_packet_size - 32) / 2))
- rs->remote_packet_size = (rs->sizeof_g_packet * 2 + 32);
+ if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
+ rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);
- /* This one is filled in when a ``g'' packet is received. */
- rs->actual_register_packet_size = 0;
-
- /* Create the buffer at a default size. Note that this would
- leak memory if the gdbarch were ever destroyed; there's no
- way to register a destructor for it, and we can't realloc
- using the gdbarch obstack. But gdbarches are never
- destroyed. */
- rs->buf_size = rs->remote_packet_size;
- rs->buf = xmalloc (rs->buf_size);
+ /* Make sure that the packet buffer is plenty big enough for
+ this architecture. */
+ if (rs->buf_size < rsa->remote_packet_size)
+ {
+ rs->buf_size = 2 * rsa->remote_packet_size;
+ rs->buf = xrealloc (rs->buf, rs->buf_size);
+ }
- return rs;
+ return rsa;
+}
+
+/* Return the current allowed size of a remote packet. This is
+ inferred from the current architecture, and should be used to
+ limit the length of outgoing packets. */
+static long
+get_remote_packet_size (void)
+{
+ struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
+
+ if (rs->explicit_packet_size)
+ return rs->explicit_packet_size;
+
+ return rsa->remote_packet_size;
}
static struct packet_reg *
-packet_reg_from_regnum (struct remote_state *rs, long regnum)
+packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
{
- if (regnum < 0 && regnum >= NUM_REGS + NUM_PSEUDO_REGS)
+ if (regnum < 0 && regnum >= gdbarch_num_regs (current_gdbarch))
return NULL;
else
{
- struct packet_reg *r = &rs->regs[regnum];
+ struct packet_reg *r = &rsa->regs[regnum];
gdb_assert (r->regnum == regnum);
return r;
}
}
static struct packet_reg *
-packet_reg_from_pnum (struct remote_state *rs, LONGEST pnum)
+packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
{
int i;
- for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
+ for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
{
- struct packet_reg *r = &rs->regs[i];
+ struct packet_reg *r = &rsa->regs[i];
if (r->pnum == pnum)
return r;
}
\f
/* User configurable variables for the number of characters in a
- memory read/write packet. MIN (rs->remote_packet_size,
- rs->sizeof_g_packet) is the default. Some targets need smaller
+ memory read/write packet. MIN (rsa->remote_packet_size,
+ rsa->sizeof_g_packet) is the default. Some targets need smaller
values (fifo overruns, et.al.) and some users need larger values
(speed up transfers). The variables ``preferred_*'' (the user
request), ``current_*'' (what was actually set) and ``forced_*''
get_memory_packet_size (struct memory_packet_config *config)
{
struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
+
/* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
law?) that some hosts don't cope very well with large alloca()
calls. Eventually the alloca() code will be replaced by calls to
}
else
{
- what_they_get = rs->remote_packet_size;
+ what_they_get = get_remote_packet_size ();
/* Limit the packet to the size specified by the user. */
if (config->size > 0
&& what_they_get > config->size)
what_they_get = config->size;
- /* Limit it to the size of the targets ``g'' response. */
- if ((rs->actual_register_packet_size) > 0
- && what_they_get > (rs->actual_register_packet_size))
- what_they_get = (rs->actual_register_packet_size);
+
+ /* Limit it to the size of the targets ``g'' response unless we have
+ permission from the stub to use a larger packet size. */
+ if (rs->explicit_packet_size == 0
+ && rsa->actual_register_packet_size > 0
+ && what_they_get > rsa->actual_register_packet_size)
+ what_they_get = rsa->actual_register_packet_size;
}
if (what_they_get > MAX_REMOTE_PACKET_SIZE)
what_they_get = MAX_REMOTE_PACKET_SIZE;
static long
get_memory_read_packet_size (void)
{
- struct remote_state *rs = get_remote_state ();
long size = get_memory_packet_size (&memory_read_packet_config);
/* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
extra buffer size argument before the memory read size can be
- increased beyond RS->remote_packet_size. */
- if (size > rs->remote_packet_size)
- size = rs->remote_packet_size;
+ increased beyond this. */
+ if (size > get_remote_packet_size ())
+ size = get_remote_packet_size ();
return size;
}
struct packet_config
{
- char *name;
- char *title;
+ const char *name;
+ const char *title;
enum auto_boolean detect;
enum packet_support support;
};
}
static void
-add_packet_config_cmd (struct packet_config *config,
- char *name,
- char *title,
- cmd_sfunc_ftype *set_func,
- show_value_ftype *show_func,
- struct cmd_list_element **set_remote_list,
- struct cmd_list_element **show_remote_list,
- int legacy)
+add_packet_config_cmd (struct packet_config *config, const char *name,
+ const char *title, int legacy)
{
char *set_doc;
char *show_doc;
cmd_name = xstrprintf ("%s-packet", title);
add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
&config->detect, set_doc, show_doc, NULL, /* help_doc */
- set_func, show_func,
- set_remote_list, show_remote_list);
+ set_remote_protocol_packet_cmd,
+ show_remote_protocol_packet_cmd,
+ &remote_set_cmdlist, &remote_show_cmdlist);
/* set/show remote NAME-packet {auto,on,off} -- legacy. */
if (legacy)
{
char *legacy_name;
legacy_name = xstrprintf ("%s-packet", name);
add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
- set_remote_list);
+ &remote_set_cmdlist);
add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
- show_remote_list);
+ &remote_show_cmdlist);
}
}
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_Z2,
PACKET_Z3,
PACKET_Z4,
- PACKET_qPart_auxv,
+ PACKET_qXfer_auxv,
+ PACKET_qXfer_features,
+ PACKET_qXfer_libraries,
+ PACKET_qXfer_memory_map,
+ PACKET_qXfer_spu_read,
+ PACKET_qXfer_spu_write,
PACKET_qGetTLSAddr,
+ PACKET_qSupported,
+ PACKET_QPassSignals,
PACKET_MAX
};
static int use_threadextra_query;
/* Tokens for use by the asynchronous signal handlers for SIGINT. */
-static void *sigint_remote_twice_token;
-static void *sigint_remote_token;
+static struct async_signal_handler *sigint_remote_twice_token;
+static struct async_signal_handler *sigint_remote_token;
/* These are pointers to hook functions that may be set in order to
modify resume/wait behavior for a particular architecture. */
}
}
+static char *last_pass_packet;
+
+/* If 'QPassSignals' is supported, tell the remote stub what signals
+ it can simply pass through to the inferior without reporting. */
+
+static void
+remote_pass_signals (void)
+{
+ 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)
+ count++;
+ }
+ pass_packet = xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
+ strcpy (pass_packet, "QPassSignals:");
+ 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 (i >= 16)
+ *p++ = tohex (i >> 4);
+ *p++ = tohex (i & 15);
+ if (count)
+ *p++ = ';';
+ else
+ break;
+ count--;
+ }
+ }
+ *p = 0;
+ if (!last_pass_packet || strcmp (last_pass_packet, pass_packet))
+ {
+ struct remote_state *rs = get_remote_state ();
+ char *buf = rs->buf;
+
+ putpkt (pass_packet);
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ packet_ok (buf, &remote_protocol_packets[PACKET_QPassSignals]);
+ if (last_pass_packet)
+ xfree (last_pass_packet);
+ last_pass_packet = pass_packet;
+ }
+ else
+ xfree (pass_packet);
+ }
+}
+
#define MAGIC_NULL_PID 42000
static void
buf[3] = '\0';
}
else if (th < 0)
- xsnprintf (&buf[2], rs->remote_packet_size - 2, "-%x", -th);
+ xsnprintf (&buf[2], get_remote_packet_size () - 2, "-%x", -th);
else
- xsnprintf (&buf[2], rs->remote_packet_size - 2, "%x", th);
+ xsnprintf (&buf[2], get_remote_packet_size () - 2, "%x", th);
putpkt (buf);
getpkt (&rs->buf, &rs->buf_size, 0);
if (gen)
{
struct remote_state *rs = get_remote_state ();
int tid = PIDGET (ptid);
- char *buf = rs->buf;
if (tid < 0)
- xsnprintf (buf, rs->remote_packet_size, "T-%08x", -tid);
+ xsnprintf (rs->buf, get_remote_packet_size (), "T-%08x", -tid);
else
- xsnprintf (buf, rs->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
typedef int gdb_threadref; /* Internal GDB thread reference. */
/* gdb_ext_thread_info is an internal GDB data structure which is
- equivalint to the reply of the remote threadinfo packet. */
+ equivalent to the reply of the remote threadinfo packet. */
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. */
- if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= rs->remote_packet_size)
- result_limit = (rs->remote_packet_size / BUF_THREAD_ID_SIZE) - 2;
+ 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);
putpkt (rs->buf);
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, rs->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)
/* Send the restart command; for reasons I don't understand the
remote side really expects a number after the "R". */
- xsnprintf (rs->buf, rs->remote_packet_size, "R%x", 0);
+ xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 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;
+ int lose, num_segments = 0, do_sections, do_segments;
+ CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
struct section_offsets *offs;
+ struct symfile_segment_data *data;
+
+ if (symfile_objfile == NULL)
+ return;
putpkt ("qOffsets");
getpkt (&rs->buf, &rs->buf_size, 0);
+ buf = rs->buf;
if (buf[0] == '\000')
return; /* Return silently. Stub doesn't support
/* Don't use strtol, could lose on big values. */
while (*ptr && *ptr != ';')
text_addr = (text_addr << 4) + fromhex (*ptr++);
- }
- else
- lose = 1;
- if (!lose && strncmp (ptr, ";Data=", 6) == 0)
- {
- ptr += 6;
- while (*ptr && *ptr != ';')
- data_addr = (data_addr << 4) + fromhex (*ptr++);
- }
- else
- lose = 1;
+ if (strncmp (ptr, ";Data=", 6) == 0)
+ {
+ ptr += 6;
+ while (*ptr && *ptr != ';')
+ data_addr = (data_addr << 4) + fromhex (*ptr++);
+ }
+ else
+ lose = 1;
- if (!lose && strncmp (ptr, ";Bss=", 5) == 0)
+ if (!lose && strncmp (ptr, ";Bss=", 5) == 0)
+ {
+ ptr += 5;
+ while (*ptr && *ptr != ';')
+ bss_addr = (bss_addr << 4) + fromhex (*ptr++);
+
+ if (bss_addr != data_addr)
+ warning (_("Target reported unsupported offsets: %s"), buf);
+ }
+ else
+ lose = 1;
+ }
+ else if (strncmp (ptr, "TextSeg=", 8) == 0)
{
- ptr += 5;
+ ptr += 8;
+ /* Don't use strtol, could lose on big values. */
while (*ptr && *ptr != ';')
- bss_addr = (bss_addr << 4) + fromhex (*ptr++);
+ text_addr = (text_addr << 4) + fromhex (*ptr++);
+ num_segments = 1;
+
+ if (strncmp (ptr, ";DataSeg=", 9) == 0)
+ {
+ ptr += 9;
+ while (*ptr && *ptr != ';')
+ data_addr = (data_addr << 4) + fromhex (*ptr++);
+ num_segments++;
+ }
}
else
lose = 1;
if (lose)
error (_("Malformed response to offset query, %s"), buf);
-
- if (symfile_objfile == NULL)
- return;
+ else if (*ptr != '\0')
+ warning (_("Target reported unsupported offsets: %s"), buf);
offs = ((struct section_offsets *)
alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
memcpy (offs, symfile_objfile->section_offsets,
SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
- offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
+ data = get_symfile_segment_data (symfile_objfile->obfd);
+ do_segments = (data != NULL);
+ do_sections = num_segments == 0;
- /* 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. */
+ /* Text= and Data= specify offsets for the text and data sections,
+ but symfile_map_offsets_to_segments expects base addresses
+ instead of offsets. If we have two segments, we can still
+ try to relocate the whole segments instead of just ".text"
+ and ".data". */
+ if (num_segments == 0)
+ {
+ do_sections = 1;
+ if (data == NULL || data->num_segments != 2)
+ do_segments = 0;
+ else
+ {
+ segments[0] = data->segment_bases[0] + text_addr;
+ segments[1] = data->segment_bases[1] + data_addr;
+ }
+ }
+ else
+ {
+ do_sections = 0;
+ segments[0] = text_addr;
+ segments[1] = data_addr;
+ }
- offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
- offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
+ if (do_segments)
+ {
+ int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data,
+ offs, num_segments, segments);
- objfile_relocate (symfile_objfile, offs);
-}
+ if (ret == 0 && !do_sections)
+ error (_("Can not handle qOffsets TextSeg response with this symbol file"));
-/* Stub for catch_errors. */
+ if (ret > 0)
+ do_sections = 0;
+ }
-static int
-remote_start_remote_dummy (struct ui_out *uiout, void *dummy)
-{
- start_remote (); /* Initialize gdb process mechanisms. */
- /* NOTE: Return something >=0. A -ve value is reserved for
- catch_exceptions. */
- return 1;
+ free_symfile_segment_data (data);
+
+ if (do_sections)
+ {
+ 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. */
+
+ offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
+ offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
+ }
+
+ objfile_relocate (symfile_objfile, offs);
}
+/* Stub for catch_exception. */
+
static void
-remote_start_remote (struct ui_out *uiout, void *dummy)
+remote_start_remote (struct ui_out *uiout, void *from_tty_p)
{
+ int from_tty = * (int *) from_tty_p;
+
immediate_quit++; /* Allow user to interrupt it. */
/* Ack any packet which the remote side has already sent. */
putpkt ("?"); /* Initiate a query from remote machine. */
immediate_quit--;
- remote_start_remote_dummy (uiout, dummy);
+ start_remote (from_tty); /* Initialize gdb process mechanisms. */
}
/* Open a connection to a remote debugger.
/* Allocate a message buffer. We can't reuse the input buffer in RS,
because we need both at the same time. */
- msg = alloca (rs->remote_packet_size);
-
- reply = rs->buf;
+ msg = alloca (get_remote_packet_size ());
/* 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)
{
msg[end] = '\0';
sym = lookup_minimal_symbol (msg, NULL, NULL);
if (sym == NULL)
- xsnprintf (msg, rs->remote_packet_size, "qSymbol::%s", &reply[8]);
+ xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
else
- xsnprintf (msg, rs->remote_packet_size, "qSymbol:%s:%s",
+ xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
paddr_nz (SYMBOL_VALUE_ADDRESS (sym)),
&reply[8]);
putpkt (msg);
getpkt (&rs->buf, &rs->buf_size, 0);
+ reply = rs->buf;
}
}
return serial_open (name);
}
+/* This type describes each known response to the qSupported
+ packet. */
+struct protocol_feature
+{
+ /* The name of this protocol feature. */
+ const char *name;
+
+ /* The default for this protocol feature. */
+ enum packet_support default_support;
+
+ /* The function to call when this feature is reported, or after
+ qSupported processing if the feature is not supported.
+ The first argument points to this structure. The second
+ argument indicates whether the packet requested support be
+ enabled, disabled, or probed (or the default, if this function
+ is being called at the end of processing and this feature was
+ not reported). The third argument may be NULL; if not NULL, it
+ is a NUL-terminated string taken from the packet following
+ this feature's name and an equals sign. */
+ void (*func) (const struct protocol_feature *, enum packet_support,
+ const char *);
+
+ /* The corresponding packet for this feature. Only used if
+ FUNC is remote_supported_packet. */
+ int packet;
+};
+
static void
-remote_open_1 (char *name, int from_tty, struct target_ops *target,
- int extended_p, int async_p)
+remote_supported_packet (const struct protocol_feature *feature,
+ enum packet_support support,
+ const char *argument)
{
- struct remote_state *rs = get_remote_state ();
- if (name == 0)
- error (_("To open a remote debug connection, you need to specify what\n"
- "serial device is attached to the remote system\n"
- "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
+ if (argument)
+ {
+ warning (_("Remote qSupported response supplied an unexpected value for"
+ " \"%s\"."), feature->name);
+ return;
+ }
- /* See FIXME above. */
- if (!async_p)
- wait_forever_enabled_p = 1;
+ if (remote_protocol_packets[feature->packet].support
+ == PACKET_SUPPORT_UNKNOWN)
+ remote_protocol_packets[feature->packet].support = support;
+}
- reopen_exec_file ();
- reread_symbols ();
+static void
+remote_packet_size (const struct protocol_feature *feature,
+ enum packet_support support, const char *value)
+{
+ struct remote_state *rs = get_remote_state ();
- target_preopen (from_tty);
+ int packet_size;
+ char *value_end;
- unpush_target (target);
+ if (support != PACKET_ENABLE)
+ return;
- remote_desc = remote_serial_open (name);
- if (!remote_desc)
- perror_with_name (name);
+ if (value == NULL || *value == '\0')
+ {
+ warning (_("Remote target reported \"%s\" without a size."),
+ feature->name);
+ return;
+ }
- if (baud_rate != -1)
+ errno = 0;
+ packet_size = strtol (value, &value_end, 16);
+ if (errno != 0 || *value_end != '\0' || packet_size < 0)
{
- if (serial_setbaudrate (remote_desc, baud_rate))
- {
- /* The requested speed could not be set. Error out to
- top level after closing remote_desc. Take care to
- set remote_desc to NULL to avoid closing remote_desc
- more than once. */
- serial_close (remote_desc);
- remote_desc = NULL;
- perror_with_name (name);
- }
+ warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
+ feature->name, value);
+ return;
}
- serial_raw (remote_desc);
+ if (packet_size > MAX_REMOTE_PACKET_SIZE)
+ {
+ warning (_("limiting remote suggested packet size (%d bytes) to %d"),
+ packet_size, MAX_REMOTE_PACKET_SIZE);
+ packet_size = MAX_REMOTE_PACKET_SIZE;
+ }
- /* If there is something sitting in the buffer we might take it as a
+ /* Record the new maximum packet size. */
+ rs->explicit_packet_size = packet_size;
+}
+
+static struct protocol_feature remote_protocol_features[] = {
+ { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
+ { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_auxv },
+ { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_features },
+ { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_libraries },
+ { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_memory_map },
+ { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_spu_read },
+ { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_spu_write },
+ { "QPassSignals", PACKET_DISABLE, remote_supported_packet,
+ PACKET_QPassSignals },
+};
+
+static void
+remote_query_supported (void)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *next;
+ int i;
+ unsigned char seen [ARRAY_SIZE (remote_protocol_features)];
+
+ /* The packet support flags are handled differently for this packet
+ than for most others. We treat an error, a disabled packet, and
+ an empty response identically: any features which must be reported
+ to be used will be automatically disabled. An empty buffer
+ accomplishes this, since that is also the representation for a list
+ containing no features. */
+
+ rs->buf[0] = 0;
+ if (remote_protocol_packets[PACKET_qSupported].support != PACKET_DISABLE)
+ {
+ putpkt ("qSupported");
+ getpkt (&rs->buf, &rs->buf_size, 0);
+
+ /* If an error occured, warn, but do not return - just reset the
+ buffer to empty and go on to disable features. */
+ if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
+ == PACKET_ERROR)
+ {
+ warning (_("Remote failure reply: %s"), rs->buf);
+ rs->buf[0] = 0;
+ }
+ }
+
+ memset (seen, 0, sizeof (seen));
+
+ next = rs->buf;
+ while (*next)
+ {
+ enum packet_support is_supported;
+ char *p, *end, *name_end, *value;
+
+ /* First separate out this item from the rest of the packet. If
+ there's another item after this, we overwrite the separator
+ (terminated strings are much easier to work with). */
+ p = next;
+ end = strchr (p, ';');
+ if (end == NULL)
+ {
+ end = p + strlen (p);
+ next = end;
+ }
+ else
+ {
+ *end = '\0';
+ next = end + 1;
+
+ if (end == p)
+ {
+ warning (_("empty item in \"qSupported\" response"));
+ continue;
+ }
+ }
+
+ name_end = strchr (p, '=');
+ if (name_end)
+ {
+ /* This is a name=value entry. */
+ is_supported = PACKET_ENABLE;
+ value = name_end + 1;
+ *name_end = '\0';
+ }
+ else
+ {
+ value = NULL;
+ switch (end[-1])
+ {
+ case '+':
+ is_supported = PACKET_ENABLE;
+ break;
+
+ case '-':
+ is_supported = PACKET_DISABLE;
+ break;
+
+ case '?':
+ is_supported = PACKET_SUPPORT_UNKNOWN;
+ break;
+
+ default:
+ warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p);
+ continue;
+ }
+ end[-1] = '\0';
+ }
+
+ for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
+ if (strcmp (remote_protocol_features[i].name, p) == 0)
+ {
+ const struct protocol_feature *feature;
+
+ seen[i] = 1;
+ feature = &remote_protocol_features[i];
+ feature->func (feature, is_supported, value);
+ break;
+ }
+ }
+
+ /* If we increased the packet size, make sure to increase the global
+ buffer size also. We delay this until after parsing the entire
+ qSupported packet, because this is the same buffer we were
+ parsing. */
+ if (rs->buf_size < rs->explicit_packet_size)
+ {
+ rs->buf_size = rs->explicit_packet_size;
+ rs->buf = xrealloc (rs->buf, rs->buf_size);
+ }
+
+ /* Handle the defaults for unmentioned features. */
+ for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
+ if (!seen[i])
+ {
+ const struct protocol_feature *feature;
+
+ feature = &remote_protocol_features[i];
+ feature->func (feature, feature->default_support, NULL);
+ }
+}
+
+
+static void
+remote_open_1 (char *name, int from_tty, struct target_ops *target,
+ int extended_p, int async_p)
+{
+ struct remote_state *rs = get_remote_state ();
+ if (name == 0)
+ error (_("To open a remote debug connection, you need to specify what\n"
+ "serial device is attached to the remote system\n"
+ "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
+
+ /* See FIXME above. */
+ if (!async_p)
+ wait_forever_enabled_p = 1;
+
+ target_preopen (from_tty);
+
+ unpush_target (target);
+
+ /* Make sure we send the passed signals list the next time we resume. */
+ xfree (last_pass_packet);
+ last_pass_packet = NULL;
+
+ remote_fileio_reset ();
+ reopen_exec_file ();
+ reread_symbols ();
+
+ remote_desc = remote_serial_open (name);
+ if (!remote_desc)
+ perror_with_name (name);
+
+ if (baud_rate != -1)
+ {
+ if (serial_setbaudrate (remote_desc, baud_rate))
+ {
+ /* The requested speed could not be set. Error out to
+ top level after closing remote_desc. Take care to
+ set remote_desc to NULL to avoid closing remote_desc
+ more than once. */
+ serial_close (remote_desc);
+ remote_desc = NULL;
+ perror_with_name (name);
+ }
+ }
+
+ serial_raw (remote_desc);
+
+ /* If there is something sitting in the buffer we might take it as a
response to a command, which would be bad. */
serial_flush_input (remote_desc);
}
push_target (target); /* Switch to using remote target now. */
+ /* Reset the target state; these things will be queried either by
+ remote_query_supported or as they are needed. */
init_all_packet_configs ();
+ rs->explicit_packet_size = 0;
general_thread = -2;
continue_thread = -2;
use_threadinfo_query = 1;
use_threadextra_query = 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. */
+ remote_query_supported ();
+
+ /* Next, if the target can specify a description, read it. We do
+ this before anything involving memory or registers. */
+ target_find_description ();
+
/* Without this, some commands which require an active target (such
as kill) won't work. This variable serves (at least) double duty
as both the pid of the target process (if it has such), and as a
function. See cli-dump.c. */
{
struct gdb_exception ex
- = catch_exception (uiout, remote_start_remote, NULL, RETURN_MASK_ALL);
+ = catch_exception (uiout, remote_start_remote, &from_tty,
+ RETURN_MASK_ALL);
if (ex.reason < 0)
{
pop_target ();
getpkt (&rs->buf, &rs->buf_size, 0);
}
- post_create_inferior (¤t_target, from_tty);
-
if (exec_bfd) /* No use without an exec file. */
remote_check_symbols (symfile_objfile);
}
/* Tell the remote target to detach. */
strcpy (rs->buf, "D");
- remote_send (&rs->buf, &rs->buf_size);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
+
+ if (rs->buf[0] == 'E')
+ error (_("Can't detach process."));
/* Unregister the file descriptor from the event loop. */
if (target_is_async_p ())
/* Same as remote_detach, but don't send the "D" packet; just disconnect. */
static void
-remote_disconnect (char *args, int from_tty)
+remote_disconnect (struct target_ops *target, char *args, int from_tty)
{
if (args)
error (_("Argument given to \"detach\" when remotely debugging."));
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)
outbuf = xstrprintf ("vCont;c:%x", pid);
}
- gdb_assert (outbuf && strlen (outbuf) < rs->remote_packet_size);
+ gdb_assert (outbuf && strlen (outbuf) < get_remote_packet_size ());
old_cleanup = make_cleanup (xfree, outbuf);
putpkt (outbuf);
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;
if (deprecated_target_resume_hook)
(*deprecated_target_resume_hook) ();
+ /* 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. */
if (remote_vcont_resume (ptid, step, siggnal))
return;
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 **)
- &sigint_remote_twice_token);
+ delete_async_signal_handler (&sigint_remote_twice_token);
if (sigint_remote_token)
- delete_async_signal_handler ((struct async_signal_handler **)
- &sigint_remote_token);
+ delete_async_signal_handler (&sigint_remote_token);
}
/* Send ^C to target to halt it. Target will respond, and send us a
remote_wait (ptid_t ptid, struct target_waitstatus *status)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf;
+ struct remote_arch_state *rsa = get_remote_arch_state ();
ULONGEST thread_num = -1;
ULONGEST addr;
+ int solibs_changed = 0;
status->kind = TARGET_WAITKIND_EXITED;
status->value.integer = 0;
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)
p = unpack_varlen_hex (++p1, &addr);
remote_watch_data_address = (CORE_ADDR)addr;
}
+ else if (strncmp (p, "library", p1 - p) == 0)
+ {
+ p1++;
+ p_temp = p1;
+ while (*p_temp && *p_temp != ';')
+ p_temp++;
+
+ solibs_changed = 1;
+ p = p_temp;
+ }
else
{
/* Silently skip unknown optional info. */
}
else
{
- struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
+ struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
p = p1;
if (*p++ != ':')
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 (get_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);
}
}
/* fall through */
case 'S': /* Old style status, just signal only. */
- status->kind = TARGET_WAITKIND_STOPPED;
- status->value.sig = (enum target_signal)
- (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
+ if (solibs_changed)
+ status->kind = TARGET_WAITKIND_LOADED;
+ else
+ {
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = (enum target_signal)
+ (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
+ }
if (buf[3] == 'p')
{
remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf;
+ struct remote_arch_state *rsa = get_remote_arch_state ();
ULONGEST thread_num = -1;
ULONGEST addr;
+ int solibs_changed = 0;
status->kind = TARGET_WAITKIND_EXITED;
status->value.integer = 0;
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)
/* If this packet is an awatch packet, don't parse the 'a'
as a register number. */
- if (!strncmp (p, "awatch", strlen ("awatch")) != 0)
+ if (strncmp (p, "awatch", strlen("awatch")) != 0)
{
/* Read the register number. */
pnum = strtol (p, &p_temp, 16);
p = unpack_varlen_hex (++p1, &addr);
remote_watch_data_address = (CORE_ADDR)addr;
}
+ else if (strncmp (p, "library", p1 - p) == 0)
+ {
+ p1++;
+ p_temp = p1;
+ while (*p_temp && *p_temp != ';')
+ p_temp++;
+
+ solibs_changed = 1;
+ p = p_temp;
+ }
else
{
/* Silently skip unknown optional info. */
else
{
- struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
+ struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
p = p1;
if (*p++ != ':')
error (_("Malformed packet(b) (missing colon): %s\n\
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);
+ regcache_raw_supply (get_current_regcache (),
+ reg->regnum, regs);
}
if (*p++ != ';')
}
/* fall through */
case 'S': /* Old style status, just signal only. */
- status->kind = TARGET_WAITKIND_STOPPED;
- status->value.sig = (enum target_signal)
- (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
+ if (solibs_changed)
+ status->kind = TARGET_WAITKIND_LOADED;
+ else
+ {
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = (enum target_signal)
+ (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
+ }
if (buf[3] == 'p')
{
return inferior_ptid;
}
-/* Number of bytes of registers this stub implements. */
-
-static int register_bytes_found;
-
-/* Read the remote registers into the block REGS. */
-/* Currently we just read all the registers, so we don't use regnum. */
+/* Fetch a single register using a 'p' packet. */
static int
-fetch_register_using_p (int regnum)
+fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf, *p;
+ char *buf, *p;
char regp[MAX_REGISTER_SIZE];
int i;
- p = buf;
+ if (remote_protocol_packets[PACKET_p].support == PACKET_DISABLE)
+ return 0;
+
+ if (reg->pnum == -1)
+ return 0;
+
+ p = rs->buf;
*p++ = 'p';
- p += hexnumstr (p, regnum);
+ p += hexnumstr (p, reg->pnum);
*p++ = '\0';
remote_send (&rs->buf, &rs->buf_size);
- /* If the stub didn't recognize the packet, or if we got an error,
- tell our caller. */
- if (buf[0] == '\0' || buf[0] == 'E')
- return 0;
+ buf = rs->buf;
+
+ switch (packet_ok (buf, &remote_protocol_packets[PACKET_p]))
+ {
+ case PACKET_OK:
+ break;
+ case PACKET_UNKNOWN:
+ return 0;
+ case PACKET_ERROR:
+ error (_("Could not fetch register \"%s\""),
+ gdbarch_register_name (current_gdbarch, reg->regnum));
+ }
/* If this register is unfetchable, tell the regcache. */
if (buf[0] == 'x')
{
- regcache_raw_supply (current_regcache, regnum, NULL);
- set_register_cached (regnum, -1);
+ regcache_raw_supply (regcache, reg->regnum, NULL);
return 1;
}
while (p[0] != 0)
{
if (p[1] == 0)
- {
- error (_("fetch_register_using_p: early buf termination"));
- return 0;
- }
+ error (_("fetch_register_using_p: early buf termination"));
regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
p += 2;
}
- regcache_raw_supply (current_regcache, regnum, regp);
+ regcache_raw_supply (regcache, reg->regnum, regp);
return 1;
}
-static void
-remote_fetch_registers (int regnum)
+/* Fetch the registers included in the target's 'g' packet. */
+
+static int
+send_g_packet (void)
{
struct remote_state *rs = get_remote_state ();
- char *buf = rs->buf;
- int i;
+ int i, buf_len;
char *p;
- char *regs = alloca (rs->sizeof_g_packet);
-
- set_thread (PIDGET (inferior_ptid), 1);
-
- if (regnum >= 0)
- {
- struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
- gdb_assert (reg != NULL);
- if (!reg->in_g_packet)
- internal_error (__FILE__, __LINE__,
- _("Attempt to fetch a non G-packet register when this "
- "remote.c does not support the p-packet."));
- }
- switch (remote_protocol_packets[PACKET_p].support)
- {
- case PACKET_DISABLE:
- break;
- case PACKET_ENABLE:
- if (fetch_register_using_p (regnum))
- return;
- else
- error (_("Protocol error: p packet not recognized by stub"));
- case PACKET_SUPPORT_UNKNOWN:
- if (fetch_register_using_p (regnum))
- {
- /* The stub recognized the 'p' packet. Remember this. */
- remote_protocol_packets[PACKET_p].support = PACKET_ENABLE;
- return;
- }
- else
- {
- /* The stub does not support the 'P' packet. Use 'G'
- instead, and don't try using 'P' in the future (it
- will just waste our time). */
- remote_protocol_packets[PACKET_p].support = PACKET_DISABLE;
- break;
- }
- }
+ char *regs;
- sprintf (buf, "g");
+ sprintf (rs->buf, "g");
remote_send (&rs->buf, &rs->buf_size);
- /* 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
- target can safely receive. */
- if ((rs->actual_register_packet_size) == 0)
- (rs->actual_register_packet_size) = strlen (buf);
-
- /* Unimplemented registers read as all bits zero. */
- memset (regs, 0, rs->sizeof_g_packet);
-
/* We can get out of synch in various cases. If the first character
in the buffer is not a hex character, assume that has happened
and try to fetch another packet to read. */
- while ((buf[0] < '0' || buf[0] > '9')
- && (buf[0] < 'A' || buf[0] > 'F')
- && (buf[0] < 'a' || buf[0] > 'f')
- && buf[0] != 'x') /* New: unavailable register value. */
+ while ((rs->buf[0] < '0' || rs->buf[0] > '9')
+ && (rs->buf[0] < 'A' || rs->buf[0] > 'F')
+ && (rs->buf[0] < 'a' || rs->buf[0] > 'f')
+ && rs->buf[0] != 'x') /* New: unavailable register value. */
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog,
getpkt (&rs->buf, &rs->buf_size, 0);
}
+ buf_len = strlen (rs->buf);
+
+ /* Sanity check the received packet. */
+ if (buf_len % 2 != 0)
+ error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf);
+
+ return buf_len / 2;
+}
+
+static void
+process_g_packet (struct regcache *regcache)
+{
+ struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
+ int i, buf_len;
+ char *p;
+ char *regs;
+
+ buf_len = strlen (rs->buf);
+
+ /* Further sanity checks, with knowledge of the architecture. */
+ if (buf_len > 2 * rsa->sizeof_g_packet)
+ error (_("Remote 'g' packet reply is too long: %s"), rs->buf);
+
+ /* Save the size of the packet sent to us by the target. It is used
+ as a heuristic when determining the max size of packets that the
+ target can safely receive. */
+ if (rsa->actual_register_packet_size == 0)
+ rsa->actual_register_packet_size = buf_len;
+
+ /* If this is smaller than we guessed the 'g' packet would be,
+ update our records. A 'g' reply that doesn't include a register's
+ value implies either that the register is not available, or that
+ the 'p' packet must be used. */
+ if (buf_len < 2 * rsa->sizeof_g_packet)
+ {
+ rsa->sizeof_g_packet = buf_len / 2;
+
+ for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
+ {
+ if (rsa->regs[i].pnum == -1)
+ continue;
+
+ if (rsa->regs[i].offset >= rsa->sizeof_g_packet)
+ rsa->regs[i].in_g_packet = 0;
+ else
+ rsa->regs[i].in_g_packet = 1;
+ }
+ }
+
+ regs = alloca (rsa->sizeof_g_packet);
+
+ /* Unimplemented registers read as all bits zero. */
+ memset (regs, 0, rsa->sizeof_g_packet);
+
/* Reply describes registers byte by byte, each byte encoded as two
hex characters. Suck them all up, then supply them to the
register cacheing/storage mechanism. */
- p = buf;
- for (i = 0; i < rs->sizeof_g_packet; i++)
+ p = rs->buf;
+ for (i = 0; i < rsa->sizeof_g_packet; i++)
{
- if (p[0] == 0)
- break;
- if (p[1] == 0)
- {
- warning (_("Remote reply is of odd length: %s"), buf);
- /* Don't change register_bytes_found in this case, and don't
- print a second warning. */
- goto supply_them;
- }
+ 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");
+
if (p[0] == 'x' && p[1] == 'x')
regs[i] = 0; /* 'x' */
else
p += 2;
}
- if (i != register_bytes_found)
- {
- register_bytes_found = i;
- if (REGISTER_BYTES_OK_P ()
- && !REGISTER_BYTES_OK (i))
- warning (_("Remote reply is too short: %s"), buf);
- }
-
- supply_them:
{
int i;
- for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
+ for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
{
- struct packet_reg *r = &rs->regs[i];
+ struct packet_reg *r = &rsa->regs[i];
if (r->in_g_packet)
{
- if (r->offset * 2 >= strlen (buf))
- /* A short packet that didn't include the register's
- value, this implies that the register is zero (and
- not that the register is unavailable). Supply that
- zero value. */
- regcache_raw_supply (current_regcache, r->regnum, NULL);
- else if (buf[r->offset * 2] == '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");
+ else if (rs->buf[r->offset * 2] == 'x')
{
- gdb_assert (r->offset * 2 < strlen (buf));
+ gdb_assert (r->offset * 2 < strlen (rs->buf));
/* The register isn't available, mark it as such (at
the same time setting the value to zero). */
- regcache_raw_supply (current_regcache, r->regnum, NULL);
- set_register_cached (i, -1);
+ regcache_raw_supply (regcache, r->regnum, NULL);
}
else
- regcache_raw_supply (current_regcache, r->regnum,
+ regcache_raw_supply (regcache, r->regnum,
regs + r->offset);
}
}
}
}
+static void
+fetch_registers_using_g (struct regcache *regcache)
+{
+ send_g_packet ();
+ process_g_packet (regcache);
+}
+
+static void
+remote_fetch_registers (struct regcache *regcache, int regnum)
+{
+ struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
+ int i;
+
+ set_thread (PIDGET (inferior_ptid), 1);
+
+ if (regnum >= 0)
+ {
+ struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
+ gdb_assert (reg != NULL);
+
+ /* If this register might be in the 'g' packet, try that first -
+ we are likely to read more than one register. If this is the
+ first 'g' packet, we might be overly optimistic about its
+ contents, so fall back to 'p'. */
+ if (reg->in_g_packet)
+ {
+ fetch_registers_using_g (regcache);
+ if (reg->in_g_packet)
+ return;
+ }
+
+ if (fetch_register_using_p (regcache, reg))
+ return;
+
+ /* This register is not available. */
+ regcache_raw_supply (regcache, reg->regnum, NULL);
+
+ return;
+ }
+
+ fetch_registers_using_g (regcache);
+
+ for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
+ if (!rsa->regs[i].in_g_packet)
+ if (!fetch_register_using_p (regcache, &rsa->regs[i]))
+ {
+ /* This register is not available. */
+ regcache_raw_supply (regcache, i, NULL);
+ }
+}
+
/* Prepare to store registers. Since we may send them all (using a
'G' request), we have to read out the ones we don't want to change
first. */
static void
-remote_prepare_to_store (void)
+remote_prepare_to_store (struct regcache *regcache)
{
- struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
int i;
gdb_byte buf[MAX_REGISTER_SIZE];
case PACKET_DISABLE:
case PACKET_SUPPORT_UNKNOWN:
/* Make sure all the necessary registers are cached. */
- for (i = 0; i < NUM_REGS; i++)
- if (rs->regs[i].in_g_packet)
- regcache_raw_read (current_regcache, rs->regs[i].regnum, buf);
+ for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
+ if (rsa->regs[i].in_g_packet)
+ regcache_raw_read (regcache, rsa->regs[i].regnum, buf);
break;
case PACKET_ENABLE:
break;
packet was not recognized. */
static int
-store_register_using_P (int regnum)
+store_register_using_P (const struct regcache *regcache, struct packet_reg *reg)
{
struct remote_state *rs = get_remote_state ();
- struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
+ struct remote_arch_state *rsa = get_remote_arch_state ();
/* Try storing a single register. */
char *buf = rs->buf;
gdb_byte regp[MAX_REGISTER_SIZE];
char *p;
- xsnprintf (buf, rs->remote_packet_size, "P%s=", phex_nz (reg->pnum, 0));
+ if (remote_protocol_packets[PACKET_P].support == PACKET_DISABLE)
+ return 0;
+
+ if (reg->pnum == -1)
+ return 0;
+
+ xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
p = buf + strlen (buf);
- regcache_raw_collect (current_regcache, reg->regnum, regp);
+ regcache_raw_collect (regcache, reg->regnum, regp);
bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
remote_send (&rs->buf, &rs->buf_size);
- return buf[0] != '\0';
+ switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
+ {
+ case PACKET_OK:
+ return 1;
+ case PACKET_ERROR:
+ error (_("Could not write register \"%s\""),
+ gdbarch_register_name (current_gdbarch, reg->regnum));
+ case PACKET_UNKNOWN:
+ return 0;
+ default:
+ internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
+ }
}
-
/* Store register REGNUM, or all registers if REGNUM == -1, from the
contents of the register cache buffer. FIXME: ignores errors. */
static void
-remote_store_registers (int regnum)
+store_registers_using_G (const struct regcache *regcache)
{
struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
gdb_byte *regs;
char *p;
- set_thread (PIDGET (inferior_ptid), 1);
-
- if (regnum >= 0)
- {
- switch (remote_protocol_packets[PACKET_P].support)
- {
- case PACKET_DISABLE:
- break;
- case PACKET_ENABLE:
- if (store_register_using_P (regnum))
- return;
- else
- error (_("Protocol error: P packet not recognized by stub"));
- case PACKET_SUPPORT_UNKNOWN:
- if (store_register_using_P (regnum))
- {
- /* The stub recognized the 'P' packet. Remember this. */
- remote_protocol_packets[PACKET_P].support = PACKET_ENABLE;
- return;
- }
- else
- {
- /* The stub does not support the 'P' packet. Use 'G'
- instead, and don't try using 'P' in the future (it
- will just waste our time). */
- remote_protocol_packets[PACKET_P].support = PACKET_DISABLE;
- break;
- }
- }
- }
-
/* Extract all the registers in the regcache copying them into a
local buffer. */
{
int i;
- regs = alloca (rs->sizeof_g_packet);
- memset (regs, 0, rs->sizeof_g_packet);
- for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
+ regs = alloca (rsa->sizeof_g_packet);
+ memset (regs, 0, rsa->sizeof_g_packet);
+ for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
{
- struct packet_reg *r = &rs->regs[i];
+ struct packet_reg *r = &rsa->regs[i];
if (r->in_g_packet)
- regcache_raw_collect (current_regcache, r->regnum, regs + r->offset);
+ regcache_raw_collect (regcache, r->regnum, regs + r->offset);
}
}
each byte encoded as two hex characters. */
p = rs->buf;
*p++ = 'G';
- /* remote_prepare_to_store insures that register_bytes_found gets set. */
- bin2hex (regs, p, register_bytes_found);
+ /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
+ updated. */
+ bin2hex (regs, p, rsa->sizeof_g_packet);
remote_send (&rs->buf, &rs->buf_size);
}
+
+/* Store register REGNUM, or all registers if REGNUM == -1, from the contents
+ of the register cache buffer. FIXME: ignores errors. */
+
+static void
+remote_store_registers (struct regcache *regcache, int regnum)
+{
+ struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
+ int i;
+
+ set_thread (PIDGET (inferior_ptid), 1);
+
+ if (regnum >= 0)
+ {
+ struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
+ gdb_assert (reg != NULL);
+
+ /* Always prefer to store registers using the 'P' packet if
+ possible; we often change only a small number of registers.
+ Sometimes we change a larger number; we'd need help from a
+ higher layer to know to use 'G'. */
+ if (store_register_using_P (regcache, reg))
+ return;
+
+ /* 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... */
+ if (!reg->in_g_packet)
+ return;
+
+ store_registers_using_G (regcache);
+ return;
+ }
+
+ store_registers_using_G (regcache);
+
+ for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
+ if (!rsa->regs[i].in_g_packet)
+ if (!store_register_using_P (regcache, &rsa->regs[i]))
+ /* See above for why we do not issue an error here. */
+ continue;
+}
\f
/* Return the number of hex digits in num. */
static CORE_ADDR
remote_address_masked (CORE_ADDR addr)
{
- if (remote_address_size > 0
- && remote_address_size < (sizeof (ULONGEST) * 8))
+ int address_size = remote_address_size;
+ /* If "remoteaddresssize" was not set, default to target address size. */
+ if (!address_size)
+ address_size = gdbarch_addr_bit (current_gdbarch);
+
+ if (address_size > 0
+ && address_size < (sizeof (ULONGEST) * 8))
{
/* Only create a mask when that mask can safely be constructed
in a ULONGEST variable. */
ULONGEST mask = 1;
- mask = (mask << remote_address_size) - 1;
+ mask = (mask << address_size) - 1;
addr &= mask;
}
return addr;
}
+/* Convert BUFFER, binary data at least LEN bytes long, into escaped
+ binary data in OUT_BUF. Set *OUT_LEN to the length of the data
+ encoded in OUT_BUF, and return the number of bytes in OUT_BUF
+ (which may be more than *OUT_LEN due to escape characters). The
+ total number of bytes in the output buffer will be at most
+ OUT_MAXLEN. */
+
+static int
+remote_escape_output (const gdb_byte *buffer, int len,
+ gdb_byte *out_buf, int *out_len,
+ int out_maxlen)
+{
+ int input_index, output_index;
+
+ output_index = 0;
+ for (input_index = 0; input_index < len; input_index++)
+ {
+ gdb_byte b = buffer[input_index];
+
+ if (b == '$' || b == '#' || b == '}')
+ {
+ /* These must be escaped. */
+ if (output_index + 2 > out_maxlen)
+ break;
+ out_buf[output_index++] = '}';
+ out_buf[output_index++] = b ^ 0x20;
+ }
+ else
+ {
+ if (output_index + 1 > out_maxlen)
+ break;
+ out_buf[output_index++] = b;
+ }
+ }
+
+ *out_len = input_index;
+ return output_index;
+}
+
+/* Convert BUFFER, escaped data LEN bytes long, into binary data
+ in OUT_BUF. Return the number of bytes written to OUT_BUF.
+ Raise an error if the total number of bytes exceeds OUT_MAXLEN.
+
+ This function reverses remote_escape_output. It allows more
+ escaped characters than that function does, in particular because
+ '*' must be escaped to avoid the run-length encoding processing
+ in reading packets. */
+
+static int
+remote_unescape_input (const gdb_byte *buffer, int len,
+ gdb_byte *out_buf, int out_maxlen)
+{
+ int input_index, output_index;
+ int escaped;
+
+ output_index = 0;
+ escaped = 0;
+ for (input_index = 0; input_index < len; input_index++)
+ {
+ gdb_byte b = buffer[input_index];
+
+ if (output_index + 1 > out_maxlen)
+ {
+ warning (_("Received too much data from remote target;"
+ " ignoring overflow."));
+ return output_index;
+ }
+
+ if (escaped)
+ {
+ out_buf[output_index++] = b ^ 0x20;
+ escaped = 0;
+ }
+ else if (b == '}')
+ escaped = 1;
+ else
+ out_buf[output_index++] = b;
+ }
+
+ if (escaped)
+ error (_("Unmatched escape character in target response."));
+
+ return output_index;
+}
+
/* Determine whether the remote target supports binary downloading.
This is accomplished by sending a no-op memory write of zero length
to the target at the specified address. It does not suffice to send
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;
- char *payload_start;
+ 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");
+
+ 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"));
+ /* If we already need another packet, then try to align the end
+ of this packet to a useful boundary. */
+ if (todo > 2 * REMOTE_ALIGN_WRITES && todo < len)
+ todo = ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr;
+
/* Append "<memaddr>". */
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. */
- payload_start = p;
- 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. */
- for (nr_bytes = 0;
- (nr_bytes < todo) && (p - payload_start) < payload_size;
- nr_bytes++)
+ payload_length = remote_escape_output (myaddr, todo, p, &nr_bytes,
+ 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. Don't do
+ this if the packet is tiny. */
+ if (nr_bytes < todo && nr_bytes > 2 * REMOTE_ALIGN_WRITES)
{
- switch (myaddr[nr_bytes] & 0xff)
- {
- case '$':
- case '#':
- case 0x7d:
- /* These must be escaped. */
- *p++ = 0x7d;
- *p++ = (myaddr[nr_bytes] & 0xff) ^ 0x20;
- break;
- default:
- *p++ = myaddr[nr_bytes] & 0xff;
- break;
- }
+ int new_nr_bytes;
+
+ new_nr_bytes = (((memaddr + nr_bytes) & ~(REMOTE_ALIGN_WRITES - 1))
+ - memaddr);
+ if (new_nr_bytes != nr_bytes)
+ payload_length = remote_escape_output (myaddr, new_nr_bytes,
+ p, &nr_bytes,
+ payload_size);
}
- if (nr_bytes < todo)
+
+ p += payload_length;
+ 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() */
}
+ }
+ 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;
+ }
+
+ putpkt_binary (rs->buf, (int) (p - rs->buf));
+ getpkt (&rs->buf, &rs->buf_size, 0);
+
+ 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
+ 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 NR_BYTES, not TODO, in case escape chars caused us to send
+ fewer bytes than we'd planned. */
+ 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:
- /* 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;
+ packet_format = "M";
break;
case PACKET_SUPPORT_UNKNOWN:
internal_error (__FILE__, __LINE__,
internal_error (__FILE__, __LINE__, _("bad switch"));
}
- putpkt_binary (buf, (int) (p - buf));
- getpkt (&rs->buf, &rs->buf_size, 0);
-
- if (buf[0] == 'E')
- {
- /* 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 NR_BYTES, not TODO, in case escape chars caused us to send
- fewer bytes than we'd planned. */
- return nr_bytes;
+ return remote_write_bytes_aux (packet_format,
+ memaddr, myaddr, len, packet_format[0], 1);
}
/* Read memory data directly from the remote machine.
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;
+ 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)
{
/* Stuff for dealing with the packets which are part of this protocol.
See comment at top of file for details. */
-/* Read a single character from the remote end, masking it down to 7
- bits. */
+/* Read a single character from the remote end. */
static int
readchar (int timeout)
ch = serial_readchar (remote_desc, timeout);
if (ch >= 0)
- return (ch & 0x7f);
+ return ch;
switch ((enum serial_rc) ch)
{
/* Send a packet to the remote machine, with error checking. The data
of the packet is in BUF. The string in BUF can be at most
- RS->remote_packet_size - 5 to account for the $, # and checksum,
+ get_remote_packet_size () - 5 to account for the $, # and checksum,
and for a possible /0 if we are debugging (remote_debug) and want
to print the sent packet as a string. */
static int
putpkt_binary (char *buf, int cnt)
{
- struct remote_state *rs = get_remote_state ();
int i;
unsigned char csum = 0;
char *buf2 = alloca (cnt + 6);
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;
}
fprintf_filtered (gdb_stdlog,
"Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
pktcsum, csum);
- fputs_filtered (buf, gdb_stdlog);
+ fputstrn_filtered (buf, bc, 0, gdb_stdlog);
fputs_filtered ("\n", gdb_stdlog);
}
/* Number of characters in buffer ignoring trailing
rather than timing out; this is used (in synchronous mode) to wait
for a target that is is executing user code to stop. If FOREVER ==
0, this function is allowed to time out gracefully and return an
- indication of this to the caller. */
+ indication of this to the caller. Otherwise return the number
+ of bytes read. */
static int
getpkt_sane (char **buf, long *sizeof_buf, int forever)
{
if (remote_debug)
{
fprintf_unfiltered (gdb_stdlog, "Packet received: ");
- fputstr_unfiltered (*buf, 0, gdb_stdlog);
+ fputstrn_unfiltered (*buf, val, 0, gdb_stdlog);
fprintf_unfiltered (gdb_stdlog, "\n");
}
serial_write (remote_desc, "+", 1);
- return 0;
+ return val;
}
/* Try the whole thing again. */
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"));
serial_write (remote_desc, "+", 1);
- return 1;
+ return -1;
}
\f
static void
/* Now restart the remote server. */
extended_remote_restart ();
+ /* NOTE: We don't need to recheck for a target description here; but
+ if we gain the ability to switch the remote executable we may
+ need to, if for instance we are running a process which requested
+ different emulated hardware from the operating system. A
+ concrete example of this is ARM GNU/Linux, where some binaries
+ will have a legacy FPA coprocessor emulated and others may have
+ access to a hardware VFP unit. */
+
/* Now put the breakpoints back in. This way we're safe if the
restart function works via a unix fork on the remote side. */
insert_breakpoints ();
/* Now restart the remote server. */
extended_remote_restart ();
+ /* NOTE: We don't need to recheck for a target description here; but
+ if we gain the ability to switch the remote executable we may
+ need to, if for instance we are running a process which requested
+ different emulated hardware from the operating system. A
+ concrete example of this is ARM GNU/Linux, where some binaries
+ will have a legacy FPA coprocessor emulated and others may have
+ access to a hardware VFP unit. */
+
/* Now put the breakpoints back in. This way we're safe if the
restart function works via a unix fork on the remote side. */
insert_breakpoints ();
}
\f
-/* On some machines, e.g. 68k, we may use a different breakpoint
- instruction than other targets; in those use
- DEPRECATED_REMOTE_BREAKPOINT instead of just BREAKPOINT_FROM_PC.
- Also, bi-endian targets may define
- DEPRECATED_LITTLE_REMOTE_BREAKPOINT and
- DEPRECATED_BIG_REMOTE_BREAKPOINT. If none of these are defined, we
- just call the standard routines that are in mem-break.c. */
-
-/* NOTE: cagney/2003-06-08: This is silly. A remote and simulator
- target should use an identical BREAKPOINT_FROM_PC. As for native,
- the ARCH-OS-tdep.c code can override the default. */
-
-#if defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && defined (DEPRECATED_BIG_REMOTE_BREAKPOINT) && !defined(DEPRECATED_REMOTE_BREAKPOINT)
-#define DEPRECATED_REMOTE_BREAKPOINT
-#endif
-
-#ifdef DEPRECATED_REMOTE_BREAKPOINT
-
-/* If the target isn't bi-endian, just pretend it is. */
-#if !defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && !defined (DEPRECATED_BIG_REMOTE_BREAKPOINT)
-#define DEPRECATED_LITTLE_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
-#define DEPRECATED_BIG_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
-#endif
-
-static unsigned char big_break_insn[] = DEPRECATED_BIG_REMOTE_BREAKPOINT;
-static unsigned char little_break_insn[] = DEPRECATED_LITTLE_REMOTE_BREAKPOINT;
-
-#endif /* DEPRECATED_REMOTE_BREAKPOINT */
-
-/* Insert a breakpoint on targets that don't have any better
- breakpoint support. We read the contents of the target location
- and stash it, then overwrite it with a breakpoint instruction.
- ADDR is the target location in the target machine. CONTENTS_CACHE
- is a pointer to memory allocated for saving the target contents.
- It is guaranteed by the caller to be long enough to save the number
- of bytes returned by BREAKPOINT_FROM_PC. */
+/* Insert a breakpoint. On targets that have software breakpoint
+ support, we ask the remote target to do the work; on targets
+ which don't, we insert a traditional memory breakpoint. */
static int
-remote_insert_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
+remote_insert_breakpoint (struct bp_target_info *bp_tgt)
{
+ CORE_ADDR addr = bp_tgt->placed_address;
struct remote_state *rs = get_remote_state ();
-#ifdef DEPRECATED_REMOTE_BREAKPOINT
- int val;
-#endif
- int bp_size;
/* Try the "Z" s/w breakpoint packet if it is not already disabled.
If it succeeds, then set the support to PACKET_ENABLE. If it
{
char *p = rs->buf;
- addr = remote_address_masked (addr);
*(p++) = 'Z';
*(p++) = '0';
*(p++) = ',';
- p += hexnumstr (p, (ULONGEST) addr);
- BREAKPOINT_FROM_PC (&addr, &bp_size);
- sprintf (p, ",%d", bp_size);
+ gdbarch_breakpoint_from_pc
+ (current_gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
+ addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
+ p += hexnumstr (p, addr);
+ sprintf (p, ",%d", bp_tgt->placed_size);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
}
}
-#ifdef DEPRECATED_REMOTE_BREAKPOINT
- val = target_read_memory (addr, contents_cache, sizeof big_break_insn);
-
- if (val == 0)
- {
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
- val = target_write_memory (addr, (char *) big_break_insn,
- sizeof big_break_insn);
- else
- val = target_write_memory (addr, (char *) little_break_insn,
- sizeof little_break_insn);
- }
-
- return val;
-#else
- return memory_insert_breakpoint (addr, contents_cache);
-#endif /* DEPRECATED_REMOTE_BREAKPOINT */
+ return memory_insert_breakpoint (bp_tgt);
}
static int
-remote_remove_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
+remote_remove_breakpoint (struct bp_target_info *bp_tgt)
{
+ CORE_ADDR addr = bp_tgt->placed_address;
struct remote_state *rs = get_remote_state ();
int bp_size;
*(p++) = '0';
*(p++) = ',';
- addr = remote_address_masked (addr);
- p += hexnumstr (p, (ULONGEST) addr);
- BREAKPOINT_FROM_PC (&addr, &bp_size);
- sprintf (p, ",%d", bp_size);
+ addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
+ p += hexnumstr (p, addr);
+ sprintf (p, ",%d", bp_tgt->placed_size);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
return (rs->buf[0] == 'E');
}
-#ifdef DEPRECATED_REMOTE_BREAKPOINT
- return target_write_memory (addr, contents_cache, sizeof big_break_insn);
-#else
- return memory_remove_breakpoint (addr, contents_cache);
-#endif /* DEPRECATED_REMOTE_BREAKPOINT */
+ return memory_remove_breakpoint (bp_tgt);
}
static int
enum Z_packet_type packet = watchpoint_to_Z_packet (type);
if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
- error (_("Can't set hardware watchpoints without the '%s' (%s) packet."),
- remote_protocol_packets[PACKET_Z0 + packet].name,
- remote_protocol_packets[PACKET_Z0 + packet].title);
+ return -1;
sprintf (rs->buf, "Z%x,", packet);
p = strchr (rs->buf, '\0');
enum Z_packet_type packet = watchpoint_to_Z_packet (type);
if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
- error (_("Can't clear hardware watchpoints without the '%s' (%s) packet."),
- remote_protocol_packets[PACKET_Z0 + packet].name,
- remote_protocol_packets[PACKET_Z0 + packet].title);
+ return -1;
sprintf (rs->buf, "z%x,", packet);
p = strchr (rs->buf, '\0');
static int
-remote_insert_hw_breakpoint (CORE_ADDR addr, gdb_byte *shadow)
+remote_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
{
- int len = 0;
+ CORE_ADDR addr;
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
/* The length field should be set to the size of a breakpoint
- instruction. */
+ instruction, even though we aren't inserting one ourselves. */
- BREAKPOINT_FROM_PC (&addr, &len);
+ gdbarch_breakpoint_from_pc
+ (current_gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
- error (_("Can't set hardware breakpoint without the '%s' (%s) packet."),
- remote_protocol_packets[PACKET_Z1].name,
- remote_protocol_packets[PACKET_Z1].title);
+ return -1;
*(p++) = 'Z';
*(p++) = '1';
*(p++) = ',';
- addr = remote_address_masked (addr);
+ addr = remote_address_masked (bp_tgt->placed_address);
p += hexnumstr (p, (ULONGEST) addr);
- sprintf (p, ",%x", len);
+ sprintf (p, ",%x", bp_tgt->placed_size);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
static int
-remote_remove_hw_breakpoint (CORE_ADDR addr, gdb_byte *shadow)
+remote_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
{
- int len;
+ CORE_ADDR addr;
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
- /* The length field should be set to the size of a breakpoint
- instruction. */
-
- BREAKPOINT_FROM_PC (&addr, &len);
-
if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
- error (_("Can't clear hardware breakpoint without the '%s' (%s) packet."),
- remote_protocol_packets[PACKET_Z1].name,
- remote_protocol_packets[PACKET_Z1].title);
+ return -1;
*(p++) = 'z';
*(p++) = '1';
*(p++) = ',';
- addr = remote_address_masked (addr);
+ addr = remote_address_masked (bp_tgt->placed_address);
p += hexnumstr (p, (ULONGEST) addr);
- sprintf (p, ",%x", len);
+ sprintf (p, ",%x", bp_tgt->placed_size);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
matched = 1; /* do this section */
lma = s->lma;
/* FIXME: assumes lma can fit into long. */
- xsnprintf (rs->buf, rs->remote_packet_size, "qCRC:%lx,%lx",
+ xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
(long) lma, (long) size);
putpkt (rs->buf);
printf_filtered (_("No loaded section named '%s'.\n"), args);
}
+/* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
+ into remote target. The number of bytes written to the remote
+ target is returned, or -1 for error. */
+
+static LONGEST
+remote_write_qxfer (struct target_ops *ops, const char *object_name,
+ const char *annex, const gdb_byte *writebuf,
+ ULONGEST offset, LONGEST len,
+ struct packet_config *packet)
+{
+ int i, buf_len;
+ ULONGEST n;
+ gdb_byte *wbuf;
+ struct remote_state *rs = get_remote_state ();
+ int max_size = get_memory_write_packet_size ();
+
+ if (packet->support == PACKET_DISABLE)
+ return -1;
+
+ /* Insert header. */
+ i = snprintf (rs->buf, max_size,
+ "qXfer:%s:write:%s:%s:",
+ object_name, annex ? annex : "",
+ phex_nz (offset, sizeof offset));
+ max_size -= (i + 1);
+
+ /* Escape as much data as fits into rs->buf. */
+ buf_len = remote_escape_output
+ (writebuf, len, (rs->buf + i), &max_size, max_size);
+
+ if (putpkt_binary (rs->buf, i + buf_len) < 0
+ || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
+ || packet_ok (rs->buf, packet) != PACKET_OK)
+ return -1;
+
+ unpack_varlen_hex (rs->buf, &n);
+ return n;
+}
+
+/* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
+ Data at OFFSET, of up to LEN bytes, is read into READBUF; the
+ number of bytes read is returned, or 0 for EOF, or -1 for error.
+ The number of bytes read may be less than LEN without indicating an
+ EOF. PACKET is checked and updated to indicate whether the remote
+ target supports this object. */
+
+static LONGEST
+remote_read_qxfer (struct target_ops *ops, const char *object_name,
+ const char *annex,
+ gdb_byte *readbuf, ULONGEST offset, LONGEST len,
+ struct packet_config *packet)
+{
+ static char *finished_object;
+ static char *finished_annex;
+ static ULONGEST finished_offset;
+
+ struct remote_state *rs = get_remote_state ();
+ unsigned int total = 0;
+ LONGEST i, n, packet_len;
+
+ if (packet->support == PACKET_DISABLE)
+ return -1;
+
+ /* Check whether we've cached an end-of-object packet that matches
+ this request. */
+ if (finished_object)
+ {
+ if (strcmp (object_name, finished_object) == 0
+ && strcmp (annex ? annex : "", finished_annex) == 0
+ && offset == finished_offset)
+ return 0;
+
+ /* Otherwise, we're now reading something different. Discard
+ the cache. */
+ xfree (finished_object);
+ xfree (finished_annex);
+ finished_object = NULL;
+ finished_annex = NULL;
+ }
+
+ /* Request only enough to fit in a single packet. The actual data
+ may not, since we don't know how much of it will need to be escaped;
+ the target is free to respond with slightly less data. We subtract
+ five to account for the response type and the protocol frame. */
+ n = min (get_remote_packet_size () - 5, len);
+ snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
+ object_name, annex ? annex : "",
+ phex_nz (offset, sizeof offset),
+ phex_nz (n, sizeof n));
+ i = putpkt (rs->buf);
+ if (i < 0)
+ return -1;
+
+ rs->buf[0] = '\0';
+ packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0);
+ if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
+ return -1;
+
+ if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
+ error (_("Unknown remote qXfer reply: %s"), rs->buf);
+
+ /* 'm' means there is (or at least might be) more data after this
+ batch. That does not make sense unless there's at least one byte
+ of data in this reply. */
+ if (rs->buf[0] == 'm' && packet_len == 1)
+ error (_("Remote qXfer reply contained no data."));
+
+ /* Got some data. */
+ i = remote_unescape_input (rs->buf + 1, packet_len - 1, readbuf, n);
+
+ /* 'l' is an EOF marker, possibly including a final block of data,
+ or possibly empty. If we have the final block of a non-empty
+ object, record this fact to bypass a subsequent partial read. */
+ if (rs->buf[0] == 'l' && offset + i > 0)
+ {
+ finished_object = xstrdup (object_name);
+ finished_annex = xstrdup (annex ? annex : "");
+ finished_offset = offset + i;
+ }
+
+ return i;
+}
+
static LONGEST
remote_xfer_partial (struct target_ops *ops, enum target_object object,
const char *annex, gdb_byte *readbuf,
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;
+ /* Handle SPU memory using qxfer packets. */
+ if (object == TARGET_OBJECT_SPU)
+ {
+ if (readbuf)
+ return remote_read_qxfer (ops, "spu", annex, readbuf, offset, len,
+ &remote_protocol_packets
+ [PACKET_qXfer_spu_read]);
+ else
+ return remote_write_qxfer (ops, "spu", annex, writebuf, offset, len,
+ &remote_protocol_packets
+ [PACKET_qXfer_spu_write]);
+ }
+
+ /* 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. */
switch (object)
{
- case TARGET_OBJECT_KOD:
- query_type = 'K';
- break;
case TARGET_OBJECT_AVR:
query_type = 'R';
break;
case TARGET_OBJECT_AUXV:
- if (remote_protocol_packets[PACKET_qPart_auxv].support != PACKET_DISABLE)
- {
- unsigned int total = 0;
- while (len > 0)
- {
- LONGEST n = min ((rs->remote_packet_size - 2) / 2, len);
- snprintf (rs->buf, rs->remote_packet_size,
- "qPart:auxv:read::%s,%s",
- phex_nz (offset, sizeof offset),
- phex_nz (n, sizeof n));
- i = putpkt (rs->buf);
- if (i < 0)
- return total > 0 ? total : i;
- rs->buf[0] = '\0';
- getpkt (&rs->buf, &rs->buf_size, 0);
- if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qPart_auxv])
- != PACKET_OK)
- return total > 0 ? total : -1;
- if (strcmp (rs->buf, "OK") == 0)
- break; /* Got EOF indicator. */
- /* Got some data. */
- i = hex2bin (rs->buf, readbuf, len);
- if (i > 0)
- {
- readbuf = (void *) ((char *) readbuf + i);
- offset += i;
- len -= i;
- total += i;
- }
- }
- return total;
- }
- return -1;
+ gdb_assert (annex == NULL);
+ return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
+ &remote_protocol_packets[PACKET_qXfer_auxv]);
+
+ case TARGET_OBJECT_AVAILABLE_FEATURES:
+ return remote_read_qxfer
+ (ops, "features", annex, readbuf, offset, len,
+ &remote_protocol_packets[PACKET_qXfer_features]);
+
+ case TARGET_OBJECT_LIBRARIES:
+ return remote_read_qxfer
+ (ops, "libraries", annex, readbuf, offset, len,
+ &remote_protocol_packets[PACKET_qXfer_libraries]);
+
+ 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;
/* Note: a zero OFFSET and LEN can be used to query the minimum
buffer size. */
if (offset == 0 && len == 0)
- return (rs->remote_packet_size);
- /* Minimum outbuf size is RS->remote_packet_size. If LEN is not
+ return (get_remote_packet_size ());
+ /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
large enough let the caller deal with it. */
- if (len < rs->remote_packet_size)
+ if (len < get_remote_packet_size ())
return -1;
- len = rs->remote_packet_size;
+ len = get_remote_packet_size ();
/* Except for querying the minimum buffer size, target must be open. */
if (!remote_desc)
(remote_debug), we have PBUFZIZ - 7 left to pack the query
string. */
i = 0;
- while (annex[i] && (i < (rs->remote_packet_size - 8)))
+ while (annex[i] && (i < (get_remote_packet_size () - 8)))
{
/* Bad caller may have sent forbidden characters. */
gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
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*/) > rs->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)
{
{
static char buf[32];
- xsnprintf (buf, sizeof buf, "thread %d", ptid_get_pid (ptid));
+ xsnprintf (buf, sizeof buf, "Thread %d", ptid_get_pid (ptid));
return buf;
}
return 0;
}
+/* Support for inferring a target description based on the current
+ architecture and the size of a 'g' packet. While the 'g' packet
+ can have any size (since optional registers can be left off the
+ end), some sizes are easily recognizable given knowledge of the
+ approximate architecture. */
+
+struct remote_g_packet_guess
+{
+ int bytes;
+ const struct target_desc *tdesc;
+};
+typedef struct remote_g_packet_guess remote_g_packet_guess_s;
+DEF_VEC_O(remote_g_packet_guess_s);
+
+struct remote_g_packet_data
+{
+ VEC(remote_g_packet_guess_s) *guesses;
+};
+
+static struct gdbarch_data *remote_g_packet_data_handle;
+
+static void *
+remote_g_packet_data_init (struct obstack *obstack)
+{
+ return OBSTACK_ZALLOC (obstack, struct remote_g_packet_data);
+}
+
+void
+register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes,
+ const struct target_desc *tdesc)
+{
+ struct remote_g_packet_data *data
+ = gdbarch_data (gdbarch, remote_g_packet_data_handle);
+ struct remote_g_packet_guess new_guess, *guess;
+ int ix;
+
+ gdb_assert (tdesc != NULL);
+
+ for (ix = 0;
+ VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
+ ix++)
+ if (guess->bytes == bytes)
+ internal_error (__FILE__, __LINE__,
+ "Duplicate g packet description added for size %d",
+ bytes);
+
+ new_guess.bytes = bytes;
+ new_guess.tdesc = tdesc;
+ VEC_safe_push (remote_g_packet_guess_s, data->guesses, &new_guess);
+}
+
+static const struct target_desc *
+remote_read_description (struct target_ops *target)
+{
+ struct remote_g_packet_data *data
+ = gdbarch_data (current_gdbarch, remote_g_packet_data_handle);
+
+ if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
+ {
+ struct remote_g_packet_guess *guess;
+ int ix;
+ int bytes = send_g_packet ();
+
+ for (ix = 0;
+ VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
+ ix++)
+ if (guess->bytes == bytes)
+ return guess->tdesc;
+
+ /* We discard the g packet. A minor optimization would be to
+ hold on to it, and fill the register cache once we have selected
+ an architecture, but it's too tricky to do safely. */
+ }
+
+ return NULL;
+}
+
static void
init_remote_ops (void)
{
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;
+ remote_ops.to_read_description = remote_read_description;
}
/* 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;
+ remote_async_ops.to_read_description = remote_read_description;
}
/* Set up the async extended remote vector by making a copy of the standard
extended_async_remote_ops.to_mourn_inferior = extended_remote_mourn;
}
-static struct cmd_list_element *remote_set_cmdlist;
-static struct cmd_list_element *remote_show_cmdlist;
-
static void
set_remote_cmd (char *args, int from_tty)
{
+ help_list (remote_set_cmdlist, "set remote ", -1, gdb_stdout);
}
static void
show_remote_cmd (char *args, int from_tty)
{
/* We can't just use cmd_show_list here, because we want to skip
- the redundant "show remote Z-packet". */
+ the redundant "show remote Z-packet" and the legacy aliases. */
struct cleanup *showlist_chain;
struct cmd_list_element *list = remote_show_cmdlist;
for (; list != NULL; list = list->next)
if (strcmp (list->name, "Z-packet") == 0)
continue;
- else if (list->type == show_cmd)
+ else if (list->type == not_set_cmd)
+ /* Alias commands are exactly like the original, except they
+ don't have the normal type. */
+ continue;
+ else
{
struct cleanup *option_chain
= make_cleanup_ui_out_tuple_begin_end (uiout, "option");
ui_out_field_string (uiout, "name", list->name);
ui_out_text (uiout, ": ");
- do_setshow_command ((char *) NULL, from_tty, list);
+ if (list->type == show_cmd)
+ do_setshow_command ((char *) NULL, from_tty, list);
+ else
+ cmd_func (list, NULL, from_tty);
/* Close the tuple. */
do_cleanups (option_chain);
}
-}
-static void
-build_remote_gdbarch_data (void)
-{
- remote_address_size = TARGET_ADDR_BIT;
+ /* Close the tuple. */
+ do_cleanups (showlist_chain);
}
-/* Saved pointer to previous owner of the new_objfile event. */
-static void (*remote_new_objfile_chain) (struct objfile *);
/* Function to be called whenever a new objfile (shlib) is detected. */
static void
remote_new_objfile (struct objfile *objfile)
{
if (remote_desc != 0) /* Have a remote connection. */
- {
- remote_check_symbols (objfile);
- }
- /* Call predecessor on chain, if any. */
- if (remote_new_objfile_chain != 0 &&
- remote_desc == 0)
- remote_new_objfile_chain (objfile);
+ remote_check_symbols (objfile);
}
void
_initialize_remote (void)
{
+ 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
- that the remote protocol has been initialized. */
- DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size);
- deprecated_register_gdbarch_swap (NULL, 0, build_remote_gdbarch_data);
+ remote_g_packet_data_handle =
+ gdbarch_data_register_pre_init (remote_g_packet_data_init);
+
+ /* Initialize the per-target state. At the moment there is only one
+ 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_raw ();
+ rs->buf_size = 400;
+ rs->buf = xmalloc (rs->buf_size);
init_remote_ops ();
add_target (&remote_ops);
add_target (&extended_async_remote_ops);
/* Hook into new objfile notification. */
- remote_new_objfile_chain = deprecated_target_new_objfile_hook;
- deprecated_target_new_objfile_hook = remote_new_objfile;
+ observer_attach_new_objfile (remote_new_objfile);
#if 0
init_remote_threadtests ();
&setlist, &showlist);
add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
- "X", "binary-download",
- set_remote_protocol_packet_cmd,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 1);
+ "X", "binary-download", 1);
add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
- "vCont", "verbose-resume",
- set_remote_protocol_packet_cmd,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ "vCont", "verbose-resume", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals],
+ "QPassSignals", "pass-signals", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
- "qSymbol", "symbol-lookup",
- set_remote_protocol_packet_cmd,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ "qSymbol", "symbol-lookup", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
- "P", "set-register",
- set_remote_protocol_packet_cmd,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 1);
+ "P", "set-register", 1);
add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
- "p", "fetch-register",
- set_remote_protocol_packet_cmd,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 1);
+ "p", "fetch-register", 1);
add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
- "Z0", "software-breakpoint",
- set_remote_protocol_packet_cmd,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ "Z0", "software-breakpoint", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
- "Z1", "hardware-breakpoint",
- set_remote_protocol_packet_cmd,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ "Z1", "hardware-breakpoint", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
- "Z2", "write-watchpoint",
- set_remote_protocol_packet_cmd,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ "Z2", "write-watchpoint", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
- "Z3", "read-watchpoint",
- set_remote_protocol_packet_cmd,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ "Z3", "read-watchpoint", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
- "Z4", "access-watchpoint",
- set_remote_protocol_packet_cmd,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ "Z4", "access-watchpoint", 0);
- add_packet_config_cmd (&remote_protocol_packets[PACKET_qPart_auxv],
- "qPart_auxv", "read-aux-vector",
- set_remote_protocol_packet_cmd,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ 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_features],
+ "qXfer:features:read", "target-features", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries],
+ "qXfer:libraries:read", "library-info", 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_qXfer_spu_read],
+ "qXfer:spu:read", "read-spu-object", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write],
+ "qXfer:spu:write", "write-spu-object", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
"qGetTLSAddr", "get-thread-local-storage-address",
- set_remote_protocol_packet_cmd,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
+ "qSupported", "supported-packets", 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