/* Remote target communications for serial-line targets in custom GDB protocol
- Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
- 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+ Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+ 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
/* See the GDB User Guide for details of the GDB remote protocol. */
#include "value.h"
#include "gdb_assert.h"
#include "observer.h"
+#include "solib.h"
+#include "cli/cli-decode.h"
+#include "cli/cli-setshow.h"
#include <ctype.h>
#include <sys/time.h>
/* Prototypes for local functions. */
static void cleanup_sigint_signal_handler (void *dummy);
static void initialize_sigint_signal_handler (void);
-static int getpkt_sane (char *buf, long sizeof_buf, int forever);
+static int getpkt_sane (char **buf, long *sizeof_buf, int forever);
static void handle_remote_sigint (int);
static void handle_remote_sigint_twice (int);
static void remote_files_info (struct target_ops *ignore);
-static int remote_xfer_memory (CORE_ADDR memaddr, char *myaddr,
- int len, int should_write,
- struct mem_attrib *attrib,
- struct target_ops *target);
-
static void remote_prepare_to_store (void);
static void remote_fetch_registers (int regno);
static void remote_mourn_1 (struct target_ops *);
-static void remote_send (char *buf, long sizeof_buf);
+static void remote_send (char **buf, long *sizeof_buf_p);
static int readchar (int timeout);
static void get_offsets (void);
-static long read_frame (char *buf, long sizeof_buf);
-
-static int remote_insert_breakpoint (CORE_ADDR, char *);
+static void skip_frame (void);
-static int remote_remove_breakpoint (CORE_ADDR, char *);
+static long read_frame (char **buf_p, long *sizeof_buf);
static int hexnumlen (ULONGEST num);
static int fromhex (int a);
-static int hex2bin (const char *hex, char *bin, int count);
+static int hex2bin (const char *hex, gdb_byte *bin, int count);
-static int bin2hex (const char *bin, char *hex, int count);
+static int bin2hex (const gdb_byte *bin, char *hex, int count);
static int putpkt_binary (char *buf, int cnt);
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 (void)
+{
+ return &remote_state;
+}
+
+/* Description of the remote protocol for a given architecture. */
struct packet_reg
{
/* char *name; == REGISTER_NAME (regnum); at present. */
};
-struct remote_state
+struct remote_arch_state
{
/* Description of the remote protocol registers. */
long sizeof_g_packet;
/* Handle for retreving the remote protocol data from gdbarch. */
static struct gdbarch_data *remote_gdbarch_data_handle;
-static struct remote_state *
-get_remote_state (void)
+static struct remote_arch_state *
+get_remote_arch_state (void)
{
return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
}
init_remote_state (struct gdbarch *gdbarch)
{
int regnum;
- struct remote_state *rs = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_state);
+ struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa;
- if (deprecated_register_bytes () != 0)
- rs->sizeof_g_packet = deprecated_register_bytes ();
- else
- rs->sizeof_g_packet = 0;
+ rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
+
+ rsa->sizeof_g_packet = 0;
/* Assume a 1:1 regnum<->pnum table. */
- rs->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, NUM_REGS + NUM_PSEUDO_REGS,
- struct packet_reg);
+ rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, NUM_REGS + NUM_PSEUDO_REGS,
+ struct packet_reg);
for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
{
- struct packet_reg *r = &rs->regs[regnum];
+ struct packet_reg *r = &rsa->regs[regnum];
r->pnum = regnum;
r->regnum = regnum;
r->offset = DEPRECATED_REGISTER_BYTE (regnum);
/* ...name = REGISTER_NAME (regnum); */
/* Compute packet size by accumulating the size of all registers. */
- if (deprecated_register_bytes () == 0)
- rs->sizeof_g_packet += register_size (current_gdbarch, regnum);
+ if (regnum < NUM_REGS)
+ rsa->sizeof_g_packet += register_size (current_gdbarch, regnum);
}
/* Default maximum number of characters in a packet body. Many
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;
+ /* 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 = xmalloc (rs->buf_size);
+ }
+
+ 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 rs;
+ 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)
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++)
{
- struct packet_reg *r = &rs->regs[i];
+ struct packet_reg *r = &rsa->regs[i];
if (r->pnum == pnum)
return r;
}
to stop for a watchpoint. */
static CORE_ADDR remote_watch_data_address;
-/* This is non-zero if taregt stopped for a watchpoint. */
+/* This is non-zero if target stopped for a watchpoint. */
static int remote_stopped_by_watchpoint_p;
-
static struct target_ops remote_ops;
static struct target_ops extended_remote_ops;
\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
- values (fifo overruns, et.al.) and some users need larger values
+ 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_*''
(Positive - a soft limit, negative - a hard limit). */
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;
if (what_they_get < MIN_REMOTE_PACKET_SIZE)
what_they_get = MIN_REMOTE_PACKET_SIZE;
+
+ /* Make sure there is room in the global buffer for this packet
+ (including its trailing NUL byte). */
+ if (rs->buf_size < what_they_get + 1)
+ {
+ rs->buf_size = 2 * what_they_get;
+ rs->buf = xrealloc (rs->buf, 2 * what_they_get);
+ }
+
return what_they_get;
}
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;
};
switch (config->detect)
{
case AUTO_BOOLEAN_AUTO:
- printf_filtered (_("Support for remote protocol `%s' (%s) packet is auto-detected, currently %s.\n"),
- config->name, config->title, support);
+ printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
+ config->name, support);
break;
case AUTO_BOOLEAN_TRUE:
case AUTO_BOOLEAN_FALSE:
- printf_filtered (_("Support for remote protocol `%s' (%s) packet is currently %s.\n"),
- config->name, config->title, support);
+ printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
+ config->name, support);
break;
}
}
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)
-{
- struct cmd_list_element *set_cmd;
- struct cmd_list_element *show_cmd;
+add_packet_config_cmd (struct packet_config *config, const char *name,
+ const char *title, int legacy)
+{
char *set_doc;
char *show_doc;
- char *help_doc;
- char *print;
char *cmd_name;
+
config->name = name;
config->title = title;
config->detect = AUTO_BOOLEAN_AUTO;
name, title);
show_doc = xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
name, title);
- print = xstrprintf ("Current use of remote protocol `%s' (%s) is %%s",
- name, title);
/* set/show TITLE-packet {auto,on,off} */
cmd_name = xstrprintf ("%s-packet", title);
add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
&config->detect, set_doc, show_doc, NULL, /* help_doc */
- 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);
}
}
}
}
-/* Should we try the 'vCont' (descriptive resume) request? */
-static struct packet_config remote_protocol_vcont;
-
-static void
-set_remote_protocol_vcont_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- update_packet_config (&remote_protocol_vcont);
-}
-
-static void
-show_remote_protocol_vcont_packet_cmd (struct ui_file *file, int from_tty,
- struct cmd_list_element *c,
- const char *value)
-{
- deprecated_show_value_hack (file, from_tty, c, value);
- show_packet_config_cmd (&remote_protocol_vcont);
-}
+enum {
+ PACKET_vCont = 0,
+ PACKET_X,
+ PACKET_qSymbol,
+ PACKET_P,
+ PACKET_p,
+ PACKET_Z0,
+ PACKET_Z1,
+ PACKET_Z2,
+ PACKET_Z3,
+ PACKET_Z4,
+ PACKET_qPart_auxv,
+ PACKET_qGetTLSAddr,
+ PACKET_qSupported,
+ PACKET_MAX
+};
-/* Should we try the 'qSymbol' (target symbol lookup service) request? */
-static struct packet_config remote_protocol_qSymbol;
+static struct packet_config remote_protocol_packets[PACKET_MAX];
static void
-set_remote_protocol_qSymbol_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
+set_remote_protocol_packet_cmd (char *args, int from_tty,
+ struct cmd_list_element *c)
{
- update_packet_config (&remote_protocol_qSymbol);
-}
+ struct packet_config *packet;
-static void
-show_remote_protocol_qSymbol_packet_cmd (struct ui_file *file, int from_tty,
- struct cmd_list_element *c,
- const char *value)
-{
- deprecated_show_value_hack (file, from_tty, c, value);
- show_packet_config_cmd (&remote_protocol_qSymbol);
+ for (packet = remote_protocol_packets;
+ packet < &remote_protocol_packets[PACKET_MAX];
+ packet++)
+ {
+ if (&packet->detect == c->var)
+ {
+ update_packet_config (packet);
+ return;
+ }
+ }
+ internal_error (__FILE__, __LINE__, "Could not find config for %s",
+ c->name);
}
-/* Should we try the 'P' (set register) request? */
-
-static struct packet_config remote_protocol_P;
-
static void
-set_remote_protocol_P_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
+show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
{
- update_packet_config (&remote_protocol_P);
-}
+ struct packet_config *packet;
-static void
-show_remote_protocol_P_packet_cmd (struct ui_file *file, int from_tty,
- struct cmd_list_element *c,
- const char *value)
-{
- deprecated_show_value_hack (file, from_tty, c, value);
- show_packet_config_cmd (&remote_protocol_P);
+ for (packet = remote_protocol_packets;
+ packet < &remote_protocol_packets[PACKET_MAX];
+ packet++)
+ {
+ if (&packet->detect == c->var)
+ {
+ show_packet_config_cmd (packet);
+ return;
+ }
+ }
+ internal_error (__FILE__, __LINE__, "Could not find config for %s",
+ c->name);
}
/* Should we try one of the 'Z' requests? */
NR_Z_PACKET_TYPES
};
-static struct packet_config remote_protocol_Z[NR_Z_PACKET_TYPES];
-
-/* FIXME: Instead of having all these boiler plate functions, the
- command callback should include a context argument. */
-
-static void
-set_remote_protocol_Z_software_bp_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- update_packet_config (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP]);
-}
-
-static void
-show_remote_protocol_Z_software_bp_packet_cmd (struct ui_file *file, int from_tty,
- struct cmd_list_element *c,
- const char *value)
-{
- deprecated_show_value_hack (file, from_tty, c, value);
- show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP]);
-}
-
-static void
-set_remote_protocol_Z_hardware_bp_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- update_packet_config (&remote_protocol_Z[Z_PACKET_HARDWARE_BP]);
-}
-
-static void
-show_remote_protocol_Z_hardware_bp_packet_cmd (struct ui_file *file, int from_tty,
- struct cmd_list_element *c,
- const char *value)
-{
- deprecated_show_value_hack (file, from_tty, c, value);
- show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_HARDWARE_BP]);
-}
-
-static void
-set_remote_protocol_Z_write_wp_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- update_packet_config (&remote_protocol_Z[Z_PACKET_WRITE_WP]);
-}
-
-static void
-show_remote_protocol_Z_write_wp_packet_cmd (struct ui_file *file, int from_tty,
- struct cmd_list_element *c,
- const char *value)
-{
- deprecated_show_value_hack (file, from_tty, c, value);
- show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_WRITE_WP]);
-}
-
-static void
-set_remote_protocol_Z_read_wp_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- update_packet_config (&remote_protocol_Z[Z_PACKET_READ_WP]);
-}
-
-static void
-show_remote_protocol_Z_read_wp_packet_cmd (struct ui_file *file, int from_tty,
- struct cmd_list_element *c,
- const char *value)
-{
- deprecated_show_value_hack (file, from_tty, c, value);
- show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_READ_WP]);
-}
-
-static void
-set_remote_protocol_Z_access_wp_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- update_packet_config (&remote_protocol_Z[Z_PACKET_ACCESS_WP]);
-}
-
-static void
-show_remote_protocol_Z_access_wp_packet_cmd (struct ui_file *file, int from_tty,
- struct cmd_list_element *c,
- const char *value)
-{
- deprecated_show_value_hack (file, from_tty, c, value);
- show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_ACCESS_WP]);
-}
-
/* For compatibility with older distributions. Provide a ``set remote
Z-packet ...'' command that updates all the Z packet types. */
int i;
for (i = 0; i < NR_Z_PACKET_TYPES; i++)
{
- remote_protocol_Z[i].detect = remote_Z_packet_detect;
- update_packet_config (&remote_protocol_Z[i]);
+ remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
+ update_packet_config (&remote_protocol_packets[PACKET_Z0 + i]);
}
}
int i;
for (i = 0; i < NR_Z_PACKET_TYPES; i++)
{
- show_packet_config_cmd (&remote_protocol_Z[i]);
+ show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
}
}
-/* Should we try the 'X' (remote binary download) packet?
-
- This variable (available to the user via "set remote X-packet")
- dictates whether downloads are sent in binary (via the 'X' packet).
- We assume that the stub can, and attempt to do it. This will be
- cleared if the stub does not understand it. This switch is still
- needed, though in cases when the packet is supported in the stub,
- but the connection does not allow it (i.e., 7-bit serial connection
- only). */
-
-static struct packet_config remote_protocol_binary_download;
-
/* Should we try the 'ThreadInfo' query packet?
This variable (NOT available to the user: auto-detect only!)
static int use_threadinfo_query;
static int use_threadextra_query;
-static void
-set_remote_protocol_binary_download_cmd (char *args,
- int from_tty,
- struct cmd_list_element *c)
-{
- update_packet_config (&remote_protocol_binary_download);
-}
-
-static void
-show_remote_protocol_binary_download_cmd (struct ui_file *file, int from_tty,
- struct cmd_list_element *c,
- const char *value)
-{
- deprecated_show_value_hack (file, from_tty, c, value);
- show_packet_config_cmd (&remote_protocol_binary_download);
-}
-
-/* Should we try the 'qPart:auxv' (target auxiliary vector read) request? */
-static struct packet_config remote_protocol_qPart_auxv;
-
-static void
-set_remote_protocol_qPart_auxv_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- update_packet_config (&remote_protocol_qPart_auxv);
-}
-
-static void
-show_remote_protocol_qPart_auxv_packet_cmd (struct ui_file *file, int from_tty,
- struct cmd_list_element *c,
- const char *value)
-{
- deprecated_show_value_hack (file, from_tty, c, value);
- show_packet_config_cmd (&remote_protocol_qPart_auxv);
-}
-
-static struct packet_config remote_protocol_p;
-
-static void
-set_remote_protocol_p_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- update_packet_config (&remote_protocol_p);
-}
-
-static void
-show_remote_protocol_p_packet_cmd (struct ui_file *file, int from_tty,
- struct cmd_list_element *c,
- const char *value)
-{
- deprecated_show_value_hack (file, from_tty, c, value);
- show_packet_config_cmd (&remote_protocol_p);
-}
-
-
-
/* Tokens for use by the asynchronous signal handlers for SIGINT. */
static void *sigint_remote_twice_token;
static void *sigint_remote_token;
set_thread (int th, int gen)
{
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
+ char *buf = rs->buf;
int state = gen ? general_thread : continue_thread;
if (state == th)
buf[3] = '\0';
}
else if (th < 0)
- sprintf (&buf[2], "-%x", -th);
+ xsnprintf (&buf[2], get_remote_packet_size () - 2, "-%x", -th);
else
- sprintf (&buf[2], "%x", th);
+ xsnprintf (&buf[2], get_remote_packet_size () - 2, "%x", th);
putpkt (buf);
- getpkt (buf, (rs->remote_packet_size), 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
if (gen)
general_thread = th;
else
static int
remote_thread_alive (ptid_t ptid)
{
+ struct remote_state *rs = get_remote_state ();
int tid = PIDGET (ptid);
- char buf[16];
+ char *buf = rs->buf;
if (tid < 0)
- sprintf (buf, "T-%08x", -tid);
+ xsnprintf (buf, get_remote_packet_size (), "T-%08x", -tid);
else
- sprintf (buf, "T%08x", tid);
+ xsnprintf (buf, get_remote_packet_size (), "T%08x", tid);
putpkt (buf);
- getpkt (buf, sizeof (buf), 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
return (buf[0] == 'O' && buf[1] == 'K');
}
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
{
int active; /* Has state interesting to GDB?
regs, stack. */
char display[256]; /* Brief state display, name,
- blocked/syspended. */
+ blocked/suspended. */
char shortname[32]; /* To be used to name threads. */
char more_display[256]; /* Long info, statistics, queue depth,
whatever. */
int i, value = 0;
unsigned char *scan;
- scan = (char *) ref;
+ scan = *ref;
scan += 4;
i = 4;
while (i-- > 0)
{
struct remote_state *rs = get_remote_state ();
int mask, length;
- unsigned int tag;
+ int tag;
threadref ref;
- char *limit = pkt + (rs->remote_packet_size); /* plausable parsing limit */
+ char *limit = pkt + rs->buf_size; /* Plausible parsing limit. */
int retval = 1;
/* info->threadid = 0; FIXME: implement zero_threadref. */
{
struct remote_state *rs = get_remote_state ();
int result;
- char *threadinfo_pkt = alloca (rs->remote_packet_size);
+ char *threadinfo_pkt = rs->buf;
pack_threadinfo_request (threadinfo_pkt, fieldset, threadid);
putpkt (threadinfo_pkt);
- getpkt (threadinfo_pkt, (rs->remote_packet_size), 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
result = remote_unpack_thread_info_response (threadinfo_pkt + 2,
threadid, info);
return result;
resultcount = 0;
/* Assume the 'q' and 'M chars have been stripped. */
- limit = pkt + ((rs->remote_packet_size) - BUF_THREAD_ID_SIZE);
+ limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE);
/* done parse past here */
pkt = unpack_byte (pkt, &count); /* count field */
pkt = unpack_nibble (pkt, &done);
{
struct remote_state *rs = get_remote_state ();
static threadref echo_nextthread;
- char *threadlist_packet = alloca (rs->remote_packet_size);
- char *t_response = alloca (rs->remote_packet_size);
+ 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 (threadlist_packet,
- startflag, result_limit, nextthread);
- putpkt (threadlist_packet);
- getpkt (t_response, (rs->remote_packet_size), 0);
+ pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
*result_count =
- parse_threadlist_response (t_response + 2, result_limit, &echo_nextthread,
+ parse_threadlist_response (rs->buf + 2, result_limit, &echo_nextthread,
threadlist, done);
if (!threadmatch (&echo_nextthread, nextthread))
remote_current_thread (ptid_t oldpid)
{
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
+ char *buf = rs->buf;
putpkt ("qC");
- getpkt (buf, (rs->remote_packet_size), 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
if (buf[0] == 'Q' && 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
remote_threads_info (void)
{
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
char *bufp;
int tid;
if (use_threadinfo_query)
{
putpkt ("qfThreadInfo");
- bufp = buf;
- getpkt (bufp, (rs->remote_packet_size), 0);
+ bufp = rs->buf;
+ getpkt (&rs->buf, &rs->buf_size, 0);
if (bufp[0] != '\0') /* q packet recognized */
{
while (*bufp++ == 'm') /* reply contains one or more TID */
}
while (*bufp++ == ','); /* comma-separated list */
putpkt ("qsThreadInfo");
- bufp = buf;
- getpkt (bufp, (rs->remote_packet_size), 0);
+ bufp = rs->buf;
+ getpkt (&rs->buf, &rs->buf_size, 0);
}
return; /* done */
}
threadref id;
struct gdb_ext_thread_info threadinfo;
static char display_buf[100]; /* arbitrary... */
- char *bufp = alloca (rs->remote_packet_size);
int n = 0; /* position in display_buf */
if (remote_desc == 0) /* paranoia */
if (use_threadextra_query)
{
- sprintf (bufp, "qThreadExtraInfo,%x", PIDGET (tp->ptid));
+ char *bufp = rs->buf;
+
+ xsnprintf (bufp, get_remote_packet_size (), "qThreadExtraInfo,%x",
+ PIDGET (tp->ptid));
putpkt (bufp);
- getpkt (bufp, (rs->remote_packet_size), 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
if (bufp[0] != 0)
{
n = min (strlen (bufp) / 2, sizeof (display_buf));
- result = hex2bin (bufp, display_buf, n);
+ result = hex2bin (bufp, (gdb_byte *) display_buf, n);
display_buf [result] = '\0';
return display_buf;
}
if (threadinfo.active)
{
if (*threadinfo.shortname)
- n += sprintf(&display_buf[0], " Name: %s,", threadinfo.shortname);
+ n += xsnprintf (&display_buf[0], sizeof (display_buf) - n,
+ " Name: %s,", threadinfo.shortname);
if (*threadinfo.display)
- n += sprintf(&display_buf[n], " State: %s,", threadinfo.display);
+ n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
+ " State: %s,", threadinfo.display);
if (*threadinfo.more_display)
- n += sprintf(&display_buf[n], " Priority: %s",
- threadinfo.more_display);
+ n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
+ " Priority: %s", threadinfo.more_display);
if (n > 0)
{
}
return NULL;
}
-
\f
-/* Restart the remote side; this is an extended protocol operation. */
+/* Restart the remote side; this is an extended protocol operation. */
static void
extended_remote_restart (void)
{
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
/* Send the restart command; for reasons I don't understand the
remote side really expects a number after the "R". */
- buf[0] = 'R';
- sprintf (&buf[1], "%x", 0);
- putpkt (buf);
+ 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 ("?");
- getpkt (buf, (rs->remote_packet_size), 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
}
\f
/* Clean up connection to a remote debugger. */
get_offsets (void)
{
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
+ char *buf = rs->buf;
char *ptr;
int lose;
CORE_ADDR text_addr, data_addr, bss_addr;
struct section_offsets *offs;
putpkt ("qOffsets");
-
- getpkt (buf, (rs->remote_packet_size), 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
if (buf[0] == '\000')
return; /* Return silently. Stub doesn't support
init_all_packet_configs (void)
{
int i;
- update_packet_config (&remote_protocol_P);
- update_packet_config (&remote_protocol_p);
- update_packet_config (&remote_protocol_qSymbol);
- update_packet_config (&remote_protocol_vcont);
- for (i = 0; i < NR_Z_PACKET_TYPES; i++)
- update_packet_config (&remote_protocol_Z[i]);
- /* Force remote_write_bytes to check whether target supports binary
- downloading. */
- update_packet_config (&remote_protocol_binary_download);
- update_packet_config (&remote_protocol_qPart_auxv);
+ for (i = 0; i < PACKET_MAX; i++)
+ update_packet_config (&remote_protocol_packets[i]);
}
/* Symbol look-up. */
struct minimal_symbol *sym;
int end;
- if (remote_protocol_qSymbol.support == PACKET_DISABLE)
+ if (remote_protocol_packets[PACKET_qSymbol].support == PACKET_DISABLE)
return;
- msg = alloca (rs->remote_packet_size);
- reply = alloca (rs->remote_packet_size);
+ /* Allocate a message buffer. We can't reuse the input buffer in RS,
+ because we need both at the same time. */
+ msg = alloca (get_remote_packet_size ());
+
+ reply = rs->buf;
/* Invite target to request symbol lookups. */
putpkt ("qSymbol::");
- getpkt (reply, (rs->remote_packet_size), 0);
- packet_ok (reply, &remote_protocol_qSymbol);
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]);
while (strncmp (reply, "qSymbol:", 8) == 0)
{
tmp = &reply[8];
- end = hex2bin (tmp, msg, strlen (tmp) / 2);
+ end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2);
msg[end] = '\0';
sym = lookup_minimal_symbol (msg, NULL, NULL);
if (sym == NULL)
- sprintf (msg, "qSymbol::%s", &reply[8]);
+ xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
else
- sprintf (msg, "qSymbol:%s:%s",
- paddr_nz (SYMBOL_VALUE_ADDRESS (sym)),
- &reply[8]);
+ xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
+ paddr_nz (SYMBOL_VALUE_ADDRESS (sym)),
+ &reply[8]);
putpkt (msg);
- getpkt (reply, (rs->remote_packet_size), 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
}
}
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;
+};
+
+#if 0
+static void
+remote_supported_packet (const struct protocol_feature *feature,
+ enum packet_support support,
+ const char *argument)
+{
+ if (argument)
+ {
+ warning (_("Remote qSupported response supplied an unexpected value for"
+ " \"%s\"."), feature->name);
+ return;
+ }
+
+ if (remote_protocol_packets[feature->packet].support
+ == PACKET_SUPPORT_UNKNOWN)
+ remote_protocol_packets[feature->packet].support = support;
+}
+#endif
+
+static void
+remote_packet_size (const struct protocol_feature *feature,
+ enum packet_support support, const char *value)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ int packet_size;
+ char *value_end;
+
+ if (support != PACKET_ENABLE)
+ return;
+
+ if (value == NULL || *value == '\0')
+ {
+ warning (_("Remote target reported \"%s\" without a size."),
+ feature->name);
+ return;
+ }
+
+ errno = 0;
+ packet_size = strtol (value, &value_end, 16);
+ if (errno != 0 || *value_end != '\0' || packet_size < 0)
+ {
+ warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
+ feature->name, value);
+ return;
+ }
+
+ 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;
+ }
+
+ /* 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 }
+};
+
+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
+ {
+ if (end == p)
+ {
+ warning (_("empty item in \"qSupported\" response"));
+ continue;
+ }
+
+ *end = '\0';
+ next = end + 1;
+ }
+
+ 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 exception ex;
struct remote_state *rs = get_remote_state ();
if (name == 0)
error (_("To open a remote debug connection, you need to specify what\n"
if (!async_p)
wait_forever_enabled_p = 1;
- reopen_exec_file ();
- reread_symbols ();
-
target_preopen (from_tty);
unpush_target (target);
+ remote_fileio_reset ();
+ reopen_exec_file ();
+ reread_symbols ();
+
remote_desc = remote_serial_open (name);
if (!remote_desc)
perror_with_name (name);
}
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 ();
+
/* 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
wait_forever_enabled_p = 0;
}
-#ifdef SOLIB_CREATE_INFERIOR_HOOK
/* First delete any symbols previously loaded from shared libraries. */
no_shared_libraries (NULL, 0);
-#endif
/* Start the remote connection. If error() or QUIT, discard this
target (we'd otherwise be in an inconsistent state) and then
been fixed - the function set_cmd_context() makes it possible for
all the ``target ....'' commands to share a common callback
function. See cli-dump.c. */
- ex = catch_exception (uiout, remote_start_remote, NULL, RETURN_MASK_ALL);
- if (ex.reason < 0)
- {
- pop_target ();
- if (async_p)
- wait_forever_enabled_p = 1;
- throw_exception (ex);
- }
+ {
+ struct gdb_exception ex
+ = catch_exception (uiout, remote_start_remote, NULL, RETURN_MASK_ALL);
+ if (ex.reason < 0)
+ {
+ pop_target ();
+ if (async_p)
+ wait_forever_enabled_p = 1;
+ throw_exception (ex);
+ }
+ }
if (async_p)
wait_forever_enabled_p = 1;
if (extended_p)
{
/* Tell the remote that we are using the extended protocol. */
- char *buf = alloca (rs->remote_packet_size);
putpkt ("!");
- getpkt (buf, (rs->remote_packet_size), 0);
- }
-#ifdef SOLIB_CREATE_INFERIOR_HOOK
- /* FIXME: need a master target_open vector from which all
- remote_opens can be called, so that stuff like this can
- go there. Failing that, the following code must be copied
- to the open function for any remote target that wants to
- support svr4 shared libraries. */
-
- /* Set up to detect and load shared libraries. */
- if (exec_bfd) /* No use without an exec file. */
- {
- SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid));
- remote_check_symbols (symfile_objfile);
+ getpkt (&rs->buf, &rs->buf_size, 0);
}
-#endif
- observer_notify_inferior_created (¤t_target, from_tty);
+ post_create_inferior (¤t_target, from_tty);
+
+ if (exec_bfd) /* No use without an exec file. */
+ remote_check_symbols (symfile_objfile);
}
/* This takes a program previously attached to and detaches it. After
remote_detach (char *args, int from_tty)
{
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
if (args)
error (_("Argument given to \"detach\" when remotely debugging."));
/* Tell the remote target to detach. */
- strcpy (buf, "D");
- remote_send (buf, (rs->remote_packet_size));
+ strcpy (rs->buf, "D");
+ remote_send (&rs->buf, &rs->buf_size);
/* 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)
{
- struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
-
if (args)
error (_("Argument given to \"detach\" when remotely debugging."));
}
static int
-hex2bin (const char *hex, char *bin, int count)
+hex2bin (const char *hex, gdb_byte *bin, int count)
{
int i;
}
static int
-bin2hex (const char *bin, char *hex, int count)
+bin2hex (const gdb_byte *bin, char *hex, int count)
{
int i;
/* May use a length, or a nul-terminated string as input. */
if (count == 0)
- count = strlen (bin);
+ count = strlen ((char *) bin);
for (i = 0; i < count; i++)
{
the response. */
static void
-remote_vcont_probe (struct remote_state *rs, char *buf)
+remote_vcont_probe (struct remote_state *rs)
{
+ char *buf = rs->buf;
+
strcpy (buf, "vCont?");
putpkt (buf);
- getpkt (buf, rs->remote_packet_size, 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
/* Make sure that the features we assume are supported. */
if (strncmp (buf, "vCont", 5) == 0)
buf[0] = 0;
}
- packet_ok (buf, &remote_protocol_vcont);
+ packet_ok (buf, &remote_protocol_packets[PACKET_vCont]);
}
/* Resume the remote inferior by using a "vCont" packet. The thread
char *buf = NULL, *outbuf;
struct cleanup *old_cleanup;
- buf = xmalloc (rs->remote_packet_size);
- old_cleanup = make_cleanup (xfree, buf);
-
- if (remote_protocol_vcont.support == PACKET_SUPPORT_UNKNOWN)
- remote_vcont_probe (rs, buf);
+ if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN)
+ remote_vcont_probe (rs);
- if (remote_protocol_vcont.support == PACKET_DISABLE)
- {
- do_cleanups (old_cleanup);
- return 0;
- }
+ if (remote_protocol_packets[PACKET_vCont].support == PACKET_DISABLE)
+ return 0;
/* If we could generate a wider range of packets, we'd have to worry
about overflowing BUF. Should there be a generic
outbuf = xstrprintf ("vCont;c:%x", pid);
}
- gdb_assert (outbuf && strlen (outbuf) < rs->remote_packet_size);
- make_cleanup (xfree, outbuf);
+ 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 = alloca (rs->remote_packet_size);
+ char *buf = rs->buf;
int pid = PIDGET (ptid);
- char *p;
last_sent_signal = siggnal;
last_sent_step = step;
remote_wait (ptid_t ptid, struct target_waitstatus *status)
{
struct remote_state *rs = get_remote_state ();
- unsigned char *buf = alloca (rs->remote_packet_size);
+ struct remote_arch_state *rsa = get_remote_arch_state ();
+ char *buf = rs->buf;
ULONGEST thread_num = -1;
ULONGEST addr;
while (1)
{
- unsigned char *p;
+ char *p;
ofunc = signal (SIGINT, remote_interrupt);
- getpkt (buf, (rs->remote_packet_size), 1);
+ getpkt (&rs->buf, &rs->buf_size, 1);
signal (SIGINT, ofunc);
/* This is a hook for when we need to do something (perhaps the
continue;
case 'T': /* Status with PC, SP, FP, ... */
{
- int i;
- char regs[MAX_REGISTER_SIZE];
+ gdb_byte regs[MAX_REGISTER_SIZE];
/* Expedited reply, containing Signal, {regno, reg} repeat. */
/* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
while (*p)
{
- unsigned char *p1;
+ char *p1;
char *p_temp;
int fieldsize;
LONGEST pnum = 0;
{
/* Read the ``P'' register number. */
pnum = strtol (p, &p_temp, 16);
- p1 = (unsigned char *) p_temp;
+ p1 = p_temp;
}
else
p1 = p;
if (p1 == p) /* No register number present here. */
{
- p1 = (unsigned char *) strchr (p, ':');
+ p1 = strchr (p, ':');
if (p1 == NULL)
- warning (_("Malformed packet(a) (missing colon): %s\n\
+ error (_("Malformed packet(a) (missing colon): %s\n\
Packet: '%s'\n"),
- p, buf);
+ p, buf);
if (strncmp (p, "thread", p1 - p) == 0)
{
p_temp = unpack_varlen_hex (++p1, &thread_num);
record_currthread (thread_num);
- p = (unsigned char *) p_temp;
+ p = p_temp;
}
else if ((strncmp (p, "watch", p1 - p) == 0)
|| (strncmp (p, "rwatch", p1 - p) == 0)
/* Silently skip unknown optional info. */
p_temp = strchr (p1 + 1, ';');
if (p_temp)
- p = (unsigned char *) p_temp;
+ p = p_temp;
}
}
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++ != ':')
Packet: '%s'\n"),
phex_nz (pnum, 0), p, buf);
- fieldsize = hex2bin (p, regs,
+ fieldsize = hex2bin (p, regs,
register_size (current_gdbarch,
reg->regnum));
p += 2 * fieldsize;
remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
{
struct remote_state *rs = get_remote_state ();
- unsigned char *buf = alloca (rs->remote_packet_size);
+ struct remote_arch_state *rsa = get_remote_arch_state ();
+ char *buf = rs->buf;
ULONGEST thread_num = -1;
ULONGEST addr;
while (1)
{
- unsigned char *p;
+ char *p;
if (!target_is_async_p ())
ofunc = signal (SIGINT, remote_interrupt);
_never_ wait for ever -> test on target_is_async_p().
However, before we do that we need to ensure that the caller
knows how to take the target into/out of async mode. */
- getpkt (buf, (rs->remote_packet_size), wait_forever_enabled_p);
+ getpkt (&rs->buf, &rs->buf_size, wait_forever_enabled_p);
if (!target_is_async_p ())
signal (SIGINT, ofunc);
continue;
case 'T': /* Status with PC, SP, FP, ... */
{
- int i;
- char regs[MAX_REGISTER_SIZE];
+ gdb_byte regs[MAX_REGISTER_SIZE];
/* Expedited reply, containing Signal, {regno, reg} repeat. */
/* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
while (*p)
{
- unsigned char *p1;
+ char *p1;
char *p_temp;
int fieldsize;
long pnum = 0;
{
/* Read the register number. */
pnum = strtol (p, &p_temp, 16);
- p1 = (unsigned char *) p_temp;
+ p1 = p_temp;
}
else
p1 = p;
if (p1 == p) /* No register number present here. */
{
- p1 = (unsigned char *) strchr (p, ':');
+ p1 = strchr (p, ':');
if (p1 == NULL)
error (_("Malformed packet(a) (missing colon): %s\n\
Packet: '%s'\n"),
{
p_temp = unpack_varlen_hex (++p1, &thread_num);
record_currthread (thread_num);
- p = (unsigned char *) p_temp;
+ p = p_temp;
}
else if ((strncmp (p, "watch", p1 - p) == 0)
|| (strncmp (p, "rwatch", p1 - p) == 0)
else
{
/* Silently skip unknown optional info. */
- p_temp = (unsigned char *) strchr (p1 + 1, ';');
+ p_temp = strchr (p1 + 1, ';');
if (p_temp)
p = p_temp;
}
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\
Packet: '%s'\n"),
pnum, p, buf);
- fieldsize = hex2bin (p, regs,
+ fieldsize = hex2bin (p, regs,
register_size (current_gdbarch,
reg->regnum));
p += 2 * fieldsize;
fetch_register_using_p (int regnum)
{
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size), *p;
+ char *buf = rs->buf, *p;
char regp[MAX_REGISTER_SIZE];
int i;
*p++ = 'p';
p += hexnumstr (p, regnum);
*p++ = '\0';
- remote_send (buf, rs->remote_packet_size);
+ remote_send (&rs->buf, &rs->buf_size);
/* If the stub didn't recognize the packet, or if we got an error,
tell our caller. */
remote_fetch_registers (int regnum)
{
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
+ struct remote_arch_state *rsa = get_remote_arch_state ();
+ char *buf = rs->buf;
int i;
char *p;
- char *regs = alloca (rs->sizeof_g_packet);
+ char *regs = alloca (rsa->sizeof_g_packet);
set_thread (PIDGET (inferior_ptid), 1);
if (regnum >= 0)
{
- struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
+ struct packet_reg *reg = packet_reg_from_regnum (rsa, 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_p.support)
+ switch (remote_protocol_packets[PACKET_p].support)
{
case PACKET_DISABLE:
break;
if (fetch_register_using_p (regnum))
{
/* The stub recognized the 'p' packet. Remember this. */
- remote_protocol_p.support = PACKET_ENABLE;
+ 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_p.support = PACKET_DISABLE;
+ remote_protocol_packets[PACKET_p].support = PACKET_DISABLE;
break;
}
}
sprintf (buf, "g");
- remote_send (buf, (rs->remote_packet_size));
+ 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);
+ if ((rsa->actual_register_packet_size) == 0)
+ (rsa->actual_register_packet_size) = strlen (buf);
/* Unimplemented registers read as all bits zero. */
- memset (regs, 0, rs->sizeof_g_packet);
+ memset (regs, 0, rsa->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
if (remote_debug)
fprintf_unfiltered (gdb_stdlog,
"Bad register packet; fetching a new packet\n");
- getpkt (buf, (rs->remote_packet_size), 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
}
/* Reply describes registers byte by byte, each byte encoded as two
register cacheing/storage mechanism. */
p = buf;
- for (i = 0; i < rs->sizeof_g_packet; i++)
+ for (i = 0; i < rsa->sizeof_g_packet; i++)
{
if (p[0] == 0)
break;
int i;
for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; 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))
static void
remote_prepare_to_store (void)
{
- struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
int i;
- char buf[MAX_REGISTER_SIZE];
+ gdb_byte buf[MAX_REGISTER_SIZE];
/* Make sure the entire registers array is valid. */
- switch (remote_protocol_P.support)
+ switch (remote_protocol_packets[PACKET_P].support)
{
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);
+ if (rsa->regs[i].in_g_packet)
+ regcache_raw_read (current_regcache, rsa->regs[i].regnum, buf);
break;
case PACKET_ENABLE:
break;
store_register_using_P (int regnum)
{
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 ();
+ struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
/* Try storing a single register. */
- char *buf = alloca (rs->remote_packet_size);
- char regp[MAX_REGISTER_SIZE];
+ char *buf = rs->buf;
+ gdb_byte regp[MAX_REGISTER_SIZE];
char *p;
- int i;
- sprintf (buf, "P%s=", phex_nz (reg->pnum, 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);
bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
- remote_send (buf, rs->remote_packet_size);
+ remote_send (&rs->buf, &rs->buf_size);
return buf[0] != '\0';
}
remote_store_registers (int regnum)
{
struct remote_state *rs = get_remote_state ();
- char *buf;
- char *regs;
- int i;
+ 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_P.support)
+ switch (remote_protocol_packets[PACKET_P].support)
{
case PACKET_DISABLE:
break;
if (store_register_using_P (regnum))
{
/* The stub recognized the 'P' packet. Remember this. */
- remote_protocol_P.support = PACKET_ENABLE;
+ 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_P.support = PACKET_DISABLE;
+ remote_protocol_packets[PACKET_P].support = PACKET_DISABLE;
break;
}
}
local buffer. */
{
int i;
- regs = alloca (rs->sizeof_g_packet);
- memset (regs, rs->sizeof_g_packet, 0);
+ regs = alloca (rsa->sizeof_g_packet);
+ memset (regs, 0, rsa->sizeof_g_packet);
for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; 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);
}
/* Command describes registers byte by byte,
each byte encoded as two hex characters. */
- buf = alloca (rs->remote_packet_size);
- p = buf;
+ p = rs->buf;
*p++ = 'G';
/* remote_prepare_to_store insures that register_bytes_found gets set. */
bin2hex (regs, p, register_bytes_found);
- remote_send (buf, (rs->remote_packet_size));
+ remote_send (&rs->buf, &rs->buf_size);
}
\f
check_binary_download (CORE_ADDR addr)
{
struct remote_state *rs = get_remote_state ();
- switch (remote_protocol_binary_download.support)
+
+ switch (remote_protocol_packets[PACKET_X].support)
{
case PACKET_DISABLE:
break;
break;
case PACKET_SUPPORT_UNKNOWN:
{
- char *buf = alloca (rs->remote_packet_size);
+ char *buf = rs->buf;
char *p;
p = buf;
*p = '\0';
putpkt_binary (buf, (int) (p - buf));
- getpkt (buf, (rs->remote_packet_size), 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
if (buf[0] == '\0')
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog,
"binary downloading NOT suppported by target\n");
- remote_protocol_binary_download.support = PACKET_DISABLE;
+ remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
}
else
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog,
"binary downloading suppported by target\n");
- remote_protocol_binary_download.support = PACKET_ENABLE;
+ remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
}
break;
}
error. Only transfer a single packet. */
int
-remote_write_bytes (CORE_ADDR memaddr, char *myaddr, int len)
+remote_write_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
{
- unsigned char *buf;
- unsigned char *p;
- unsigned char *plen;
- long sizeof_buf;
+ struct remote_state *rs = get_remote_state ();
+ char *buf;
+ char *p;
+ char *plen;
int plenlen;
int todo;
int nr_bytes;
int payload_size;
- unsigned char *payload_start;
+ char *payload_start;
/* Verify that the target can support a binary download. */
check_binary_download (memaddr);
payload_size = get_memory_write_packet_size ();
- /* Compute the size, and then allocate space for the largest
- possible packet. Include space for an extra trailing NUL. */
- sizeof_buf = payload_size + 1;
- buf = alloca (sizeof_buf);
+ /* The packet buffer will be large enough for the payload;
+ get_memory_packet_size ensures this. */
+ buf = rs->buf;
/* Compute the size of the actual payload by subtracting out the
packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
/* Append "[XM]". Compute a best guess of the number of bytes
actually transfered. */
p = buf;
- switch (remote_protocol_binary_download.support)
+ switch (remote_protocol_packets[PACKET_X].support)
{
case PACKET_ENABLE:
*p++ = 'X';
/* Append the packet body. */
payload_start = p;
- switch (remote_protocol_binary_download.support)
+ switch (remote_protocol_packets[PACKET_X].support)
{
case PACKET_ENABLE:
/* Binary mode. Send target system values byte by byte, in
}
putpkt_binary (buf, (int) (p - buf));
- getpkt (buf, sizeof_buf, 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
if (buf[0] == 'E')
{
handling partial reads. */
int
-remote_read_bytes (CORE_ADDR memaddr, char *myaddr, int len)
+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. */
- long sizeof_buf;
int origlen;
- /* Create a buffer big enough for this packet. */
max_buf_size = get_memory_read_packet_size ();
- sizeof_buf = max_buf_size + 1; /* Space for trailing NULL. */
- buf = alloca (sizeof_buf);
+ /* The packet buffer will be large enough for the payload;
+ get_memory_packet_size ensures this. */
+ buf = rs->buf;
origlen = len;
while (len > 0)
*p = '\0';
putpkt (buf);
- getpkt (buf, sizeof_buf, 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
if (buf[0] == 'E'
&& isxdigit (buf[1]) && isxdigit (buf[2])
read; 0 for error. TARGET is unused. */
static int
-remote_xfer_memory (CORE_ADDR mem_addr, char *buffer, int mem_len,
+remote_xfer_memory (CORE_ADDR mem_addr, gdb_byte *buffer, int mem_len,
int should_write, struct mem_attrib *attrib,
struct target_ops *target)
{
return ch;
}
-/* Send the command in BUF to the remote machine, and read the reply
- into BUF. Report an error if we get an error reply. */
+/* Send the command in *BUF to the remote machine, and read the reply
+ into *BUF. Report an error if we get an error reply. Resize
+ *BUF using xrealloc if necessary to hold the result, and update
+ *SIZEOF_BUF. */
static void
-remote_send (char *buf,
- long sizeof_buf)
+remote_send (char **buf,
+ long *sizeof_buf)
{
- putpkt (buf);
+ putpkt (*buf);
getpkt (buf, sizeof_buf, 0);
- if (buf[0] == 'E')
- error (_("Remote failure reply: %s"), buf);
+ if ((*buf)[0] == 'E')
+ error (_("Remote failure reply: %s"), *buf);
}
/* Display a null-terminated packet on stdout, for debugging, using C
/* 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);
- long sizeof_junkbuf = (rs->remote_packet_size);
- char *junkbuf = alloca (sizeof_junkbuf);
int ch;
int tcount = 0;
was lost. Gobble up the packet and ack it so it
doesn't get retransmitted when we resend this
packet. */
- read_frame (junkbuf, sizeof_junkbuf);
+ skip_frame ();
serial_write (remote_desc, "+", 1);
continue; /* Now, go look for +. */
}
}
}
+/* Come here after finding the start of a frame when we expected an
+ ack. Do our best to discard the rest of this packet. */
+
+static void
+skip_frame (void)
+{
+ int c;
+
+ while (1)
+ {
+ c = readchar (remote_timeout);
+ switch (c)
+ {
+ case SERIAL_TIMEOUT:
+ /* Nothing we can do. */
+ return;
+ case '#':
+ /* Discard the two bytes of checksum and stop. */
+ c = readchar (remote_timeout);
+ if (c >= 0)
+ c = readchar (remote_timeout);
+
+ return;
+ case '*': /* Run length encoding. */
+ /* Discard the repeat count. */
+ c = readchar (remote_timeout);
+ if (c < 0)
+ return;
+ break;
+ default:
+ /* A regular character. */
+ break;
+ }
+ }
+}
+
/* Come here after finding the start of the frame. Collect the rest
- into BUF, verifying the checksum, length, and handling run-length
- compression. No more than sizeof_buf-1 characters are read so that
- the buffer can be NUL terminated.
+ into *BUF, verifying the checksum, length, and handling run-length
+ compression. NUL terminate the buffer. If there is not enough room,
+ expand *BUF using xrealloc.
Returns -1 on error, number of characters in buffer (ignoring the
trailing NULL) on success. (could be extended to return one of the
SERIAL status indications). */
static long
-read_frame (char *buf,
- long sizeof_buf)
+read_frame (char **buf_p,
+ long *sizeof_buf)
{
unsigned char csum;
long bc;
int c;
+ char *buf = *buf_p;
csum = 0;
bc = 0;
while (1)
{
- /* ASSERT (bc < sizeof_buf - 1) - space for trailing NULL. */
c = readchar (remote_timeout);
switch (c)
{
/* The character before ``*'' is repeated. */
- if (repeat > 0 && repeat <= 255
- && bc > 0
- && bc + repeat - 1 < sizeof_buf - 1)
+ if (repeat > 0 && repeat <= 255 && bc > 0)
{
+ if (bc + repeat - 1 >= *sizeof_buf - 1)
+ {
+ /* Make some more room in the buffer. */
+ *sizeof_buf += repeat;
+ *buf_p = xrealloc (*buf_p, *sizeof_buf);
+ buf = *buf_p;
+ }
+
memset (&buf[bc], buf[bc - 1], repeat);
bc += repeat;
continue;
}
buf[bc] = '\0';
- printf_filtered (_("Repeat count %d too large for buffer: "),
- repeat);
- puts_filtered (buf);
- puts_filtered ("\n");
+ printf_filtered (_("Invalid run length encoding: %s\n"), buf);
return -1;
}
default:
- if (bc < sizeof_buf - 1)
+ if (bc >= *sizeof_buf - 1)
{
- buf[bc++] = c;
- csum += c;
- continue;
+ /* Make some more room in the buffer. */
+ *sizeof_buf *= 2;
+ *buf_p = xrealloc (*buf_p, *sizeof_buf);
+ buf = *buf_p;
}
- buf[bc] = '\0';
- puts_filtered ("Remote packet too long: ");
- puts_filtered (buf);
- puts_filtered ("\n");
-
- return -1;
+ buf[bc++] = c;
+ csum += c;
+ continue;
}
}
}
/* Read a packet from the remote machine, with error checking, and
- store it in BUF. If FOREVER, wait forever rather than timing out;
- this is used (in synchronous mode) to wait for a target that is is
- executing user code to stop. */
+ store it in *BUF. Resize *BUF using xrealloc if necessary to hold
+ the result, and update *SIZEOF_BUF. If FOREVER, wait forever
+ rather than timing out; this is used (in synchronous mode) to wait
+ for a target that is is executing user code to stop. */
/* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
don't have to change all the calls to getpkt to deal with the
return value, because at the moment I don't know what the right
thing to do it for those. */
void
-getpkt (char *buf,
- long sizeof_buf,
+getpkt (char **buf,
+ long *sizeof_buf,
int forever)
{
int timed_out;
/* Read a packet from the remote machine, with error checking, and
- store it in BUF. If FOREVER, wait forever 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. */
+ store it in *BUF. Resize *BUF using xrealloc if necessary to hold
+ the result, and update *SIZEOF_BUF. If FOREVER, wait forever
+ 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. */
static int
-getpkt_sane (char *buf,
- long sizeof_buf,
- int forever)
+getpkt_sane (char **buf, long *sizeof_buf, int forever)
{
int c;
int tries;
int timeout;
int val;
- strcpy (buf, "timeout");
+ strcpy (*buf, "timeout");
if (forever)
{
if (remote_debug)
{
fprintf_unfiltered (gdb_stdlog, "Packet received: ");
- fputstr_unfiltered (buf, 0, gdb_stdlog);
+ fputstr_unfiltered (*buf, 0, gdb_stdlog);
fprintf_unfiltered (gdb_stdlog, "\n");
}
serial_write (remote_desc, "+", 1);
/* Clean up from the last time we were running. */
clear_proceed_status ();
-
- /* Let the remote process run. */
- proceed (-1, TARGET_SIGNAL_0, 0);
}
/* Async version of extended_remote_create_inferior. */
/* Clean up from the last time we were running. */
clear_proceed_status ();
-
- /* Let the remote process run. */
- proceed (-1, TARGET_SIGNAL_0, 0);
}
\f
#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, char *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
fails, and the user has explicitly requested the Z support then
report an error, otherwise, mark it disabled and go on. */
- if (remote_protocol_Z[Z_PACKET_SOFTWARE_BP].support != PACKET_DISABLE)
+ if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
{
- char *buf = alloca (rs->remote_packet_size);
- char *p = buf;
+ 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);
+ BREAKPOINT_FROM_PC (&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 (buf);
- getpkt (buf, (rs->remote_packet_size), 0);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
- switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_SOFTWARE_BP]))
+ switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
{
case PACKET_ERROR:
return -1;
}
#ifdef DEPRECATED_REMOTE_BREAKPOINT
- val = target_read_memory (addr, contents_cache, sizeof big_break_insn);
+ bp_tgt->placed_size = bp_tgt->shadow_len = sizeof big_break_insn;
+ val = target_read_memory (addr, bp_tgt->shadow_contents, bp_tgt->shadow_len);
if (val == 0)
{
return val;
#else
- return memory_insert_breakpoint (addr, contents_cache);
+ return memory_insert_breakpoint (bp_tgt);
#endif /* DEPRECATED_REMOTE_BREAKPOINT */
}
static int
-remote_remove_breakpoint (CORE_ADDR addr, char *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;
- if (remote_protocol_Z[Z_PACKET_SOFTWARE_BP].support != PACKET_DISABLE)
+ if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
{
- char *buf = alloca (rs->remote_packet_size);
- char *p = buf;
+ char *p = rs->buf;
*(p++) = 'z';
*(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 (buf);
- getpkt (buf, (rs->remote_packet_size), 0);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
- return (buf[0] == 'E');
+ return (rs->buf[0] == 'E');
}
#ifdef DEPRECATED_REMOTE_BREAKPOINT
- return target_write_memory (addr, contents_cache, sizeof big_break_insn);
+ return target_write_memory (bp_tgt->placed_address, bp_tgt->shadow_contents,
+ bp_tgt->shadow_len);
#else
- return memory_remove_breakpoint (addr, contents_cache);
+ return memory_remove_breakpoint (bp_tgt);
#endif /* DEPRECATED_REMOTE_BREAKPOINT */
}
switch (type)
{
case hw_write:
- return 2;
+ return Z_PACKET_WRITE_WP;
break;
case hw_read:
- return 3;
+ return Z_PACKET_READ_WP;
break;
case hw_access:
- return 4;
+ return Z_PACKET_ACCESS_WP;
break;
default:
internal_error (__FILE__, __LINE__,
remote_insert_watchpoint (CORE_ADDR addr, int len, int type)
{
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
char *p;
enum Z_packet_type packet = watchpoint_to_Z_packet (type);
- if (remote_protocol_Z[packet].support == PACKET_DISABLE)
- error (_("Can't set hardware watchpoints without the '%s' (%s) packet."),
- remote_protocol_Z[packet].name,
- remote_protocol_Z[packet].title);
+ if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
+ return -1;
- sprintf (buf, "Z%x,", packet);
- p = strchr (buf, '\0');
+ sprintf (rs->buf, "Z%x,", packet);
+ p = strchr (rs->buf, '\0');
addr = remote_address_masked (addr);
p += hexnumstr (p, (ULONGEST) addr);
sprintf (p, ",%x", len);
- putpkt (buf);
- getpkt (buf, (rs->remote_packet_size), 0);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
- switch (packet_ok (buf, &remote_protocol_Z[packet]))
+ switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
{
case PACKET_ERROR:
case PACKET_UNKNOWN:
remote_remove_watchpoint (CORE_ADDR addr, int len, int type)
{
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
char *p;
enum Z_packet_type packet = watchpoint_to_Z_packet (type);
- if (remote_protocol_Z[packet].support == PACKET_DISABLE)
- error (_("Can't clear hardware watchpoints without the '%s' (%s) packet."),
- remote_protocol_Z[packet].name,
- remote_protocol_Z[packet].title);
+ if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
+ return -1;
- sprintf (buf, "z%x,", packet);
- p = strchr (buf, '\0');
+ sprintf (rs->buf, "z%x,", packet);
+ p = strchr (rs->buf, '\0');
addr = remote_address_masked (addr);
p += hexnumstr (p, (ULONGEST) addr);
sprintf (p, ",%x", len);
- putpkt (buf);
- getpkt (buf, (rs->remote_packet_size), 0);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
- switch (packet_ok (buf, &remote_protocol_Z[packet]))
+ switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
{
case PACKET_ERROR:
case PACKET_UNKNOWN:
static int
-remote_insert_hw_breakpoint (CORE_ADDR addr, char *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 *buf = alloca (rs->remote_packet_size);
- char *p = buf;
+ 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);
-
- if (remote_protocol_Z[Z_PACKET_HARDWARE_BP].support == PACKET_DISABLE)
- error (_("Can't set hardware breakpoint without the '%s' (%s) packet."),
- remote_protocol_Z[Z_PACKET_HARDWARE_BP].name,
- remote_protocol_Z[Z_PACKET_HARDWARE_BP].title);
+ BREAKPOINT_FROM_PC (&bp_tgt->placed_address, &bp_tgt->placed_size);
+ if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
+ 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 (buf);
- getpkt (buf, (rs->remote_packet_size), 0);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
- switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_HARDWARE_BP]))
+ switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
{
case PACKET_ERROR:
case PACKET_UNKNOWN:
static int
-remote_remove_hw_breakpoint (CORE_ADDR addr, char *shadow)
+remote_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
{
- int len;
+ CORE_ADDR addr;
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
- char *p = buf;
-
- /* The length field should be set to the size of a breakpoint
- instruction. */
+ char *p = rs->buf;
- BREAKPOINT_FROM_PC (&addr, &len);
-
- if (remote_protocol_Z[Z_PACKET_HARDWARE_BP].support == PACKET_DISABLE)
- error (_("Can't clear hardware breakpoint without the '%s' (%s) packet."),
- remote_protocol_Z[Z_PACKET_HARDWARE_BP].name,
- remote_protocol_Z[Z_PACKET_HARDWARE_BP].title);
+ if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
+ 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(buf);
- getpkt (buf, (rs->remote_packet_size), 0);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
- switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_HARDWARE_BP]))
+ switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
{
case PACKET_ERROR:
case PACKET_UNKNOWN:
char *tmp;
char *sectdata;
const char *sectname;
- char *buf = alloca (rs->remote_packet_size);
bfd_size_type size;
bfd_vma lma;
int matched = 0;
matched = 1; /* do this section */
lma = s->lma;
/* FIXME: assumes lma can fit into long. */
- sprintf (buf, "qCRC:%lx,%lx", (long) lma, (long) size);
- putpkt (buf);
+ xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
+ (long) lma, (long) size);
+ putpkt (rs->buf);
/* Be clever; compute the host_crc before waiting for target
reply. */
bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff);
- getpkt (buf, (rs->remote_packet_size), 0);
- if (buf[0] == 'E')
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ if (rs->buf[0] == 'E')
error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
sectname, paddr (lma), paddr (lma + size));
- if (buf[0] != 'C')
+ if (rs->buf[0] != 'C')
error (_("remote target does not support this operation"));
- for (target_crc = 0, tmp = &buf[1]; *tmp; tmp++)
+ for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
target_crc = target_crc * 16 + fromhex (*tmp);
printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
static LONGEST
remote_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, void *readbuf, const void *writebuf,
- ULONGEST offset, LONGEST len)
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
{
struct remote_state *rs = get_remote_state ();
int i;
- char *buf2 = alloca (rs->remote_packet_size);
- char *p2 = &buf2[0];
+ char *p2;
char query_type;
/* Handle memory using remote_xfer_memory. */
break;
case TARGET_OBJECT_AUXV:
- if (remote_protocol_qPart_auxv.support != PACKET_DISABLE)
+ 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 (buf2, rs->remote_packet_size,
+ LONGEST n = min ((get_remote_packet_size () - 2) / 2, len);
+ snprintf (rs->buf, get_remote_packet_size (),
"qPart:auxv:read::%s,%s",
phex_nz (offset, sizeof offset),
phex_nz (n, sizeof n));
- i = putpkt (buf2);
+ i = putpkt (rs->buf);
if (i < 0)
return total > 0 ? total : i;
- buf2[0] = '\0';
- getpkt (buf2, rs->remote_packet_size, 0);
- if (packet_ok (buf2, &remote_protocol_qPart_auxv) != PACKET_OK)
+ 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 (buf2[0] == 'O' && buf2[1] == 'K' && buf2[2] == '\0')
+ if (strcmp (rs->buf, "OK") == 0)
break; /* Got EOF indicator. */
/* Got some data. */
- i = hex2bin (buf2, readbuf, len);
+ i = hex2bin (rs->buf, readbuf, len);
if (i > 0)
{
readbuf = (void *) ((char *) readbuf + i);
/* 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 bufsiz is
- not large enough let the caller. */
- if (len < (rs->remote_packet_size))
+ 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 < 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)
gdb_assert (annex != NULL);
gdb_assert (readbuf != NULL);
+ p2 = rs->buf;
*p2++ = 'q';
*p2++ = query_type;
(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] != '#');
*p2 = '\0';
gdb_assert (annex[i] == '\0');
- i = putpkt (buf2);
+ i = putpkt (rs->buf);
if (i < 0)
return i;
- getpkt (readbuf, len, 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ strcpy ((char *) readbuf, rs->buf);
- return strlen (readbuf);
+ return strlen ((char *) readbuf);
}
static void
struct ui_file *outbuf)
{
struct remote_state *rs = get_remote_state ();
- int i;
- char *buf = alloca (rs->remote_packet_size);
+ char *buf = rs->buf;
char *p = buf;
if (!remote_desc)
strcpy (buf, "qRcmd,");
p = strchr (buf, '\0');
- if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > (rs->remote_packet_size))
+ if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ())
error (_("\"monitor\" command ``%s'' is too long."), command);
/* Encode the actual command. */
- bin2hex (command, p, 0);
+ bin2hex ((gdb_byte *) command, p, 0);
- if (putpkt (buf) < 0)
+ if (putpkt (rs->buf) < 0)
error (_("Communication problem with target."));
/* get/display the response */
{
/* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
buf[0] = '\0';
- getpkt (buf, (rs->remote_packet_size), 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
if (buf[0] == '\0')
error (_("Target does not support this command."));
if (buf[0] == 'O' && buf[1] != 'K')
packet_command (char *args, int from_tty)
{
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
if (!remote_desc)
error (_("command can only be used with remote target"));
puts_filtered ("\n");
putpkt (args);
- getpkt (buf, (rs->remote_packet_size), 0);
+ getpkt (&rs->buf, &rs->buf_size, 0);
puts_filtered ("received: ");
- print_packet (buf);
+ print_packet (rs->buf);
puts_filtered ("\n");
}
remote_pid_to_str (ptid_t ptid)
{
static char buf[32];
- int size;
- size = snprintf (buf, sizeof buf, "thread %d", ptid_get_pid (ptid));
- gdb_assert (size < sizeof buf);
+ xsnprintf (buf, sizeof buf, "thread %d", ptid_get_pid (ptid));
return buf;
}
+/* Get the address of the thread local variable in OBJFILE which is
+ stored at OFFSET within the thread local storage for thread PTID. */
+
+static CORE_ADDR
+remote_get_thread_local_address (ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
+{
+ if (remote_protocol_packets[PACKET_qGetTLSAddr].support != PACKET_DISABLE)
+ {
+ struct remote_state *rs = get_remote_state ();
+ char *p = rs->buf;
+ enum packet_result result;
+
+ strcpy (p, "qGetTLSAddr:");
+ p += strlen (p);
+ p += hexnumstr (p, PIDGET (ptid));
+ *p++ = ',';
+ p += hexnumstr (p, offset);
+ *p++ = ',';
+ p += hexnumstr (p, lm);
+ *p++ = '\0';
+
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_qGetTLSAddr]);
+ if (result == PACKET_OK)
+ {
+ ULONGEST result;
+
+ unpack_varlen_hex (rs->buf, &result);
+ return result;
+ }
+ else if (result == PACKET_UNKNOWN)
+ throw_error (TLS_GENERIC_ERROR,
+ _("Remote target doesn't support qGetTLSAddr packet"));
+ else
+ throw_error (TLS_GENERIC_ERROR,
+ _("Remote target failed to process qGetTLSAddr request"));
+ }
+ else
+ throw_error (TLS_GENERIC_ERROR,
+ _("TLS not supported or disabled on this target"));
+ /* Not reached. */
+ return 0;
+}
+
static void
init_remote_ops (void)
{
remote_ops.to_stop = remote_stop;
remote_ops.to_xfer_partial = remote_xfer_partial;
remote_ops.to_rcmd = remote_rcmd;
+ remote_ops.to_get_thread_local_address = remote_get_thread_local_address;
remote_ops.to_stratum = process_stratum;
remote_ops.to_has_all_memory = 1;
remote_ops.to_has_memory = 1;
static void
show_remote_cmd (char *args, int from_tty)
{
- /* FIXME: cagney/2002-06-15: This function should iterate over
- remote_show_cmdlist for a list of sub commands to show. */
- show_remote_protocol_Z_packet_cmd (gdb_stdout, from_tty, NULL, NULL);
- show_remote_protocol_P_packet_cmd (gdb_stdout, from_tty, NULL, NULL);
- show_remote_protocol_p_packet_cmd (gdb_stdout, from_tty, NULL, NULL);
- show_remote_protocol_qSymbol_packet_cmd (gdb_stdout, from_tty, NULL, NULL);
- show_remote_protocol_vcont_packet_cmd (gdb_stdout, from_tty, NULL, NULL);
- show_remote_protocol_binary_download_cmd (gdb_stdout, from_tty, NULL, NULL);
- show_remote_protocol_qPart_auxv_packet_cmd (gdb_stdout, from_tty, NULL, NULL);
+ /* We can't just use cmd_show_list here, because we want to skip
+ the redundant "show remote Z-packet". */
+ struct cleanup *showlist_chain;
+ struct cmd_list_element *list = remote_show_cmdlist;
+
+ showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
+ for (; list != NULL; list = list->next)
+ if (strcmp (list->name, "Z-packet") == 0)
+ continue;
+ else if (list->type == show_cmd)
+ {
+ 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);
+ /* Close the tuple. */
+ do_cleanups (option_chain);
+ }
}
static void
void
_initialize_remote (void)
{
- static struct cmd_list_element *remote_set_cmdlist;
- static struct cmd_list_element *remote_show_cmdlist;
- struct cmd_list_element *tmpcmd;
+ struct remote_state *rs;
/* architecture specific data */
remote_gdbarch_data_handle =
DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size);
deprecated_register_gdbarch_swap (NULL, 0, build_remote_gdbarch_data);
+ /* 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 ();
+ rs->buf_size = 400;
+ rs->buf = xmalloc (rs->buf_size);
+
init_remote_ops ();
add_target (&remote_ops);
NULL, /* FIXME: i18n: */
&setlist, &showlist);
- add_packet_config_cmd (&remote_protocol_binary_download,
- "X", "binary-download",
- set_remote_protocol_binary_download_cmd,
- show_remote_protocol_binary_download_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 1);
-
- add_packet_config_cmd (&remote_protocol_vcont,
- "vCont", "verbose-resume",
- set_remote_protocol_vcont_packet_cmd,
- show_remote_protocol_vcont_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
+ "X", "binary-download", 1);
- add_packet_config_cmd (&remote_protocol_qSymbol,
- "qSymbol", "symbol-lookup",
- set_remote_protocol_qSymbol_packet_cmd,
- show_remote_protocol_qSymbol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
+ "vCont", "verbose-resume", 0);
- add_packet_config_cmd (&remote_protocol_P,
- "P", "set-register",
- set_remote_protocol_P_packet_cmd,
- show_remote_protocol_P_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 1);
-
- add_packet_config_cmd (&remote_protocol_p,
- "p", "fetch-register",
- set_remote_protocol_p_packet_cmd,
- show_remote_protocol_p_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 1);
-
- add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP],
- "Z0", "software-breakpoint",
- set_remote_protocol_Z_software_bp_packet_cmd,
- show_remote_protocol_Z_software_bp_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
+ "qSymbol", "symbol-lookup", 0);
- add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_HARDWARE_BP],
- "Z1", "hardware-breakpoint",
- set_remote_protocol_Z_hardware_bp_packet_cmd,
- show_remote_protocol_Z_hardware_bp_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
+ "P", "set-register", 1);
- add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_WRITE_WP],
- "Z2", "write-watchpoint",
- set_remote_protocol_Z_write_wp_packet_cmd,
- show_remote_protocol_Z_write_wp_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
+ "p", "fetch-register", 1);
- add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_READ_WP],
- "Z3", "read-watchpoint",
- set_remote_protocol_Z_read_wp_packet_cmd,
- show_remote_protocol_Z_read_wp_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
+ "Z0", "software-breakpoint", 0);
- add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_ACCESS_WP],
- "Z4", "access-watchpoint",
- set_remote_protocol_Z_access_wp_packet_cmd,
- show_remote_protocol_Z_access_wp_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
- 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
+ "Z1", "hardware-breakpoint", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
+ "Z2", "write-watchpoint", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
+ "Z3", "read-watchpoint", 0);
- add_packet_config_cmd (&remote_protocol_qPart_auxv,
- "qPart_auxv", "read-aux-vector",
- set_remote_protocol_qPart_auxv_packet_cmd,
- show_remote_protocol_qPart_auxv_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist,
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
+ "Z4", "access-watchpoint", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qPart_auxv],
+ "qPart:auxv", "read-aux-vector", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
+ "qGetTLSAddr", "get-thread-local-storage-address",
0);
- /* Keep the old ``set remote Z-packet ...'' working. */
+ 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
+ documentation). */
add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
&remote_Z_packet_detect, _("\
Set use of remote protocol `Z' packets"), _("\
projects / deliverable / binutils-gdb.git / blobdiff