/* 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
+ 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 "regcache.h"
#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);
enum target_signal siggnal);
static void remote_async_resume (ptid_t ptid, int step,
enum target_signal siggnal);
-static int remote_start_remote (struct ui_out *uiout, void *dummy);
-
static void remote_open (char *name, int from_tty);
static void remote_async_open (char *name, int from_tty);
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 void skip_frame (void);
-static int remote_insert_breakpoint (CORE_ADDR, char *);
+static long read_frame (char **buf_p, long *sizeof_buf);
-static int remote_remove_breakpoint (CORE_ADDR, char *);
+static int remote_insert_breakpoint (CORE_ADDR, bfd_byte *);
+
+static int remote_remove_breakpoint (CORE_ADDR, bfd_byte *);
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);
/* 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;
};
int regnum;
struct remote_state *rs = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_state);
- if (deprecated_register_bytes () != 0)
- rs->sizeof_g_packet = deprecated_register_bytes ();
- else
- rs->sizeof_g_packet = 0;
+ rs->sizeof_g_packet = 0;
/* Assume a 1:1 regnum<->pnum table. */
rs->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, NUM_REGS + NUM_PSEUDO_REGS,
/* ...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)
+ rs->sizeof_g_packet += register_size (current_gdbarch, regnum);
}
/* Default maximum number of characters in a packet body. Many
/* 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);
+
return rs;
}
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),
+ 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
+ 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). */
#ifndef MAX_REMOTE_PACKET_SIZE
#define MAX_REMOTE_PACKET_SIZE 16384
#endif
- /* NOTE: 16 is just chosen at random. */
+ /* NOTE: 20 ensures we can write at least one byte. */
#ifndef MIN_REMOTE_PACKET_SIZE
-#define MIN_REMOTE_PACKET_SIZE 16
+#define MIN_REMOTE_PACKET_SIZE 20
#endif
long what_they_get;
if (config->fixed_p)
}
else
{
- what_they_get = (rs->remote_packet_size);
+ what_they_get = rs->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 = 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;
}
int fixed_p = config->fixed_p;
long size = config->size;
if (args == NULL)
- error ("Argument required (integer, `fixed' or `limited').");
+ error (_("Argument required (integer, `fixed' or `limited')."));
else if (strcmp (args, "hard") == 0
|| strcmp (args, "fixed") == 0)
fixed_p = 1;
char *end;
size = strtoul (args, &end, 0);
if (args == end)
- error ("Invalid %s (bad syntax).", config->name);
+ error (_("Invalid %s (bad syntax)."), config->name);
#if 0
/* Instead of explicitly capping the size of a packet to
MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
instead allowed to set the size to something arbitrarily
large. */
if (size > MAX_REMOTE_PACKET_SIZE)
- error ("Invalid %s (too large).", config->name);
+ error (_("Invalid %s (too large)."), config->name);
#endif
}
/* Extra checks? */
if (fixed_p && !config->fixed_p)
{
- if (! query ("The target may not be able to correctly handle a %s\n"
- "of %ld bytes. Change the packet size? ",
+ if (! query (_("The target may not be able to correctly handle a %s\n"
+ "of %ld bytes. Change the packet size? "),
config->name, size))
- error ("Packet size not changed.");
+ error (_("Packet size not changed."));
}
/* Update the config. */
config->fixed_p = fixed_p;
static void
show_memory_packet_size (struct memory_packet_config *config)
{
- printf_filtered ("The %s is %ld. ", config->name, config->size);
+ printf_filtered (_("The %s is %ld. "), config->name, config->size);
if (config->fixed_p)
- printf_filtered ("Packets are fixed at %ld bytes.\n",
+ printf_filtered (_("Packets are fixed at %ld bytes.\n"),
get_memory_packet_size (config));
else
- printf_filtered ("Packets are limited to %ld bytes.\n",
+ printf_filtered (_("Packets are limited to %ld bytes.\n"),
get_memory_packet_size (config));
}
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 RS->remote_packet_size. */
+ if (size > rs->remote_packet_size)
+ size = rs->remote_packet_size;
return size;
}
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;
}
}
char *name,
char *title,
cmd_sfunc_ftype *set_func,
- cmd_sfunc_ftype *show_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;
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,
- "", print,
+ &config->detect, set_doc, show_doc, NULL, /* help_doc */
set_func, show_func,
set_remote_list, show_remote_list);
/* set/show remote NAME-packet {auto,on,off} -- legacy. */
break;
case PACKET_DISABLE:
internal_error (__FILE__, __LINE__,
- "packet_ok: attempt to use a disabled packet");
+ _("packet_ok: attempt to use a disabled packet"));
break;
case PACKET_ENABLE:
break;
if (config->detect == AUTO_BOOLEAN_AUTO)
/* If the stub previously indicated that the packet was
supported then there is a protocol error.. */
- error ("Protocol error: %s (%s) conflicting enabled responses.",
+ error (_("Protocol error: %s (%s) conflicting enabled responses."),
config->name, config->title);
else
/* The user set it wrong. */
- error ("Enabled packet %s (%s) not recognized by stub",
+ error (_("Enabled packet %s (%s) not recognized by stub"),
config->name, config->title);
break;
case PACKET_SUPPORT_UNKNOWN:
}
}
-/* Should we try the 'vCont' (descriptive resume) request? */
-static struct packet_config 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_MAX
+};
-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 struct packet_config remote_protocol_packets[PACKET_MAX];
static void
-show_remote_protocol_vcont_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)
{
- show_packet_config_cmd (&remote_protocol_vcont);
-}
-
-/* Should we try the 'qSymbol' (target symbol lookup service) request? */
-static struct packet_config remote_protocol_qSymbol;
+ struct packet_config *packet;
-static void
-set_remote_protocol_qSymbol_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- update_packet_config (&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);
}
static void
-show_remote_protocol_qSymbol_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)
{
- show_packet_config_cmd (&remote_protocol_qSymbol);
-}
+ struct packet_config *packet;
-/* 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)
-{
- update_packet_config (&remote_protocol_P);
-}
-
-static void
-show_remote_protocol_P_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- 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 (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- 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 (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- 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 (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- 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 (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- 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 (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- 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]);
}
}
static void
-show_remote_protocol_Z_packet_cmd (char *args, int from_tty,
- struct cmd_list_element *c)
+show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
{
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 (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- 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 (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- 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 (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- 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], rs->remote_packet_size - 2, "-%x", -th);
else
- sprintf (&buf[2], "%x", th);
+ xsnprintf (&buf[2], rs->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, rs->remote_packet_size, "T-%08x", -tid);
else
- sprintf (buf, "T%08x", tid);
+ xsnprintf (buf, rs->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');
}
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. */
pkt = unpack_threadid (pkt, &ref);
if (mask == 0)
- warning ("Incomplete response to threadinfo request\n");
+ warning (_("Incomplete response to threadinfo request."));
if (!threadmatch (&ref, expectedref))
{ /* This is an answer to a different request. */
- warning ("ERROR RMT Thread info mismatch\n");
+ warning (_("ERROR RMT Thread info mismatch."));
return 0;
}
copy_threadref (&info->threadid, &ref);
pkt = unpack_byte (pkt, &length); /* length */
if (!(tag & mask)) /* Tags out of synch with mask. */
{
- warning ("ERROR RMT: threadinfo tag mismatch\n");
+ warning (_("ERROR RMT: threadinfo tag mismatch."));
retval = 0;
break;
}
{
if (length != 16)
{
- warning ("ERROR RMT: length of threadid is not 16\n");
+ warning (_("ERROR RMT: length of threadid is not 16."));
retval = 0;
break;
}
mask = mask & ~(TAG_EXISTS);
if (length > 8)
{
- warning ("ERROR RMT: 'exists' length too long\n");
+ warning (_("ERROR RMT: 'exists' length too long."));
retval = 0;
break;
}
mask = mask & ~TAG_MOREDISPLAY;
continue;
}
- warning ("ERROR RMT: unknown thread info tag\n");
+ warning (_("ERROR RMT: unknown thread info tag."));
break; /* Not a tag we know about. */
}
return retval;
{
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) >= rs->remote_packet_size)
+ result_limit = (rs->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))
exit
wait for packet, then exit
*/
- warning ("HMM: threadlist did not echo arg thread, dropping it\n");
+ warning (_("HMM: threadlist did not echo arg thread, dropping it."));
return 0; /* I choose simply exiting. */
}
if (*result_count <= 0)
{
if (*done != 1)
{
- warning ("RMT ERROR : failed to get remote thread list\n");
+ warning (_("RMT ERROR : failed to get remote thread list."));
result = 0;
}
return result; /* break; */
if (*result_count > result_limit)
{
*result_count = 0;
- warning ("RMT ERROR: threadlist response longer than requested\n");
+ warning (_("RMT ERROR: threadlist response longer than requested."));
return 0;
}
return result;
if (loopcount++ > looplimit)
{
result = 0;
- warning ("Remote fetch threadlist -infinite loop-\n");
+ warning (_("Remote fetch threadlist -infinite loop-."));
break;
}
if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS,
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 (remote_desc == 0) /* paranoia */
- error ("Command can only be used when connected to the remote target.");
+ error (_("Command can only be used when connected to the remote target."));
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 */
internal_error (__FILE__, __LINE__,
- "remote_threads_extra_info");
+ _("remote_threads_extra_info"));
if (use_threadextra_query)
{
- sprintf (bufp, "qThreadExtraInfo,%x", PIDGET (tp->ptid));
+ char *bufp = rs->buf;
+
+ xsnprintf (bufp, rs->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, rs->remote_packet_size, "R%x", 0);
+ putpkt (rs->buf);
/* 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->remote_packet_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
this command. */
if (buf[0] == 'E')
{
- warning ("Remote failure reply: %s", buf);
+ warning (_("Remote failure reply: %s"), buf);
return;
}
lose = 1;
if (lose)
- error ("Malformed response to offset query, %s", buf);
+ error (_("Malformed response to offset query, %s"), buf);
if (symfile_objfile == NULL)
return;
return 1;
}
-static int
+static void
remote_start_remote (struct ui_out *uiout, void *dummy)
{
immediate_quit++; /* Allow user to interrupt it. */
putpkt ("?"); /* Initiate a query from remote machine. */
immediate_quit--;
- /* NOTE: See comment above in remote_start_remote_dummy(). This
- function returns something >=0. */
- return remote_start_remote_dummy (uiout, dummy);
+ remote_start_remote_dummy (uiout, dummy);
}
/* Open a connection to a remote debugger.
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 (rs->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, rs->remote_packet_size, "qSymbol::%s", &reply[8]);
else
- sprintf (msg, "qSymbol:%s:%s",
- paddr_nz (SYMBOL_VALUE_ADDRESS (sym)),
- &reply[8]);
+ xsnprintf (msg, rs->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);
}
}
to be. */
if (!udp_warning && strncmp (name, "udp:", 4) == 0)
{
- warning ("The remote protocol may be unreliable over UDP.");
- warning ("Some events may be lost, rendering further debugging "
- "impossible.");
+ warning (_("\
+The remote protocol may be unreliable over UDP.\n\
+Some events may be lost, rendering further debugging impossible."));
udp_warning = 1;
}
remote_open_1 (char *name, int from_tty, struct target_ops *target,
int extended_p, int async_p)
{
- int ex;
struct remote_state *rs = get_remote_state ();
if (name == 0)
- error ("To open a remote debug connection, you need to specify what\n"
+ 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.).");
+ "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
/* See FIXME above. */
if (!async_p)
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_exceptions (uiout,
- remote_start_remote, NULL,
- "Couldn't establish connection to remote"
- " target\n",
- RETURN_MASK_ALL);
- if (ex < 0)
- {
- pop_target ();
- if (async_p)
- wait_forever_enabled_p = 1;
- throw_reason (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);
+ getpkt (&rs->buf, &rs->buf_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. */
+
+ post_create_inferior (¤t_target, from_tty);
+
if (exec_bfd) /* No use without an exec file. */
- {
- SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid));
- remote_check_symbols (symfile_objfile);
- }
-#endif
+ 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.");
+ 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 ())
static void
remote_disconnect (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.");
+ error (_("Argument given to \"detach\" when remotely debugging."));
/* Unregister the file descriptor from the event loop. */
if (target_is_async_p ())
else if (a >= 'A' && a <= 'F')
return a - 'A' + 10;
else
- error ("Reply contains invalid hex digit %d", a);
+ error (_("Reply contains invalid hex digit %d"), a);
}
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_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN)
+ remote_vcont_probe (rs);
- if (remote_protocol_vcont.support == PACKET_SUPPORT_UNKNOWN)
- remote_vcont_probe (rs, buf);
-
- 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
}
gdb_assert (outbuf && strlen (outbuf) < rs->remote_packet_size);
- make_cleanup (xfree, outbuf);
+ 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;
Give up (and stop debugging it)? "))
{
target_mourn_inferior ();
- throw_reason (RETURN_QUIT);
+ deprecated_throw_reason (RETURN_QUIT);
}
target_terminal_inferior ();
remote_wait (ptid_t ptid, struct target_waitstatus *status)
{
struct remote_state *rs = get_remote_state ();
- unsigned char *buf = alloca (rs->remote_packet_size);
+ 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
switch (buf[0])
{
case 'E': /* Error of some sort. */
- warning ("Remote failure reply: %s", buf);
+ warning (_("Remote failure reply: %s"), buf);
continue;
case 'F': /* File-I/O request. */
remote_fileio_request (buf);
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\
-Packet: '%s'\n",
+ warning (_("Malformed packet(a) (missing colon): %s\n\
+Packet: '%s'\n"),
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
p = p1;
if (*p++ != ':')
- error ("Malformed packet(b) (missing colon): %s\n\
-Packet: '%s'\n",
+ error (_("Malformed packet(b) (missing colon): %s\n\
+Packet: '%s'\n"),
p, buf);
if (reg == NULL)
- error ("Remote sent bad register number %s: %s\n\
-Packet: '%s'\n",
+ error (_("Remote sent bad register number %s: %s\n\
+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;
if (fieldsize < register_size (current_gdbarch,
reg->regnum))
- warning ("Remote reply is too short: %s", buf);
+ warning (_("Remote reply is too short: %s"), buf);
regcache_raw_supply (current_regcache,
reg->regnum, regs);
}
if (*p++ != ';')
- error ("Remote register badly formatted: %s\nhere: %s",
+ error (_("Remote register badly formatted: %s\nhere: %s"),
buf, p);
}
}
}
/* else fallthrough */
default:
- warning ("Invalid remote reply: %s", buf);
+ warning (_("Invalid remote reply: %s"), buf);
continue;
}
}
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);
+ 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);
switch (buf[0])
{
case 'E': /* Error of some sort. */
- warning ("Remote failure reply: %s", buf);
+ warning (_("Remote failure reply: %s"), buf);
continue;
case 'F': /* File-I/O request. */
remote_fileio_request (buf);
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",
+ error (_("Malformed packet(a) (missing colon): %s\n\
+Packet: '%s'\n"),
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)
else
{
/* Silently skip unknown optional info. */
- p_temp = (unsigned char *) strchr (p1 + 1, ';');
+ p_temp = strchr (p1 + 1, ';');
if (p_temp)
p = p_temp;
}
struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
p = p1;
if (*p++ != ':')
- error ("Malformed packet(b) (missing colon): %s\n\
-Packet: '%s'\n",
+ error (_("Malformed packet(b) (missing colon): %s\n\
+Packet: '%s'\n"),
p, buf);
if (reg == NULL)
- error ("Remote sent bad register number %ld: %s\n\
-Packet: '%s'\n",
+ error (_("Remote sent bad register number %ld: %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;
if (fieldsize < register_size (current_gdbarch,
reg->regnum))
- warning ("Remote reply is too short: %s", buf);
+ warning (_("Remote reply is too short: %s"), buf);
regcache_raw_supply (current_regcache, reg->regnum, regs);
}
if (*p++ != ';')
- error ("Remote register badly formatted: %s\nhere: %s",
+ error (_("Remote register badly formatted: %s\nhere: %s"),
buf, p);
}
}
}
/* else fallthrough */
default:
- warning ("Invalid remote reply: %s", buf);
+ warning (_("Invalid remote reply: %s"), buf);
continue;
}
}
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. */
{
if (p[1] == 0)
{
- error ("fetch_register_using_p: early buf termination");
+ error (_("fetch_register_using_p: early buf termination"));
return 0;
}
remote_fetch_registers (int regnum)
{
struct remote_state *rs = get_remote_state ();
- char *buf = alloca (rs->remote_packet_size);
+ char *buf = rs->buf;
int i;
char *p;
char *regs = alloca (rs->sizeof_g_packet);
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.");
+ _("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))
return;
else
- error ("Protocol error: p packet not recognized by stub");
+ 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_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
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. */
{
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
break;
if (p[1] == 0)
{
- warning ("Remote reply is of odd length: %s", buf);
+ 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;
register_bytes_found = i;
if (REGISTER_BYTES_OK_P ()
&& !REGISTER_BYTES_OK (i))
- warning ("Remote reply is too short: %s", buf);
+ warning (_("Remote reply is too short: %s"), buf);
}
supply_them:
{
struct remote_state *rs = get_remote_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:
struct remote_state *rs = get_remote_state ();
struct packet_reg *reg = packet_reg_from_regnum (rs, 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, rs->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;
+ 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))
return;
else
- error ("Protocol error: P packet not recognized by stub");
+ 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_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;
}
}
{
int i;
regs = alloca (rs->sizeof_g_packet);
- memset (regs, rs->sizeof_g_packet, 0);
+ memset (regs, 0, rs->sizeof_g_packet);
for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
{
struct packet_reg *r = &rs->regs[i];
/* 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);
- /* Compute the size, and then allocate space for the largest
- possible packet. Include space for an extra trailing NULL. */
- sizeof_buf = get_memory_write_packet_size () + 1;
- buf = alloca (sizeof_buf);
+ 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;
/* Compute the size of the actual payload by subtracting out the
- packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
- payload_size = (get_memory_write_packet_size () - (strlen ("$M,:#NN")
- + hexnumlen (memaddr)
- + hexnumlen (len)));
+ packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
+ */
+ payload_size -= strlen ("$M,:#NN");
+ payload_size -= hexnumlen (memaddr);
/* Construct the packet header: "[MX]<memaddr>,<len>:". */
/* 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';
/* Best guess at number of bytes that will fit. */
todo = min (len, payload_size);
+ payload_size -= hexnumlen (todo);
+ todo = min (todo, payload_size);
break;
case PACKET_DISABLE:
*p++ = 'M';
/* Num bytes that will fit. */
todo = min (len, payload_size / 2);
+ 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");
+ _("remote_write_bytes: bad internal state"));
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
+ if (todo <= 0)
+ internal_error (__FILE__, __LINE__,
+ _("minumum packet size too small to write data"));
/* Append "<memaddr>". */
memaddr = remote_address_masked (memaddr);
/* 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
break;
case PACKET_SUPPORT_UNKNOWN:
internal_error (__FILE__, __LINE__,
- "remote_write_bytes: bad internal state");
+ _("remote_write_bytes: bad internal state"));
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
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)
{
{
case SERIAL_EOF:
target_mourn_inferior ();
- error ("Remote connection closed");
+ error (_("Remote connection closed"));
/* no return */
case SERIAL_ERROR:
- perror_with_name ("Remote communication error");
+ perror_with_name (_("Remote communication error"));
/* no return */
case SERIAL_TIMEOUT:
break;
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,
+ RS->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. */
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;
gdb_flush (gdb_stdlog);
}
if (serial_write (remote_desc, buf2, p - buf2))
- perror_with_name ("putpkt: write failed");
+ perror_with_name (_("putpkt: write failed"));
/* Read until either a timeout occurs (-2) or '+' is read. */
while (1)
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)
{
{
QUIT;
target_mourn_inferior ();
- error ("Watchdog has expired. Target detached.\n");
+ error (_("Watchdog has expired. Target detached."));
}
if (remote_debug)
fputs_filtered ("Timed out.\n", gdb_stdlog);
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);
/* We have tried hard enough, and just can't receive the packet.
Give up. */
- printf_unfiltered ("Ignoring packet error, continuing...\n");
+ printf_unfiltered (_("Ignoring packet error, continuing...\n"));
serial_write (remote_desc, "+", 1);
return 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
of bytes returned by BREAKPOINT_FROM_PC. */
static int
-remote_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
+remote_insert_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
{
struct remote_state *rs = get_remote_state ();
#ifdef DEPRECATED_REMOTE_BREAKPOINT
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';
BREAKPOINT_FROM_PC (&addr, &bp_size);
sprintf (p, ",%d", bp_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;
}
static int
-remote_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
+remote_remove_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
{
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';
BREAKPOINT_FROM_PC (&addr, &bp_size);
sprintf (p, ",%d", bp_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
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__,
- "hw_bp_to_z: bad watchpoint type %d", type);
+ _("hw_bp_to_z: bad watchpoint type %d"), type);
}
}
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\n",
- remote_protocol_Z[packet].name,
- remote_protocol_Z[packet].title);
+ 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);
- 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:
return 0;
}
internal_error (__FILE__, __LINE__,
- "remote_insert_watchpoint: reached end of function");
+ _("remote_insert_watchpoint: reached end of function"));
}
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\n",
- remote_protocol_Z[packet].name,
- remote_protocol_Z[packet].title);
+ 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);
- 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:
return 0;
}
internal_error (__FILE__, __LINE__,
- "remote_remove_watchpoint: reached end of function");
+ _("remote_remove_watchpoint: reached end of function"));
}
static int
-remote_insert_hw_breakpoint (CORE_ADDR addr, char *shadow)
+remote_insert_hw_breakpoint (CORE_ADDR addr, gdb_byte *shadow)
{
int len = 0;
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. */
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\n",
- 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)
+ error (_("Can't set hardware breakpoint without the '%s' (%s) packet."),
+ remote_protocol_packets[PACKET_Z1].name,
+ remote_protocol_packets[PACKET_Z1].title);
*(p++) = 'Z';
*(p++) = '1';
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[Z_PACKET_HARDWARE_BP]))
+ switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
{
case PACKET_ERROR:
case PACKET_UNKNOWN:
return 0;
}
internal_error (__FILE__, __LINE__,
- "remote_insert_hw_breakpoint: reached end of function");
+ _("remote_insert_hw_breakpoint: reached end of function"));
}
static int
-remote_remove_hw_breakpoint (CORE_ADDR addr, char *shadow)
+remote_remove_hw_breakpoint (CORE_ADDR addr, gdb_byte *shadow)
{
int len;
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. */
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\n",
- 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)
+ error (_("Can't clear hardware breakpoint without the '%s' (%s) packet."),
+ remote_protocol_packets[PACKET_Z1].name,
+ remote_protocol_packets[PACKET_Z1].title);
*(p++) = 'z';
*(p++) = '1';
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[Z_PACKET_HARDWARE_BP]))
+ switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
{
case PACKET_ERROR:
case PACKET_UNKNOWN:
return 0;
}
internal_error (__FILE__, __LINE__,
- "remote_remove_hw_breakpoint: reached end of function");
+ _("remote_remove_hw_breakpoint: reached end of function"));
}
/* Some targets are only capable of doing downloads, and afterwards
void
push_remote_target (char *name, int from_tty)
{
- printf_filtered ("Switching to remote protocol\n");
+ printf_filtered (_("Switching to remote protocol\n"));
remote_open (name, from_tty);
}
char *tmp;
char *sectdata;
const char *sectname;
- char *buf = alloca (rs->remote_packet_size);
bfd_size_type size;
bfd_vma lma;
int matched = 0;
int mismatched = 0;
if (!exec_bfd)
- error ("command cannot be used without an exec file");
+ error (_("command cannot be used without an exec file"));
if (!current_target.to_shortname ||
strcmp (current_target.to_shortname, "remote") != 0)
- error ("command can only be used with remote target");
+ error (_("command can only be used with remote target"));
for (s = exec_bfd->sections; s; s = s->next)
{
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, rs->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')
- error ("target memory fault, section %s, range 0x%s -- 0x%s",
+ 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')
- error ("remote target does not support this operation");
+ 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: ",
do_cleanups (old_chain);
}
if (mismatched > 0)
- warning ("One or more sections of the remote executable does not match\n\
-the loaded file\n");
+ warning (_("One or more sections of the remote executable does not match\n\
+the loaded file\n"));
if (args && !matched)
- printf_filtered ("No loaded section named '%s'.\n", args);
+ printf_filtered (_("No loaded section named '%s'.\n"), args);
}
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,
+ snprintf (rs->buf, rs->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);
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))
+ /* Minimum outbuf size is RS->remote_packet_size. If LEN is not
+ large enough let the caller deal with it. */
+ if (len < rs->remote_packet_size)
return -1;
len = rs->remote_packet_size;
/* Except for querying the minimum buffer size, target must be open. */
if (!remote_desc)
- error ("remote query is only available after target open");
+ error (_("remote query is only available after target open"));
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 < (rs->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)
- error ("remote rcmd is only available after target open");
+ error (_("remote rcmd is only available after target open"));
/* Send a NULL command across as an empty command. */
if (command == NULL)
strcpy (buf, "qRcmd,");
p = strchr (buf, '\0');
- if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > (rs->remote_packet_size))
- error ("\"monitor\" command ``%s'' is too long\n", command);
+ if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > rs->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)
- error ("Communication problem with target\n");
+ if (putpkt (rs->buf) < 0)
+ error (_("Communication problem with target."));
/* get/display the response */
while (1)
{
/* 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\n");
+ error (_("Target does not support this command."));
if (buf[0] == 'O' && buf[1] != 'K')
{
remote_console_output (buf + 1); /* 'O' message from stub. */
if (strlen (buf) == 3 && buf[0] == 'E'
&& isdigit (buf[1]) && isdigit (buf[2]))
{
- error ("Protocol error with Rcmd");
+ error (_("Protocol error with Rcmd"));
}
for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
{
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");
+ error (_("command can only be used with remote target"));
if (!args)
- error ("remote-packet command requires packet text as argument");
+ error (_("remote-packet command requires packet text as argument"));
puts_filtered ("sending: ");
print_packet (args);
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");
}
{
int sample_thread = SAMPLE_THREAD;
- printf_filtered ("Remote threadset test\n");
+ printf_filtered (_("Remote threadset test\n"));
set_thread (sample_thread, 1);
}
static void
init_remote_threadtests (void)
{
- add_com ("tlist", class_obscure, threadlist_test_cmd,
- "Fetch and print the remote list of thread identifiers, one pkt only");
+ add_com ("tlist", class_obscure, threadlist_test_cmd, _("\
+Fetch and print the remote list of thread identifiers, one pkt only"));
add_com ("tinfo", class_obscure, threadinfo_test_cmd,
- "Fetch and display info about one thread");
+ _("Fetch and display info about one thread"));
add_com ("tset", class_obscure, threadset_test_cmd,
- "Test setting to a different thread");
+ _("Test setting to a different thread"));
add_com ("tupd", class_obscure, threadlist_update_test_cmd,
- "Iterate through updating all remote thread info");
+ _("Iterate through updating all remote thread info"));
add_com ("talive", class_obscure, threadalive_test,
- " Remote thread alive test ");
+ _(" Remote thread alive test "));
}
#endif /* 0 */
static char *
remote_pid_to_str (ptid_t ptid)
{
- static char buf[30];
+ static char buf[32];
- sprintf (buf, "Thread %d", PIDGET (ptid));
+ 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;
{
if (current_target.to_async_mask_value == 0)
internal_error (__FILE__, __LINE__,
- "Calling remote_async when async is masked");
+ _("Calling remote_async when async is masked"));
if (callback != NULL)
{
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)
{
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 (args, from_tty, NULL);
- show_remote_protocol_P_packet_cmd (args, from_tty, NULL);
- show_remote_protocol_p_packet_cmd (args, from_tty, NULL);
- show_remote_protocol_qSymbol_packet_cmd (args, from_tty, NULL);
- show_remote_protocol_vcont_packet_cmd (args, from_tty, NULL);
- show_remote_protocol_binary_download_cmd (args, from_tty, NULL);
- show_remote_protocol_qPart_auxv_packet_cmd (args, from_tty, 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;
-
/* architecture specific data */
remote_gdbarch_data_handle =
gdbarch_data_register_post_init (init_remote_state);
/* set/show remote ... */
- add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, "\
+ add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
Remote protocol specific variables\n\
Configure various remote-protocol specific variables such as\n\
-the packets being used",
+the packets being used"),
&remote_set_cmdlist, "set remote ",
0 /* allow-unknown */, &setlist);
- add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, "\
+ add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
Remote protocol specific variables\n\
Configure various remote-protocol specific variables such as\n\
-the packets being used",
+the packets being used"),
&remote_show_cmdlist, "show remote ",
0 /* allow-unknown */, &showlist);
- add_cmd ("compare-sections", class_obscure, compare_sections_command,
- "Compare section data on target to the exec file.\n\
-Argument is a single section name (default: all loaded sections).",
+ add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
+Compare section data on target to the exec file.\n\
+Argument is a single section name (default: all loaded sections)."),
&cmdlist);
- add_cmd ("packet", class_maintenance, packet_command,
- "Send an arbitrary packet to a remote target.\n\
+ add_cmd ("packet", class_maintenance, packet_command, _("\
+Send an arbitrary packet to a remote target.\n\
maintenance packet TEXT\n\
If GDB is talking to an inferior via the GDB serial protocol, then\n\
this command sends the string TEXT to the inferior, and displays the\n\
response packet. GDB supplies the initial `$' character, and the\n\
-terminating `#' character and checksum.",
+terminating `#' character and checksum."),
&maintenancelist);
- add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, "\
-Set whether to send break if interrupted.", "\
-Show whether to send break if interrupted.", "\
-If set, a break, instead of a cntrl-c, is sent to the remote target.", "\
-Whether to send break if interrupted is %s.",
- NULL, NULL,
+ add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
+Set whether to send break if interrupted."), _("\
+Show whether to send break if interrupted."), _("\
+If set, a break, instead of a cntrl-c, is sent to the remote target."),
+ NULL, NULL, /* FIXME: i18n: Whether to send break if interrupted is %s. */
&setlist, &showlist);
/* Install commands for configuring memory read/write packets. */
- add_cmd ("remotewritesize", no_class, set_memory_write_packet_size,
- "Set the maximum number of bytes per memory write packet (deprecated).\n",
+ add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\
+Set the maximum number of bytes per memory write packet (deprecated)."),
&setlist);
- add_cmd ("remotewritesize", no_class, show_memory_write_packet_size,
- "Show the maximum number of bytes per memory write packet (deprecated).\n",
+ add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\
+Show the maximum number of bytes per memory write packet (deprecated)."),
&showlist);
add_cmd ("memory-write-packet-size", no_class,
- set_memory_write_packet_size,
- "Set the maximum number of bytes per memory-write packet.\n"
- "Specify the number of bytes in a packet or 0 (zero) for the\n"
- "default packet size. The actual limit is further reduced\n"
- "dependent on the target. Specify ``fixed'' to disable the\n"
- "further restriction and ``limit'' to enable that restriction\n",
+ set_memory_write_packet_size, _("\
+Set the maximum number of bytes per memory-write packet.\n\
+Specify the number of bytes in a packet or 0 (zero) for the\n\
+default packet size. The actual limit is further reduced\n\
+dependent on the target. Specify ``fixed'' to disable the\n\
+further restriction and ``limit'' to enable that restriction."),
&remote_set_cmdlist);
add_cmd ("memory-read-packet-size", no_class,
- set_memory_read_packet_size,
- "Set the maximum number of bytes per memory-read packet.\n"
- "Specify the number of bytes in a packet or 0 (zero) for the\n"
- "default packet size. The actual limit is further reduced\n"
- "dependent on the target. Specify ``fixed'' to disable the\n"
- "further restriction and ``limit'' to enable that restriction\n",
+ set_memory_read_packet_size, _("\
+Set the maximum number of bytes per memory-read packet.\n\
+Specify the number of bytes in a packet or 0 (zero) for the\n\
+default packet size. The actual limit is further reduced\n\
+dependent on the target. Specify ``fixed'' to disable the\n\
+further restriction and ``limit'' to enable that restriction."),
&remote_set_cmdlist);
add_cmd ("memory-write-packet-size", no_class,
show_memory_write_packet_size,
- "Show the maximum number of bytes per memory-write packet.\n",
+ _("Show the maximum number of bytes per memory-write packet."),
&remote_show_cmdlist);
add_cmd ("memory-read-packet-size", no_class,
show_memory_read_packet_size,
- "Show the maximum number of bytes per memory-read packet.\n",
+ _("Show the maximum number of bytes per memory-read packet."),
&remote_show_cmdlist);
add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class,
- &remote_hw_watchpoint_limit, "\
-Set the maximum number of target hardware watchpoints.", "\
-Show the maximum number of target hardware watchpoints.", "\
-Specify a negative limit for unlimited.", "\
-The maximum number of target hardware watchpoints is %s.",
- NULL, NULL,
+ &remote_hw_watchpoint_limit, _("\
+Set the maximum number of target hardware watchpoints."), _("\
+Show the maximum number of target hardware watchpoints."), _("\
+Specify a negative limit for unlimited."),
+ NULL, NULL, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
&remote_set_cmdlist, &remote_show_cmdlist);
add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class,
- &remote_hw_breakpoint_limit, "\
-Set the maximum number of target hardware breakpoints.", "\
-Show the maximum number of target hardware breakpoints.", "\
-Specify a negative limit for unlimited.", "\
-The maximum number of target hardware breakpoints is %s.",
- NULL, NULL,
+ &remote_hw_breakpoint_limit, _("\
+Set the maximum number of target hardware breakpoints."), _("\
+Show the maximum number of target hardware breakpoints."), _("\
+Specify a negative limit for unlimited."),
+ NULL, NULL, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
&remote_set_cmdlist, &remote_show_cmdlist);
- deprecated_add_show_from_set
- (add_set_cmd ("remoteaddresssize", class_obscure,
- var_integer, (char *) &remote_address_size,
- "Set the maximum size of the address (in bits) \
-in a memory packet.\n",
- &setlist),
- &showlist);
+ add_setshow_integer_cmd ("remoteaddresssize", class_obscure,
+ &remote_address_size, _("\
+Set the maximum size of the address (in bits) in a memory packet."), _("\
+Show the maximum size of the address (in bits) in a memory packet."), NULL,
+ NULL,
+ NULL, /* FIXME: i18n: */
+ &setlist, &showlist);
- add_packet_config_cmd (&remote_protocol_binary_download,
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
"X", "binary-download",
- set_remote_protocol_binary_download_cmd,
- show_remote_protocol_binary_download_cmd,
+ set_remote_protocol_packet_cmd,
+ show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist,
1);
-#if 0
- /* XXXX - should ``set remotebinarydownload'' be retained for
- compatibility. */
- deprecated_add_show_from_set
- (add_set_cmd ("remotebinarydownload", no_class,
- var_boolean, (char *) &remote_binary_download,
- "Set binary downloads.\n", &setlist),
- &showlist);
-#endif
- add_packet_config_cmd (&remote_protocol_vcont,
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
"vCont", "verbose-resume",
- set_remote_protocol_vcont_packet_cmd,
- show_remote_protocol_vcont_packet_cmd,
+ set_remote_protocol_packet_cmd,
+ show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist,
0);
- add_packet_config_cmd (&remote_protocol_qSymbol,
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
"qSymbol", "symbol-lookup",
- set_remote_protocol_qSymbol_packet_cmd,
- show_remote_protocol_qSymbol_packet_cmd,
+ set_remote_protocol_packet_cmd,
+ show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist,
0);
- add_packet_config_cmd (&remote_protocol_P,
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
"P", "set-register",
- set_remote_protocol_P_packet_cmd,
- show_remote_protocol_P_packet_cmd,
+ set_remote_protocol_packet_cmd,
+ show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist,
1);
- add_packet_config_cmd (&remote_protocol_p,
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
"p", "fetch-register",
- set_remote_protocol_p_packet_cmd,
- show_remote_protocol_p_packet_cmd,
+ set_remote_protocol_packet_cmd,
+ show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist,
1);
- add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP],
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
"Z0", "software-breakpoint",
- set_remote_protocol_Z_software_bp_packet_cmd,
- show_remote_protocol_Z_software_bp_packet_cmd,
+ set_remote_protocol_packet_cmd,
+ show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist,
0);
- add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_HARDWARE_BP],
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
"Z1", "hardware-breakpoint",
- set_remote_protocol_Z_hardware_bp_packet_cmd,
- show_remote_protocol_Z_hardware_bp_packet_cmd,
+ set_remote_protocol_packet_cmd,
+ show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist,
0);
- add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_WRITE_WP],
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
"Z2", "write-watchpoint",
- set_remote_protocol_Z_write_wp_packet_cmd,
- show_remote_protocol_Z_write_wp_packet_cmd,
+ set_remote_protocol_packet_cmd,
+ show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist,
0);
- add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_READ_WP],
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
"Z3", "read-watchpoint",
- set_remote_protocol_Z_read_wp_packet_cmd,
- show_remote_protocol_Z_read_wp_packet_cmd,
+ set_remote_protocol_packet_cmd,
+ show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist,
0);
- add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_ACCESS_WP],
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
"Z4", "access-watchpoint",
- set_remote_protocol_Z_access_wp_packet_cmd,
- show_remote_protocol_Z_access_wp_packet_cmd,
+ set_remote_protocol_packet_cmd,
+ show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist,
0);
- add_packet_config_cmd (&remote_protocol_qPart_auxv,
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qPart_auxv],
"qPart_auxv", "read-aux-vector",
- set_remote_protocol_qPart_auxv_packet_cmd,
- show_remote_protocol_qPart_auxv_packet_cmd,
+ 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_qGetTLSAddr],
+ "qGetTLSAddr", "get-thread-local-storage-address",
+ set_remote_protocol_packet_cmd,
+ show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist,
0);
- /* Keep the old ``set remote Z-packet ...'' working. */
+ /* 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", "\
-Show use of remote protocol `Z' packets ", "\
+ &remote_Z_packet_detect, _("\
+Set use of remote protocol `Z' packets"), _("\
+Show use of remote protocol `Z' packets "), _("\
When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
-packets.", "\
-Use of remote protocol `Z' packets is %s",
+packets."),
set_remote_protocol_Z_packet_cmd,
- show_remote_protocol_Z_packet_cmd,
+ show_remote_protocol_Z_packet_cmd, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
&remote_set_cmdlist, &remote_show_cmdlist);
/* Eventually initialize fileio. See fileio.c */
projects / deliverable / binutils-gdb.git / blobdiff