1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
24 /* See the GDB User Guide for details of the GDB remote protocol. */
27 #include "gdb_string.h"
33 #include "exceptions.h"
35 /*#include "terminal.h" */
38 #include "gdb-stabs.h"
39 #include "gdbthread.h"
43 #include "gdb_assert.h"
46 #include "cli/cli-decode.h"
47 #include "cli/cli-setshow.h"
52 #include "event-loop.h"
53 #include "event-top.h"
59 #include "gdbcore.h" /* for exec_bfd */
61 #include "remote-fileio.h"
63 /* The size to align memory write packets, when practical. The protocol
64 does not guarantee any alignment, and gdb will generate short
65 writes and unaligned writes, but even as a best-effort attempt this
66 can improve bulk transfers. For instance, if a write is misaligned
67 relative to the target's data bus, the stub may need to make an extra
68 round trip fetching data from the target. This doesn't make a
69 huge difference, but it's easy to do, so we try to be helpful.
71 The alignment chosen is arbitrary; usually data bus width is
72 important here, not the possibly larger cache line size. */
73 enum { REMOTE_ALIGN_WRITES = 16 };
75 /* Prototypes for local functions. */
76 static void cleanup_sigint_signal_handler (void *dummy);
77 static void initialize_sigint_signal_handler (void);
78 static int getpkt_sane (char **buf, long *sizeof_buf, int forever);
80 static void handle_remote_sigint (int);
81 static void handle_remote_sigint_twice (int);
82 static void async_remote_interrupt (gdb_client_data);
83 void async_remote_interrupt_twice (gdb_client_data);
85 static void build_remote_gdbarch_data (void);
87 static void remote_files_info (struct target_ops *ignore);
89 static void remote_prepare_to_store (void);
91 static void remote_fetch_registers (int regno);
93 static void remote_resume (ptid_t ptid, int step,
94 enum target_signal siggnal);
95 static void remote_async_resume (ptid_t ptid, int step,
96 enum target_signal siggnal);
97 static void remote_open (char *name, int from_tty);
98 static void remote_async_open (char *name, int from_tty);
100 static void extended_remote_open (char *name, int from_tty);
101 static void extended_remote_async_open (char *name, int from_tty);
103 static void remote_open_1 (char *, int, struct target_ops *, int extended_p,
106 static void remote_close (int quitting);
108 static void remote_store_registers (int regno);
110 static void remote_mourn (void);
111 static void remote_async_mourn (void);
113 static void extended_remote_restart (void);
115 static void extended_remote_mourn (void);
117 static void remote_mourn_1 (struct target_ops *);
119 static void remote_send (char **buf, long *sizeof_buf_p);
121 static int readchar (int timeout);
123 static ptid_t remote_wait (ptid_t ptid,
124 struct target_waitstatus *status);
125 static ptid_t remote_async_wait (ptid_t ptid,
126 struct target_waitstatus *status);
128 static void remote_kill (void);
129 static void remote_async_kill (void);
131 static int tohex (int nib);
133 static void remote_detach (char *args, int from_tty);
135 static void remote_interrupt (int signo);
137 static void remote_interrupt_twice (int signo);
139 static void interrupt_query (void);
141 static void set_thread (int, int);
143 static int remote_thread_alive (ptid_t);
145 static void get_offsets (void);
147 static void skip_frame (void);
149 static long read_frame (char **buf_p, long *sizeof_buf);
151 static int hexnumlen (ULONGEST num);
153 static void init_remote_ops (void);
155 static void init_extended_remote_ops (void);
157 static void remote_stop (void);
159 static int ishex (int ch, int *val);
161 static int stubhex (int ch);
163 static int hexnumstr (char *, ULONGEST);
165 static int hexnumnstr (char *, ULONGEST, int);
167 static CORE_ADDR remote_address_masked (CORE_ADDR);
169 static void print_packet (char *);
171 static unsigned long crc32 (unsigned char *, int, unsigned int);
173 static void compare_sections_command (char *, int);
175 static void packet_command (char *, int);
177 static int stub_unpack_int (char *buff, int fieldlength);
179 static ptid_t remote_current_thread (ptid_t oldptid);
181 static void remote_find_new_threads (void);
183 static void record_currthread (int currthread);
185 static int fromhex (int a);
187 static int hex2bin (const char *hex, gdb_byte *bin, int count);
189 static int bin2hex (const gdb_byte *bin, char *hex, int count);
191 static int putpkt_binary (char *buf, int cnt);
193 static void check_binary_download (CORE_ADDR addr);
195 struct packet_config;
197 static void show_packet_config_cmd (struct packet_config *config);
199 static void update_packet_config (struct packet_config *config);
201 static void set_remote_protocol_packet_cmd (char *args, int from_tty,
202 struct cmd_list_element *c);
204 static void show_remote_protocol_packet_cmd (struct ui_file *file,
206 struct cmd_list_element *c,
209 void _initialize_remote (void);
211 /* For "set remote" and "show remote". */
213 static struct cmd_list_element *remote_set_cmdlist;
214 static struct cmd_list_element *remote_show_cmdlist;
216 /* Description of the remote protocol state for the currently
217 connected target. This is per-target state, and independent of the
218 selected architecture. */
222 /* A buffer to use for incoming packets, and its current size. The
223 buffer is grown dynamically for larger incoming packets.
224 Outgoing packets may also be constructed in this buffer.
225 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
226 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
231 /* If we negotiated packet size explicitly (and thus can bypass
232 heuristics for the largest packet size that will not overflow
233 a buffer in the stub), this will be set to that packet size.
234 Otherwise zero, meaning to use the guessed size. */
235 long explicit_packet_size;
238 /* This data could be associated with a target, but we do not always
239 have access to the current target when we need it, so for now it is
240 static. This will be fine for as long as only one target is in use
242 static struct remote_state remote_state;
244 static struct remote_state *
245 get_remote_state (void)
247 return &remote_state;
250 /* Description of the remote protocol for a given architecture. */
254 long offset; /* Offset into G packet. */
255 long regnum; /* GDB's internal register number. */
256 LONGEST pnum; /* Remote protocol register number. */
257 int in_g_packet; /* Always part of G packet. */
258 /* long size in bytes; == register_size (current_gdbarch, regnum);
260 /* char *name; == REGISTER_NAME (regnum); at present. */
263 struct remote_arch_state
265 /* Description of the remote protocol registers. */
266 long sizeof_g_packet;
268 /* Description of the remote protocol registers indexed by REGNUM
269 (making an array of NUM_REGS + NUM_PSEUDO_REGS in size). */
270 struct packet_reg *regs;
272 /* This is the size (in chars) of the first response to the ``g''
273 packet. It is used as a heuristic when determining the maximum
274 size of memory-read and memory-write packets. A target will
275 typically only reserve a buffer large enough to hold the ``g''
276 packet. The size does not include packet overhead (headers and
278 long actual_register_packet_size;
280 /* This is the maximum size (in chars) of a non read/write packet.
281 It is also used as a cap on the size of read/write packets. */
282 long remote_packet_size;
286 /* Handle for retreving the remote protocol data from gdbarch. */
287 static struct gdbarch_data *remote_gdbarch_data_handle;
289 static struct remote_arch_state *
290 get_remote_arch_state (void)
292 return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
296 init_remote_state (struct gdbarch *gdbarch)
299 struct remote_state *rs = get_remote_state ();
300 struct remote_arch_state *rsa;
302 rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
304 rsa->sizeof_g_packet = 0;
306 /* Assume a 1:1 regnum<->pnum table. */
307 rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, NUM_REGS + NUM_PSEUDO_REGS,
309 for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
311 struct packet_reg *r = &rsa->regs[regnum];
314 r->offset = DEPRECATED_REGISTER_BYTE (regnum);
315 r->in_g_packet = (regnum < NUM_REGS);
316 /* ...name = REGISTER_NAME (regnum); */
318 /* Compute packet size by accumulating the size of all registers. */
319 if (regnum < NUM_REGS)
320 rsa->sizeof_g_packet += register_size (current_gdbarch, regnum);
323 /* Default maximum number of characters in a packet body. Many
324 remote stubs have a hardwired buffer size of 400 bytes
325 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
326 as the maximum packet-size to ensure that the packet and an extra
327 NUL character can always fit in the buffer. This stops GDB
328 trashing stubs that try to squeeze an extra NUL into what is
329 already a full buffer (As of 1999-12-04 that was most stubs). */
330 rsa->remote_packet_size = 400 - 1;
332 /* This one is filled in when a ``g'' packet is received. */
333 rsa->actual_register_packet_size = 0;
335 /* Should rsa->sizeof_g_packet needs more space than the
336 default, adjust the size accordingly. Remember that each byte is
337 encoded as two characters. 32 is the overhead for the packet
338 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
339 (``$NN:G...#NN'') is a better guess, the below has been padded a
341 if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
342 rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);
344 /* Make sure that the packet buffer is plenty big enough for
345 this architecture. */
346 if (rs->buf_size < rsa->remote_packet_size)
348 rs->buf_size = 2 * rsa->remote_packet_size;
349 rs->buf = xrealloc (rs->buf, rs->buf_size);
355 /* Return the current allowed size of a remote packet. This is
356 inferred from the current architecture, and should be used to
357 limit the length of outgoing packets. */
359 get_remote_packet_size (void)
361 struct remote_state *rs = get_remote_state ();
362 struct remote_arch_state *rsa = get_remote_arch_state ();
364 if (rs->explicit_packet_size)
365 return rs->explicit_packet_size;
367 return rsa->remote_packet_size;
370 static struct packet_reg *
371 packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
373 if (regnum < 0 && regnum >= NUM_REGS + NUM_PSEUDO_REGS)
377 struct packet_reg *r = &rsa->regs[regnum];
378 gdb_assert (r->regnum == regnum);
383 static struct packet_reg *
384 packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
387 for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
389 struct packet_reg *r = &rsa->regs[i];
396 /* FIXME: graces/2002-08-08: These variables should eventually be
397 bound to an instance of the target object (as in gdbarch-tdep()),
398 when such a thing exists. */
400 /* This is set to the data address of the access causing the target
401 to stop for a watchpoint. */
402 static CORE_ADDR remote_watch_data_address;
404 /* This is non-zero if target stopped for a watchpoint. */
405 static int remote_stopped_by_watchpoint_p;
407 static struct target_ops remote_ops;
409 static struct target_ops extended_remote_ops;
411 /* Temporary target ops. Just like the remote_ops and
412 extended_remote_ops, but with asynchronous support. */
413 static struct target_ops remote_async_ops;
415 static struct target_ops extended_async_remote_ops;
417 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
418 ``forever'' still use the normal timeout mechanism. This is
419 currently used by the ASYNC code to guarentee that target reads
420 during the initial connect always time-out. Once getpkt has been
421 modified to return a timeout indication and, in turn
422 remote_wait()/wait_for_inferior() have gained a timeout parameter
424 static int wait_forever_enabled_p = 1;
427 /* This variable chooses whether to send a ^C or a break when the user
428 requests program interruption. Although ^C is usually what remote
429 systems expect, and that is the default here, sometimes a break is
430 preferable instead. */
432 static int remote_break;
434 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
435 remote_open knows that we don't have a file open when the program
437 static struct serial *remote_desc = NULL;
439 /* This variable sets the number of bits in an address that are to be
440 sent in a memory ("M" or "m") packet. Normally, after stripping
441 leading zeros, the entire address would be sent. This variable
442 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
443 initial implementation of remote.c restricted the address sent in
444 memory packets to ``host::sizeof long'' bytes - (typically 32
445 bits). Consequently, for 64 bit targets, the upper 32 bits of an
446 address was never sent. Since fixing this bug may cause a break in
447 some remote targets this variable is principly provided to
448 facilitate backward compatibility. */
450 static int remote_address_size;
452 /* Tempoary to track who currently owns the terminal. See
453 target_async_terminal_* for more details. */
455 static int remote_async_terminal_ours_p;
458 /* User configurable variables for the number of characters in a
459 memory read/write packet. MIN (rsa->remote_packet_size,
460 rsa->sizeof_g_packet) is the default. Some targets need smaller
461 values (fifo overruns, et.al.) and some users need larger values
462 (speed up transfers). The variables ``preferred_*'' (the user
463 request), ``current_*'' (what was actually set) and ``forced_*''
464 (Positive - a soft limit, negative - a hard limit). */
466 struct memory_packet_config
473 /* Compute the current size of a read/write packet. Since this makes
474 use of ``actual_register_packet_size'' the computation is dynamic. */
477 get_memory_packet_size (struct memory_packet_config *config)
479 struct remote_state *rs = get_remote_state ();
480 struct remote_arch_state *rsa = get_remote_arch_state ();
482 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
483 law?) that some hosts don't cope very well with large alloca()
484 calls. Eventually the alloca() code will be replaced by calls to
485 xmalloc() and make_cleanups() allowing this restriction to either
486 be lifted or removed. */
487 #ifndef MAX_REMOTE_PACKET_SIZE
488 #define MAX_REMOTE_PACKET_SIZE 16384
490 /* NOTE: 20 ensures we can write at least one byte. */
491 #ifndef MIN_REMOTE_PACKET_SIZE
492 #define MIN_REMOTE_PACKET_SIZE 20
497 if (config->size <= 0)
498 what_they_get = MAX_REMOTE_PACKET_SIZE;
500 what_they_get = config->size;
504 what_they_get = get_remote_packet_size ();
505 /* Limit the packet to the size specified by the user. */
507 && what_they_get > config->size)
508 what_they_get = config->size;
510 /* Limit it to the size of the targets ``g'' response unless we have
511 permission from the stub to use a larger packet size. */
512 if (rs->explicit_packet_size == 0
513 && rsa->actual_register_packet_size > 0
514 && what_they_get > rsa->actual_register_packet_size)
515 what_they_get = rsa->actual_register_packet_size;
517 if (what_they_get > MAX_REMOTE_PACKET_SIZE)
518 what_they_get = MAX_REMOTE_PACKET_SIZE;
519 if (what_they_get < MIN_REMOTE_PACKET_SIZE)
520 what_they_get = MIN_REMOTE_PACKET_SIZE;
522 /* Make sure there is room in the global buffer for this packet
523 (including its trailing NUL byte). */
524 if (rs->buf_size < what_they_get + 1)
526 rs->buf_size = 2 * what_they_get;
527 rs->buf = xrealloc (rs->buf, 2 * what_they_get);
530 return what_they_get;
533 /* Update the size of a read/write packet. If they user wants
534 something really big then do a sanity check. */
537 set_memory_packet_size (char *args, struct memory_packet_config *config)
539 int fixed_p = config->fixed_p;
540 long size = config->size;
542 error (_("Argument required (integer, `fixed' or `limited')."));
543 else if (strcmp (args, "hard") == 0
544 || strcmp (args, "fixed") == 0)
546 else if (strcmp (args, "soft") == 0
547 || strcmp (args, "limit") == 0)
552 size = strtoul (args, &end, 0);
554 error (_("Invalid %s (bad syntax)."), config->name);
556 /* Instead of explicitly capping the size of a packet to
557 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
558 instead allowed to set the size to something arbitrarily
560 if (size > MAX_REMOTE_PACKET_SIZE)
561 error (_("Invalid %s (too large)."), config->name);
565 if (fixed_p && !config->fixed_p)
567 if (! query (_("The target may not be able to correctly handle a %s\n"
568 "of %ld bytes. Change the packet size? "),
570 error (_("Packet size not changed."));
572 /* Update the config. */
573 config->fixed_p = fixed_p;
578 show_memory_packet_size (struct memory_packet_config *config)
580 printf_filtered (_("The %s is %ld. "), config->name, config->size);
582 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
583 get_memory_packet_size (config));
585 printf_filtered (_("Packets are limited to %ld bytes.\n"),
586 get_memory_packet_size (config));
589 static struct memory_packet_config memory_write_packet_config =
591 "memory-write-packet-size",
595 set_memory_write_packet_size (char *args, int from_tty)
597 set_memory_packet_size (args, &memory_write_packet_config);
601 show_memory_write_packet_size (char *args, int from_tty)
603 show_memory_packet_size (&memory_write_packet_config);
607 get_memory_write_packet_size (void)
609 return get_memory_packet_size (&memory_write_packet_config);
612 static struct memory_packet_config memory_read_packet_config =
614 "memory-read-packet-size",
618 set_memory_read_packet_size (char *args, int from_tty)
620 set_memory_packet_size (args, &memory_read_packet_config);
624 show_memory_read_packet_size (char *args, int from_tty)
626 show_memory_packet_size (&memory_read_packet_config);
630 get_memory_read_packet_size (void)
632 long size = get_memory_packet_size (&memory_read_packet_config);
633 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
634 extra buffer size argument before the memory read size can be
635 increased beyond this. */
636 if (size > get_remote_packet_size ())
637 size = get_remote_packet_size ();
642 /* Generic configuration support for packets the stub optionally
643 supports. Allows the user to specify the use of the packet as well
644 as allowing GDB to auto-detect support in the remote stub. */
648 PACKET_SUPPORT_UNKNOWN = 0,
657 enum auto_boolean detect;
658 enum packet_support support;
661 /* Analyze a packet's return value and update the packet config
672 update_packet_config (struct packet_config *config)
674 switch (config->detect)
676 case AUTO_BOOLEAN_TRUE:
677 config->support = PACKET_ENABLE;
679 case AUTO_BOOLEAN_FALSE:
680 config->support = PACKET_DISABLE;
682 case AUTO_BOOLEAN_AUTO:
683 config->support = PACKET_SUPPORT_UNKNOWN;
689 show_packet_config_cmd (struct packet_config *config)
691 char *support = "internal-error";
692 switch (config->support)
698 support = "disabled";
700 case PACKET_SUPPORT_UNKNOWN:
704 switch (config->detect)
706 case AUTO_BOOLEAN_AUTO:
707 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
708 config->name, support);
710 case AUTO_BOOLEAN_TRUE:
711 case AUTO_BOOLEAN_FALSE:
712 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
713 config->name, support);
719 add_packet_config_cmd (struct packet_config *config, const char *name,
720 const char *title, int legacy)
727 config->title = title;
728 config->detect = AUTO_BOOLEAN_AUTO;
729 config->support = PACKET_SUPPORT_UNKNOWN;
730 set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
732 show_doc = xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
734 /* set/show TITLE-packet {auto,on,off} */
735 cmd_name = xstrprintf ("%s-packet", title);
736 add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
737 &config->detect, set_doc, show_doc, NULL, /* help_doc */
738 set_remote_protocol_packet_cmd,
739 show_remote_protocol_packet_cmd,
740 &remote_set_cmdlist, &remote_show_cmdlist);
741 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
745 legacy_name = xstrprintf ("%s-packet", name);
746 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
747 &remote_set_cmdlist);
748 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
749 &remote_show_cmdlist);
753 static enum packet_result
754 packet_ok (const char *buf, struct packet_config *config)
758 /* The stub recognized the packet request. Check that the
759 operation succeeded. */
760 switch (config->support)
762 case PACKET_SUPPORT_UNKNOWN:
764 fprintf_unfiltered (gdb_stdlog,
765 "Packet %s (%s) is supported\n",
766 config->name, config->title);
767 config->support = PACKET_ENABLE;
770 internal_error (__FILE__, __LINE__,
771 _("packet_ok: attempt to use a disabled packet"));
776 if (buf[0] == 'O' && buf[1] == 'K' && buf[2] == '\0')
777 /* "OK" - definitly OK. */
780 && isxdigit (buf[1]) && isxdigit (buf[2])
782 /* "Enn" - definitly an error. */
784 /* The packet may or may not be OK. Just assume it is. */
789 /* The stub does not support the packet. */
790 switch (config->support)
793 if (config->detect == AUTO_BOOLEAN_AUTO)
794 /* If the stub previously indicated that the packet was
795 supported then there is a protocol error.. */
796 error (_("Protocol error: %s (%s) conflicting enabled responses."),
797 config->name, config->title);
799 /* The user set it wrong. */
800 error (_("Enabled packet %s (%s) not recognized by stub"),
801 config->name, config->title);
803 case PACKET_SUPPORT_UNKNOWN:
805 fprintf_unfiltered (gdb_stdlog,
806 "Packet %s (%s) is NOT supported\n",
807 config->name, config->title);
808 config->support = PACKET_DISABLE;
813 return PACKET_UNKNOWN;
834 static struct packet_config remote_protocol_packets[PACKET_MAX];
837 set_remote_protocol_packet_cmd (char *args, int from_tty,
838 struct cmd_list_element *c)
840 struct packet_config *packet;
842 for (packet = remote_protocol_packets;
843 packet < &remote_protocol_packets[PACKET_MAX];
846 if (&packet->detect == c->var)
848 update_packet_config (packet);
852 internal_error (__FILE__, __LINE__, "Could not find config for %s",
857 show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty,
858 struct cmd_list_element *c,
861 struct packet_config *packet;
863 for (packet = remote_protocol_packets;
864 packet < &remote_protocol_packets[PACKET_MAX];
867 if (&packet->detect == c->var)
869 show_packet_config_cmd (packet);
873 internal_error (__FILE__, __LINE__, "Could not find config for %s",
877 /* Should we try one of the 'Z' requests? */
881 Z_PACKET_SOFTWARE_BP,
882 Z_PACKET_HARDWARE_BP,
889 /* For compatibility with older distributions. Provide a ``set remote
890 Z-packet ...'' command that updates all the Z packet types. */
892 static enum auto_boolean remote_Z_packet_detect;
895 set_remote_protocol_Z_packet_cmd (char *args, int from_tty,
896 struct cmd_list_element *c)
899 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
901 remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
902 update_packet_config (&remote_protocol_packets[PACKET_Z0 + i]);
907 show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
908 struct cmd_list_element *c,
912 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
914 show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
918 /* Should we try the 'ThreadInfo' query packet?
920 This variable (NOT available to the user: auto-detect only!)
921 determines whether GDB will use the new, simpler "ThreadInfo"
922 query or the older, more complex syntax for thread queries.
923 This is an auto-detect variable (set to true at each connect,
924 and set to false when the target fails to recognize it). */
926 static int use_threadinfo_query;
927 static int use_threadextra_query;
929 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
930 static void *sigint_remote_twice_token;
931 static void *sigint_remote_token;
933 /* These are pointers to hook functions that may be set in order to
934 modify resume/wait behavior for a particular architecture. */
936 void (*deprecated_target_resume_hook) (void);
937 void (*deprecated_target_wait_loop_hook) (void);
941 /* These are the threads which we last sent to the remote system.
942 -1 for all or -2 for not sent yet. */
943 static int general_thread;
944 static int continue_thread;
946 /* Call this function as a result of
947 1) A halt indication (T packet) containing a thread id
948 2) A direct query of currthread
949 3) Successful execution of set thread
953 record_currthread (int currthread)
955 general_thread = currthread;
957 /* If this is a new thread, add it to GDB's thread list.
958 If we leave it up to WFI to do this, bad things will happen. */
959 if (!in_thread_list (pid_to_ptid (currthread)))
961 add_thread (pid_to_ptid (currthread));
962 ui_out_text (uiout, "[New ");
963 ui_out_text (uiout, target_pid_to_str (pid_to_ptid (currthread)));
964 ui_out_text (uiout, "]\n");
968 #define MAGIC_NULL_PID 42000
971 set_thread (int th, int gen)
973 struct remote_state *rs = get_remote_state ();
975 int state = gen ? general_thread : continue_thread;
981 buf[1] = gen ? 'g' : 'c';
982 if (th == MAGIC_NULL_PID)
988 xsnprintf (&buf[2], get_remote_packet_size () - 2, "-%x", -th);
990 xsnprintf (&buf[2], get_remote_packet_size () - 2, "%x", th);
992 getpkt (&rs->buf, &rs->buf_size, 0);
996 continue_thread = th;
999 /* Return nonzero if the thread TH is still alive on the remote system. */
1002 remote_thread_alive (ptid_t ptid)
1004 struct remote_state *rs = get_remote_state ();
1005 int tid = PIDGET (ptid);
1006 char *buf = rs->buf;
1009 xsnprintf (buf, get_remote_packet_size (), "T-%08x", -tid);
1011 xsnprintf (buf, get_remote_packet_size (), "T%08x", tid);
1013 getpkt (&rs->buf, &rs->buf_size, 0);
1014 return (buf[0] == 'O' && buf[1] == 'K');
1017 /* About these extended threadlist and threadinfo packets. They are
1018 variable length packets but, the fields within them are often fixed
1019 length. They are redundent enough to send over UDP as is the
1020 remote protocol in general. There is a matching unit test module
1023 #define OPAQUETHREADBYTES 8
1025 /* a 64 bit opaque identifier */
1026 typedef unsigned char threadref[OPAQUETHREADBYTES];
1028 /* WARNING: This threadref data structure comes from the remote O.S.,
1029 libstub protocol encoding, and remote.c. it is not particularly
1032 /* Right now, the internal structure is int. We want it to be bigger.
1036 typedef int gdb_threadref; /* Internal GDB thread reference. */
1038 /* gdb_ext_thread_info is an internal GDB data structure which is
1039 equivalent to the reply of the remote threadinfo packet. */
1041 struct gdb_ext_thread_info
1043 threadref threadid; /* External form of thread reference. */
1044 int active; /* Has state interesting to GDB?
1046 char display[256]; /* Brief state display, name,
1047 blocked/suspended. */
1048 char shortname[32]; /* To be used to name threads. */
1049 char more_display[256]; /* Long info, statistics, queue depth,
1053 /* The volume of remote transfers can be limited by submitting
1054 a mask containing bits specifying the desired information.
1055 Use a union of these values as the 'selection' parameter to
1056 get_thread_info. FIXME: Make these TAG names more thread specific.
1059 #define TAG_THREADID 1
1060 #define TAG_EXISTS 2
1061 #define TAG_DISPLAY 4
1062 #define TAG_THREADNAME 8
1063 #define TAG_MOREDISPLAY 16
1065 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1067 char *unpack_varlen_hex (char *buff, ULONGEST *result);
1069 static char *unpack_nibble (char *buf, int *val);
1071 static char *pack_nibble (char *buf, int nibble);
1073 static char *pack_hex_byte (char *pkt, int /* unsigned char */ byte);
1075 static char *unpack_byte (char *buf, int *value);
1077 static char *pack_int (char *buf, int value);
1079 static char *unpack_int (char *buf, int *value);
1081 static char *unpack_string (char *src, char *dest, int length);
1083 static char *pack_threadid (char *pkt, threadref *id);
1085 static char *unpack_threadid (char *inbuf, threadref *id);
1087 void int_to_threadref (threadref *id, int value);
1089 static int threadref_to_int (threadref *ref);
1091 static void copy_threadref (threadref *dest, threadref *src);
1093 static int threadmatch (threadref *dest, threadref *src);
1095 static char *pack_threadinfo_request (char *pkt, int mode,
1098 static int remote_unpack_thread_info_response (char *pkt,
1099 threadref *expectedref,
1100 struct gdb_ext_thread_info
1104 static int remote_get_threadinfo (threadref *threadid,
1105 int fieldset, /*TAG mask */
1106 struct gdb_ext_thread_info *info);
1108 static char *pack_threadlist_request (char *pkt, int startflag,
1110 threadref *nextthread);
1112 static int parse_threadlist_response (char *pkt,
1114 threadref *original_echo,
1115 threadref *resultlist,
1118 static int remote_get_threadlist (int startflag,
1119 threadref *nextthread,
1123 threadref *threadlist);
1125 typedef int (*rmt_thread_action) (threadref *ref, void *context);
1127 static int remote_threadlist_iterator (rmt_thread_action stepfunction,
1128 void *context, int looplimit);
1130 static int remote_newthread_step (threadref *ref, void *context);
1132 /* Encode 64 bits in 16 chars of hex. */
1134 static const char hexchars[] = "0123456789abcdef";
1137 ishex (int ch, int *val)
1139 if ((ch >= 'a') && (ch <= 'f'))
1141 *val = ch - 'a' + 10;
1144 if ((ch >= 'A') && (ch <= 'F'))
1146 *val = ch - 'A' + 10;
1149 if ((ch >= '0') && (ch <= '9'))
1160 if (ch >= 'a' && ch <= 'f')
1161 return ch - 'a' + 10;
1162 if (ch >= '0' && ch <= '9')
1164 if (ch >= 'A' && ch <= 'F')
1165 return ch - 'A' + 10;
1170 stub_unpack_int (char *buff, int fieldlength)
1177 nibble = stubhex (*buff++);
1181 retval = retval << 4;
1187 unpack_varlen_hex (char *buff, /* packet to parse */
1191 ULONGEST retval = 0;
1193 while (ishex (*buff, &nibble))
1196 retval = retval << 4;
1197 retval |= nibble & 0x0f;
1204 unpack_nibble (char *buf, int *val)
1206 ishex (*buf++, val);
1211 pack_nibble (char *buf, int nibble)
1213 *buf++ = hexchars[(nibble & 0x0f)];
1218 pack_hex_byte (char *pkt, int byte)
1220 *pkt++ = hexchars[(byte >> 4) & 0xf];
1221 *pkt++ = hexchars[(byte & 0xf)];
1226 unpack_byte (char *buf, int *value)
1228 *value = stub_unpack_int (buf, 2);
1233 pack_int (char *buf, int value)
1235 buf = pack_hex_byte (buf, (value >> 24) & 0xff);
1236 buf = pack_hex_byte (buf, (value >> 16) & 0xff);
1237 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
1238 buf = pack_hex_byte (buf, (value & 0xff));
1243 unpack_int (char *buf, int *value)
1245 *value = stub_unpack_int (buf, 8);
1249 #if 0 /* Currently unused, uncomment when needed. */
1250 static char *pack_string (char *pkt, char *string);
1253 pack_string (char *pkt, char *string)
1258 len = strlen (string);
1260 len = 200; /* Bigger than most GDB packets, junk??? */
1261 pkt = pack_hex_byte (pkt, len);
1265 if ((ch == '\0') || (ch == '#'))
1266 ch = '*'; /* Protect encapsulation. */
1271 #endif /* 0 (unused) */
1274 unpack_string (char *src, char *dest, int length)
1283 pack_threadid (char *pkt, threadref *id)
1286 unsigned char *altid;
1288 altid = (unsigned char *) id;
1289 limit = pkt + BUF_THREAD_ID_SIZE;
1291 pkt = pack_hex_byte (pkt, *altid++);
1297 unpack_threadid (char *inbuf, threadref *id)
1300 char *limit = inbuf + BUF_THREAD_ID_SIZE;
1303 altref = (char *) id;
1305 while (inbuf < limit)
1307 x = stubhex (*inbuf++);
1308 y = stubhex (*inbuf++);
1309 *altref++ = (x << 4) | y;
1314 /* Externally, threadrefs are 64 bits but internally, they are still
1315 ints. This is due to a mismatch of specifications. We would like
1316 to use 64bit thread references internally. This is an adapter
1320 int_to_threadref (threadref *id, int value)
1322 unsigned char *scan;
1324 scan = (unsigned char *) id;
1330 *scan++ = (value >> 24) & 0xff;
1331 *scan++ = (value >> 16) & 0xff;
1332 *scan++ = (value >> 8) & 0xff;
1333 *scan++ = (value & 0xff);
1337 threadref_to_int (threadref *ref)
1340 unsigned char *scan;
1346 value = (value << 8) | ((*scan++) & 0xff);
1351 copy_threadref (threadref *dest, threadref *src)
1354 unsigned char *csrc, *cdest;
1356 csrc = (unsigned char *) src;
1357 cdest = (unsigned char *) dest;
1364 threadmatch (threadref *dest, threadref *src)
1366 /* Things are broken right now, so just assume we got a match. */
1368 unsigned char *srcp, *destp;
1370 srcp = (char *) src;
1371 destp = (char *) dest;
1375 result &= (*srcp++ == *destp++) ? 1 : 0;
1382 threadid:1, # always request threadid
1389 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1392 pack_threadinfo_request (char *pkt, int mode, threadref *id)
1394 *pkt++ = 'q'; /* Info Query */
1395 *pkt++ = 'P'; /* process or thread info */
1396 pkt = pack_int (pkt, mode); /* mode */
1397 pkt = pack_threadid (pkt, id); /* threadid */
1398 *pkt = '\0'; /* terminate */
1402 /* These values tag the fields in a thread info response packet. */
1403 /* Tagging the fields allows us to request specific fields and to
1404 add more fields as time goes by. */
1406 #define TAG_THREADID 1 /* Echo the thread identifier. */
1407 #define TAG_EXISTS 2 /* Is this process defined enough to
1408 fetch registers and its stack? */
1409 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1410 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1411 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1415 remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
1416 struct gdb_ext_thread_info *info)
1418 struct remote_state *rs = get_remote_state ();
1422 char *limit = pkt + rs->buf_size; /* Plausible parsing limit. */
1425 /* info->threadid = 0; FIXME: implement zero_threadref. */
1427 info->display[0] = '\0';
1428 info->shortname[0] = '\0';
1429 info->more_display[0] = '\0';
1431 /* Assume the characters indicating the packet type have been
1433 pkt = unpack_int (pkt, &mask); /* arg mask */
1434 pkt = unpack_threadid (pkt, &ref);
1437 warning (_("Incomplete response to threadinfo request."));
1438 if (!threadmatch (&ref, expectedref))
1439 { /* This is an answer to a different request. */
1440 warning (_("ERROR RMT Thread info mismatch."));
1443 copy_threadref (&info->threadid, &ref);
1445 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1447 /* Packets are terminated with nulls. */
1448 while ((pkt < limit) && mask && *pkt)
1450 pkt = unpack_int (pkt, &tag); /* tag */
1451 pkt = unpack_byte (pkt, &length); /* length */
1452 if (!(tag & mask)) /* Tags out of synch with mask. */
1454 warning (_("ERROR RMT: threadinfo tag mismatch."));
1458 if (tag == TAG_THREADID)
1462 warning (_("ERROR RMT: length of threadid is not 16."));
1466 pkt = unpack_threadid (pkt, &ref);
1467 mask = mask & ~TAG_THREADID;
1470 if (tag == TAG_EXISTS)
1472 info->active = stub_unpack_int (pkt, length);
1474 mask = mask & ~(TAG_EXISTS);
1477 warning (_("ERROR RMT: 'exists' length too long."));
1483 if (tag == TAG_THREADNAME)
1485 pkt = unpack_string (pkt, &info->shortname[0], length);
1486 mask = mask & ~TAG_THREADNAME;
1489 if (tag == TAG_DISPLAY)
1491 pkt = unpack_string (pkt, &info->display[0], length);
1492 mask = mask & ~TAG_DISPLAY;
1495 if (tag == TAG_MOREDISPLAY)
1497 pkt = unpack_string (pkt, &info->more_display[0], length);
1498 mask = mask & ~TAG_MOREDISPLAY;
1501 warning (_("ERROR RMT: unknown thread info tag."));
1502 break; /* Not a tag we know about. */
1508 remote_get_threadinfo (threadref *threadid, int fieldset, /* TAG mask */
1509 struct gdb_ext_thread_info *info)
1511 struct remote_state *rs = get_remote_state ();
1513 char *threadinfo_pkt = rs->buf;
1515 pack_threadinfo_request (threadinfo_pkt, fieldset, threadid);
1516 putpkt (threadinfo_pkt);
1517 getpkt (&rs->buf, &rs->buf_size, 0);
1518 result = remote_unpack_thread_info_response (threadinfo_pkt + 2,
1523 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1526 pack_threadlist_request (char *pkt, int startflag, int threadcount,
1527 threadref *nextthread)
1529 *pkt++ = 'q'; /* info query packet */
1530 *pkt++ = 'L'; /* Process LIST or threadLIST request */
1531 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */
1532 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */
1533 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */
1538 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1541 parse_threadlist_response (char *pkt, int result_limit,
1542 threadref *original_echo, threadref *resultlist,
1545 struct remote_state *rs = get_remote_state ();
1547 int count, resultcount, done;
1550 /* Assume the 'q' and 'M chars have been stripped. */
1551 limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE);
1552 /* done parse past here */
1553 pkt = unpack_byte (pkt, &count); /* count field */
1554 pkt = unpack_nibble (pkt, &done);
1555 /* The first threadid is the argument threadid. */
1556 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */
1557 while ((count-- > 0) && (pkt < limit))
1559 pkt = unpack_threadid (pkt, resultlist++);
1560 if (resultcount++ >= result_limit)
1569 remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
1570 int *done, int *result_count, threadref *threadlist)
1572 struct remote_state *rs = get_remote_state ();
1573 static threadref echo_nextthread;
1574 char *threadlist_packet = rs->buf;
1577 /* Trancate result limit to be smaller than the packet size. */
1578 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= get_remote_packet_size ())
1579 result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
1581 pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
1583 getpkt (&rs->buf, &rs->buf_size, 0);
1586 parse_threadlist_response (rs->buf + 2, result_limit, &echo_nextthread,
1589 if (!threadmatch (&echo_nextthread, nextthread))
1591 /* FIXME: This is a good reason to drop the packet. */
1592 /* Possably, there is a duplicate response. */
1594 retransmit immediatly - race conditions
1595 retransmit after timeout - yes
1597 wait for packet, then exit
1599 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1600 return 0; /* I choose simply exiting. */
1602 if (*result_count <= 0)
1606 warning (_("RMT ERROR : failed to get remote thread list."));
1609 return result; /* break; */
1611 if (*result_count > result_limit)
1614 warning (_("RMT ERROR: threadlist response longer than requested."));
1620 /* This is the interface between remote and threads, remotes upper
1623 /* remote_find_new_threads retrieves the thread list and for each
1624 thread in the list, looks up the thread in GDB's internal list,
1625 ading the thread if it does not already exist. This involves
1626 getting partial thread lists from the remote target so, polling the
1627 quit_flag is required. */
1630 /* About this many threadisds fit in a packet. */
1632 #define MAXTHREADLISTRESULTS 32
1635 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
1638 int done, i, result_count;
1642 static threadref nextthread;
1643 static threadref resultthreadlist[MAXTHREADLISTRESULTS];
1648 if (loopcount++ > looplimit)
1651 warning (_("Remote fetch threadlist -infinite loop-."));
1654 if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS,
1655 &done, &result_count, resultthreadlist))
1660 /* Clear for later iterations. */
1662 /* Setup to resume next batch of thread references, set nextthread. */
1663 if (result_count >= 1)
1664 copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
1666 while (result_count--)
1667 if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
1674 remote_newthread_step (threadref *ref, void *context)
1678 ptid = pid_to_ptid (threadref_to_int (ref));
1680 if (!in_thread_list (ptid))
1682 return 1; /* continue iterator */
1685 #define CRAZY_MAX_THREADS 1000
1688 remote_current_thread (ptid_t oldpid)
1690 struct remote_state *rs = get_remote_state ();
1691 char *buf = rs->buf;
1694 getpkt (&rs->buf, &rs->buf_size, 0);
1695 if (buf[0] == 'Q' && buf[1] == 'C')
1696 /* Use strtoul here, so we'll correctly parse values whose highest
1697 bit is set. The protocol carries them as a simple series of
1698 hex digits; in the absence of a sign, strtol will see such
1699 values as positive numbers out of range for signed 'long', and
1700 return LONG_MAX to indicate an overflow. */
1701 return pid_to_ptid (strtoul (&buf[2], NULL, 16));
1706 /* Find new threads for info threads command.
1707 * Original version, using John Metzler's thread protocol.
1711 remote_find_new_threads (void)
1713 remote_threadlist_iterator (remote_newthread_step, 0,
1715 if (PIDGET (inferior_ptid) == MAGIC_NULL_PID) /* ack ack ack */
1716 inferior_ptid = remote_current_thread (inferior_ptid);
1720 * Find all threads for info threads command.
1721 * Uses new thread protocol contributed by Cisco.
1722 * Falls back and attempts to use the older method (above)
1723 * if the target doesn't respond to the new method.
1727 remote_threads_info (void)
1729 struct remote_state *rs = get_remote_state ();
1733 if (remote_desc == 0) /* paranoia */
1734 error (_("Command can only be used when connected to the remote target."));
1736 if (use_threadinfo_query)
1738 putpkt ("qfThreadInfo");
1740 getpkt (&rs->buf, &rs->buf_size, 0);
1741 if (bufp[0] != '\0') /* q packet recognized */
1743 while (*bufp++ == 'm') /* reply contains one or more TID */
1747 /* Use strtoul here, so we'll correctly parse values
1748 whose highest bit is set. The protocol carries
1749 them as a simple series of hex digits; in the
1750 absence of a sign, strtol will see such values as
1751 positive numbers out of range for signed 'long',
1752 and return LONG_MAX to indicate an overflow. */
1753 tid = strtoul (bufp, &bufp, 16);
1754 if (tid != 0 && !in_thread_list (pid_to_ptid (tid)))
1755 add_thread (pid_to_ptid (tid));
1757 while (*bufp++ == ','); /* comma-separated list */
1758 putpkt ("qsThreadInfo");
1760 getpkt (&rs->buf, &rs->buf_size, 0);
1766 /* Else fall back to old method based on jmetzler protocol. */
1767 use_threadinfo_query = 0;
1768 remote_find_new_threads ();
1773 * Collect a descriptive string about the given thread.
1774 * The target may say anything it wants to about the thread
1775 * (typically info about its blocked / runnable state, name, etc.).
1776 * This string will appear in the info threads display.
1778 * Optional: targets are not required to implement this function.
1782 remote_threads_extra_info (struct thread_info *tp)
1784 struct remote_state *rs = get_remote_state ();
1788 struct gdb_ext_thread_info threadinfo;
1789 static char display_buf[100]; /* arbitrary... */
1790 int n = 0; /* position in display_buf */
1792 if (remote_desc == 0) /* paranoia */
1793 internal_error (__FILE__, __LINE__,
1794 _("remote_threads_extra_info"));
1796 if (use_threadextra_query)
1798 char *bufp = rs->buf;
1800 xsnprintf (bufp, get_remote_packet_size (), "qThreadExtraInfo,%x",
1803 getpkt (&rs->buf, &rs->buf_size, 0);
1806 n = min (strlen (bufp) / 2, sizeof (display_buf));
1807 result = hex2bin (bufp, (gdb_byte *) display_buf, n);
1808 display_buf [result] = '\0';
1813 /* If the above query fails, fall back to the old method. */
1814 use_threadextra_query = 0;
1815 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
1816 | TAG_MOREDISPLAY | TAG_DISPLAY;
1817 int_to_threadref (&id, PIDGET (tp->ptid));
1818 if (remote_get_threadinfo (&id, set, &threadinfo))
1819 if (threadinfo.active)
1821 if (*threadinfo.shortname)
1822 n += xsnprintf (&display_buf[0], sizeof (display_buf) - n,
1823 " Name: %s,", threadinfo.shortname);
1824 if (*threadinfo.display)
1825 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
1826 " State: %s,", threadinfo.display);
1827 if (*threadinfo.more_display)
1828 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
1829 " Priority: %s", threadinfo.more_display);
1833 /* For purely cosmetic reasons, clear up trailing commas. */
1834 if (',' == display_buf[n-1])
1835 display_buf[n-1] = ' ';
1843 /* Restart the remote side; this is an extended protocol operation. */
1846 extended_remote_restart (void)
1848 struct remote_state *rs = get_remote_state ();
1850 /* Send the restart command; for reasons I don't understand the
1851 remote side really expects a number after the "R". */
1852 xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0);
1855 remote_fileio_reset ();
1857 /* Now query for status so this looks just like we restarted
1858 gdbserver from scratch. */
1860 getpkt (&rs->buf, &rs->buf_size, 0);
1863 /* Clean up connection to a remote debugger. */
1866 remote_close (int quitting)
1869 serial_close (remote_desc);
1873 /* Query the remote side for the text, data and bss offsets. */
1878 struct remote_state *rs = get_remote_state ();
1879 char *buf = rs->buf;
1882 CORE_ADDR text_addr, data_addr, bss_addr;
1883 struct section_offsets *offs;
1885 putpkt ("qOffsets");
1886 getpkt (&rs->buf, &rs->buf_size, 0);
1888 if (buf[0] == '\000')
1889 return; /* Return silently. Stub doesn't support
1893 warning (_("Remote failure reply: %s"), buf);
1897 /* Pick up each field in turn. This used to be done with scanf, but
1898 scanf will make trouble if CORE_ADDR size doesn't match
1899 conversion directives correctly. The following code will work
1900 with any size of CORE_ADDR. */
1901 text_addr = data_addr = bss_addr = 0;
1905 if (strncmp (ptr, "Text=", 5) == 0)
1908 /* Don't use strtol, could lose on big values. */
1909 while (*ptr && *ptr != ';')
1910 text_addr = (text_addr << 4) + fromhex (*ptr++);
1915 if (!lose && strncmp (ptr, ";Data=", 6) == 0)
1918 while (*ptr && *ptr != ';')
1919 data_addr = (data_addr << 4) + fromhex (*ptr++);
1924 if (!lose && strncmp (ptr, ";Bss=", 5) == 0)
1927 while (*ptr && *ptr != ';')
1928 bss_addr = (bss_addr << 4) + fromhex (*ptr++);
1934 error (_("Malformed response to offset query, %s"), buf);
1936 if (symfile_objfile == NULL)
1939 offs = ((struct section_offsets *)
1940 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
1941 memcpy (offs, symfile_objfile->section_offsets,
1942 SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
1944 offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
1946 /* This is a temporary kludge to force data and bss to use the same offsets
1947 because that's what nlmconv does now. The real solution requires changes
1948 to the stub and remote.c that I don't have time to do right now. */
1950 offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
1951 offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
1953 objfile_relocate (symfile_objfile, offs);
1956 /* Stub for catch_errors. */
1959 remote_start_remote_dummy (struct ui_out *uiout, void *dummy)
1961 start_remote (); /* Initialize gdb process mechanisms. */
1962 /* NOTE: Return something >=0. A -ve value is reserved for
1963 catch_exceptions. */
1968 remote_start_remote (struct ui_out *uiout, void *dummy)
1970 immediate_quit++; /* Allow user to interrupt it. */
1972 /* Ack any packet which the remote side has already sent. */
1973 serial_write (remote_desc, "+", 1);
1975 /* Let the stub know that we want it to return the thread. */
1978 inferior_ptid = remote_current_thread (inferior_ptid);
1980 get_offsets (); /* Get text, data & bss offsets. */
1982 putpkt ("?"); /* Initiate a query from remote machine. */
1985 remote_start_remote_dummy (uiout, dummy);
1988 /* Open a connection to a remote debugger.
1989 NAME is the filename used for communication. */
1992 remote_open (char *name, int from_tty)
1994 remote_open_1 (name, from_tty, &remote_ops, 0, 0);
1997 /* Just like remote_open, but with asynchronous support. */
1999 remote_async_open (char *name, int from_tty)
2001 remote_open_1 (name, from_tty, &remote_async_ops, 0, 1);
2004 /* Open a connection to a remote debugger using the extended
2005 remote gdb protocol. NAME is the filename used for communication. */
2008 extended_remote_open (char *name, int from_tty)
2010 remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */,
2014 /* Just like extended_remote_open, but with asynchronous support. */
2016 extended_remote_async_open (char *name, int from_tty)
2018 remote_open_1 (name, from_tty, &extended_async_remote_ops,
2019 1 /*extended_p */, 1 /* async_p */);
2022 /* Generic code for opening a connection to a remote target. */
2025 init_all_packet_configs (void)
2028 for (i = 0; i < PACKET_MAX; i++)
2029 update_packet_config (&remote_protocol_packets[i]);
2032 /* Symbol look-up. */
2035 remote_check_symbols (struct objfile *objfile)
2037 struct remote_state *rs = get_remote_state ();
2038 char *msg, *reply, *tmp;
2039 struct minimal_symbol *sym;
2042 if (remote_protocol_packets[PACKET_qSymbol].support == PACKET_DISABLE)
2045 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2046 because we need both at the same time. */
2047 msg = alloca (get_remote_packet_size ());
2051 /* Invite target to request symbol lookups. */
2053 putpkt ("qSymbol::");
2054 getpkt (&rs->buf, &rs->buf_size, 0);
2055 packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]);
2057 while (strncmp (reply, "qSymbol:", 8) == 0)
2060 end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2);
2062 sym = lookup_minimal_symbol (msg, NULL, NULL);
2064 xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
2066 xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
2067 paddr_nz (SYMBOL_VALUE_ADDRESS (sym)),
2070 getpkt (&rs->buf, &rs->buf_size, 0);
2074 static struct serial *
2075 remote_serial_open (char *name)
2077 static int udp_warning = 0;
2079 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2080 of in ser-tcp.c, because it is the remote protocol assuming that the
2081 serial connection is reliable and not the serial connection promising
2083 if (!udp_warning && strncmp (name, "udp:", 4) == 0)
2086 The remote protocol may be unreliable over UDP.\n\
2087 Some events may be lost, rendering further debugging impossible."));
2091 return serial_open (name);
2094 /* This type describes each known response to the qSupported
2096 struct protocol_feature
2098 /* The name of this protocol feature. */
2101 /* The default for this protocol feature. */
2102 enum packet_support default_support;
2104 /* The function to call when this feature is reported, or after
2105 qSupported processing if the feature is not supported.
2106 The first argument points to this structure. The second
2107 argument indicates whether the packet requested support be
2108 enabled, disabled, or probed (or the default, if this function
2109 is being called at the end of processing and this feature was
2110 not reported). The third argument may be NULL; if not NULL, it
2111 is a NUL-terminated string taken from the packet following
2112 this feature's name and an equals sign. */
2113 void (*func) (const struct protocol_feature *, enum packet_support,
2116 /* The corresponding packet for this feature. Only used if
2117 FUNC is remote_supported_packet. */
2122 remote_supported_packet (const struct protocol_feature *feature,
2123 enum packet_support support,
2124 const char *argument)
2128 warning (_("Remote qSupported response supplied an unexpected value for"
2129 " \"%s\"."), feature->name);
2133 if (remote_protocol_packets[feature->packet].support
2134 == PACKET_SUPPORT_UNKNOWN)
2135 remote_protocol_packets[feature->packet].support = support;
2139 remote_packet_size (const struct protocol_feature *feature,
2140 enum packet_support support, const char *value)
2142 struct remote_state *rs = get_remote_state ();
2147 if (support != PACKET_ENABLE)
2150 if (value == NULL || *value == '\0')
2152 warning (_("Remote target reported \"%s\" without a size."),
2158 packet_size = strtol (value, &value_end, 16);
2159 if (errno != 0 || *value_end != '\0' || packet_size < 0)
2161 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2162 feature->name, value);
2166 if (packet_size > MAX_REMOTE_PACKET_SIZE)
2168 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2169 packet_size, MAX_REMOTE_PACKET_SIZE);
2170 packet_size = MAX_REMOTE_PACKET_SIZE;
2173 /* Record the new maximum packet size. */
2174 rs->explicit_packet_size = packet_size;
2177 static struct protocol_feature remote_protocol_features[] = {
2178 { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
2179 { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
2184 remote_query_supported (void)
2186 struct remote_state *rs = get_remote_state ();
2189 unsigned char seen [ARRAY_SIZE (remote_protocol_features)];
2191 /* The packet support flags are handled differently for this packet
2192 than for most others. We treat an error, a disabled packet, and
2193 an empty response identically: any features which must be reported
2194 to be used will be automatically disabled. An empty buffer
2195 accomplishes this, since that is also the representation for a list
2196 containing no features. */
2199 if (remote_protocol_packets[PACKET_qSupported].support != PACKET_DISABLE)
2201 putpkt ("qSupported");
2202 getpkt (&rs->buf, &rs->buf_size, 0);
2204 /* If an error occured, warn, but do not return - just reset the
2205 buffer to empty and go on to disable features. */
2206 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
2209 warning (_("Remote failure reply: %s"), rs->buf);
2214 memset (seen, 0, sizeof (seen));
2219 enum packet_support is_supported;
2220 char *p, *end, *name_end, *value;
2222 /* First separate out this item from the rest of the packet. If
2223 there's another item after this, we overwrite the separator
2224 (terminated strings are much easier to work with). */
2226 end = strchr (p, ';');
2229 end = p + strlen (p);
2236 warning (_("empty item in \"qSupported\" response"));
2244 name_end = strchr (p, '=');
2247 /* This is a name=value entry. */
2248 is_supported = PACKET_ENABLE;
2249 value = name_end + 1;
2258 is_supported = PACKET_ENABLE;
2262 is_supported = PACKET_DISABLE;
2266 is_supported = PACKET_SUPPORT_UNKNOWN;
2270 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p);
2276 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
2277 if (strcmp (remote_protocol_features[i].name, p) == 0)
2279 const struct protocol_feature *feature;
2282 feature = &remote_protocol_features[i];
2283 feature->func (feature, is_supported, value);
2288 /* If we increased the packet size, make sure to increase the global
2289 buffer size also. We delay this until after parsing the entire
2290 qSupported packet, because this is the same buffer we were
2292 if (rs->buf_size < rs->explicit_packet_size)
2294 rs->buf_size = rs->explicit_packet_size;
2295 rs->buf = xrealloc (rs->buf, rs->buf_size);
2298 /* Handle the defaults for unmentioned features. */
2299 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
2302 const struct protocol_feature *feature;
2304 feature = &remote_protocol_features[i];
2305 feature->func (feature, feature->default_support, NULL);
2311 remote_open_1 (char *name, int from_tty, struct target_ops *target,
2312 int extended_p, int async_p)
2314 struct remote_state *rs = get_remote_state ();
2316 error (_("To open a remote debug connection, you need to specify what\n"
2317 "serial device is attached to the remote system\n"
2318 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2320 /* See FIXME above. */
2322 wait_forever_enabled_p = 1;
2324 target_preopen (from_tty);
2326 unpush_target (target);
2328 remote_fileio_reset ();
2329 reopen_exec_file ();
2332 remote_desc = remote_serial_open (name);
2334 perror_with_name (name);
2336 if (baud_rate != -1)
2338 if (serial_setbaudrate (remote_desc, baud_rate))
2340 /* The requested speed could not be set. Error out to
2341 top level after closing remote_desc. Take care to
2342 set remote_desc to NULL to avoid closing remote_desc
2344 serial_close (remote_desc);
2346 perror_with_name (name);
2350 serial_raw (remote_desc);
2352 /* If there is something sitting in the buffer we might take it as a
2353 response to a command, which would be bad. */
2354 serial_flush_input (remote_desc);
2358 puts_filtered ("Remote debugging using ");
2359 puts_filtered (name);
2360 puts_filtered ("\n");
2362 push_target (target); /* Switch to using remote target now. */
2364 /* Reset the target state; these things will be queried either by
2365 remote_query_supported or as they are needed. */
2366 init_all_packet_configs ();
2367 rs->explicit_packet_size = 0;
2369 general_thread = -2;
2370 continue_thread = -2;
2372 /* Probe for ability to use "ThreadInfo" query, as required. */
2373 use_threadinfo_query = 1;
2374 use_threadextra_query = 1;
2376 /* The first packet we send to the target is the optional "supported
2377 packets" request. If the target can answer this, it will tell us
2378 which later probes to skip. */
2379 remote_query_supported ();
2381 /* Without this, some commands which require an active target (such
2382 as kill) won't work. This variable serves (at least) double duty
2383 as both the pid of the target process (if it has such), and as a
2384 flag indicating that a target is active. These functions should
2385 be split out into seperate variables, especially since GDB will
2386 someday have a notion of debugging several processes. */
2388 inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
2392 /* With this target we start out by owning the terminal. */
2393 remote_async_terminal_ours_p = 1;
2395 /* FIXME: cagney/1999-09-23: During the initial connection it is
2396 assumed that the target is already ready and able to respond to
2397 requests. Unfortunately remote_start_remote() eventually calls
2398 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2399 around this. Eventually a mechanism that allows
2400 wait_for_inferior() to expect/get timeouts will be
2402 wait_forever_enabled_p = 0;
2405 /* First delete any symbols previously loaded from shared libraries. */
2406 no_shared_libraries (NULL, 0);
2408 /* Start the remote connection. If error() or QUIT, discard this
2409 target (we'd otherwise be in an inconsistent state) and then
2410 propogate the error on up the exception chain. This ensures that
2411 the caller doesn't stumble along blindly assuming that the
2412 function succeeded. The CLI doesn't have this problem but other
2413 UI's, such as MI do.
2415 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2416 this function should return an error indication letting the
2417 caller restore the previous state. Unfortunately the command
2418 ``target remote'' is directly wired to this function making that
2419 impossible. On a positive note, the CLI side of this problem has
2420 been fixed - the function set_cmd_context() makes it possible for
2421 all the ``target ....'' commands to share a common callback
2422 function. See cli-dump.c. */
2424 struct gdb_exception ex
2425 = catch_exception (uiout, remote_start_remote, NULL, RETURN_MASK_ALL);
2430 wait_forever_enabled_p = 1;
2431 throw_exception (ex);
2436 wait_forever_enabled_p = 1;
2440 /* Tell the remote that we are using the extended protocol. */
2442 getpkt (&rs->buf, &rs->buf_size, 0);
2445 post_create_inferior (¤t_target, from_tty);
2447 if (exec_bfd) /* No use without an exec file. */
2448 remote_check_symbols (symfile_objfile);
2451 /* This takes a program previously attached to and detaches it. After
2452 this is done, GDB can be used to debug some other program. We
2453 better not have left any breakpoints in the target program or it'll
2454 die when it hits one. */
2457 remote_detach (char *args, int from_tty)
2459 struct remote_state *rs = get_remote_state ();
2462 error (_("Argument given to \"detach\" when remotely debugging."));
2464 /* Tell the remote target to detach. */
2465 strcpy (rs->buf, "D");
2466 remote_send (&rs->buf, &rs->buf_size);
2468 /* Unregister the file descriptor from the event loop. */
2469 if (target_is_async_p ())
2470 serial_async (remote_desc, NULL, 0);
2472 target_mourn_inferior ();
2474 puts_filtered ("Ending remote debugging.\n");
2477 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2480 remote_disconnect (struct target_ops *target, char *args, int from_tty)
2483 error (_("Argument given to \"detach\" when remotely debugging."));
2485 /* Unregister the file descriptor from the event loop. */
2486 if (target_is_async_p ())
2487 serial_async (remote_desc, NULL, 0);
2489 target_mourn_inferior ();
2491 puts_filtered ("Ending remote debugging.\n");
2494 /* Convert hex digit A to a number. */
2499 if (a >= '0' && a <= '9')
2501 else if (a >= 'a' && a <= 'f')
2502 return a - 'a' + 10;
2503 else if (a >= 'A' && a <= 'F')
2504 return a - 'A' + 10;
2506 error (_("Reply contains invalid hex digit %d"), a);
2510 hex2bin (const char *hex, gdb_byte *bin, int count)
2514 for (i = 0; i < count; i++)
2516 if (hex[0] == 0 || hex[1] == 0)
2518 /* Hex string is short, or of uneven length.
2519 Return the count that has been converted so far. */
2522 *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
2528 /* Convert number NIB to a hex digit. */
2536 return 'a' + nib - 10;
2540 bin2hex (const gdb_byte *bin, char *hex, int count)
2543 /* May use a length, or a nul-terminated string as input. */
2545 count = strlen ((char *) bin);
2547 for (i = 0; i < count; i++)
2549 *hex++ = tohex ((*bin >> 4) & 0xf);
2550 *hex++ = tohex (*bin++ & 0xf);
2556 /* Check for the availability of vCont. This function should also check
2560 remote_vcont_probe (struct remote_state *rs)
2562 char *buf = rs->buf;
2564 strcpy (buf, "vCont?");
2566 getpkt (&rs->buf, &rs->buf_size, 0);
2568 /* Make sure that the features we assume are supported. */
2569 if (strncmp (buf, "vCont", 5) == 0)
2572 int support_s, support_S, support_c, support_C;
2578 while (p && *p == ';')
2581 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0))
2583 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0))
2585 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0))
2587 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0))
2590 p = strchr (p, ';');
2593 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2594 BUF will make packet_ok disable the packet. */
2595 if (!support_s || !support_S || !support_c || !support_C)
2599 packet_ok (buf, &remote_protocol_packets[PACKET_vCont]);
2602 /* Resume the remote inferior by using a "vCont" packet. The thread
2603 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2604 resumed thread should be single-stepped and/or signalled. If PTID's
2605 PID is -1, then all threads are resumed; the thread to be stepped and/or
2606 signalled is given in the global INFERIOR_PTID. This function returns
2607 non-zero iff it resumes the inferior.
2609 This function issues a strict subset of all possible vCont commands at the
2613 remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal)
2615 struct remote_state *rs = get_remote_state ();
2616 int pid = PIDGET (ptid);
2617 char *buf = NULL, *outbuf;
2618 struct cleanup *old_cleanup;
2620 if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN)
2621 remote_vcont_probe (rs);
2623 if (remote_protocol_packets[PACKET_vCont].support == PACKET_DISABLE)
2626 /* If we could generate a wider range of packets, we'd have to worry
2627 about overflowing BUF. Should there be a generic
2628 "multi-part-packet" packet? */
2630 if (PIDGET (inferior_ptid) == MAGIC_NULL_PID)
2632 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2633 don't have any PID numbers the inferior will understand. Make sure
2634 to only send forms that do not specify a PID. */
2635 if (step && siggnal != TARGET_SIGNAL_0)
2636 outbuf = xstrprintf ("vCont;S%02x", siggnal);
2638 outbuf = xstrprintf ("vCont;s");
2639 else if (siggnal != TARGET_SIGNAL_0)
2640 outbuf = xstrprintf ("vCont;C%02x", siggnal);
2642 outbuf = xstrprintf ("vCont;c");
2646 /* Resume all threads, with preference for INFERIOR_PTID. */
2647 if (step && siggnal != TARGET_SIGNAL_0)
2648 outbuf = xstrprintf ("vCont;S%02x:%x;c", siggnal,
2649 PIDGET (inferior_ptid));
2651 outbuf = xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid));
2652 else if (siggnal != TARGET_SIGNAL_0)
2653 outbuf = xstrprintf ("vCont;C%02x:%x;c", siggnal,
2654 PIDGET (inferior_ptid));
2656 outbuf = xstrprintf ("vCont;c");
2660 /* Scheduler locking; resume only PTID. */
2661 if (step && siggnal != TARGET_SIGNAL_0)
2662 outbuf = xstrprintf ("vCont;S%02x:%x", siggnal, pid);
2664 outbuf = xstrprintf ("vCont;s:%x", pid);
2665 else if (siggnal != TARGET_SIGNAL_0)
2666 outbuf = xstrprintf ("vCont;C%02x:%x", siggnal, pid);
2668 outbuf = xstrprintf ("vCont;c:%x", pid);
2671 gdb_assert (outbuf && strlen (outbuf) < get_remote_packet_size ());
2672 old_cleanup = make_cleanup (xfree, outbuf);
2676 do_cleanups (old_cleanup);
2681 /* Tell the remote machine to resume. */
2683 static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
2685 static int last_sent_step;
2688 remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
2690 struct remote_state *rs = get_remote_state ();
2691 char *buf = rs->buf;
2692 int pid = PIDGET (ptid);
2694 last_sent_signal = siggnal;
2695 last_sent_step = step;
2697 /* A hook for when we need to do something at the last moment before
2699 if (deprecated_target_resume_hook)
2700 (*deprecated_target_resume_hook) ();
2702 /* The vCont packet doesn't need to specify threads via Hc. */
2703 if (remote_vcont_resume (ptid, step, siggnal))
2706 /* All other supported resume packets do use Hc, so call set_thread. */
2708 set_thread (0, 0); /* Run any thread. */
2710 set_thread (pid, 0); /* Run this thread. */
2712 if (siggnal != TARGET_SIGNAL_0)
2714 buf[0] = step ? 'S' : 'C';
2715 buf[1] = tohex (((int) siggnal >> 4) & 0xf);
2716 buf[2] = tohex (((int) siggnal) & 0xf);
2720 strcpy (buf, step ? "s" : "c");
2725 /* Same as remote_resume, but with async support. */
2727 remote_async_resume (ptid_t ptid, int step, enum target_signal siggnal)
2729 remote_resume (ptid, step, siggnal);
2731 /* We are about to start executing the inferior, let's register it
2732 with the event loop. NOTE: this is the one place where all the
2733 execution commands end up. We could alternatively do this in each
2734 of the execution commands in infcmd.c. */
2735 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2736 into infcmd.c in order to allow inferior function calls to work
2737 NOT asynchronously. */
2738 if (target_can_async_p ())
2739 target_async (inferior_event_handler, 0);
2740 /* Tell the world that the target is now executing. */
2741 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2742 this? Instead, should the client of target just assume (for
2743 async targets) that the target is going to start executing? Is
2744 this information already found in the continuation block? */
2745 if (target_is_async_p ())
2746 target_executing = 1;
2750 /* Set up the signal handler for SIGINT, while the target is
2751 executing, ovewriting the 'regular' SIGINT signal handler. */
2753 initialize_sigint_signal_handler (void)
2755 sigint_remote_token =
2756 create_async_signal_handler (async_remote_interrupt, NULL);
2757 signal (SIGINT, handle_remote_sigint);
2760 /* Signal handler for SIGINT, while the target is executing. */
2762 handle_remote_sigint (int sig)
2764 signal (sig, handle_remote_sigint_twice);
2765 sigint_remote_twice_token =
2766 create_async_signal_handler (async_remote_interrupt_twice, NULL);
2767 mark_async_signal_handler_wrapper (sigint_remote_token);
2770 /* Signal handler for SIGINT, installed after SIGINT has already been
2771 sent once. It will take effect the second time that the user sends
2774 handle_remote_sigint_twice (int sig)
2776 signal (sig, handle_sigint);
2777 sigint_remote_twice_token =
2778 create_async_signal_handler (inferior_event_handler_wrapper, NULL);
2779 mark_async_signal_handler_wrapper (sigint_remote_twice_token);
2782 /* Perform the real interruption of the target execution, in response
2785 async_remote_interrupt (gdb_client_data arg)
2788 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
2793 /* Perform interrupt, if the first attempt did not succeed. Just give
2794 up on the target alltogether. */
2796 async_remote_interrupt_twice (gdb_client_data arg)
2799 fprintf_unfiltered (gdb_stdlog, "remote_interrupt_twice called\n");
2800 /* Do something only if the target was not killed by the previous
2802 if (target_executing)
2805 signal (SIGINT, handle_remote_sigint);
2809 /* Reinstall the usual SIGINT handlers, after the target has
2812 cleanup_sigint_signal_handler (void *dummy)
2814 signal (SIGINT, handle_sigint);
2815 if (sigint_remote_twice_token)
2816 delete_async_signal_handler ((struct async_signal_handler **)
2817 &sigint_remote_twice_token);
2818 if (sigint_remote_token)
2819 delete_async_signal_handler ((struct async_signal_handler **)
2820 &sigint_remote_token);
2823 /* Send ^C to target to halt it. Target will respond, and send us a
2825 static void (*ofunc) (int);
2827 /* The command line interface's stop routine. This function is installed
2828 as a signal handler for SIGINT. The first time a user requests a
2829 stop, we call remote_stop to send a break or ^C. If there is no
2830 response from the target (it didn't stop when the user requested it),
2831 we ask the user if he'd like to detach from the target. */
2833 remote_interrupt (int signo)
2835 /* If this doesn't work, try more severe steps. */
2836 signal (signo, remote_interrupt_twice);
2839 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
2844 /* The user typed ^C twice. */
2847 remote_interrupt_twice (int signo)
2849 signal (signo, ofunc);
2851 signal (signo, remote_interrupt);
2854 /* This is the generic stop called via the target vector. When a target
2855 interrupt is requested, either by the command line or the GUI, we
2856 will eventually end up here. */
2860 /* Send a break or a ^C, depending on user preference. */
2862 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
2865 serial_send_break (remote_desc);
2867 serial_write (remote_desc, "\003", 1);
2870 /* Ask the user what to do when an interrupt is received. */
2873 interrupt_query (void)
2875 target_terminal_ours ();
2877 if (query ("Interrupted while waiting for the program.\n\
2878 Give up (and stop debugging it)? "))
2880 target_mourn_inferior ();
2881 deprecated_throw_reason (RETURN_QUIT);
2884 target_terminal_inferior ();
2887 /* Enable/disable target terminal ownership. Most targets can use
2888 terminal groups to control terminal ownership. Remote targets are
2889 different in that explicit transfer of ownership to/from GDB/target
2893 remote_async_terminal_inferior (void)
2895 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
2896 sync_execution here. This function should only be called when
2897 GDB is resuming the inferior in the forground. A background
2898 resume (``run&'') should leave GDB in control of the terminal and
2899 consequently should not call this code. */
2900 if (!sync_execution)
2902 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
2903 calls target_terminal_*() idenpotent. The event-loop GDB talking
2904 to an asynchronous target with a synchronous command calls this
2905 function from both event-top.c and infrun.c/infcmd.c. Once GDB
2906 stops trying to transfer the terminal to the target when it
2907 shouldn't this guard can go away. */
2908 if (!remote_async_terminal_ours_p)
2910 delete_file_handler (input_fd);
2911 remote_async_terminal_ours_p = 0;
2912 initialize_sigint_signal_handler ();
2913 /* NOTE: At this point we could also register our selves as the
2914 recipient of all input. Any characters typed could then be
2915 passed on down to the target. */
2919 remote_async_terminal_ours (void)
2921 /* See FIXME in remote_async_terminal_inferior. */
2922 if (!sync_execution)
2924 /* See FIXME in remote_async_terminal_inferior. */
2925 if (remote_async_terminal_ours_p)
2927 cleanup_sigint_signal_handler (NULL);
2928 add_file_handler (input_fd, stdin_event_handler, 0);
2929 remote_async_terminal_ours_p = 1;
2932 /* If nonzero, ignore the next kill. */
2937 remote_console_output (char *msg)
2941 for (p = msg; p[0] && p[1]; p += 2)
2944 char c = fromhex (p[0]) * 16 + fromhex (p[1]);
2947 fputs_unfiltered (tb, gdb_stdtarg);
2949 gdb_flush (gdb_stdtarg);
2952 /* Wait until the remote machine stops, then return,
2953 storing status in STATUS just as `wait' would.
2954 Returns "pid", which in the case of a multi-threaded
2955 remote OS, is the thread-id. */
2958 remote_wait (ptid_t ptid, struct target_waitstatus *status)
2960 struct remote_state *rs = get_remote_state ();
2961 struct remote_arch_state *rsa = get_remote_arch_state ();
2962 char *buf = rs->buf;
2963 ULONGEST thread_num = -1;
2966 status->kind = TARGET_WAITKIND_EXITED;
2967 status->value.integer = 0;
2973 ofunc = signal (SIGINT, remote_interrupt);
2974 getpkt (&rs->buf, &rs->buf_size, 1);
2975 signal (SIGINT, ofunc);
2977 /* This is a hook for when we need to do something (perhaps the
2978 collection of trace data) every time the target stops. */
2979 if (deprecated_target_wait_loop_hook)
2980 (*deprecated_target_wait_loop_hook) ();
2982 remote_stopped_by_watchpoint_p = 0;
2986 case 'E': /* Error of some sort. */
2987 warning (_("Remote failure reply: %s"), buf);
2989 case 'F': /* File-I/O request. */
2990 remote_fileio_request (buf);
2992 case 'T': /* Status with PC, SP, FP, ... */
2994 gdb_byte regs[MAX_REGISTER_SIZE];
2996 /* Expedited reply, containing Signal, {regno, reg} repeat. */
2997 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
2999 n... = register number
3000 r... = register contents
3002 p = &buf[3]; /* after Txx */
3011 /* If the packet contains a register number save it in
3012 pnum and set p1 to point to the character following
3013 it. Otherwise p1 points to p. */
3015 /* If this packet is an awatch packet, don't parse the
3016 'a' as a register number. */
3018 if (strncmp (p, "awatch", strlen("awatch")) != 0)
3020 /* Read the ``P'' register number. */
3021 pnum = strtol (p, &p_temp, 16);
3027 if (p1 == p) /* No register number present here. */
3029 p1 = strchr (p, ':');
3031 error (_("Malformed packet(a) (missing colon): %s\n\
3034 if (strncmp (p, "thread", p1 - p) == 0)
3036 p_temp = unpack_varlen_hex (++p1, &thread_num);
3037 record_currthread (thread_num);
3040 else if ((strncmp (p, "watch", p1 - p) == 0)
3041 || (strncmp (p, "rwatch", p1 - p) == 0)
3042 || (strncmp (p, "awatch", p1 - p) == 0))
3044 remote_stopped_by_watchpoint_p = 1;
3045 p = unpack_varlen_hex (++p1, &addr);
3046 remote_watch_data_address = (CORE_ADDR)addr;
3050 /* Silently skip unknown optional info. */
3051 p_temp = strchr (p1 + 1, ';');
3058 struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
3062 error (_("Malformed packet(b) (missing colon): %s\n\
3067 error (_("Remote sent bad register number %s: %s\n\
3069 phex_nz (pnum, 0), p, buf);
3071 fieldsize = hex2bin (p, regs,
3072 register_size (current_gdbarch,
3075 if (fieldsize < register_size (current_gdbarch,
3077 warning (_("Remote reply is too short: %s"), buf);
3078 regcache_raw_supply (current_regcache,
3083 error (_("Remote register badly formatted: %s\nhere: %s"),
3088 case 'S': /* Old style status, just signal only. */
3089 status->kind = TARGET_WAITKIND_STOPPED;
3090 status->value.sig = (enum target_signal)
3091 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3095 thread_num = strtol ((const char *) &buf[4], NULL, 16);
3096 record_currthread (thread_num);
3099 case 'W': /* Target exited. */
3101 /* The remote process exited. */
3102 status->kind = TARGET_WAITKIND_EXITED;
3103 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
3107 status->kind = TARGET_WAITKIND_SIGNALLED;
3108 status->value.sig = (enum target_signal)
3109 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3113 case 'O': /* Console output. */
3114 remote_console_output (buf + 1);
3117 if (last_sent_signal != TARGET_SIGNAL_0)
3119 /* Zero length reply means that we tried 'S' or 'C' and
3120 the remote system doesn't support it. */
3121 target_terminal_ours_for_output ();
3123 ("Can't send signals to this remote system. %s not sent.\n",
3124 target_signal_to_name (last_sent_signal));
3125 last_sent_signal = TARGET_SIGNAL_0;
3126 target_terminal_inferior ();
3128 strcpy ((char *) buf, last_sent_step ? "s" : "c");
3129 putpkt ((char *) buf);
3132 /* else fallthrough */
3134 warning (_("Invalid remote reply: %s"), buf);
3139 if (thread_num != -1)
3141 return pid_to_ptid (thread_num);
3143 return inferior_ptid;
3146 /* Async version of remote_wait. */
3148 remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
3150 struct remote_state *rs = get_remote_state ();
3151 struct remote_arch_state *rsa = get_remote_arch_state ();
3152 char *buf = rs->buf;
3153 ULONGEST thread_num = -1;
3156 status->kind = TARGET_WAITKIND_EXITED;
3157 status->value.integer = 0;
3159 remote_stopped_by_watchpoint_p = 0;
3165 if (!target_is_async_p ())
3166 ofunc = signal (SIGINT, remote_interrupt);
3167 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3168 _never_ wait for ever -> test on target_is_async_p().
3169 However, before we do that we need to ensure that the caller
3170 knows how to take the target into/out of async mode. */
3171 getpkt (&rs->buf, &rs->buf_size, wait_forever_enabled_p);
3172 if (!target_is_async_p ())
3173 signal (SIGINT, ofunc);
3175 /* This is a hook for when we need to do something (perhaps the
3176 collection of trace data) every time the target stops. */
3177 if (deprecated_target_wait_loop_hook)
3178 (*deprecated_target_wait_loop_hook) ();
3182 case 'E': /* Error of some sort. */
3183 warning (_("Remote failure reply: %s"), buf);
3185 case 'F': /* File-I/O request. */
3186 remote_fileio_request (buf);
3188 case 'T': /* Status with PC, SP, FP, ... */
3190 gdb_byte regs[MAX_REGISTER_SIZE];
3192 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3193 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3195 n... = register number
3196 r... = register contents
3198 p = &buf[3]; /* after Txx */
3207 /* If the packet contains a register number, save it
3208 in pnum and set p1 to point to the character
3209 following it. Otherwise p1 points to p. */
3211 /* If this packet is an awatch packet, don't parse the 'a'
3212 as a register number. */
3214 if (!strncmp (p, "awatch", strlen ("awatch")) != 0)
3216 /* Read the register number. */
3217 pnum = strtol (p, &p_temp, 16);
3223 if (p1 == p) /* No register number present here. */
3225 p1 = strchr (p, ':');
3227 error (_("Malformed packet(a) (missing colon): %s\n\
3230 if (strncmp (p, "thread", p1 - p) == 0)
3232 p_temp = unpack_varlen_hex (++p1, &thread_num);
3233 record_currthread (thread_num);
3236 else if ((strncmp (p, "watch", p1 - p) == 0)
3237 || (strncmp (p, "rwatch", p1 - p) == 0)
3238 || (strncmp (p, "awatch", p1 - p) == 0))
3240 remote_stopped_by_watchpoint_p = 1;
3241 p = unpack_varlen_hex (++p1, &addr);
3242 remote_watch_data_address = (CORE_ADDR)addr;
3246 /* Silently skip unknown optional info. */
3247 p_temp = strchr (p1 + 1, ';');
3255 struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
3258 error (_("Malformed packet(b) (missing colon): %s\n\
3263 error (_("Remote sent bad register number %ld: %s\n\
3267 fieldsize = hex2bin (p, regs,
3268 register_size (current_gdbarch,
3271 if (fieldsize < register_size (current_gdbarch,
3273 warning (_("Remote reply is too short: %s"), buf);
3274 regcache_raw_supply (current_regcache, reg->regnum, regs);
3278 error (_("Remote register badly formatted: %s\nhere: %s"),
3283 case 'S': /* Old style status, just signal only. */
3284 status->kind = TARGET_WAITKIND_STOPPED;
3285 status->value.sig = (enum target_signal)
3286 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3290 thread_num = strtol ((const char *) &buf[4], NULL, 16);
3291 record_currthread (thread_num);
3294 case 'W': /* Target exited. */
3296 /* The remote process exited. */
3297 status->kind = TARGET_WAITKIND_EXITED;
3298 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
3302 status->kind = TARGET_WAITKIND_SIGNALLED;
3303 status->value.sig = (enum target_signal)
3304 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3308 case 'O': /* Console output. */
3309 remote_console_output (buf + 1);
3310 /* Return immediately to the event loop. The event loop will
3311 still be waiting on the inferior afterwards. */
3312 status->kind = TARGET_WAITKIND_IGNORE;
3315 if (last_sent_signal != TARGET_SIGNAL_0)
3317 /* Zero length reply means that we tried 'S' or 'C' and
3318 the remote system doesn't support it. */
3319 target_terminal_ours_for_output ();
3321 ("Can't send signals to this remote system. %s not sent.\n",
3322 target_signal_to_name (last_sent_signal));
3323 last_sent_signal = TARGET_SIGNAL_0;
3324 target_terminal_inferior ();
3326 strcpy ((char *) buf, last_sent_step ? "s" : "c");
3327 putpkt ((char *) buf);
3330 /* else fallthrough */
3332 warning (_("Invalid remote reply: %s"), buf);
3337 if (thread_num != -1)
3339 return pid_to_ptid (thread_num);
3341 return inferior_ptid;
3344 /* Number of bytes of registers this stub implements. */
3346 static int register_bytes_found;
3348 /* Read the remote registers into the block REGS. */
3349 /* Currently we just read all the registers, so we don't use regnum. */
3352 fetch_register_using_p (int regnum)
3354 struct remote_state *rs = get_remote_state ();
3355 char *buf = rs->buf, *p;
3356 char regp[MAX_REGISTER_SIZE];
3361 p += hexnumstr (p, regnum);
3363 remote_send (&rs->buf, &rs->buf_size);
3365 /* If the stub didn't recognize the packet, or if we got an error,
3367 if (buf[0] == '\0' || buf[0] == 'E')
3370 /* If this register is unfetchable, tell the regcache. */
3373 regcache_raw_supply (current_regcache, regnum, NULL);
3374 set_register_cached (regnum, -1);
3378 /* Otherwise, parse and supply the value. */
3385 error (_("fetch_register_using_p: early buf termination"));
3389 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
3392 regcache_raw_supply (current_regcache, regnum, regp);
3397 remote_fetch_registers (int regnum)
3399 struct remote_state *rs = get_remote_state ();
3400 struct remote_arch_state *rsa = get_remote_arch_state ();
3401 char *buf = rs->buf;
3404 char *regs = alloca (rsa->sizeof_g_packet);
3406 set_thread (PIDGET (inferior_ptid), 1);
3410 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
3411 gdb_assert (reg != NULL);
3412 if (!reg->in_g_packet)
3413 internal_error (__FILE__, __LINE__,
3414 _("Attempt to fetch a non G-packet register when this "
3415 "remote.c does not support the p-packet."));
3417 switch (remote_protocol_packets[PACKET_p].support)
3419 case PACKET_DISABLE:
3422 if (fetch_register_using_p (regnum))
3425 error (_("Protocol error: p packet not recognized by stub"));
3426 case PACKET_SUPPORT_UNKNOWN:
3427 if (fetch_register_using_p (regnum))
3429 /* The stub recognized the 'p' packet. Remember this. */
3430 remote_protocol_packets[PACKET_p].support = PACKET_ENABLE;
3435 /* The stub does not support the 'P' packet. Use 'G'
3436 instead, and don't try using 'P' in the future (it
3437 will just waste our time). */
3438 remote_protocol_packets[PACKET_p].support = PACKET_DISABLE;
3444 remote_send (&rs->buf, &rs->buf_size);
3446 /* Save the size of the packet sent to us by the target. Its used
3447 as a heuristic when determining the max size of packets that the
3448 target can safely receive. */
3449 if ((rsa->actual_register_packet_size) == 0)
3450 (rsa->actual_register_packet_size) = strlen (buf);
3452 /* Unimplemented registers read as all bits zero. */
3453 memset (regs, 0, rsa->sizeof_g_packet);
3455 /* We can get out of synch in various cases. If the first character
3456 in the buffer is not a hex character, assume that has happened
3457 and try to fetch another packet to read. */
3458 while ((buf[0] < '0' || buf[0] > '9')
3459 && (buf[0] < 'A' || buf[0] > 'F')
3460 && (buf[0] < 'a' || buf[0] > 'f')
3461 && buf[0] != 'x') /* New: unavailable register value. */
3464 fprintf_unfiltered (gdb_stdlog,
3465 "Bad register packet; fetching a new packet\n");
3466 getpkt (&rs->buf, &rs->buf_size, 0);
3469 /* Reply describes registers byte by byte, each byte encoded as two
3470 hex characters. Suck them all up, then supply them to the
3471 register cacheing/storage mechanism. */
3474 for (i = 0; i < rsa->sizeof_g_packet; i++)
3480 warning (_("Remote reply is of odd length: %s"), buf);
3481 /* Don't change register_bytes_found in this case, and don't
3482 print a second warning. */
3485 if (p[0] == 'x' && p[1] == 'x')
3486 regs[i] = 0; /* 'x' */
3488 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
3492 if (i != register_bytes_found)
3494 register_bytes_found = i;
3495 if (REGISTER_BYTES_OK_P ()
3496 && !REGISTER_BYTES_OK (i))
3497 warning (_("Remote reply is too short: %s"), buf);
3503 for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
3505 struct packet_reg *r = &rsa->regs[i];
3508 if (r->offset * 2 >= strlen (buf))
3509 /* A short packet that didn't include the register's
3510 value, this implies that the register is zero (and
3511 not that the register is unavailable). Supply that
3513 regcache_raw_supply (current_regcache, r->regnum, NULL);
3514 else if (buf[r->offset * 2] == 'x')
3516 gdb_assert (r->offset * 2 < strlen (buf));
3517 /* The register isn't available, mark it as such (at
3518 the same time setting the value to zero). */
3519 regcache_raw_supply (current_regcache, r->regnum, NULL);
3520 set_register_cached (i, -1);
3523 regcache_raw_supply (current_regcache, r->regnum,
3530 /* Prepare to store registers. Since we may send them all (using a
3531 'G' request), we have to read out the ones we don't want to change
3535 remote_prepare_to_store (void)
3537 struct remote_arch_state *rsa = get_remote_arch_state ();
3539 gdb_byte buf[MAX_REGISTER_SIZE];
3541 /* Make sure the entire registers array is valid. */
3542 switch (remote_protocol_packets[PACKET_P].support)
3544 case PACKET_DISABLE:
3545 case PACKET_SUPPORT_UNKNOWN:
3546 /* Make sure all the necessary registers are cached. */
3547 for (i = 0; i < NUM_REGS; i++)
3548 if (rsa->regs[i].in_g_packet)
3549 regcache_raw_read (current_regcache, rsa->regs[i].regnum, buf);
3556 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3557 packet was not recognized. */
3560 store_register_using_P (int regnum)
3562 struct remote_state *rs = get_remote_state ();
3563 struct remote_arch_state *rsa = get_remote_arch_state ();
3564 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
3565 /* Try storing a single register. */
3566 char *buf = rs->buf;
3567 gdb_byte regp[MAX_REGISTER_SIZE];
3570 xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
3571 p = buf + strlen (buf);
3572 regcache_raw_collect (current_regcache, reg->regnum, regp);
3573 bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
3574 remote_send (&rs->buf, &rs->buf_size);
3576 return buf[0] != '\0';
3580 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3581 contents of the register cache buffer. FIXME: ignores errors. */
3584 remote_store_registers (int regnum)
3586 struct remote_state *rs = get_remote_state ();
3587 struct remote_arch_state *rsa = get_remote_arch_state ();
3591 set_thread (PIDGET (inferior_ptid), 1);
3595 switch (remote_protocol_packets[PACKET_P].support)
3597 case PACKET_DISABLE:
3600 if (store_register_using_P (regnum))
3603 error (_("Protocol error: P packet not recognized by stub"));
3604 case PACKET_SUPPORT_UNKNOWN:
3605 if (store_register_using_P (regnum))
3607 /* The stub recognized the 'P' packet. Remember this. */
3608 remote_protocol_packets[PACKET_P].support = PACKET_ENABLE;
3613 /* The stub does not support the 'P' packet. Use 'G'
3614 instead, and don't try using 'P' in the future (it
3615 will just waste our time). */
3616 remote_protocol_packets[PACKET_P].support = PACKET_DISABLE;
3622 /* Extract all the registers in the regcache copying them into a
3626 regs = alloca (rsa->sizeof_g_packet);
3627 memset (regs, 0, rsa->sizeof_g_packet);
3628 for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
3630 struct packet_reg *r = &rsa->regs[i];
3632 regcache_raw_collect (current_regcache, r->regnum, regs + r->offset);
3636 /* Command describes registers byte by byte,
3637 each byte encoded as two hex characters. */
3640 /* remote_prepare_to_store insures that register_bytes_found gets set. */
3641 bin2hex (regs, p, register_bytes_found);
3642 remote_send (&rs->buf, &rs->buf_size);
3646 /* Return the number of hex digits in num. */
3649 hexnumlen (ULONGEST num)
3653 for (i = 0; num != 0; i++)
3659 /* Set BUF to the minimum number of hex digits representing NUM. */
3662 hexnumstr (char *buf, ULONGEST num)
3664 int len = hexnumlen (num);
3665 return hexnumnstr (buf, num, len);
3669 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3672 hexnumnstr (char *buf, ULONGEST num, int width)
3678 for (i = width - 1; i >= 0; i--)
3680 buf[i] = "0123456789abcdef"[(num & 0xf)];
3687 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3690 remote_address_masked (CORE_ADDR addr)
3692 if (remote_address_size > 0
3693 && remote_address_size < (sizeof (ULONGEST) * 8))
3695 /* Only create a mask when that mask can safely be constructed
3696 in a ULONGEST variable. */
3698 mask = (mask << remote_address_size) - 1;
3704 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
3705 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
3706 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
3707 (which may be more than *OUT_LEN due to escape characters). The
3708 total number of bytes in the output buffer will be at most
3712 remote_escape_output (const gdb_byte *buffer, int len,
3713 gdb_byte *out_buf, int *out_len,
3716 int input_index, output_index;
3719 for (input_index = 0; input_index < len; input_index++)
3721 gdb_byte b = buffer[input_index];
3723 if (b == '$' || b == '#' || b == '}')
3725 /* These must be escaped. */
3726 if (output_index + 2 > out_maxlen)
3728 out_buf[output_index++] = '}';
3729 out_buf[output_index++] = b ^ 0x20;
3733 if (output_index + 1 > out_maxlen)
3735 out_buf[output_index++] = b;
3739 *out_len = input_index;
3740 return output_index;
3743 /* Convert BUFFER, escaped data LEN bytes long, into binary data
3744 in OUT_BUF. Return the number of bytes written to OUT_BUF.
3745 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
3747 This function reverses remote_escape_output. It allows more
3748 escaped characters than that function does, in particular because
3749 '*' must be escaped to avoid the run-length encoding processing
3750 in reading packets. */
3753 remote_unescape_input (const gdb_byte *buffer, int len,
3754 gdb_byte *out_buf, int out_maxlen)
3756 int input_index, output_index;
3761 for (input_index = 0; input_index < len; input_index++)
3763 gdb_byte b = buffer[input_index];
3765 if (output_index + 1 > out_maxlen)
3767 warning (_("Received too much data from remote target;"
3768 " ignoring overflow."));
3769 return output_index;
3774 out_buf[output_index++] = b ^ 0x20;
3780 out_buf[output_index++] = b;
3784 error (_("Unmatched escape character in target response."));
3786 return output_index;
3789 /* Determine whether the remote target supports binary downloading.
3790 This is accomplished by sending a no-op memory write of zero length
3791 to the target at the specified address. It does not suffice to send
3792 the whole packet, since many stubs strip the eighth bit and
3793 subsequently compute a wrong checksum, which causes real havoc with
3796 NOTE: This can still lose if the serial line is not eight-bit
3797 clean. In cases like this, the user should clear "remote
3801 check_binary_download (CORE_ADDR addr)
3803 struct remote_state *rs = get_remote_state ();
3805 switch (remote_protocol_packets[PACKET_X].support)
3807 case PACKET_DISABLE:
3811 case PACKET_SUPPORT_UNKNOWN:
3813 char *buf = rs->buf;
3818 p += hexnumstr (p, (ULONGEST) addr);
3820 p += hexnumstr (p, (ULONGEST) 0);
3824 putpkt_binary (buf, (int) (p - buf));
3825 getpkt (&rs->buf, &rs->buf_size, 0);
3830 fprintf_unfiltered (gdb_stdlog,
3831 "binary downloading NOT suppported by target\n");
3832 remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
3837 fprintf_unfiltered (gdb_stdlog,
3838 "binary downloading suppported by target\n");
3839 remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
3846 /* Write memory data directly to the remote machine.
3847 This does not inform the data cache; the data cache uses this.
3848 MEMADDR is the address in the remote memory space.
3849 MYADDR is the address of the buffer in our space.
3850 LEN is the number of bytes.
3852 Returns number of bytes transferred, or 0 (setting errno) for
3853 error. Only transfer a single packet. */
3856 remote_write_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
3858 struct remote_state *rs = get_remote_state ();
3868 /* Verify that the target can support a binary download. */
3869 check_binary_download (memaddr);
3871 payload_size = get_memory_write_packet_size ();
3873 /* The packet buffer will be large enough for the payload;
3874 get_memory_packet_size ensures this. */
3877 /* Compute the size of the actual payload by subtracting out the
3878 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
3880 payload_size -= strlen ("$M,:#NN");
3881 payload_size -= hexnumlen (memaddr);
3883 /* Construct the packet header: "[MX]<memaddr>,<len>:". */
3885 /* Append "[XM]". Compute a best guess of the number of bytes
3886 actually transfered. */
3888 switch (remote_protocol_packets[PACKET_X].support)
3892 /* Best guess at number of bytes that will fit. */
3893 todo = min (len, payload_size);
3894 payload_size -= hexnumlen (todo);
3895 todo = min (todo, payload_size);
3897 case PACKET_DISABLE:
3899 /* Num bytes that will fit. */
3900 todo = min (len, payload_size / 2);
3901 payload_size -= hexnumlen (todo);
3902 todo = min (todo, payload_size / 2);
3904 case PACKET_SUPPORT_UNKNOWN:
3905 internal_error (__FILE__, __LINE__,
3906 _("remote_write_bytes: bad internal state"));
3908 internal_error (__FILE__, __LINE__, _("bad switch"));
3911 internal_error (__FILE__, __LINE__,
3912 _("minumum packet size too small to write data"));
3914 /* If we already need another packet, then try to align the end
3915 of this packet to a useful boundary. */
3916 if (todo > 2 * REMOTE_ALIGN_WRITES && todo < len)
3917 todo = ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr;
3919 /* Append "<memaddr>". */
3920 memaddr = remote_address_masked (memaddr);
3921 p += hexnumstr (p, (ULONGEST) memaddr);
3926 /* Append <len>. Retain the location/size of <len>. It may need to
3927 be adjusted once the packet body has been created. */
3929 plenlen = hexnumstr (p, (ULONGEST) todo);
3936 /* Append the packet body. */
3937 switch (remote_protocol_packets[PACKET_X].support)
3940 /* Binary mode. Send target system values byte by byte, in
3941 increasing byte addresses. Only escape certain critical
3943 payload_length = remote_escape_output (myaddr, todo, p, &nr_bytes,
3946 /* If not all TODO bytes fit, then we'll need another packet. Make
3947 a second try to keep the end of the packet aligned. */
3948 if (nr_bytes < todo)
3952 new_nr_bytes = (((memaddr + nr_bytes) & ~(REMOTE_ALIGN_WRITES - 1))
3954 if (new_nr_bytes != nr_bytes)
3955 payload_length = remote_escape_output (myaddr, new_nr_bytes,
3960 p += payload_length;
3961 if (nr_bytes < todo)
3963 /* Escape chars have filled up the buffer prematurely,
3964 and we have actually sent fewer bytes than planned.
3965 Fix-up the length field of the packet. Use the same
3966 number of characters as before. */
3967 plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
3968 *plen = ':'; /* overwrite \0 from hexnumnstr() */
3971 case PACKET_DISABLE:
3972 /* Normal mode: Send target system values byte by byte, in
3973 increasing byte addresses. Each byte is encoded as a two hex
3975 nr_bytes = bin2hex (myaddr, p, todo);
3978 case PACKET_SUPPORT_UNKNOWN:
3979 internal_error (__FILE__, __LINE__,
3980 _("remote_write_bytes: bad internal state"));
3982 internal_error (__FILE__, __LINE__, _("bad switch"));
3985 putpkt_binary (buf, (int) (p - buf));
3986 getpkt (&rs->buf, &rs->buf_size, 0);
3990 /* There is no correspondance between what the remote protocol
3991 uses for errors and errno codes. We would like a cleaner way
3992 of representing errors (big enough to include errno codes,
3993 bfd_error codes, and others). But for now just return EIO. */
3998 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
3999 fewer bytes than we'd planned. */
4003 /* Read memory data directly from the remote machine.
4004 This does not use the data cache; the data cache uses this.
4005 MEMADDR is the address in the remote memory space.
4006 MYADDR is the address of the buffer in our space.
4007 LEN is the number of bytes.
4009 Returns number of bytes transferred, or 0 for error. */
4011 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4012 remote targets) shouldn't attempt to read the entire buffer.
4013 Instead it should read a single packet worth of data and then
4014 return the byte size of that packet to the caller. The caller (its
4015 caller and its callers caller ;-) already contains code for
4016 handling partial reads. */
4019 remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
4021 struct remote_state *rs = get_remote_state ();
4023 int max_buf_size; /* Max size of packet output buffer. */
4026 max_buf_size = get_memory_read_packet_size ();
4027 /* The packet buffer will be large enough for the payload;
4028 get_memory_packet_size ensures this. */
4038 todo = min (len, max_buf_size / 2); /* num bytes that will fit */
4040 /* construct "m"<memaddr>","<len>" */
4041 /* sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4042 memaddr = remote_address_masked (memaddr);
4045 p += hexnumstr (p, (ULONGEST) memaddr);
4047 p += hexnumstr (p, (ULONGEST) todo);
4051 getpkt (&rs->buf, &rs->buf_size, 0);
4054 && isxdigit (buf[1]) && isxdigit (buf[2])
4057 /* There is no correspondance between what the remote
4058 protocol uses for errors and errno codes. We would like
4059 a cleaner way of representing errors (big enough to
4060 include errno codes, bfd_error codes, and others). But
4061 for now just return EIO. */
4066 /* Reply describes memory byte by byte,
4067 each byte encoded as two hex characters. */
4070 if ((i = hex2bin (p, myaddr, todo)) < todo)
4072 /* Reply is short. This means that we were able to read
4073 only part of what we wanted to. */
4074 return i + (origlen - len);
4083 /* Read or write LEN bytes from inferior memory at MEMADDR,
4084 transferring to or from debugger address BUFFER. Write to inferior
4085 if SHOULD_WRITE is nonzero. Returns length of data written or
4086 read; 0 for error. TARGET is unused. */
4089 remote_xfer_memory (CORE_ADDR mem_addr, gdb_byte *buffer, int mem_len,
4090 int should_write, struct mem_attrib *attrib,
4091 struct target_ops *target)
4093 CORE_ADDR targ_addr;
4097 /* Should this be the selected frame? */
4098 gdbarch_remote_translate_xfer_address (current_gdbarch,
4101 &targ_addr, &targ_len);
4106 res = remote_write_bytes (targ_addr, buffer, targ_len);
4108 res = remote_read_bytes (targ_addr, buffer, targ_len);
4114 remote_files_info (struct target_ops *ignore)
4116 puts_filtered ("Debugging a target over a serial line.\n");
4119 /* Stuff for dealing with the packets which are part of this protocol.
4120 See comment at top of file for details. */
4122 /* Read a single character from the remote end. */
4125 readchar (int timeout)
4129 ch = serial_readchar (remote_desc, timeout);
4134 switch ((enum serial_rc) ch)
4137 target_mourn_inferior ();
4138 error (_("Remote connection closed"));
4141 perror_with_name (_("Remote communication error"));
4143 case SERIAL_TIMEOUT:
4149 /* Send the command in *BUF to the remote machine, and read the reply
4150 into *BUF. Report an error if we get an error reply. Resize
4151 *BUF using xrealloc if necessary to hold the result, and update
4155 remote_send (char **buf,
4159 getpkt (buf, sizeof_buf, 0);
4161 if ((*buf)[0] == 'E')
4162 error (_("Remote failure reply: %s"), *buf);
4165 /* Display a null-terminated packet on stdout, for debugging, using C
4169 print_packet (char *buf)
4171 puts_filtered ("\"");
4172 fputstr_filtered (buf, '"', gdb_stdout);
4173 puts_filtered ("\"");
4179 return putpkt_binary (buf, strlen (buf));
4182 /* Send a packet to the remote machine, with error checking. The data
4183 of the packet is in BUF. The string in BUF can be at most
4184 get_remote_packet_size () - 5 to account for the $, # and checksum,
4185 and for a possible /0 if we are debugging (remote_debug) and want
4186 to print the sent packet as a string. */
4189 putpkt_binary (char *buf, int cnt)
4192 unsigned char csum = 0;
4193 char *buf2 = alloca (cnt + 6);
4199 /* Copy the packet into buffer BUF2, encapsulating it
4200 and giving it a checksum. */
4205 for (i = 0; i < cnt; i++)
4211 *p++ = tohex ((csum >> 4) & 0xf);
4212 *p++ = tohex (csum & 0xf);
4214 /* Send it over and over until we get a positive ack. */
4218 int started_error_output = 0;
4223 fprintf_unfiltered (gdb_stdlog, "Sending packet: ");
4224 fputstrn_unfiltered (buf2, p - buf2, 0, gdb_stdlog);
4225 fprintf_unfiltered (gdb_stdlog, "...");
4226 gdb_flush (gdb_stdlog);
4228 if (serial_write (remote_desc, buf2, p - buf2))
4229 perror_with_name (_("putpkt: write failed"));
4231 /* Read until either a timeout occurs (-2) or '+' is read. */
4234 ch = readchar (remote_timeout);
4242 case SERIAL_TIMEOUT:
4244 if (started_error_output)
4246 putchar_unfiltered ('\n');
4247 started_error_output = 0;
4256 fprintf_unfiltered (gdb_stdlog, "Ack\n");
4260 fprintf_unfiltered (gdb_stdlog, "Nak\n");
4261 case SERIAL_TIMEOUT:
4265 break; /* Retransmit buffer. */
4269 fprintf_unfiltered (gdb_stdlog,
4270 "Packet instead of Ack, ignoring it\n");
4271 /* It's probably an old response sent because an ACK
4272 was lost. Gobble up the packet and ack it so it
4273 doesn't get retransmitted when we resend this
4276 serial_write (remote_desc, "+", 1);
4277 continue; /* Now, go look for +. */
4282 if (!started_error_output)
4284 started_error_output = 1;
4285 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
4287 fputc_unfiltered (ch & 0177, gdb_stdlog);
4291 break; /* Here to retransmit. */
4295 /* This is wrong. If doing a long backtrace, the user should be
4296 able to get out next time we call QUIT, without anything as
4297 violent as interrupt_query. If we want to provide a way out of
4298 here without getting to the next QUIT, it should be based on
4299 hitting ^C twice as in remote_wait. */
4309 /* Come here after finding the start of a frame when we expected an
4310 ack. Do our best to discard the rest of this packet. */
4319 c = readchar (remote_timeout);
4322 case SERIAL_TIMEOUT:
4323 /* Nothing we can do. */
4326 /* Discard the two bytes of checksum and stop. */
4327 c = readchar (remote_timeout);
4329 c = readchar (remote_timeout);
4332 case '*': /* Run length encoding. */
4333 /* Discard the repeat count. */
4334 c = readchar (remote_timeout);
4339 /* A regular character. */
4345 /* Come here after finding the start of the frame. Collect the rest
4346 into *BUF, verifying the checksum, length, and handling run-length
4347 compression. NUL terminate the buffer. If there is not enough room,
4348 expand *BUF using xrealloc.
4350 Returns -1 on error, number of characters in buffer (ignoring the
4351 trailing NULL) on success. (could be extended to return one of the
4352 SERIAL status indications). */
4355 read_frame (char **buf_p,
4368 c = readchar (remote_timeout);
4371 case SERIAL_TIMEOUT:
4373 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
4377 fputs_filtered ("Saw new packet start in middle of old one\n",
4379 return -1; /* Start a new packet, count retries. */
4382 unsigned char pktcsum;
4388 check_0 = readchar (remote_timeout);
4390 check_1 = readchar (remote_timeout);
4392 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
4395 fputs_filtered ("Timeout in checksum, retrying\n",
4399 else if (check_0 < 0 || check_1 < 0)
4402 fputs_filtered ("Communication error in checksum\n",
4407 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
4408 if (csum == pktcsum)
4413 fprintf_filtered (gdb_stdlog,
4414 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4416 fputstrn_filtered (buf, bc, 0, gdb_stdlog);
4417 fputs_filtered ("\n", gdb_stdlog);
4419 /* Number of characters in buffer ignoring trailing
4423 case '*': /* Run length encoding. */
4428 c = readchar (remote_timeout);
4430 repeat = c - ' ' + 3; /* Compute repeat count. */
4432 /* The character before ``*'' is repeated. */
4434 if (repeat > 0 && repeat <= 255 && bc > 0)
4436 if (bc + repeat - 1 >= *sizeof_buf - 1)
4438 /* Make some more room in the buffer. */
4439 *sizeof_buf += repeat;
4440 *buf_p = xrealloc (*buf_p, *sizeof_buf);
4444 memset (&buf[bc], buf[bc - 1], repeat);
4450 printf_filtered (_("Invalid run length encoding: %s\n"), buf);
4454 if (bc >= *sizeof_buf - 1)
4456 /* Make some more room in the buffer. */
4458 *buf_p = xrealloc (*buf_p, *sizeof_buf);
4469 /* Read a packet from the remote machine, with error checking, and
4470 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4471 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4472 rather than timing out; this is used (in synchronous mode) to wait
4473 for a target that is is executing user code to stop. */
4474 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4475 don't have to change all the calls to getpkt to deal with the
4476 return value, because at the moment I don't know what the right
4477 thing to do it for those. */
4485 timed_out = getpkt_sane (buf, sizeof_buf, forever);
4489 /* Read a packet from the remote machine, with error checking, and
4490 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4491 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4492 rather than timing out; this is used (in synchronous mode) to wait
4493 for a target that is is executing user code to stop. If FOREVER ==
4494 0, this function is allowed to time out gracefully and return an
4495 indication of this to the caller. Otherwise return the number
4498 getpkt_sane (char **buf, long *sizeof_buf, int forever)
4505 strcpy (*buf, "timeout");
4509 timeout = watchdog > 0 ? watchdog : -1;
4513 timeout = remote_timeout;
4517 for (tries = 1; tries <= MAX_TRIES; tries++)
4519 /* This can loop forever if the remote side sends us characters
4520 continuously, but if it pauses, we'll get a zero from
4521 readchar because of timeout. Then we'll count that as a
4524 /* Note that we will only wait forever prior to the start of a
4525 packet. After that, we expect characters to arrive at a
4526 brisk pace. They should show up within remote_timeout
4531 c = readchar (timeout);
4533 if (c == SERIAL_TIMEOUT)
4535 if (forever) /* Watchdog went off? Kill the target. */
4538 target_mourn_inferior ();
4539 error (_("Watchdog has expired. Target detached."));
4542 fputs_filtered ("Timed out.\n", gdb_stdlog);
4548 /* We've found the start of a packet, now collect the data. */
4550 val = read_frame (buf, sizeof_buf);
4556 fprintf_unfiltered (gdb_stdlog, "Packet received: ");
4557 fputstrn_unfiltered (*buf, val, 0, gdb_stdlog);
4558 fprintf_unfiltered (gdb_stdlog, "\n");
4560 serial_write (remote_desc, "+", 1);
4564 /* Try the whole thing again. */
4566 serial_write (remote_desc, "-", 1);
4569 /* We have tried hard enough, and just can't receive the packet.
4572 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
4573 serial_write (remote_desc, "+", 1);
4580 /* For some mysterious reason, wait_for_inferior calls kill instead of
4581 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4585 target_mourn_inferior ();
4589 /* Use catch_errors so the user can quit from gdb even when we aren't on
4590 speaking terms with the remote system. */
4591 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
4593 /* Don't wait for it to die. I'm not really sure it matters whether
4594 we do or not. For the existing stubs, kill is a noop. */
4595 target_mourn_inferior ();
4598 /* Async version of remote_kill. */
4600 remote_async_kill (void)
4602 /* Unregister the file descriptor from the event loop. */
4603 if (target_is_async_p ())
4604 serial_async (remote_desc, NULL, 0);
4606 /* For some mysterious reason, wait_for_inferior calls kill instead of
4607 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4611 target_mourn_inferior ();
4615 /* Use catch_errors so the user can quit from gdb even when we
4616 aren't on speaking terms with the remote system. */
4617 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
4619 /* Don't wait for it to die. I'm not really sure it matters whether
4620 we do or not. For the existing stubs, kill is a noop. */
4621 target_mourn_inferior ();
4627 remote_mourn_1 (&remote_ops);
4631 remote_async_mourn (void)
4633 remote_mourn_1 (&remote_async_ops);
4637 extended_remote_mourn (void)
4639 /* We do _not_ want to mourn the target like this; this will
4640 remove the extended remote target from the target stack,
4641 and the next time the user says "run" it'll fail.
4643 FIXME: What is the right thing to do here? */
4645 remote_mourn_1 (&extended_remote_ops);
4649 /* Worker function for remote_mourn. */
4651 remote_mourn_1 (struct target_ops *target)
4653 unpush_target (target);
4654 generic_mourn_inferior ();
4657 /* In the extended protocol we want to be able to do things like
4658 "run" and have them basically work as expected. So we need
4659 a special create_inferior function.
4661 FIXME: One day add support for changing the exec file
4662 we're debugging, arguments and an environment. */
4665 extended_remote_create_inferior (char *exec_file, char *args,
4666 char **env, int from_tty)
4668 /* Rip out the breakpoints; we'll reinsert them after restarting
4669 the remote server. */
4670 remove_breakpoints ();
4672 /* Now restart the remote server. */
4673 extended_remote_restart ();
4675 /* Now put the breakpoints back in. This way we're safe if the
4676 restart function works via a unix fork on the remote side. */
4677 insert_breakpoints ();
4679 /* Clean up from the last time we were running. */
4680 clear_proceed_status ();
4683 /* Async version of extended_remote_create_inferior. */
4685 extended_remote_async_create_inferior (char *exec_file, char *args,
4686 char **env, int from_tty)
4688 /* Rip out the breakpoints; we'll reinsert them after restarting
4689 the remote server. */
4690 remove_breakpoints ();
4692 /* If running asynchronously, register the target file descriptor
4693 with the event loop. */
4694 if (target_can_async_p ())
4695 target_async (inferior_event_handler, 0);
4697 /* Now restart the remote server. */
4698 extended_remote_restart ();
4700 /* Now put the breakpoints back in. This way we're safe if the
4701 restart function works via a unix fork on the remote side. */
4702 insert_breakpoints ();
4704 /* Clean up from the last time we were running. */
4705 clear_proceed_status ();
4709 /* On some machines, e.g. 68k, we may use a different breakpoint
4710 instruction than other targets; in those use
4711 DEPRECATED_REMOTE_BREAKPOINT instead of just BREAKPOINT_FROM_PC.
4712 Also, bi-endian targets may define
4713 DEPRECATED_LITTLE_REMOTE_BREAKPOINT and
4714 DEPRECATED_BIG_REMOTE_BREAKPOINT. If none of these are defined, we
4715 just call the standard routines that are in mem-break.c. */
4717 /* NOTE: cagney/2003-06-08: This is silly. A remote and simulator
4718 target should use an identical BREAKPOINT_FROM_PC. As for native,
4719 the ARCH-OS-tdep.c code can override the default. */
4721 #if defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && defined (DEPRECATED_BIG_REMOTE_BREAKPOINT) && !defined(DEPRECATED_REMOTE_BREAKPOINT)
4722 #define DEPRECATED_REMOTE_BREAKPOINT
4725 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4727 /* If the target isn't bi-endian, just pretend it is. */
4728 #if !defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && !defined (DEPRECATED_BIG_REMOTE_BREAKPOINT)
4729 #define DEPRECATED_LITTLE_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
4730 #define DEPRECATED_BIG_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
4733 static unsigned char big_break_insn[] = DEPRECATED_BIG_REMOTE_BREAKPOINT;
4734 static unsigned char little_break_insn[] = DEPRECATED_LITTLE_REMOTE_BREAKPOINT;
4736 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4738 /* Insert a breakpoint. On targets that have software breakpoint
4739 support, we ask the remote target to do the work; on targets
4740 which don't, we insert a traditional memory breakpoint. */
4743 remote_insert_breakpoint (struct bp_target_info *bp_tgt)
4745 CORE_ADDR addr = bp_tgt->placed_address;
4746 struct remote_state *rs = get_remote_state ();
4747 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4751 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
4752 If it succeeds, then set the support to PACKET_ENABLE. If it
4753 fails, and the user has explicitly requested the Z support then
4754 report an error, otherwise, mark it disabled and go on. */
4756 if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
4763 BREAKPOINT_FROM_PC (&bp_tgt->placed_address, &bp_tgt->placed_size);
4764 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
4765 p += hexnumstr (p, addr);
4766 sprintf (p, ",%d", bp_tgt->placed_size);
4769 getpkt (&rs->buf, &rs->buf_size, 0);
4771 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
4777 case PACKET_UNKNOWN:
4782 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4783 bp_tgt->placed_size = bp_tgt->shadow_len = sizeof big_break_insn;
4784 val = target_read_memory (addr, bp_tgt->shadow_contents, bp_tgt->shadow_len);
4788 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
4789 val = target_write_memory (addr, (char *) big_break_insn,
4790 sizeof big_break_insn);
4792 val = target_write_memory (addr, (char *) little_break_insn,
4793 sizeof little_break_insn);
4798 return memory_insert_breakpoint (bp_tgt);
4799 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4803 remote_remove_breakpoint (struct bp_target_info *bp_tgt)
4805 CORE_ADDR addr = bp_tgt->placed_address;
4806 struct remote_state *rs = get_remote_state ();
4809 if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
4817 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
4818 p += hexnumstr (p, addr);
4819 sprintf (p, ",%d", bp_tgt->placed_size);
4822 getpkt (&rs->buf, &rs->buf_size, 0);
4824 return (rs->buf[0] == 'E');
4827 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4828 return target_write_memory (bp_tgt->placed_address, bp_tgt->shadow_contents,
4829 bp_tgt->shadow_len);
4831 return memory_remove_breakpoint (bp_tgt);
4832 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4836 watchpoint_to_Z_packet (int type)
4841 return Z_PACKET_WRITE_WP;
4844 return Z_PACKET_READ_WP;
4847 return Z_PACKET_ACCESS_WP;
4850 internal_error (__FILE__, __LINE__,
4851 _("hw_bp_to_z: bad watchpoint type %d"), type);
4856 remote_insert_watchpoint (CORE_ADDR addr, int len, int type)
4858 struct remote_state *rs = get_remote_state ();
4860 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
4862 if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
4865 sprintf (rs->buf, "Z%x,", packet);
4866 p = strchr (rs->buf, '\0');
4867 addr = remote_address_masked (addr);
4868 p += hexnumstr (p, (ULONGEST) addr);
4869 sprintf (p, ",%x", len);
4872 getpkt (&rs->buf, &rs->buf_size, 0);
4874 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
4877 case PACKET_UNKNOWN:
4882 internal_error (__FILE__, __LINE__,
4883 _("remote_insert_watchpoint: reached end of function"));
4888 remote_remove_watchpoint (CORE_ADDR addr, int len, int type)
4890 struct remote_state *rs = get_remote_state ();
4892 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
4894 if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
4897 sprintf (rs->buf, "z%x,", packet);
4898 p = strchr (rs->buf, '\0');
4899 addr = remote_address_masked (addr);
4900 p += hexnumstr (p, (ULONGEST) addr);
4901 sprintf (p, ",%x", len);
4903 getpkt (&rs->buf, &rs->buf_size, 0);
4905 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
4908 case PACKET_UNKNOWN:
4913 internal_error (__FILE__, __LINE__,
4914 _("remote_remove_watchpoint: reached end of function"));
4918 int remote_hw_watchpoint_limit = -1;
4919 int remote_hw_breakpoint_limit = -1;
4922 remote_check_watch_resources (int type, int cnt, int ot)
4924 if (type == bp_hardware_breakpoint)
4926 if (remote_hw_breakpoint_limit == 0)
4928 else if (remote_hw_breakpoint_limit < 0)
4930 else if (cnt <= remote_hw_breakpoint_limit)
4935 if (remote_hw_watchpoint_limit == 0)
4937 else if (remote_hw_watchpoint_limit < 0)
4941 else if (cnt <= remote_hw_watchpoint_limit)
4948 remote_stopped_by_watchpoint (void)
4950 return remote_stopped_by_watchpoint_p;
4953 extern int stepped_after_stopped_by_watchpoint;
4956 remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
4959 if (remote_stopped_by_watchpoint ()
4960 || stepped_after_stopped_by_watchpoint)
4962 *addr_p = remote_watch_data_address;
4971 remote_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
4974 struct remote_state *rs = get_remote_state ();
4977 /* The length field should be set to the size of a breakpoint
4978 instruction, even though we aren't inserting one ourselves. */
4980 BREAKPOINT_FROM_PC (&bp_tgt->placed_address, &bp_tgt->placed_size);
4982 if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
4989 addr = remote_address_masked (bp_tgt->placed_address);
4990 p += hexnumstr (p, (ULONGEST) addr);
4991 sprintf (p, ",%x", bp_tgt->placed_size);
4994 getpkt (&rs->buf, &rs->buf_size, 0);
4996 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
4999 case PACKET_UNKNOWN:
5004 internal_error (__FILE__, __LINE__,
5005 _("remote_insert_hw_breakpoint: reached end of function"));
5010 remote_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
5013 struct remote_state *rs = get_remote_state ();
5016 if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
5023 addr = remote_address_masked (bp_tgt->placed_address);
5024 p += hexnumstr (p, (ULONGEST) addr);
5025 sprintf (p, ",%x", bp_tgt->placed_size);
5028 getpkt (&rs->buf, &rs->buf_size, 0);
5030 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
5033 case PACKET_UNKNOWN:
5038 internal_error (__FILE__, __LINE__,
5039 _("remote_remove_hw_breakpoint: reached end of function"));
5042 /* Some targets are only capable of doing downloads, and afterwards
5043 they switch to the remote serial protocol. This function provides
5044 a clean way to get from the download target to the remote target.
5045 It's basically just a wrapper so that we don't have to expose any
5046 of the internal workings of remote.c.
5048 Prior to calling this routine, you should shutdown the current
5049 target code, else you will get the "A program is being debugged
5050 already..." message. Usually a call to pop_target() suffices. */
5053 push_remote_target (char *name, int from_tty)
5055 printf_filtered (_("Switching to remote protocol\n"));
5056 remote_open (name, from_tty);
5059 /* Table used by the crc32 function to calcuate the checksum. */
5061 static unsigned long crc32_table[256] =
5064 static unsigned long
5065 crc32 (unsigned char *buf, int len, unsigned int crc)
5067 if (!crc32_table[1])
5069 /* Initialize the CRC table and the decoding table. */
5073 for (i = 0; i < 256; i++)
5075 for (c = i << 24, j = 8; j > 0; --j)
5076 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
5083 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
5089 /* compare-sections command
5091 With no arguments, compares each loadable section in the exec bfd
5092 with the same memory range on the target, and reports mismatches.
5093 Useful for verifying the image on the target against the exec file.
5094 Depends on the target understanding the new "qCRC:" request. */
5096 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5097 target method (target verify memory) and generic version of the
5098 actual command. This will allow other high-level code (especially
5099 generic_load()) to make use of this target functionality. */
5102 compare_sections_command (char *args, int from_tty)
5104 struct remote_state *rs = get_remote_state ();
5106 unsigned long host_crc, target_crc;
5107 extern bfd *exec_bfd;
5108 struct cleanup *old_chain;
5111 const char *sectname;
5118 error (_("command cannot be used without an exec file"));
5119 if (!current_target.to_shortname ||
5120 strcmp (current_target.to_shortname, "remote") != 0)
5121 error (_("command can only be used with remote target"));
5123 for (s = exec_bfd->sections; s; s = s->next)
5125 if (!(s->flags & SEC_LOAD))
5126 continue; /* skip non-loadable section */
5128 size = bfd_get_section_size (s);
5130 continue; /* skip zero-length section */
5132 sectname = bfd_get_section_name (exec_bfd, s);
5133 if (args && strcmp (args, sectname) != 0)
5134 continue; /* not the section selected by user */
5136 matched = 1; /* do this section */
5138 /* FIXME: assumes lma can fit into long. */
5139 xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
5140 (long) lma, (long) size);
5143 /* Be clever; compute the host_crc before waiting for target
5145 sectdata = xmalloc (size);
5146 old_chain = make_cleanup (xfree, sectdata);
5147 bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
5148 host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff);
5150 getpkt (&rs->buf, &rs->buf_size, 0);
5151 if (rs->buf[0] == 'E')
5152 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5153 sectname, paddr (lma), paddr (lma + size));
5154 if (rs->buf[0] != 'C')
5155 error (_("remote target does not support this operation"));
5157 for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
5158 target_crc = target_crc * 16 + fromhex (*tmp);
5160 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5161 sectname, paddr (lma), paddr (lma + size));
5162 if (host_crc == target_crc)
5163 printf_filtered ("matched.\n");
5166 printf_filtered ("MIS-MATCHED!\n");
5170 do_cleanups (old_chain);
5173 warning (_("One or more sections of the remote executable does not match\n\
5174 the loaded file\n"));
5175 if (args && !matched)
5176 printf_filtered (_("No loaded section named '%s'.\n"), args);
5179 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5180 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5181 number of bytes read is returned, or 0 for EOF, or -1 for error.
5182 The number of bytes read may be less than LEN without indicating an
5183 EOF. PACKET is checked and updated to indicate whether the remote
5184 target supports this object. */
5187 remote_read_qxfer (struct target_ops *ops, const char *object_name,
5189 gdb_byte *readbuf, ULONGEST offset, LONGEST len,
5190 struct packet_config *packet)
5192 static char *finished_object;
5193 static char *finished_annex;
5194 static ULONGEST finished_offset;
5196 struct remote_state *rs = get_remote_state ();
5197 unsigned int total = 0;
5198 LONGEST i, n, packet_len;
5200 if (packet->support == PACKET_DISABLE)
5203 /* Check whether we've cached an end-of-object packet that matches
5205 if (finished_object)
5207 if (strcmp (object_name, finished_object) == 0
5208 && strcmp (annex ? annex : "", finished_annex) == 0
5209 && offset == finished_offset)
5212 /* Otherwise, we're now reading something different. Discard
5214 xfree (finished_object);
5215 xfree (finished_annex);
5216 finished_object = NULL;
5217 finished_annex = NULL;
5220 /* Request only enough to fit in a single packet. The actual data
5221 may not, since we don't know how much of it will need to be escaped;
5222 the target is free to respond with slightly less data. We subtract
5223 five to account for the response type and the protocol frame. */
5224 n = min (get_remote_packet_size () - 5, len);
5225 snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5226 object_name, annex ? annex : "",
5227 phex_nz (offset, sizeof offset),
5228 phex_nz (n, sizeof n));
5229 i = putpkt (rs->buf);
5234 packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0);
5235 if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
5238 if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
5239 error (_("Unknown remote qXfer reply: %s"), rs->buf);
5241 /* 'm' means there is (or at least might be) more data after this
5242 batch. That does not make sense unless there's at least one byte
5243 of data in this reply. */
5244 if (rs->buf[0] == 'm' && packet_len == 1)
5245 error (_("Remote qXfer reply contained no data."));
5247 /* Got some data. */
5248 i = remote_unescape_input (rs->buf + 1, packet_len - 1, readbuf, n);
5250 /* 'l' is an EOF marker, possibly including a final block of data,
5251 or possibly empty. Record it to bypass the next read, if one is
5253 if (rs->buf[0] == 'l')
5255 finished_object = xstrdup (object_name);
5256 finished_annex = xstrdup (annex ? annex : "");
5257 finished_offset = offset + i;
5264 remote_xfer_partial (struct target_ops *ops, enum target_object object,
5265 const char *annex, gdb_byte *readbuf,
5266 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
5268 struct remote_state *rs = get_remote_state ();
5273 /* Handle memory using remote_xfer_memory. */
5274 if (object == TARGET_OBJECT_MEMORY)
5279 if (writebuf != NULL)
5281 void *buffer = xmalloc (len);
5282 struct cleanup *cleanup = make_cleanup (xfree, buffer);
5283 memcpy (buffer, writebuf, len);
5284 xfered = remote_xfer_memory (offset, buffer, len, 1, NULL, ops);
5285 do_cleanups (cleanup);
5288 xfered = remote_xfer_memory (offset, readbuf, len, 0, NULL, ops);
5292 else if (xfered == 0 && errno == 0)
5298 /* Only handle reads. */
5299 if (writebuf != NULL || readbuf == NULL)
5302 /* Map pre-existing objects onto letters. DO NOT do this for new
5303 objects!!! Instead specify new query packets. */
5306 case TARGET_OBJECT_AVR:
5310 case TARGET_OBJECT_AUXV:
5311 gdb_assert (annex == NULL);
5312 return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
5313 &remote_protocol_packets[PACKET_qXfer_auxv]);
5319 /* Note: a zero OFFSET and LEN can be used to query the minimum
5321 if (offset == 0 && len == 0)
5322 return (get_remote_packet_size ());
5323 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5324 large enough let the caller deal with it. */
5325 if (len < get_remote_packet_size ())
5327 len = get_remote_packet_size ();
5329 /* Except for querying the minimum buffer size, target must be open. */
5331 error (_("remote query is only available after target open"));
5333 gdb_assert (annex != NULL);
5334 gdb_assert (readbuf != NULL);
5340 /* We used one buffer char for the remote protocol q command and
5341 another for the query type. As the remote protocol encapsulation
5342 uses 4 chars plus one extra in case we are debugging
5343 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5346 while (annex[i] && (i < (get_remote_packet_size () - 8)))
5348 /* Bad caller may have sent forbidden characters. */
5349 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
5354 gdb_assert (annex[i] == '\0');
5356 i = putpkt (rs->buf);
5360 getpkt (&rs->buf, &rs->buf_size, 0);
5361 strcpy ((char *) readbuf, rs->buf);
5363 return strlen ((char *) readbuf);
5367 remote_rcmd (char *command,
5368 struct ui_file *outbuf)
5370 struct remote_state *rs = get_remote_state ();
5371 char *buf = rs->buf;
5375 error (_("remote rcmd is only available after target open"));
5377 /* Send a NULL command across as an empty command. */
5378 if (command == NULL)
5381 /* The query prefix. */
5382 strcpy (buf, "qRcmd,");
5383 p = strchr (buf, '\0');
5385 if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ())
5386 error (_("\"monitor\" command ``%s'' is too long."), command);
5388 /* Encode the actual command. */
5389 bin2hex ((gdb_byte *) command, p, 0);
5391 if (putpkt (rs->buf) < 0)
5392 error (_("Communication problem with target."));
5394 /* get/display the response */
5397 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5399 getpkt (&rs->buf, &rs->buf_size, 0);
5401 error (_("Target does not support this command."));
5402 if (buf[0] == 'O' && buf[1] != 'K')
5404 remote_console_output (buf + 1); /* 'O' message from stub. */
5407 if (strcmp (buf, "OK") == 0)
5409 if (strlen (buf) == 3 && buf[0] == 'E'
5410 && isdigit (buf[1]) && isdigit (buf[2]))
5412 error (_("Protocol error with Rcmd"));
5414 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
5416 char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
5417 fputc_unfiltered (c, outbuf);
5424 packet_command (char *args, int from_tty)
5426 struct remote_state *rs = get_remote_state ();
5429 error (_("command can only be used with remote target"));
5432 error (_("remote-packet command requires packet text as argument"));
5434 puts_filtered ("sending: ");
5435 print_packet (args);
5436 puts_filtered ("\n");
5439 getpkt (&rs->buf, &rs->buf_size, 0);
5440 puts_filtered ("received: ");
5441 print_packet (rs->buf);
5442 puts_filtered ("\n");
5446 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5448 static void display_thread_info (struct gdb_ext_thread_info *info);
5450 static void threadset_test_cmd (char *cmd, int tty);
5452 static void threadalive_test (char *cmd, int tty);
5454 static void threadlist_test_cmd (char *cmd, int tty);
5456 int get_and_display_threadinfo (threadref *ref);
5458 static void threadinfo_test_cmd (char *cmd, int tty);
5460 static int thread_display_step (threadref *ref, void *context);
5462 static void threadlist_update_test_cmd (char *cmd, int tty);
5464 static void init_remote_threadtests (void);
5466 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
5469 threadset_test_cmd (char *cmd, int tty)
5471 int sample_thread = SAMPLE_THREAD;
5473 printf_filtered (_("Remote threadset test\n"));
5474 set_thread (sample_thread, 1);
5479 threadalive_test (char *cmd, int tty)
5481 int sample_thread = SAMPLE_THREAD;
5483 if (remote_thread_alive (pid_to_ptid (sample_thread)))
5484 printf_filtered ("PASS: Thread alive test\n");
5486 printf_filtered ("FAIL: Thread alive test\n");
5489 void output_threadid (char *title, threadref *ref);
5492 output_threadid (char *title, threadref *ref)
5496 pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */
5498 printf_filtered ("%s %s\n", title, (&hexid[0]));
5502 threadlist_test_cmd (char *cmd, int tty)
5505 threadref nextthread;
5506 int done, result_count;
5507 threadref threadlist[3];
5509 printf_filtered ("Remote Threadlist test\n");
5510 if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
5511 &result_count, &threadlist[0]))
5512 printf_filtered ("FAIL: threadlist test\n");
5515 threadref *scan = threadlist;
5516 threadref *limit = scan + result_count;
5518 while (scan < limit)
5519 output_threadid (" thread ", scan++);
5524 display_thread_info (struct gdb_ext_thread_info *info)
5526 output_threadid ("Threadid: ", &info->threadid);
5527 printf_filtered ("Name: %s\n ", info->shortname);
5528 printf_filtered ("State: %s\n", info->display);
5529 printf_filtered ("other: %s\n\n", info->more_display);
5533 get_and_display_threadinfo (threadref *ref)
5537 struct gdb_ext_thread_info threadinfo;
5539 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
5540 | TAG_MOREDISPLAY | TAG_DISPLAY;
5541 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
5542 display_thread_info (&threadinfo);
5547 threadinfo_test_cmd (char *cmd, int tty)
5549 int athread = SAMPLE_THREAD;
5553 int_to_threadref (&thread, athread);
5554 printf_filtered ("Remote Threadinfo test\n");
5555 if (!get_and_display_threadinfo (&thread))
5556 printf_filtered ("FAIL cannot get thread info\n");
5560 thread_display_step (threadref *ref, void *context)
5562 /* output_threadid(" threadstep ",ref); *//* simple test */
5563 return get_and_display_threadinfo (ref);
5567 threadlist_update_test_cmd (char *cmd, int tty)
5569 printf_filtered ("Remote Threadlist update test\n");
5570 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
5574 init_remote_threadtests (void)
5576 add_com ("tlist", class_obscure, threadlist_test_cmd, _("\
5577 Fetch and print the remote list of thread identifiers, one pkt only"));
5578 add_com ("tinfo", class_obscure, threadinfo_test_cmd,
5579 _("Fetch and display info about one thread"));
5580 add_com ("tset", class_obscure, threadset_test_cmd,
5581 _("Test setting to a different thread"));
5582 add_com ("tupd", class_obscure, threadlist_update_test_cmd,
5583 _("Iterate through updating all remote thread info"));
5584 add_com ("talive", class_obscure, threadalive_test,
5585 _(" Remote thread alive test "));
5590 /* Convert a thread ID to a string. Returns the string in a static
5594 remote_pid_to_str (ptid_t ptid)
5596 static char buf[32];
5598 xsnprintf (buf, sizeof buf, "thread %d", ptid_get_pid (ptid));
5602 /* Get the address of the thread local variable in OBJFILE which is
5603 stored at OFFSET within the thread local storage for thread PTID. */
5606 remote_get_thread_local_address (ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
5608 if (remote_protocol_packets[PACKET_qGetTLSAddr].support != PACKET_DISABLE)
5610 struct remote_state *rs = get_remote_state ();
5612 enum packet_result result;
5614 strcpy (p, "qGetTLSAddr:");
5616 p += hexnumstr (p, PIDGET (ptid));
5618 p += hexnumstr (p, offset);
5620 p += hexnumstr (p, lm);
5624 getpkt (&rs->buf, &rs->buf_size, 0);
5625 result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_qGetTLSAddr]);
5626 if (result == PACKET_OK)
5630 unpack_varlen_hex (rs->buf, &result);
5633 else if (result == PACKET_UNKNOWN)
5634 throw_error (TLS_GENERIC_ERROR,
5635 _("Remote target doesn't support qGetTLSAddr packet"));
5637 throw_error (TLS_GENERIC_ERROR,
5638 _("Remote target failed to process qGetTLSAddr request"));
5641 throw_error (TLS_GENERIC_ERROR,
5642 _("TLS not supported or disabled on this target"));
5648 init_remote_ops (void)
5650 remote_ops.to_shortname = "remote";
5651 remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
5653 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5654 Specify the serial device it is connected to\n\
5655 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
5656 remote_ops.to_open = remote_open;
5657 remote_ops.to_close = remote_close;
5658 remote_ops.to_detach = remote_detach;
5659 remote_ops.to_disconnect = remote_disconnect;
5660 remote_ops.to_resume = remote_resume;
5661 remote_ops.to_wait = remote_wait;
5662 remote_ops.to_fetch_registers = remote_fetch_registers;
5663 remote_ops.to_store_registers = remote_store_registers;
5664 remote_ops.to_prepare_to_store = remote_prepare_to_store;
5665 remote_ops.deprecated_xfer_memory = remote_xfer_memory;
5666 remote_ops.to_files_info = remote_files_info;
5667 remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
5668 remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
5669 remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
5670 remote_ops.to_stopped_data_address = remote_stopped_data_address;
5671 remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
5672 remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
5673 remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
5674 remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
5675 remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
5676 remote_ops.to_kill = remote_kill;
5677 remote_ops.to_load = generic_load;
5678 remote_ops.to_mourn_inferior = remote_mourn;
5679 remote_ops.to_thread_alive = remote_thread_alive;
5680 remote_ops.to_find_new_threads = remote_threads_info;
5681 remote_ops.to_pid_to_str = remote_pid_to_str;
5682 remote_ops.to_extra_thread_info = remote_threads_extra_info;
5683 remote_ops.to_stop = remote_stop;
5684 remote_ops.to_xfer_partial = remote_xfer_partial;
5685 remote_ops.to_rcmd = remote_rcmd;
5686 remote_ops.to_get_thread_local_address = remote_get_thread_local_address;
5687 remote_ops.to_stratum = process_stratum;
5688 remote_ops.to_has_all_memory = 1;
5689 remote_ops.to_has_memory = 1;
5690 remote_ops.to_has_stack = 1;
5691 remote_ops.to_has_registers = 1;
5692 remote_ops.to_has_execution = 1;
5693 remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
5694 remote_ops.to_magic = OPS_MAGIC;
5697 /* Set up the extended remote vector by making a copy of the standard
5698 remote vector and adding to it. */
5701 init_extended_remote_ops (void)
5703 extended_remote_ops = remote_ops;
5705 extended_remote_ops.to_shortname = "extended-remote";
5706 extended_remote_ops.to_longname =
5707 "Extended remote serial target in gdb-specific protocol";
5708 extended_remote_ops.to_doc =
5709 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5710 Specify the serial device it is connected to (e.g. /dev/ttya).",
5711 extended_remote_ops.to_open = extended_remote_open;
5712 extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
5713 extended_remote_ops.to_mourn_inferior = extended_remote_mourn;
5717 remote_can_async_p (void)
5719 /* We're async whenever the serial device is. */
5720 return (current_target.to_async_mask_value) && serial_can_async_p (remote_desc);
5724 remote_is_async_p (void)
5726 /* We're async whenever the serial device is. */
5727 return (current_target.to_async_mask_value) && serial_is_async_p (remote_desc);
5730 /* Pass the SERIAL event on and up to the client. One day this code
5731 will be able to delay notifying the client of an event until the
5732 point where an entire packet has been received. */
5734 static void (*async_client_callback) (enum inferior_event_type event_type,
5736 static void *async_client_context;
5737 static serial_event_ftype remote_async_serial_handler;
5740 remote_async_serial_handler (struct serial *scb, void *context)
5742 /* Don't propogate error information up to the client. Instead let
5743 the client find out about the error by querying the target. */
5744 async_client_callback (INF_REG_EVENT, async_client_context);
5748 remote_async (void (*callback) (enum inferior_event_type event_type,
5749 void *context), void *context)
5751 if (current_target.to_async_mask_value == 0)
5752 internal_error (__FILE__, __LINE__,
5753 _("Calling remote_async when async is masked"));
5755 if (callback != NULL)
5757 serial_async (remote_desc, remote_async_serial_handler, NULL);
5758 async_client_callback = callback;
5759 async_client_context = context;
5762 serial_async (remote_desc, NULL, NULL);
5765 /* Target async and target extended-async.
5767 This are temporary targets, until it is all tested. Eventually
5768 async support will be incorporated int the usual 'remote'
5772 init_remote_async_ops (void)
5774 remote_async_ops.to_shortname = "async";
5775 remote_async_ops.to_longname =
5776 "Remote serial target in async version of the gdb-specific protocol";
5777 remote_async_ops.to_doc =
5778 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5779 Specify the serial device it is connected to (e.g. /dev/ttya).";
5780 remote_async_ops.to_open = remote_async_open;
5781 remote_async_ops.to_close = remote_close;
5782 remote_async_ops.to_detach = remote_detach;
5783 remote_async_ops.to_disconnect = remote_disconnect;
5784 remote_async_ops.to_resume = remote_async_resume;
5785 remote_async_ops.to_wait = remote_async_wait;
5786 remote_async_ops.to_fetch_registers = remote_fetch_registers;
5787 remote_async_ops.to_store_registers = remote_store_registers;
5788 remote_async_ops.to_prepare_to_store = remote_prepare_to_store;
5789 remote_async_ops.deprecated_xfer_memory = remote_xfer_memory;
5790 remote_async_ops.to_files_info = remote_files_info;
5791 remote_async_ops.to_insert_breakpoint = remote_insert_breakpoint;
5792 remote_async_ops.to_remove_breakpoint = remote_remove_breakpoint;
5793 remote_async_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
5794 remote_async_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
5795 remote_async_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
5796 remote_async_ops.to_insert_watchpoint = remote_insert_watchpoint;
5797 remote_async_ops.to_remove_watchpoint = remote_remove_watchpoint;
5798 remote_async_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
5799 remote_async_ops.to_stopped_data_address = remote_stopped_data_address;
5800 remote_async_ops.to_terminal_inferior = remote_async_terminal_inferior;
5801 remote_async_ops.to_terminal_ours = remote_async_terminal_ours;
5802 remote_async_ops.to_kill = remote_async_kill;
5803 remote_async_ops.to_load = generic_load;
5804 remote_async_ops.to_mourn_inferior = remote_async_mourn;
5805 remote_async_ops.to_thread_alive = remote_thread_alive;
5806 remote_async_ops.to_find_new_threads = remote_threads_info;
5807 remote_async_ops.to_pid_to_str = remote_pid_to_str;
5808 remote_async_ops.to_extra_thread_info = remote_threads_extra_info;
5809 remote_async_ops.to_stop = remote_stop;
5810 remote_async_ops.to_xfer_partial = remote_xfer_partial;
5811 remote_async_ops.to_rcmd = remote_rcmd;
5812 remote_async_ops.to_stratum = process_stratum;
5813 remote_async_ops.to_has_all_memory = 1;
5814 remote_async_ops.to_has_memory = 1;
5815 remote_async_ops.to_has_stack = 1;
5816 remote_async_ops.to_has_registers = 1;
5817 remote_async_ops.to_has_execution = 1;
5818 remote_async_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
5819 remote_async_ops.to_can_async_p = remote_can_async_p;
5820 remote_async_ops.to_is_async_p = remote_is_async_p;
5821 remote_async_ops.to_async = remote_async;
5822 remote_async_ops.to_async_mask_value = 1;
5823 remote_async_ops.to_magic = OPS_MAGIC;
5826 /* Set up the async extended remote vector by making a copy of the standard
5827 remote vector and adding to it. */
5830 init_extended_async_remote_ops (void)
5832 extended_async_remote_ops = remote_async_ops;
5834 extended_async_remote_ops.to_shortname = "extended-async";
5835 extended_async_remote_ops.to_longname =
5836 "Extended remote serial target in async gdb-specific protocol";
5837 extended_async_remote_ops.to_doc =
5838 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
5839 Specify the serial device it is connected to (e.g. /dev/ttya).",
5840 extended_async_remote_ops.to_open = extended_remote_async_open;
5841 extended_async_remote_ops.to_create_inferior = extended_remote_async_create_inferior;
5842 extended_async_remote_ops.to_mourn_inferior = extended_remote_mourn;
5846 set_remote_cmd (char *args, int from_tty)
5851 show_remote_cmd (char *args, int from_tty)
5853 /* We can't just use cmd_show_list here, because we want to skip
5854 the redundant "show remote Z-packet". */
5855 struct cleanup *showlist_chain;
5856 struct cmd_list_element *list = remote_show_cmdlist;
5858 showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
5859 for (; list != NULL; list = list->next)
5860 if (strcmp (list->name, "Z-packet") == 0)
5862 else if (list->type == show_cmd)
5864 struct cleanup *option_chain
5865 = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
5866 ui_out_field_string (uiout, "name", list->name);
5867 ui_out_text (uiout, ": ");
5868 do_setshow_command ((char *) NULL, from_tty, list);
5869 /* Close the tuple. */
5870 do_cleanups (option_chain);
5875 build_remote_gdbarch_data (void)
5877 remote_address_size = TARGET_ADDR_BIT;
5880 /* Saved pointer to previous owner of the new_objfile event. */
5881 static void (*remote_new_objfile_chain) (struct objfile *);
5883 /* Function to be called whenever a new objfile (shlib) is detected. */
5885 remote_new_objfile (struct objfile *objfile)
5887 if (remote_desc != 0) /* Have a remote connection. */
5889 remote_check_symbols (objfile);
5891 /* Call predecessor on chain, if any. */
5892 if (remote_new_objfile_chain != 0 &&
5894 remote_new_objfile_chain (objfile);
5898 _initialize_remote (void)
5900 struct remote_state *rs;
5902 /* architecture specific data */
5903 remote_gdbarch_data_handle =
5904 gdbarch_data_register_post_init (init_remote_state);
5906 /* Old tacky stuff. NOTE: This comes after the remote protocol so
5907 that the remote protocol has been initialized. */
5908 DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size);
5909 deprecated_register_gdbarch_swap (NULL, 0, build_remote_gdbarch_data);
5911 /* Initialize the per-target state. At the moment there is only one
5912 of these, not one per target. Only one target is active at a
5913 time. The default buffer size is unimportant; it will be expanded
5914 whenever a larger buffer is needed. */
5915 rs = get_remote_state ();
5917 rs->buf = xmalloc (rs->buf_size);
5920 add_target (&remote_ops);
5922 init_extended_remote_ops ();
5923 add_target (&extended_remote_ops);
5925 init_remote_async_ops ();
5926 add_target (&remote_async_ops);
5928 init_extended_async_remote_ops ();
5929 add_target (&extended_async_remote_ops);
5931 /* Hook into new objfile notification. */
5932 remote_new_objfile_chain = deprecated_target_new_objfile_hook;
5933 deprecated_target_new_objfile_hook = remote_new_objfile;
5936 init_remote_threadtests ();
5939 /* set/show remote ... */
5941 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
5942 Remote protocol specific variables\n\
5943 Configure various remote-protocol specific variables such as\n\
5944 the packets being used"),
5945 &remote_set_cmdlist, "set remote ",
5946 0 /* allow-unknown */, &setlist);
5947 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
5948 Remote protocol specific variables\n\
5949 Configure various remote-protocol specific variables such as\n\
5950 the packets being used"),
5951 &remote_show_cmdlist, "show remote ",
5952 0 /* allow-unknown */, &showlist);
5954 add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
5955 Compare section data on target to the exec file.\n\
5956 Argument is a single section name (default: all loaded sections)."),
5959 add_cmd ("packet", class_maintenance, packet_command, _("\
5960 Send an arbitrary packet to a remote target.\n\
5961 maintenance packet TEXT\n\
5962 If GDB is talking to an inferior via the GDB serial protocol, then\n\
5963 this command sends the string TEXT to the inferior, and displays the\n\
5964 response packet. GDB supplies the initial `$' character, and the\n\
5965 terminating `#' character and checksum."),
5968 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
5969 Set whether to send break if interrupted."), _("\
5970 Show whether to send break if interrupted."), _("\
5971 If set, a break, instead of a cntrl-c, is sent to the remote target."),
5972 NULL, NULL, /* FIXME: i18n: Whether to send break if interrupted is %s. */
5973 &setlist, &showlist);
5975 /* Install commands for configuring memory read/write packets. */
5977 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\
5978 Set the maximum number of bytes per memory write packet (deprecated)."),
5980 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\
5981 Show the maximum number of bytes per memory write packet (deprecated)."),
5983 add_cmd ("memory-write-packet-size", no_class,
5984 set_memory_write_packet_size, _("\
5985 Set the maximum number of bytes per memory-write packet.\n\
5986 Specify the number of bytes in a packet or 0 (zero) for the\n\
5987 default packet size. The actual limit is further reduced\n\
5988 dependent on the target. Specify ``fixed'' to disable the\n\
5989 further restriction and ``limit'' to enable that restriction."),
5990 &remote_set_cmdlist);
5991 add_cmd ("memory-read-packet-size", no_class,
5992 set_memory_read_packet_size, _("\
5993 Set the maximum number of bytes per memory-read packet.\n\
5994 Specify the number of bytes in a packet or 0 (zero) for the\n\
5995 default packet size. The actual limit is further reduced\n\
5996 dependent on the target. Specify ``fixed'' to disable the\n\
5997 further restriction and ``limit'' to enable that restriction."),
5998 &remote_set_cmdlist);
5999 add_cmd ("memory-write-packet-size", no_class,
6000 show_memory_write_packet_size,
6001 _("Show the maximum number of bytes per memory-write packet."),
6002 &remote_show_cmdlist);
6003 add_cmd ("memory-read-packet-size", no_class,
6004 show_memory_read_packet_size,
6005 _("Show the maximum number of bytes per memory-read packet."),
6006 &remote_show_cmdlist);
6008 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class,
6009 &remote_hw_watchpoint_limit, _("\
6010 Set the maximum number of target hardware watchpoints."), _("\
6011 Show the maximum number of target hardware watchpoints."), _("\
6012 Specify a negative limit for unlimited."),
6013 NULL, NULL, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6014 &remote_set_cmdlist, &remote_show_cmdlist);
6015 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class,
6016 &remote_hw_breakpoint_limit, _("\
6017 Set the maximum number of target hardware breakpoints."), _("\
6018 Show the maximum number of target hardware breakpoints."), _("\
6019 Specify a negative limit for unlimited."),
6020 NULL, NULL, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6021 &remote_set_cmdlist, &remote_show_cmdlist);
6023 add_setshow_integer_cmd ("remoteaddresssize", class_obscure,
6024 &remote_address_size, _("\
6025 Set the maximum size of the address (in bits) in a memory packet."), _("\
6026 Show the maximum size of the address (in bits) in a memory packet."), NULL,
6028 NULL, /* FIXME: i18n: */
6029 &setlist, &showlist);
6031 add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
6032 "X", "binary-download", 1);
6034 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
6035 "vCont", "verbose-resume", 0);
6037 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
6038 "qSymbol", "symbol-lookup", 0);
6040 add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
6041 "P", "set-register", 1);
6043 add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
6044 "p", "fetch-register", 1);
6046 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
6047 "Z0", "software-breakpoint", 0);
6049 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
6050 "Z1", "hardware-breakpoint", 0);
6052 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
6053 "Z2", "write-watchpoint", 0);
6055 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
6056 "Z3", "read-watchpoint", 0);
6058 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
6059 "Z4", "access-watchpoint", 0);
6061 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
6062 "qXfer:auxv:read", "read-aux-vector", 0);
6064 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
6065 "qGetTLSAddr", "get-thread-local-storage-address",
6068 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
6069 "qSupported", "supported-packets", 0);
6071 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6072 Z sub-packet has its own set and show commands, but users may
6073 have sets to this variable in their .gdbinit files (or in their
6075 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
6076 &remote_Z_packet_detect, _("\
6077 Set use of remote protocol `Z' packets"), _("\
6078 Show use of remote protocol `Z' packets "), _("\
6079 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6081 set_remote_protocol_Z_packet_cmd,
6082 show_remote_protocol_Z_packet_cmd, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6083 &remote_set_cmdlist, &remote_show_cmdlist);
6085 /* Eventually initialize fileio. See fileio.c */
6086 initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);