1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
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., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, 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"
48 #include "event-loop.h"
49 #include "event-top.h"
55 #include "gdbcore.h" /* for exec_bfd */
57 #include "remote-fileio.h"
59 /* Prototypes for local functions. */
60 static void cleanup_sigint_signal_handler (void *dummy);
61 static void initialize_sigint_signal_handler (void);
62 static int getpkt_sane (char *buf, long sizeof_buf, int forever);
64 static void handle_remote_sigint (int);
65 static void handle_remote_sigint_twice (int);
66 static void async_remote_interrupt (gdb_client_data);
67 void async_remote_interrupt_twice (gdb_client_data);
69 static void build_remote_gdbarch_data (void);
71 static void remote_files_info (struct target_ops *ignore);
73 static int remote_xfer_memory (CORE_ADDR memaddr, char *myaddr,
74 int len, int should_write,
75 struct mem_attrib *attrib,
76 struct target_ops *target);
78 static void remote_prepare_to_store (void);
80 static void remote_fetch_registers (int regno);
82 static void remote_resume (ptid_t ptid, int step,
83 enum target_signal siggnal);
84 static void remote_async_resume (ptid_t ptid, int step,
85 enum target_signal siggnal);
86 static void remote_open (char *name, int from_tty);
87 static void remote_async_open (char *name, int from_tty);
89 static void extended_remote_open (char *name, int from_tty);
90 static void extended_remote_async_open (char *name, int from_tty);
92 static void remote_open_1 (char *, int, struct target_ops *, int extended_p,
95 static void remote_close (int quitting);
97 static void remote_store_registers (int regno);
99 static void remote_mourn (void);
100 static void remote_async_mourn (void);
102 static void extended_remote_restart (void);
104 static void extended_remote_mourn (void);
106 static void remote_mourn_1 (struct target_ops *);
108 static void remote_send (char *buf, long sizeof_buf);
110 static int readchar (int timeout);
112 static ptid_t remote_wait (ptid_t ptid,
113 struct target_waitstatus *status);
114 static ptid_t remote_async_wait (ptid_t ptid,
115 struct target_waitstatus *status);
117 static void remote_kill (void);
118 static void remote_async_kill (void);
120 static int tohex (int nib);
122 static void remote_detach (char *args, int from_tty);
124 static void remote_interrupt (int signo);
126 static void remote_interrupt_twice (int signo);
128 static void interrupt_query (void);
130 static void set_thread (int, int);
132 static int remote_thread_alive (ptid_t);
134 static void get_offsets (void);
136 static long read_frame (char *buf, long sizeof_buf);
138 static int remote_insert_breakpoint (CORE_ADDR, char *);
140 static int remote_remove_breakpoint (CORE_ADDR, char *);
142 static int hexnumlen (ULONGEST num);
144 static void init_remote_ops (void);
146 static void init_extended_remote_ops (void);
148 static void remote_stop (void);
150 static int ishex (int ch, int *val);
152 static int stubhex (int ch);
154 static int hexnumstr (char *, ULONGEST);
156 static int hexnumnstr (char *, ULONGEST, int);
158 static CORE_ADDR remote_address_masked (CORE_ADDR);
160 static void print_packet (char *);
162 static unsigned long crc32 (unsigned char *, int, unsigned int);
164 static void compare_sections_command (char *, int);
166 static void packet_command (char *, int);
168 static int stub_unpack_int (char *buff, int fieldlength);
170 static ptid_t remote_current_thread (ptid_t oldptid);
172 static void remote_find_new_threads (void);
174 static void record_currthread (int currthread);
176 static int fromhex (int a);
178 static int hex2bin (const char *hex, char *bin, int count);
180 static int bin2hex (const char *bin, char *hex, int count);
182 static int putpkt_binary (char *buf, int cnt);
184 static void check_binary_download (CORE_ADDR addr);
186 struct packet_config;
188 static void show_packet_config_cmd (struct packet_config *config);
190 static void update_packet_config (struct packet_config *config);
192 void _initialize_remote (void);
194 /* Description of the remote protocol. Strictly speaking, when the
195 target is open()ed, remote.c should create a per-target description
196 of the remote protocol using that target's architecture.
197 Unfortunately, the target stack doesn't include local state. For
198 the moment keep the information in the target's architecture
203 long offset; /* Offset into G packet. */
204 long regnum; /* GDB's internal register number. */
205 LONGEST pnum; /* Remote protocol register number. */
206 int in_g_packet; /* Always part of G packet. */
207 /* long size in bytes; == register_size (current_gdbarch, regnum);
209 /* char *name; == REGISTER_NAME (regnum); at present. */
214 /* Description of the remote protocol registers. */
215 long sizeof_g_packet;
217 /* Description of the remote protocol registers indexed by REGNUM
218 (making an array of NUM_REGS + NUM_PSEUDO_REGS in size). */
219 struct packet_reg *regs;
221 /* This is the size (in chars) of the first response to the ``g''
222 packet. It is used as a heuristic when determining the maximum
223 size of memory-read and memory-write packets. A target will
224 typically only reserve a buffer large enough to hold the ``g''
225 packet. The size does not include packet overhead (headers and
227 long actual_register_packet_size;
229 /* This is the maximum size (in chars) of a non read/write packet.
230 It is also used as a cap on the size of read/write packets. */
231 long remote_packet_size;
235 /* Handle for retreving the remote protocol data from gdbarch. */
236 static struct gdbarch_data *remote_gdbarch_data_handle;
238 static struct remote_state *
239 get_remote_state (void)
241 return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
245 init_remote_state (struct gdbarch *gdbarch)
248 struct remote_state *rs = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_state);
250 if (deprecated_register_bytes () != 0)
251 rs->sizeof_g_packet = deprecated_register_bytes ();
253 rs->sizeof_g_packet = 0;
255 /* Assume a 1:1 regnum<->pnum table. */
256 rs->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, NUM_REGS + NUM_PSEUDO_REGS,
258 for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
260 struct packet_reg *r = &rs->regs[regnum];
263 r->offset = DEPRECATED_REGISTER_BYTE (regnum);
264 r->in_g_packet = (regnum < NUM_REGS);
265 /* ...name = REGISTER_NAME (regnum); */
267 /* Compute packet size by accumulating the size of all registers. */
268 if (deprecated_register_bytes () == 0)
269 rs->sizeof_g_packet += register_size (current_gdbarch, regnum);
272 /* Default maximum number of characters in a packet body. Many
273 remote stubs have a hardwired buffer size of 400 bytes
274 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
275 as the maximum packet-size to ensure that the packet and an extra
276 NUL character can always fit in the buffer. This stops GDB
277 trashing stubs that try to squeeze an extra NUL into what is
278 already a full buffer (As of 1999-12-04 that was most stubs. */
279 rs->remote_packet_size = 400 - 1;
281 /* Should rs->sizeof_g_packet needs more space than the
282 default, adjust the size accordingly. Remember that each byte is
283 encoded as two characters. 32 is the overhead for the packet
284 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
285 (``$NN:G...#NN'') is a better guess, the below has been padded a
287 if (rs->sizeof_g_packet > ((rs->remote_packet_size - 32) / 2))
288 rs->remote_packet_size = (rs->sizeof_g_packet * 2 + 32);
290 /* This one is filled in when a ``g'' packet is received. */
291 rs->actual_register_packet_size = 0;
296 static struct packet_reg *
297 packet_reg_from_regnum (struct remote_state *rs, long regnum)
299 if (regnum < 0 && regnum >= NUM_REGS + NUM_PSEUDO_REGS)
303 struct packet_reg *r = &rs->regs[regnum];
304 gdb_assert (r->regnum == regnum);
309 static struct packet_reg *
310 packet_reg_from_pnum (struct remote_state *rs, LONGEST pnum)
313 for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
315 struct packet_reg *r = &rs->regs[i];
322 /* FIXME: graces/2002-08-08: These variables should eventually be
323 bound to an instance of the target object (as in gdbarch-tdep()),
324 when such a thing exists. */
326 /* This is set to the data address of the access causing the target
327 to stop for a watchpoint. */
328 static CORE_ADDR remote_watch_data_address;
330 /* This is non-zero if taregt stopped for a watchpoint. */
331 static int remote_stopped_by_watchpoint_p;
334 static struct target_ops remote_ops;
336 static struct target_ops extended_remote_ops;
338 /* Temporary target ops. Just like the remote_ops and
339 extended_remote_ops, but with asynchronous support. */
340 static struct target_ops remote_async_ops;
342 static struct target_ops extended_async_remote_ops;
344 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
345 ``forever'' still use the normal timeout mechanism. This is
346 currently used by the ASYNC code to guarentee that target reads
347 during the initial connect always time-out. Once getpkt has been
348 modified to return a timeout indication and, in turn
349 remote_wait()/wait_for_inferior() have gained a timeout parameter
351 static int wait_forever_enabled_p = 1;
354 /* This variable chooses whether to send a ^C or a break when the user
355 requests program interruption. Although ^C is usually what remote
356 systems expect, and that is the default here, sometimes a break is
357 preferable instead. */
359 static int remote_break;
361 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
362 remote_open knows that we don't have a file open when the program
364 static struct serial *remote_desc = NULL;
366 /* This variable sets the number of bits in an address that are to be
367 sent in a memory ("M" or "m") packet. Normally, after stripping
368 leading zeros, the entire address would be sent. This variable
369 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
370 initial implementation of remote.c restricted the address sent in
371 memory packets to ``host::sizeof long'' bytes - (typically 32
372 bits). Consequently, for 64 bit targets, the upper 32 bits of an
373 address was never sent. Since fixing this bug may cause a break in
374 some remote targets this variable is principly provided to
375 facilitate backward compatibility. */
377 static int remote_address_size;
379 /* Tempoary to track who currently owns the terminal. See
380 target_async_terminal_* for more details. */
382 static int remote_async_terminal_ours_p;
385 /* User configurable variables for the number of characters in a
386 memory read/write packet. MIN ((rs->remote_packet_size),
387 rs->sizeof_g_packet) is the default. Some targets need smaller
388 values (fifo overruns, et.al.) and some users need larger values
389 (speed up transfers). The variables ``preferred_*'' (the user
390 request), ``current_*'' (what was actually set) and ``forced_*''
391 (Positive - a soft limit, negative - a hard limit). */
393 struct memory_packet_config
400 /* Compute the current size of a read/write packet. Since this makes
401 use of ``actual_register_packet_size'' the computation is dynamic. */
404 get_memory_packet_size (struct memory_packet_config *config)
406 struct remote_state *rs = get_remote_state ();
407 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
408 law?) that some hosts don't cope very well with large alloca()
409 calls. Eventually the alloca() code will be replaced by calls to
410 xmalloc() and make_cleanups() allowing this restriction to either
411 be lifted or removed. */
412 #ifndef MAX_REMOTE_PACKET_SIZE
413 #define MAX_REMOTE_PACKET_SIZE 16384
415 /* NOTE: 16 is just chosen at random. */
416 #ifndef MIN_REMOTE_PACKET_SIZE
417 #define MIN_REMOTE_PACKET_SIZE 16
422 if (config->size <= 0)
423 what_they_get = MAX_REMOTE_PACKET_SIZE;
425 what_they_get = config->size;
429 what_they_get = (rs->remote_packet_size);
430 /* Limit the packet to the size specified by the user. */
432 && what_they_get > config->size)
433 what_they_get = config->size;
434 /* Limit it to the size of the targets ``g'' response. */
435 if ((rs->actual_register_packet_size) > 0
436 && what_they_get > (rs->actual_register_packet_size))
437 what_they_get = (rs->actual_register_packet_size);
439 if (what_they_get > MAX_REMOTE_PACKET_SIZE)
440 what_they_get = MAX_REMOTE_PACKET_SIZE;
441 if (what_they_get < MIN_REMOTE_PACKET_SIZE)
442 what_they_get = MIN_REMOTE_PACKET_SIZE;
443 return what_they_get;
446 /* Update the size of a read/write packet. If they user wants
447 something really big then do a sanity check. */
450 set_memory_packet_size (char *args, struct memory_packet_config *config)
452 int fixed_p = config->fixed_p;
453 long size = config->size;
455 error ("Argument required (integer, `fixed' or `limited').");
456 else if (strcmp (args, "hard") == 0
457 || strcmp (args, "fixed") == 0)
459 else if (strcmp (args, "soft") == 0
460 || strcmp (args, "limit") == 0)
465 size = strtoul (args, &end, 0);
467 error ("Invalid %s (bad syntax).", config->name);
469 /* Instead of explicitly capping the size of a packet to
470 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
471 instead allowed to set the size to something arbitrarily
473 if (size > MAX_REMOTE_PACKET_SIZE)
474 error ("Invalid %s (too large).", config->name);
478 if (fixed_p && !config->fixed_p)
480 if (! query ("The target may not be able to correctly handle a %s\n"
481 "of %ld bytes. Change the packet size? ",
483 error ("Packet size not changed.");
485 /* Update the config. */
486 config->fixed_p = fixed_p;
491 show_memory_packet_size (struct memory_packet_config *config)
493 printf_filtered ("The %s is %ld. ", config->name, config->size);
495 printf_filtered ("Packets are fixed at %ld bytes.\n",
496 get_memory_packet_size (config));
498 printf_filtered ("Packets are limited to %ld bytes.\n",
499 get_memory_packet_size (config));
502 static struct memory_packet_config memory_write_packet_config =
504 "memory-write-packet-size",
508 set_memory_write_packet_size (char *args, int from_tty)
510 set_memory_packet_size (args, &memory_write_packet_config);
514 show_memory_write_packet_size (char *args, int from_tty)
516 show_memory_packet_size (&memory_write_packet_config);
520 get_memory_write_packet_size (void)
522 return get_memory_packet_size (&memory_write_packet_config);
525 static struct memory_packet_config memory_read_packet_config =
527 "memory-read-packet-size",
531 set_memory_read_packet_size (char *args, int from_tty)
533 set_memory_packet_size (args, &memory_read_packet_config);
537 show_memory_read_packet_size (char *args, int from_tty)
539 show_memory_packet_size (&memory_read_packet_config);
543 get_memory_read_packet_size (void)
545 struct remote_state *rs = get_remote_state ();
546 long size = get_memory_packet_size (&memory_read_packet_config);
547 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
548 extra buffer size argument before the memory read size can be
549 increased beyond (rs->remote_packet_size). */
550 if (size > (rs->remote_packet_size))
551 size = (rs->remote_packet_size);
556 /* Generic configuration support for packets the stub optionally
557 supports. Allows the user to specify the use of the packet as well
558 as allowing GDB to auto-detect support in the remote stub. */
562 PACKET_SUPPORT_UNKNOWN = 0,
571 enum auto_boolean detect;
572 enum packet_support support;
575 /* Analyze a packet's return value and update the packet config
586 update_packet_config (struct packet_config *config)
588 switch (config->detect)
590 case AUTO_BOOLEAN_TRUE:
591 config->support = PACKET_ENABLE;
593 case AUTO_BOOLEAN_FALSE:
594 config->support = PACKET_DISABLE;
596 case AUTO_BOOLEAN_AUTO:
597 config->support = PACKET_SUPPORT_UNKNOWN;
603 show_packet_config_cmd (struct packet_config *config)
605 char *support = "internal-error";
606 switch (config->support)
612 support = "disabled";
614 case PACKET_SUPPORT_UNKNOWN:
618 switch (config->detect)
620 case AUTO_BOOLEAN_AUTO:
621 printf_filtered ("Support for remote protocol `%s' (%s) packet is auto-detected, currently %s.\n",
622 config->name, config->title, support);
624 case AUTO_BOOLEAN_TRUE:
625 case AUTO_BOOLEAN_FALSE:
626 printf_filtered ("Support for remote protocol `%s' (%s) packet is currently %s.\n",
627 config->name, config->title, support);
633 add_packet_config_cmd (struct packet_config *config,
636 cmd_sfunc_ftype *set_func,
637 cmd_sfunc_ftype *show_func,
638 struct cmd_list_element **set_remote_list,
639 struct cmd_list_element **show_remote_list,
642 struct cmd_list_element *set_cmd;
643 struct cmd_list_element *show_cmd;
650 config->title = title;
651 config->detect = AUTO_BOOLEAN_AUTO;
652 config->support = PACKET_SUPPORT_UNKNOWN;
653 set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
655 show_doc = xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
657 print = xstrprintf ("Current use of remote protocol `%s' (%s) is %%s",
659 /* set/show TITLE-packet {auto,on,off} */
660 cmd_name = xstrprintf ("%s-packet", title);
661 add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
662 &config->detect, set_doc, show_doc,
665 set_remote_list, show_remote_list);
666 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
670 legacy_name = xstrprintf ("%s-packet", name);
671 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
673 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
678 static enum packet_result
679 packet_ok (const char *buf, struct packet_config *config)
683 /* The stub recognized the packet request. Check that the
684 operation succeeded. */
685 switch (config->support)
687 case PACKET_SUPPORT_UNKNOWN:
689 fprintf_unfiltered (gdb_stdlog,
690 "Packet %s (%s) is supported\n",
691 config->name, config->title);
692 config->support = PACKET_ENABLE;
695 internal_error (__FILE__, __LINE__,
696 "packet_ok: attempt to use a disabled packet");
701 if (buf[0] == 'O' && buf[1] == 'K' && buf[2] == '\0')
702 /* "OK" - definitly OK. */
705 && isxdigit (buf[1]) && isxdigit (buf[2])
707 /* "Enn" - definitly an error. */
709 /* The packet may or may not be OK. Just assume it is. */
714 /* The stub does not support the packet. */
715 switch (config->support)
718 if (config->detect == AUTO_BOOLEAN_AUTO)
719 /* If the stub previously indicated that the packet was
720 supported then there is a protocol error.. */
721 error ("Protocol error: %s (%s) conflicting enabled responses.",
722 config->name, config->title);
724 /* The user set it wrong. */
725 error ("Enabled packet %s (%s) not recognized by stub",
726 config->name, config->title);
728 case PACKET_SUPPORT_UNKNOWN:
730 fprintf_unfiltered (gdb_stdlog,
731 "Packet %s (%s) is NOT supported\n",
732 config->name, config->title);
733 config->support = PACKET_DISABLE;
738 return PACKET_UNKNOWN;
742 /* Should we try the 'vCont' (descriptive resume) request? */
743 static struct packet_config remote_protocol_vcont;
746 set_remote_protocol_vcont_packet_cmd (char *args, int from_tty,
747 struct cmd_list_element *c)
749 update_packet_config (&remote_protocol_vcont);
753 show_remote_protocol_vcont_packet_cmd (char *args, int from_tty,
754 struct cmd_list_element *c)
756 show_packet_config_cmd (&remote_protocol_vcont);
759 /* Should we try the 'qSymbol' (target symbol lookup service) request? */
760 static struct packet_config remote_protocol_qSymbol;
763 set_remote_protocol_qSymbol_packet_cmd (char *args, int from_tty,
764 struct cmd_list_element *c)
766 update_packet_config (&remote_protocol_qSymbol);
770 show_remote_protocol_qSymbol_packet_cmd (char *args, int from_tty,
771 struct cmd_list_element *c)
773 show_packet_config_cmd (&remote_protocol_qSymbol);
776 /* Should we try the 'P' (set register) request? */
778 static struct packet_config remote_protocol_P;
781 set_remote_protocol_P_packet_cmd (char *args, int from_tty,
782 struct cmd_list_element *c)
784 update_packet_config (&remote_protocol_P);
788 show_remote_protocol_P_packet_cmd (char *args, int from_tty,
789 struct cmd_list_element *c)
791 show_packet_config_cmd (&remote_protocol_P);
794 /* Should we try one of the 'Z' requests? */
798 Z_PACKET_SOFTWARE_BP,
799 Z_PACKET_HARDWARE_BP,
806 static struct packet_config remote_protocol_Z[NR_Z_PACKET_TYPES];
808 /* FIXME: Instead of having all these boiler plate functions, the
809 command callback should include a context argument. */
812 set_remote_protocol_Z_software_bp_packet_cmd (char *args, int from_tty,
813 struct cmd_list_element *c)
815 update_packet_config (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP]);
819 show_remote_protocol_Z_software_bp_packet_cmd (char *args, int from_tty,
820 struct cmd_list_element *c)
822 show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP]);
826 set_remote_protocol_Z_hardware_bp_packet_cmd (char *args, int from_tty,
827 struct cmd_list_element *c)
829 update_packet_config (&remote_protocol_Z[Z_PACKET_HARDWARE_BP]);
833 show_remote_protocol_Z_hardware_bp_packet_cmd (char *args, int from_tty,
834 struct cmd_list_element *c)
836 show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_HARDWARE_BP]);
840 set_remote_protocol_Z_write_wp_packet_cmd (char *args, int from_tty,
841 struct cmd_list_element *c)
843 update_packet_config (&remote_protocol_Z[Z_PACKET_WRITE_WP]);
847 show_remote_protocol_Z_write_wp_packet_cmd (char *args, int from_tty,
848 struct cmd_list_element *c)
850 show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_WRITE_WP]);
854 set_remote_protocol_Z_read_wp_packet_cmd (char *args, int from_tty,
855 struct cmd_list_element *c)
857 update_packet_config (&remote_protocol_Z[Z_PACKET_READ_WP]);
861 show_remote_protocol_Z_read_wp_packet_cmd (char *args, int from_tty,
862 struct cmd_list_element *c)
864 show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_READ_WP]);
868 set_remote_protocol_Z_access_wp_packet_cmd (char *args, int from_tty,
869 struct cmd_list_element *c)
871 update_packet_config (&remote_protocol_Z[Z_PACKET_ACCESS_WP]);
875 show_remote_protocol_Z_access_wp_packet_cmd (char *args, int from_tty,
876 struct cmd_list_element *c)
878 show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_ACCESS_WP]);
881 /* For compatibility with older distributions. Provide a ``set remote
882 Z-packet ...'' command that updates all the Z packet types. */
884 static enum auto_boolean remote_Z_packet_detect;
887 set_remote_protocol_Z_packet_cmd (char *args, int from_tty,
888 struct cmd_list_element *c)
891 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
893 remote_protocol_Z[i].detect = remote_Z_packet_detect;
894 update_packet_config (&remote_protocol_Z[i]);
899 show_remote_protocol_Z_packet_cmd (char *args, int from_tty,
900 struct cmd_list_element *c)
903 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
905 show_packet_config_cmd (&remote_protocol_Z[i]);
909 /* Should we try the 'X' (remote binary download) packet?
911 This variable (available to the user via "set remote X-packet")
912 dictates whether downloads are sent in binary (via the 'X' packet).
913 We assume that the stub can, and attempt to do it. This will be
914 cleared if the stub does not understand it. This switch is still
915 needed, though in cases when the packet is supported in the stub,
916 but the connection does not allow it (i.e., 7-bit serial connection
919 static struct packet_config remote_protocol_binary_download;
921 /* Should we try the 'ThreadInfo' query packet?
923 This variable (NOT available to the user: auto-detect only!)
924 determines whether GDB will use the new, simpler "ThreadInfo"
925 query or the older, more complex syntax for thread queries.
926 This is an auto-detect variable (set to true at each connect,
927 and set to false when the target fails to recognize it). */
929 static int use_threadinfo_query;
930 static int use_threadextra_query;
933 set_remote_protocol_binary_download_cmd (char *args,
935 struct cmd_list_element *c)
937 update_packet_config (&remote_protocol_binary_download);
941 show_remote_protocol_binary_download_cmd (char *args, int from_tty,
942 struct cmd_list_element *c)
944 show_packet_config_cmd (&remote_protocol_binary_download);
947 /* Should we try the 'qPart:auxv' (target auxiliary vector read) request? */
948 static struct packet_config remote_protocol_qPart_auxv;
951 set_remote_protocol_qPart_auxv_packet_cmd (char *args, int from_tty,
952 struct cmd_list_element *c)
954 update_packet_config (&remote_protocol_qPart_auxv);
958 show_remote_protocol_qPart_auxv_packet_cmd (char *args, int from_tty,
959 struct cmd_list_element *c)
961 show_packet_config_cmd (&remote_protocol_qPart_auxv);
964 static struct packet_config remote_protocol_p;
967 set_remote_protocol_p_packet_cmd (char *args, int from_tty,
968 struct cmd_list_element *c)
970 update_packet_config (&remote_protocol_p);
974 show_remote_protocol_p_packet_cmd (char *args, int from_tty,
975 struct cmd_list_element *c)
977 show_packet_config_cmd (&remote_protocol_p);
982 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
983 static void *sigint_remote_twice_token;
984 static void *sigint_remote_token;
986 /* These are pointers to hook functions that may be set in order to
987 modify resume/wait behavior for a particular architecture. */
989 void (*deprecated_target_resume_hook) (void);
990 void (*deprecated_target_wait_loop_hook) (void);
994 /* These are the threads which we last sent to the remote system.
995 -1 for all or -2 for not sent yet. */
996 static int general_thread;
997 static int continue_thread;
999 /* Call this function as a result of
1000 1) A halt indication (T packet) containing a thread id
1001 2) A direct query of currthread
1002 3) Successful execution of set thread
1006 record_currthread (int currthread)
1008 general_thread = currthread;
1010 /* If this is a new thread, add it to GDB's thread list.
1011 If we leave it up to WFI to do this, bad things will happen. */
1012 if (!in_thread_list (pid_to_ptid (currthread)))
1014 add_thread (pid_to_ptid (currthread));
1015 ui_out_text (uiout, "[New ");
1016 ui_out_text (uiout, target_pid_to_str (pid_to_ptid (currthread)));
1017 ui_out_text (uiout, "]\n");
1021 #define MAGIC_NULL_PID 42000
1024 set_thread (int th, int gen)
1026 struct remote_state *rs = get_remote_state ();
1027 char *buf = alloca (rs->remote_packet_size);
1028 int state = gen ? general_thread : continue_thread;
1034 buf[1] = gen ? 'g' : 'c';
1035 if (th == MAGIC_NULL_PID)
1041 sprintf (&buf[2], "-%x", -th);
1043 sprintf (&buf[2], "%x", th);
1045 getpkt (buf, (rs->remote_packet_size), 0);
1047 general_thread = th;
1049 continue_thread = th;
1052 /* Return nonzero if the thread TH is still alive on the remote system. */
1055 remote_thread_alive (ptid_t ptid)
1057 int tid = PIDGET (ptid);
1061 sprintf (buf, "T-%08x", -tid);
1063 sprintf (buf, "T%08x", tid);
1065 getpkt (buf, sizeof (buf), 0);
1066 return (buf[0] == 'O' && buf[1] == 'K');
1069 /* About these extended threadlist and threadinfo packets. They are
1070 variable length packets but, the fields within them are often fixed
1071 length. They are redundent enough to send over UDP as is the
1072 remote protocol in general. There is a matching unit test module
1075 #define OPAQUETHREADBYTES 8
1077 /* a 64 bit opaque identifier */
1078 typedef unsigned char threadref[OPAQUETHREADBYTES];
1080 /* WARNING: This threadref data structure comes from the remote O.S.,
1081 libstub protocol encoding, and remote.c. it is not particularly
1084 /* Right now, the internal structure is int. We want it to be bigger.
1088 typedef int gdb_threadref; /* Internal GDB thread reference. */
1090 /* gdb_ext_thread_info is an internal GDB data structure which is
1091 equivalint to the reply of the remote threadinfo packet. */
1093 struct gdb_ext_thread_info
1095 threadref threadid; /* External form of thread reference. */
1096 int active; /* Has state interesting to GDB?
1098 char display[256]; /* Brief state display, name,
1099 blocked/syspended. */
1100 char shortname[32]; /* To be used to name threads. */
1101 char more_display[256]; /* Long info, statistics, queue depth,
1105 /* The volume of remote transfers can be limited by submitting
1106 a mask containing bits specifying the desired information.
1107 Use a union of these values as the 'selection' parameter to
1108 get_thread_info. FIXME: Make these TAG names more thread specific.
1111 #define TAG_THREADID 1
1112 #define TAG_EXISTS 2
1113 #define TAG_DISPLAY 4
1114 #define TAG_THREADNAME 8
1115 #define TAG_MOREDISPLAY 16
1117 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1119 char *unpack_varlen_hex (char *buff, ULONGEST *result);
1121 static char *unpack_nibble (char *buf, int *val);
1123 static char *pack_nibble (char *buf, int nibble);
1125 static char *pack_hex_byte (char *pkt, int /* unsigned char */ byte);
1127 static char *unpack_byte (char *buf, int *value);
1129 static char *pack_int (char *buf, int value);
1131 static char *unpack_int (char *buf, int *value);
1133 static char *unpack_string (char *src, char *dest, int length);
1135 static char *pack_threadid (char *pkt, threadref *id);
1137 static char *unpack_threadid (char *inbuf, threadref *id);
1139 void int_to_threadref (threadref *id, int value);
1141 static int threadref_to_int (threadref *ref);
1143 static void copy_threadref (threadref *dest, threadref *src);
1145 static int threadmatch (threadref *dest, threadref *src);
1147 static char *pack_threadinfo_request (char *pkt, int mode,
1150 static int remote_unpack_thread_info_response (char *pkt,
1151 threadref *expectedref,
1152 struct gdb_ext_thread_info
1156 static int remote_get_threadinfo (threadref *threadid,
1157 int fieldset, /*TAG mask */
1158 struct gdb_ext_thread_info *info);
1160 static char *pack_threadlist_request (char *pkt, int startflag,
1162 threadref *nextthread);
1164 static int parse_threadlist_response (char *pkt,
1166 threadref *original_echo,
1167 threadref *resultlist,
1170 static int remote_get_threadlist (int startflag,
1171 threadref *nextthread,
1175 threadref *threadlist);
1177 typedef int (*rmt_thread_action) (threadref *ref, void *context);
1179 static int remote_threadlist_iterator (rmt_thread_action stepfunction,
1180 void *context, int looplimit);
1182 static int remote_newthread_step (threadref *ref, void *context);
1184 /* Encode 64 bits in 16 chars of hex. */
1186 static const char hexchars[] = "0123456789abcdef";
1189 ishex (int ch, int *val)
1191 if ((ch >= 'a') && (ch <= 'f'))
1193 *val = ch - 'a' + 10;
1196 if ((ch >= 'A') && (ch <= 'F'))
1198 *val = ch - 'A' + 10;
1201 if ((ch >= '0') && (ch <= '9'))
1212 if (ch >= 'a' && ch <= 'f')
1213 return ch - 'a' + 10;
1214 if (ch >= '0' && ch <= '9')
1216 if (ch >= 'A' && ch <= 'F')
1217 return ch - 'A' + 10;
1222 stub_unpack_int (char *buff, int fieldlength)
1229 nibble = stubhex (*buff++);
1233 retval = retval << 4;
1239 unpack_varlen_hex (char *buff, /* packet to parse */
1245 while (ishex (*buff, &nibble))
1248 retval = retval << 4;
1249 retval |= nibble & 0x0f;
1256 unpack_nibble (char *buf, int *val)
1258 ishex (*buf++, val);
1263 pack_nibble (char *buf, int nibble)
1265 *buf++ = hexchars[(nibble & 0x0f)];
1270 pack_hex_byte (char *pkt, int byte)
1272 *pkt++ = hexchars[(byte >> 4) & 0xf];
1273 *pkt++ = hexchars[(byte & 0xf)];
1278 unpack_byte (char *buf, int *value)
1280 *value = stub_unpack_int (buf, 2);
1285 pack_int (char *buf, int value)
1287 buf = pack_hex_byte (buf, (value >> 24) & 0xff);
1288 buf = pack_hex_byte (buf, (value >> 16) & 0xff);
1289 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
1290 buf = pack_hex_byte (buf, (value & 0xff));
1295 unpack_int (char *buf, int *value)
1297 *value = stub_unpack_int (buf, 8);
1301 #if 0 /* Currently unused, uncomment when needed. */
1302 static char *pack_string (char *pkt, char *string);
1305 pack_string (char *pkt, char *string)
1310 len = strlen (string);
1312 len = 200; /* Bigger than most GDB packets, junk??? */
1313 pkt = pack_hex_byte (pkt, len);
1317 if ((ch == '\0') || (ch == '#'))
1318 ch = '*'; /* Protect encapsulation. */
1323 #endif /* 0 (unused) */
1326 unpack_string (char *src, char *dest, int length)
1335 pack_threadid (char *pkt, threadref *id)
1338 unsigned char *altid;
1340 altid = (unsigned char *) id;
1341 limit = pkt + BUF_THREAD_ID_SIZE;
1343 pkt = pack_hex_byte (pkt, *altid++);
1349 unpack_threadid (char *inbuf, threadref *id)
1352 char *limit = inbuf + BUF_THREAD_ID_SIZE;
1355 altref = (char *) id;
1357 while (inbuf < limit)
1359 x = stubhex (*inbuf++);
1360 y = stubhex (*inbuf++);
1361 *altref++ = (x << 4) | y;
1366 /* Externally, threadrefs are 64 bits but internally, they are still
1367 ints. This is due to a mismatch of specifications. We would like
1368 to use 64bit thread references internally. This is an adapter
1372 int_to_threadref (threadref *id, int value)
1374 unsigned char *scan;
1376 scan = (unsigned char *) id;
1382 *scan++ = (value >> 24) & 0xff;
1383 *scan++ = (value >> 16) & 0xff;
1384 *scan++ = (value >> 8) & 0xff;
1385 *scan++ = (value & 0xff);
1389 threadref_to_int (threadref *ref)
1392 unsigned char *scan;
1394 scan = (char *) ref;
1398 value = (value << 8) | ((*scan++) & 0xff);
1403 copy_threadref (threadref *dest, threadref *src)
1406 unsigned char *csrc, *cdest;
1408 csrc = (unsigned char *) src;
1409 cdest = (unsigned char *) dest;
1416 threadmatch (threadref *dest, threadref *src)
1418 /* Things are broken right now, so just assume we got a match. */
1420 unsigned char *srcp, *destp;
1422 srcp = (char *) src;
1423 destp = (char *) dest;
1427 result &= (*srcp++ == *destp++) ? 1 : 0;
1434 threadid:1, # always request threadid
1441 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1444 pack_threadinfo_request (char *pkt, int mode, threadref *id)
1446 *pkt++ = 'q'; /* Info Query */
1447 *pkt++ = 'P'; /* process or thread info */
1448 pkt = pack_int (pkt, mode); /* mode */
1449 pkt = pack_threadid (pkt, id); /* threadid */
1450 *pkt = '\0'; /* terminate */
1454 /* These values tag the fields in a thread info response packet. */
1455 /* Tagging the fields allows us to request specific fields and to
1456 add more fields as time goes by. */
1458 #define TAG_THREADID 1 /* Echo the thread identifier. */
1459 #define TAG_EXISTS 2 /* Is this process defined enough to
1460 fetch registers and its stack? */
1461 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1462 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1463 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1467 remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
1468 struct gdb_ext_thread_info *info)
1470 struct remote_state *rs = get_remote_state ();
1474 char *limit = pkt + (rs->remote_packet_size); /* plausable parsing limit */
1477 /* info->threadid = 0; FIXME: implement zero_threadref. */
1479 info->display[0] = '\0';
1480 info->shortname[0] = '\0';
1481 info->more_display[0] = '\0';
1483 /* Assume the characters indicating the packet type have been
1485 pkt = unpack_int (pkt, &mask); /* arg mask */
1486 pkt = unpack_threadid (pkt, &ref);
1489 warning ("Incomplete response to threadinfo request\n");
1490 if (!threadmatch (&ref, expectedref))
1491 { /* This is an answer to a different request. */
1492 warning ("ERROR RMT Thread info mismatch\n");
1495 copy_threadref (&info->threadid, &ref);
1497 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1499 /* Packets are terminated with nulls. */
1500 while ((pkt < limit) && mask && *pkt)
1502 pkt = unpack_int (pkt, &tag); /* tag */
1503 pkt = unpack_byte (pkt, &length); /* length */
1504 if (!(tag & mask)) /* Tags out of synch with mask. */
1506 warning ("ERROR RMT: threadinfo tag mismatch\n");
1510 if (tag == TAG_THREADID)
1514 warning ("ERROR RMT: length of threadid is not 16\n");
1518 pkt = unpack_threadid (pkt, &ref);
1519 mask = mask & ~TAG_THREADID;
1522 if (tag == TAG_EXISTS)
1524 info->active = stub_unpack_int (pkt, length);
1526 mask = mask & ~(TAG_EXISTS);
1529 warning ("ERROR RMT: 'exists' length too long\n");
1535 if (tag == TAG_THREADNAME)
1537 pkt = unpack_string (pkt, &info->shortname[0], length);
1538 mask = mask & ~TAG_THREADNAME;
1541 if (tag == TAG_DISPLAY)
1543 pkt = unpack_string (pkt, &info->display[0], length);
1544 mask = mask & ~TAG_DISPLAY;
1547 if (tag == TAG_MOREDISPLAY)
1549 pkt = unpack_string (pkt, &info->more_display[0], length);
1550 mask = mask & ~TAG_MOREDISPLAY;
1553 warning ("ERROR RMT: unknown thread info tag\n");
1554 break; /* Not a tag we know about. */
1560 remote_get_threadinfo (threadref *threadid, int fieldset, /* TAG mask */
1561 struct gdb_ext_thread_info *info)
1563 struct remote_state *rs = get_remote_state ();
1565 char *threadinfo_pkt = alloca (rs->remote_packet_size);
1567 pack_threadinfo_request (threadinfo_pkt, fieldset, threadid);
1568 putpkt (threadinfo_pkt);
1569 getpkt (threadinfo_pkt, (rs->remote_packet_size), 0);
1570 result = remote_unpack_thread_info_response (threadinfo_pkt + 2,
1575 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1578 pack_threadlist_request (char *pkt, int startflag, int threadcount,
1579 threadref *nextthread)
1581 *pkt++ = 'q'; /* info query packet */
1582 *pkt++ = 'L'; /* Process LIST or threadLIST request */
1583 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */
1584 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */
1585 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */
1590 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1593 parse_threadlist_response (char *pkt, int result_limit,
1594 threadref *original_echo, threadref *resultlist,
1597 struct remote_state *rs = get_remote_state ();
1599 int count, resultcount, done;
1602 /* Assume the 'q' and 'M chars have been stripped. */
1603 limit = pkt + ((rs->remote_packet_size) - BUF_THREAD_ID_SIZE);
1604 /* done parse past here */
1605 pkt = unpack_byte (pkt, &count); /* count field */
1606 pkt = unpack_nibble (pkt, &done);
1607 /* The first threadid is the argument threadid. */
1608 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */
1609 while ((count-- > 0) && (pkt < limit))
1611 pkt = unpack_threadid (pkt, resultlist++);
1612 if (resultcount++ >= result_limit)
1621 remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
1622 int *done, int *result_count, threadref *threadlist)
1624 struct remote_state *rs = get_remote_state ();
1625 static threadref echo_nextthread;
1626 char *threadlist_packet = alloca (rs->remote_packet_size);
1627 char *t_response = alloca (rs->remote_packet_size);
1630 /* Trancate result limit to be smaller than the packet size. */
1631 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= (rs->remote_packet_size))
1632 result_limit = ((rs->remote_packet_size) / BUF_THREAD_ID_SIZE) - 2;
1634 pack_threadlist_request (threadlist_packet,
1635 startflag, result_limit, nextthread);
1636 putpkt (threadlist_packet);
1637 getpkt (t_response, (rs->remote_packet_size), 0);
1640 parse_threadlist_response (t_response + 2, result_limit, &echo_nextthread,
1643 if (!threadmatch (&echo_nextthread, nextthread))
1645 /* FIXME: This is a good reason to drop the packet. */
1646 /* Possably, there is a duplicate response. */
1648 retransmit immediatly - race conditions
1649 retransmit after timeout - yes
1651 wait for packet, then exit
1653 warning ("HMM: threadlist did not echo arg thread, dropping it\n");
1654 return 0; /* I choose simply exiting. */
1656 if (*result_count <= 0)
1660 warning ("RMT ERROR : failed to get remote thread list\n");
1663 return result; /* break; */
1665 if (*result_count > result_limit)
1668 warning ("RMT ERROR: threadlist response longer than requested\n");
1674 /* This is the interface between remote and threads, remotes upper
1677 /* remote_find_new_threads retrieves the thread list and for each
1678 thread in the list, looks up the thread in GDB's internal list,
1679 ading the thread if it does not already exist. This involves
1680 getting partial thread lists from the remote target so, polling the
1681 quit_flag is required. */
1684 /* About this many threadisds fit in a packet. */
1686 #define MAXTHREADLISTRESULTS 32
1689 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
1692 int done, i, result_count;
1696 static threadref nextthread;
1697 static threadref resultthreadlist[MAXTHREADLISTRESULTS];
1702 if (loopcount++ > looplimit)
1705 warning ("Remote fetch threadlist -infinite loop-\n");
1708 if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS,
1709 &done, &result_count, resultthreadlist))
1714 /* Clear for later iterations. */
1716 /* Setup to resume next batch of thread references, set nextthread. */
1717 if (result_count >= 1)
1718 copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
1720 while (result_count--)
1721 if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
1728 remote_newthread_step (threadref *ref, void *context)
1732 ptid = pid_to_ptid (threadref_to_int (ref));
1734 if (!in_thread_list (ptid))
1736 return 1; /* continue iterator */
1739 #define CRAZY_MAX_THREADS 1000
1742 remote_current_thread (ptid_t oldpid)
1744 struct remote_state *rs = get_remote_state ();
1745 char *buf = alloca (rs->remote_packet_size);
1748 getpkt (buf, (rs->remote_packet_size), 0);
1749 if (buf[0] == 'Q' && buf[1] == 'C')
1750 /* Use strtoul here, so we'll correctly parse values whose highest
1751 bit is set. The protocol carries them as a simple series of
1752 hex digits; in the absence of a sign, strtol will see such
1753 values as positive numbers out of range for signed 'long', and
1754 return LONG_MAX to indicate an overflow. */
1755 return pid_to_ptid (strtoul (&buf[2], NULL, 16));
1760 /* Find new threads for info threads command.
1761 * Original version, using John Metzler's thread protocol.
1765 remote_find_new_threads (void)
1767 remote_threadlist_iterator (remote_newthread_step, 0,
1769 if (PIDGET (inferior_ptid) == MAGIC_NULL_PID) /* ack ack ack */
1770 inferior_ptid = remote_current_thread (inferior_ptid);
1774 * Find all threads for info threads command.
1775 * Uses new thread protocol contributed by Cisco.
1776 * Falls back and attempts to use the older method (above)
1777 * if the target doesn't respond to the new method.
1781 remote_threads_info (void)
1783 struct remote_state *rs = get_remote_state ();
1784 char *buf = alloca (rs->remote_packet_size);
1788 if (remote_desc == 0) /* paranoia */
1789 error ("Command can only be used when connected to the remote target.");
1791 if (use_threadinfo_query)
1793 putpkt ("qfThreadInfo");
1795 getpkt (bufp, (rs->remote_packet_size), 0);
1796 if (bufp[0] != '\0') /* q packet recognized */
1798 while (*bufp++ == 'm') /* reply contains one or more TID */
1802 /* Use strtoul here, so we'll correctly parse values
1803 whose highest bit is set. The protocol carries
1804 them as a simple series of hex digits; in the
1805 absence of a sign, strtol will see such values as
1806 positive numbers out of range for signed 'long',
1807 and return LONG_MAX to indicate an overflow. */
1808 tid = strtoul (bufp, &bufp, 16);
1809 if (tid != 0 && !in_thread_list (pid_to_ptid (tid)))
1810 add_thread (pid_to_ptid (tid));
1812 while (*bufp++ == ','); /* comma-separated list */
1813 putpkt ("qsThreadInfo");
1815 getpkt (bufp, (rs->remote_packet_size), 0);
1821 /* Else fall back to old method based on jmetzler protocol. */
1822 use_threadinfo_query = 0;
1823 remote_find_new_threads ();
1828 * Collect a descriptive string about the given thread.
1829 * The target may say anything it wants to about the thread
1830 * (typically info about its blocked / runnable state, name, etc.).
1831 * This string will appear in the info threads display.
1833 * Optional: targets are not required to implement this function.
1837 remote_threads_extra_info (struct thread_info *tp)
1839 struct remote_state *rs = get_remote_state ();
1843 struct gdb_ext_thread_info threadinfo;
1844 static char display_buf[100]; /* arbitrary... */
1845 char *bufp = alloca (rs->remote_packet_size);
1846 int n = 0; /* position in display_buf */
1848 if (remote_desc == 0) /* paranoia */
1849 internal_error (__FILE__, __LINE__,
1850 "remote_threads_extra_info");
1852 if (use_threadextra_query)
1854 sprintf (bufp, "qThreadExtraInfo,%x", PIDGET (tp->ptid));
1856 getpkt (bufp, (rs->remote_packet_size), 0);
1859 n = min (strlen (bufp) / 2, sizeof (display_buf));
1860 result = hex2bin (bufp, display_buf, n);
1861 display_buf [result] = '\0';
1866 /* If the above query fails, fall back to the old method. */
1867 use_threadextra_query = 0;
1868 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
1869 | TAG_MOREDISPLAY | TAG_DISPLAY;
1870 int_to_threadref (&id, PIDGET (tp->ptid));
1871 if (remote_get_threadinfo (&id, set, &threadinfo))
1872 if (threadinfo.active)
1874 if (*threadinfo.shortname)
1875 n += sprintf(&display_buf[0], " Name: %s,", threadinfo.shortname);
1876 if (*threadinfo.display)
1877 n += sprintf(&display_buf[n], " State: %s,", threadinfo.display);
1878 if (*threadinfo.more_display)
1879 n += sprintf(&display_buf[n], " Priority: %s",
1880 threadinfo.more_display);
1884 /* For purely cosmetic reasons, clear up trailing commas. */
1885 if (',' == display_buf[n-1])
1886 display_buf[n-1] = ' ';
1895 /* Restart the remote side; this is an extended protocol operation. */
1898 extended_remote_restart (void)
1900 struct remote_state *rs = get_remote_state ();
1901 char *buf = alloca (rs->remote_packet_size);
1903 /* Send the restart command; for reasons I don't understand the
1904 remote side really expects a number after the "R". */
1906 sprintf (&buf[1], "%x", 0);
1909 /* Now query for status so this looks just like we restarted
1910 gdbserver from scratch. */
1912 getpkt (buf, (rs->remote_packet_size), 0);
1915 /* Clean up connection to a remote debugger. */
1918 remote_close (int quitting)
1921 serial_close (remote_desc);
1925 /* Query the remote side for the text, data and bss offsets. */
1930 struct remote_state *rs = get_remote_state ();
1931 char *buf = alloca (rs->remote_packet_size);
1934 CORE_ADDR text_addr, data_addr, bss_addr;
1935 struct section_offsets *offs;
1937 putpkt ("qOffsets");
1939 getpkt (buf, (rs->remote_packet_size), 0);
1941 if (buf[0] == '\000')
1942 return; /* Return silently. Stub doesn't support
1946 warning ("Remote failure reply: %s", buf);
1950 /* Pick up each field in turn. This used to be done with scanf, but
1951 scanf will make trouble if CORE_ADDR size doesn't match
1952 conversion directives correctly. The following code will work
1953 with any size of CORE_ADDR. */
1954 text_addr = data_addr = bss_addr = 0;
1958 if (strncmp (ptr, "Text=", 5) == 0)
1961 /* Don't use strtol, could lose on big values. */
1962 while (*ptr && *ptr != ';')
1963 text_addr = (text_addr << 4) + fromhex (*ptr++);
1968 if (!lose && strncmp (ptr, ";Data=", 6) == 0)
1971 while (*ptr && *ptr != ';')
1972 data_addr = (data_addr << 4) + fromhex (*ptr++);
1977 if (!lose && strncmp (ptr, ";Bss=", 5) == 0)
1980 while (*ptr && *ptr != ';')
1981 bss_addr = (bss_addr << 4) + fromhex (*ptr++);
1987 error ("Malformed response to offset query, %s", buf);
1989 if (symfile_objfile == NULL)
1992 offs = ((struct section_offsets *)
1993 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
1994 memcpy (offs, symfile_objfile->section_offsets,
1995 SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
1997 offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
1999 /* This is a temporary kludge to force data and bss to use the same offsets
2000 because that's what nlmconv does now. The real solution requires changes
2001 to the stub and remote.c that I don't have time to do right now. */
2003 offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
2004 offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
2006 objfile_relocate (symfile_objfile, offs);
2009 /* Stub for catch_errors. */
2012 remote_start_remote_dummy (struct ui_out *uiout, void *dummy)
2014 start_remote (); /* Initialize gdb process mechanisms. */
2015 /* NOTE: Return something >=0. A -ve value is reserved for
2016 catch_exceptions. */
2021 remote_start_remote (struct ui_out *uiout, void *dummy)
2023 immediate_quit++; /* Allow user to interrupt it. */
2025 /* Ack any packet which the remote side has already sent. */
2026 serial_write (remote_desc, "+", 1);
2028 /* Let the stub know that we want it to return the thread. */
2031 inferior_ptid = remote_current_thread (inferior_ptid);
2033 get_offsets (); /* Get text, data & bss offsets. */
2035 putpkt ("?"); /* Initiate a query from remote machine. */
2038 remote_start_remote_dummy (uiout, dummy);
2041 /* Open a connection to a remote debugger.
2042 NAME is the filename used for communication. */
2045 remote_open (char *name, int from_tty)
2047 remote_open_1 (name, from_tty, &remote_ops, 0, 0);
2050 /* Just like remote_open, but with asynchronous support. */
2052 remote_async_open (char *name, int from_tty)
2054 remote_open_1 (name, from_tty, &remote_async_ops, 0, 1);
2057 /* Open a connection to a remote debugger using the extended
2058 remote gdb protocol. NAME is the filename used for communication. */
2061 extended_remote_open (char *name, int from_tty)
2063 remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */,
2067 /* Just like extended_remote_open, but with asynchronous support. */
2069 extended_remote_async_open (char *name, int from_tty)
2071 remote_open_1 (name, from_tty, &extended_async_remote_ops,
2072 1 /*extended_p */, 1 /* async_p */);
2075 /* Generic code for opening a connection to a remote target. */
2078 init_all_packet_configs (void)
2081 update_packet_config (&remote_protocol_P);
2082 update_packet_config (&remote_protocol_p);
2083 update_packet_config (&remote_protocol_qSymbol);
2084 update_packet_config (&remote_protocol_vcont);
2085 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
2086 update_packet_config (&remote_protocol_Z[i]);
2087 /* Force remote_write_bytes to check whether target supports binary
2089 update_packet_config (&remote_protocol_binary_download);
2090 update_packet_config (&remote_protocol_qPart_auxv);
2093 /* Symbol look-up. */
2096 remote_check_symbols (struct objfile *objfile)
2098 struct remote_state *rs = get_remote_state ();
2099 char *msg, *reply, *tmp;
2100 struct minimal_symbol *sym;
2103 if (remote_protocol_qSymbol.support == PACKET_DISABLE)
2106 msg = alloca (rs->remote_packet_size);
2107 reply = alloca (rs->remote_packet_size);
2109 /* Invite target to request symbol lookups. */
2111 putpkt ("qSymbol::");
2112 getpkt (reply, (rs->remote_packet_size), 0);
2113 packet_ok (reply, &remote_protocol_qSymbol);
2115 while (strncmp (reply, "qSymbol:", 8) == 0)
2118 end = hex2bin (tmp, msg, strlen (tmp) / 2);
2120 sym = lookup_minimal_symbol (msg, NULL, NULL);
2122 sprintf (msg, "qSymbol::%s", &reply[8]);
2124 sprintf (msg, "qSymbol:%s:%s",
2125 paddr_nz (SYMBOL_VALUE_ADDRESS (sym)),
2128 getpkt (reply, (rs->remote_packet_size), 0);
2132 static struct serial *
2133 remote_serial_open (char *name)
2135 static int udp_warning = 0;
2137 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2138 of in ser-tcp.c, because it is the remote protocol assuming that the
2139 serial connection is reliable and not the serial connection promising
2141 if (!udp_warning && strncmp (name, "udp:", 4) == 0)
2143 warning ("The remote protocol may be unreliable over UDP.");
2144 warning ("Some events may be lost, rendering further debugging "
2149 return serial_open (name);
2153 remote_open_1 (char *name, int from_tty, struct target_ops *target,
2154 int extended_p, int async_p)
2156 struct exception ex;
2157 struct remote_state *rs = get_remote_state ();
2159 error ("To open a remote debug connection, you need to specify what\n"
2160 "serial device is attached to the remote system\n"
2161 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
2163 /* See FIXME above. */
2165 wait_forever_enabled_p = 1;
2167 reopen_exec_file ();
2170 target_preopen (from_tty);
2172 unpush_target (target);
2174 remote_desc = remote_serial_open (name);
2176 perror_with_name (name);
2178 if (baud_rate != -1)
2180 if (serial_setbaudrate (remote_desc, baud_rate))
2182 /* The requested speed could not be set. Error out to
2183 top level after closing remote_desc. Take care to
2184 set remote_desc to NULL to avoid closing remote_desc
2186 serial_close (remote_desc);
2188 perror_with_name (name);
2192 serial_raw (remote_desc);
2194 /* If there is something sitting in the buffer we might take it as a
2195 response to a command, which would be bad. */
2196 serial_flush_input (remote_desc);
2200 puts_filtered ("Remote debugging using ");
2201 puts_filtered (name);
2202 puts_filtered ("\n");
2204 push_target (target); /* Switch to using remote target now. */
2206 init_all_packet_configs ();
2208 general_thread = -2;
2209 continue_thread = -2;
2211 /* Probe for ability to use "ThreadInfo" query, as required. */
2212 use_threadinfo_query = 1;
2213 use_threadextra_query = 1;
2215 /* Without this, some commands which require an active target (such
2216 as kill) won't work. This variable serves (at least) double duty
2217 as both the pid of the target process (if it has such), and as a
2218 flag indicating that a target is active. These functions should
2219 be split out into seperate variables, especially since GDB will
2220 someday have a notion of debugging several processes. */
2222 inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
2226 /* With this target we start out by owning the terminal. */
2227 remote_async_terminal_ours_p = 1;
2229 /* FIXME: cagney/1999-09-23: During the initial connection it is
2230 assumed that the target is already ready and able to respond to
2231 requests. Unfortunately remote_start_remote() eventually calls
2232 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2233 around this. Eventually a mechanism that allows
2234 wait_for_inferior() to expect/get timeouts will be
2236 wait_forever_enabled_p = 0;
2239 #ifdef SOLIB_CREATE_INFERIOR_HOOK
2240 /* First delete any symbols previously loaded from shared libraries. */
2241 no_shared_libraries (NULL, 0);
2244 /* Start the remote connection. If error() or QUIT, discard this
2245 target (we'd otherwise be in an inconsistent state) and then
2246 propogate the error on up the exception chain. This ensures that
2247 the caller doesn't stumble along blindly assuming that the
2248 function succeeded. The CLI doesn't have this problem but other
2249 UI's, such as MI do.
2251 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2252 this function should return an error indication letting the
2253 caller restore the previous state. Unfortunately the command
2254 ``target remote'' is directly wired to this function making that
2255 impossible. On a positive note, the CLI side of this problem has
2256 been fixed - the function set_cmd_context() makes it possible for
2257 all the ``target ....'' commands to share a common callback
2258 function. See cli-dump.c. */
2259 ex = catch_exception (uiout, remote_start_remote, NULL, RETURN_MASK_ALL);
2260 exception_fprintf (gdb_stderr, ex, "Couldn't establish connection to remote"
2266 wait_forever_enabled_p = 1;
2267 throw_reason (ex.reason);
2271 wait_forever_enabled_p = 1;
2275 /* Tell the remote that we are using the extended protocol. */
2276 char *buf = alloca (rs->remote_packet_size);
2278 getpkt (buf, (rs->remote_packet_size), 0);
2280 #ifdef SOLIB_CREATE_INFERIOR_HOOK
2281 /* FIXME: need a master target_open vector from which all
2282 remote_opens can be called, so that stuff like this can
2283 go there. Failing that, the following code must be copied
2284 to the open function for any remote target that wants to
2285 support svr4 shared libraries. */
2287 /* Set up to detect and load shared libraries. */
2288 if (exec_bfd) /* No use without an exec file. */
2290 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid));
2291 remote_check_symbols (symfile_objfile);
2296 /* This takes a program previously attached to and detaches it. After
2297 this is done, GDB can be used to debug some other program. We
2298 better not have left any breakpoints in the target program or it'll
2299 die when it hits one. */
2302 remote_detach (char *args, int from_tty)
2304 struct remote_state *rs = get_remote_state ();
2305 char *buf = alloca (rs->remote_packet_size);
2308 error ("Argument given to \"detach\" when remotely debugging.");
2310 /* Tell the remote target to detach. */
2312 remote_send (buf, (rs->remote_packet_size));
2314 /* Unregister the file descriptor from the event loop. */
2315 if (target_is_async_p ())
2316 serial_async (remote_desc, NULL, 0);
2318 target_mourn_inferior ();
2320 puts_filtered ("Ending remote debugging.\n");
2323 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2326 remote_disconnect (char *args, int from_tty)
2328 struct remote_state *rs = get_remote_state ();
2329 char *buf = alloca (rs->remote_packet_size);
2332 error ("Argument given to \"detach\" when remotely debugging.");
2334 /* Unregister the file descriptor from the event loop. */
2335 if (target_is_async_p ())
2336 serial_async (remote_desc, NULL, 0);
2338 target_mourn_inferior ();
2340 puts_filtered ("Ending remote debugging.\n");
2343 /* Convert hex digit A to a number. */
2348 if (a >= '0' && a <= '9')
2350 else if (a >= 'a' && a <= 'f')
2351 return a - 'a' + 10;
2352 else if (a >= 'A' && a <= 'F')
2353 return a - 'A' + 10;
2355 error ("Reply contains invalid hex digit %d", a);
2359 hex2bin (const char *hex, char *bin, int count)
2363 for (i = 0; i < count; i++)
2365 if (hex[0] == 0 || hex[1] == 0)
2367 /* Hex string is short, or of uneven length.
2368 Return the count that has been converted so far. */
2371 *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
2377 /* Convert number NIB to a hex digit. */
2385 return 'a' + nib - 10;
2389 bin2hex (const char *bin, char *hex, int count)
2392 /* May use a length, or a nul-terminated string as input. */
2394 count = strlen (bin);
2396 for (i = 0; i < count; i++)
2398 *hex++ = tohex ((*bin >> 4) & 0xf);
2399 *hex++ = tohex (*bin++ & 0xf);
2405 /* Check for the availability of vCont. This function should also check
2409 remote_vcont_probe (struct remote_state *rs, char *buf)
2411 strcpy (buf, "vCont?");
2413 getpkt (buf, rs->remote_packet_size, 0);
2415 /* Make sure that the features we assume are supported. */
2416 if (strncmp (buf, "vCont", 5) == 0)
2419 int support_s, support_S, support_c, support_C;
2425 while (p && *p == ';')
2428 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0))
2430 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0))
2432 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0))
2434 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0))
2437 p = strchr (p, ';');
2440 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2441 BUF will make packet_ok disable the packet. */
2442 if (!support_s || !support_S || !support_c || !support_C)
2446 packet_ok (buf, &remote_protocol_vcont);
2449 /* Resume the remote inferior by using a "vCont" packet. The thread
2450 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2451 resumed thread should be single-stepped and/or signalled. If PTID's
2452 PID is -1, then all threads are resumed; the thread to be stepped and/or
2453 signalled is given in the global INFERIOR_PTID. This function returns
2454 non-zero iff it resumes the inferior.
2456 This function issues a strict subset of all possible vCont commands at the
2460 remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal)
2462 struct remote_state *rs = get_remote_state ();
2463 int pid = PIDGET (ptid);
2464 char *buf = NULL, *outbuf;
2465 struct cleanup *old_cleanup;
2467 buf = xmalloc (rs->remote_packet_size);
2468 old_cleanup = make_cleanup (xfree, buf);
2470 if (remote_protocol_vcont.support == PACKET_SUPPORT_UNKNOWN)
2471 remote_vcont_probe (rs, buf);
2473 if (remote_protocol_vcont.support == PACKET_DISABLE)
2475 do_cleanups (old_cleanup);
2479 /* If we could generate a wider range of packets, we'd have to worry
2480 about overflowing BUF. Should there be a generic
2481 "multi-part-packet" packet? */
2483 if (PIDGET (inferior_ptid) == MAGIC_NULL_PID)
2485 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2486 don't have any PID numbers the inferior will understand. Make sure
2487 to only send forms that do not specify a PID. */
2488 if (step && siggnal != TARGET_SIGNAL_0)
2489 outbuf = xstrprintf ("vCont;S%02x", siggnal);
2491 outbuf = xstrprintf ("vCont;s");
2492 else if (siggnal != TARGET_SIGNAL_0)
2493 outbuf = xstrprintf ("vCont;C%02x", siggnal);
2495 outbuf = xstrprintf ("vCont;c");
2499 /* Resume all threads, with preference for INFERIOR_PTID. */
2500 if (step && siggnal != TARGET_SIGNAL_0)
2501 outbuf = xstrprintf ("vCont;S%02x:%x;c", siggnal,
2502 PIDGET (inferior_ptid));
2504 outbuf = xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid));
2505 else if (siggnal != TARGET_SIGNAL_0)
2506 outbuf = xstrprintf ("vCont;C%02x:%x;c", siggnal,
2507 PIDGET (inferior_ptid));
2509 outbuf = xstrprintf ("vCont;c");
2513 /* Scheduler locking; resume only PTID. */
2514 if (step && siggnal != TARGET_SIGNAL_0)
2515 outbuf = xstrprintf ("vCont;S%02x:%x", siggnal, pid);
2517 outbuf = xstrprintf ("vCont;s:%x", pid);
2518 else if (siggnal != TARGET_SIGNAL_0)
2519 outbuf = xstrprintf ("vCont;C%02x:%x", siggnal, pid);
2521 outbuf = xstrprintf ("vCont;c:%x", pid);
2524 gdb_assert (outbuf && strlen (outbuf) < rs->remote_packet_size);
2525 make_cleanup (xfree, outbuf);
2529 do_cleanups (old_cleanup);
2534 /* Tell the remote machine to resume. */
2536 static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
2538 static int last_sent_step;
2541 remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
2543 struct remote_state *rs = get_remote_state ();
2544 char *buf = alloca (rs->remote_packet_size);
2545 int pid = PIDGET (ptid);
2548 last_sent_signal = siggnal;
2549 last_sent_step = step;
2551 /* A hook for when we need to do something at the last moment before
2553 if (deprecated_target_resume_hook)
2554 (*deprecated_target_resume_hook) ();
2556 /* The vCont packet doesn't need to specify threads via Hc. */
2557 if (remote_vcont_resume (ptid, step, siggnal))
2560 /* All other supported resume packets do use Hc, so call set_thread. */
2562 set_thread (0, 0); /* Run any thread. */
2564 set_thread (pid, 0); /* Run this thread. */
2566 if (siggnal != TARGET_SIGNAL_0)
2568 buf[0] = step ? 'S' : 'C';
2569 buf[1] = tohex (((int) siggnal >> 4) & 0xf);
2570 buf[2] = tohex (((int) siggnal) & 0xf);
2574 strcpy (buf, step ? "s" : "c");
2579 /* Same as remote_resume, but with async support. */
2581 remote_async_resume (ptid_t ptid, int step, enum target_signal siggnal)
2583 remote_resume (ptid, step, siggnal);
2585 /* We are about to start executing the inferior, let's register it
2586 with the event loop. NOTE: this is the one place where all the
2587 execution commands end up. We could alternatively do this in each
2588 of the execution commands in infcmd.c. */
2589 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2590 into infcmd.c in order to allow inferior function calls to work
2591 NOT asynchronously. */
2592 if (target_can_async_p ())
2593 target_async (inferior_event_handler, 0);
2594 /* Tell the world that the target is now executing. */
2595 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2596 this? Instead, should the client of target just assume (for
2597 async targets) that the target is going to start executing? Is
2598 this information already found in the continuation block? */
2599 if (target_is_async_p ())
2600 target_executing = 1;
2604 /* Set up the signal handler for SIGINT, while the target is
2605 executing, ovewriting the 'regular' SIGINT signal handler. */
2607 initialize_sigint_signal_handler (void)
2609 sigint_remote_token =
2610 create_async_signal_handler (async_remote_interrupt, NULL);
2611 signal (SIGINT, handle_remote_sigint);
2614 /* Signal handler for SIGINT, while the target is executing. */
2616 handle_remote_sigint (int sig)
2618 signal (sig, handle_remote_sigint_twice);
2619 sigint_remote_twice_token =
2620 create_async_signal_handler (async_remote_interrupt_twice, NULL);
2621 mark_async_signal_handler_wrapper (sigint_remote_token);
2624 /* Signal handler for SIGINT, installed after SIGINT has already been
2625 sent once. It will take effect the second time that the user sends
2628 handle_remote_sigint_twice (int sig)
2630 signal (sig, handle_sigint);
2631 sigint_remote_twice_token =
2632 create_async_signal_handler (inferior_event_handler_wrapper, NULL);
2633 mark_async_signal_handler_wrapper (sigint_remote_twice_token);
2636 /* Perform the real interruption of the target execution, in response
2639 async_remote_interrupt (gdb_client_data arg)
2642 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
2647 /* Perform interrupt, if the first attempt did not succeed. Just give
2648 up on the target alltogether. */
2650 async_remote_interrupt_twice (gdb_client_data arg)
2653 fprintf_unfiltered (gdb_stdlog, "remote_interrupt_twice called\n");
2654 /* Do something only if the target was not killed by the previous
2656 if (target_executing)
2659 signal (SIGINT, handle_remote_sigint);
2663 /* Reinstall the usual SIGINT handlers, after the target has
2666 cleanup_sigint_signal_handler (void *dummy)
2668 signal (SIGINT, handle_sigint);
2669 if (sigint_remote_twice_token)
2670 delete_async_signal_handler ((struct async_signal_handler **)
2671 &sigint_remote_twice_token);
2672 if (sigint_remote_token)
2673 delete_async_signal_handler ((struct async_signal_handler **)
2674 &sigint_remote_token);
2677 /* Send ^C to target to halt it. Target will respond, and send us a
2679 static void (*ofunc) (int);
2681 /* The command line interface's stop routine. This function is installed
2682 as a signal handler for SIGINT. The first time a user requests a
2683 stop, we call remote_stop to send a break or ^C. If there is no
2684 response from the target (it didn't stop when the user requested it),
2685 we ask the user if he'd like to detach from the target. */
2687 remote_interrupt (int signo)
2689 /* If this doesn't work, try more severe steps. */
2690 signal (signo, remote_interrupt_twice);
2693 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
2698 /* The user typed ^C twice. */
2701 remote_interrupt_twice (int signo)
2703 signal (signo, ofunc);
2705 signal (signo, remote_interrupt);
2708 /* This is the generic stop called via the target vector. When a target
2709 interrupt is requested, either by the command line or the GUI, we
2710 will eventually end up here. */
2714 /* Send a break or a ^C, depending on user preference. */
2716 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
2719 serial_send_break (remote_desc);
2721 serial_write (remote_desc, "\003", 1);
2724 /* Ask the user what to do when an interrupt is received. */
2727 interrupt_query (void)
2729 target_terminal_ours ();
2731 if (query ("Interrupted while waiting for the program.\n\
2732 Give up (and stop debugging it)? "))
2734 target_mourn_inferior ();
2735 throw_reason (RETURN_QUIT);
2738 target_terminal_inferior ();
2741 /* Enable/disable target terminal ownership. Most targets can use
2742 terminal groups to control terminal ownership. Remote targets are
2743 different in that explicit transfer of ownership to/from GDB/target
2747 remote_async_terminal_inferior (void)
2749 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
2750 sync_execution here. This function should only be called when
2751 GDB is resuming the inferior in the forground. A background
2752 resume (``run&'') should leave GDB in control of the terminal and
2753 consequently should not call this code. */
2754 if (!sync_execution)
2756 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
2757 calls target_terminal_*() idenpotent. The event-loop GDB talking
2758 to an asynchronous target with a synchronous command calls this
2759 function from both event-top.c and infrun.c/infcmd.c. Once GDB
2760 stops trying to transfer the terminal to the target when it
2761 shouldn't this guard can go away. */
2762 if (!remote_async_terminal_ours_p)
2764 delete_file_handler (input_fd);
2765 remote_async_terminal_ours_p = 0;
2766 initialize_sigint_signal_handler ();
2767 /* NOTE: At this point we could also register our selves as the
2768 recipient of all input. Any characters typed could then be
2769 passed on down to the target. */
2773 remote_async_terminal_ours (void)
2775 /* See FIXME in remote_async_terminal_inferior. */
2776 if (!sync_execution)
2778 /* See FIXME in remote_async_terminal_inferior. */
2779 if (remote_async_terminal_ours_p)
2781 cleanup_sigint_signal_handler (NULL);
2782 add_file_handler (input_fd, stdin_event_handler, 0);
2783 remote_async_terminal_ours_p = 1;
2786 /* If nonzero, ignore the next kill. */
2791 remote_console_output (char *msg)
2795 for (p = msg; p[0] && p[1]; p += 2)
2798 char c = fromhex (p[0]) * 16 + fromhex (p[1]);
2801 fputs_unfiltered (tb, gdb_stdtarg);
2803 gdb_flush (gdb_stdtarg);
2806 /* Wait until the remote machine stops, then return,
2807 storing status in STATUS just as `wait' would.
2808 Returns "pid", which in the case of a multi-threaded
2809 remote OS, is the thread-id. */
2812 remote_wait (ptid_t ptid, struct target_waitstatus *status)
2814 struct remote_state *rs = get_remote_state ();
2815 unsigned char *buf = alloca (rs->remote_packet_size);
2816 ULONGEST thread_num = -1;
2819 status->kind = TARGET_WAITKIND_EXITED;
2820 status->value.integer = 0;
2826 ofunc = signal (SIGINT, remote_interrupt);
2827 getpkt (buf, (rs->remote_packet_size), 1);
2828 signal (SIGINT, ofunc);
2830 /* This is a hook for when we need to do something (perhaps the
2831 collection of trace data) every time the target stops. */
2832 if (deprecated_target_wait_loop_hook)
2833 (*deprecated_target_wait_loop_hook) ();
2835 remote_stopped_by_watchpoint_p = 0;
2839 case 'E': /* Error of some sort. */
2840 warning ("Remote failure reply: %s", buf);
2842 case 'F': /* File-I/O request. */
2843 remote_fileio_request (buf);
2845 case 'T': /* Status with PC, SP, FP, ... */
2848 char regs[MAX_REGISTER_SIZE];
2850 /* Expedited reply, containing Signal, {regno, reg} repeat. */
2851 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
2853 n... = register number
2854 r... = register contents
2856 p = &buf[3]; /* after Txx */
2865 /* If the packet contains a register number save it in
2866 pnum and set p1 to point to the character following
2867 it. Otherwise p1 points to p. */
2869 /* If this packet is an awatch packet, don't parse the
2870 'a' as a register number. */
2872 if (strncmp (p, "awatch", strlen("awatch")) != 0)
2874 /* Read the ``P'' register number. */
2875 pnum = strtol (p, &p_temp, 16);
2876 p1 = (unsigned char *) p_temp;
2881 if (p1 == p) /* No register number present here. */
2883 p1 = (unsigned char *) strchr (p, ':');
2885 warning ("Malformed packet(a) (missing colon): %s\n\
2888 if (strncmp (p, "thread", p1 - p) == 0)
2890 p_temp = unpack_varlen_hex (++p1, &thread_num);
2891 record_currthread (thread_num);
2892 p = (unsigned char *) p_temp;
2894 else if ((strncmp (p, "watch", p1 - p) == 0)
2895 || (strncmp (p, "rwatch", p1 - p) == 0)
2896 || (strncmp (p, "awatch", p1 - p) == 0))
2898 remote_stopped_by_watchpoint_p = 1;
2899 p = unpack_varlen_hex (++p1, &addr);
2900 remote_watch_data_address = (CORE_ADDR)addr;
2904 /* Silently skip unknown optional info. */
2905 p_temp = strchr (p1 + 1, ';');
2907 p = (unsigned char *) p_temp;
2912 struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
2916 error ("Malformed packet(b) (missing colon): %s\n\
2921 error ("Remote sent bad register number %s: %s\n\
2923 phex_nz (pnum, 0), p, buf);
2925 fieldsize = hex2bin (p, regs,
2926 register_size (current_gdbarch,
2929 if (fieldsize < register_size (current_gdbarch,
2931 warning ("Remote reply is too short: %s", buf);
2932 regcache_raw_supply (current_regcache,
2937 error ("Remote register badly formatted: %s\nhere: %s",
2942 case 'S': /* Old style status, just signal only. */
2943 status->kind = TARGET_WAITKIND_STOPPED;
2944 status->value.sig = (enum target_signal)
2945 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
2949 thread_num = strtol ((const char *) &buf[4], NULL, 16);
2950 record_currthread (thread_num);
2953 case 'W': /* Target exited. */
2955 /* The remote process exited. */
2956 status->kind = TARGET_WAITKIND_EXITED;
2957 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
2961 status->kind = TARGET_WAITKIND_SIGNALLED;
2962 status->value.sig = (enum target_signal)
2963 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
2967 case 'O': /* Console output. */
2968 remote_console_output (buf + 1);
2971 if (last_sent_signal != TARGET_SIGNAL_0)
2973 /* Zero length reply means that we tried 'S' or 'C' and
2974 the remote system doesn't support it. */
2975 target_terminal_ours_for_output ();
2977 ("Can't send signals to this remote system. %s not sent.\n",
2978 target_signal_to_name (last_sent_signal));
2979 last_sent_signal = TARGET_SIGNAL_0;
2980 target_terminal_inferior ();
2982 strcpy ((char *) buf, last_sent_step ? "s" : "c");
2983 putpkt ((char *) buf);
2986 /* else fallthrough */
2988 warning ("Invalid remote reply: %s", buf);
2993 if (thread_num != -1)
2995 return pid_to_ptid (thread_num);
2997 return inferior_ptid;
3000 /* Async version of remote_wait. */
3002 remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
3004 struct remote_state *rs = get_remote_state ();
3005 unsigned char *buf = alloca (rs->remote_packet_size);
3006 ULONGEST thread_num = -1;
3009 status->kind = TARGET_WAITKIND_EXITED;
3010 status->value.integer = 0;
3012 remote_stopped_by_watchpoint_p = 0;
3018 if (!target_is_async_p ())
3019 ofunc = signal (SIGINT, remote_interrupt);
3020 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3021 _never_ wait for ever -> test on target_is_async_p().
3022 However, before we do that we need to ensure that the caller
3023 knows how to take the target into/out of async mode. */
3024 getpkt (buf, (rs->remote_packet_size), wait_forever_enabled_p);
3025 if (!target_is_async_p ())
3026 signal (SIGINT, ofunc);
3028 /* This is a hook for when we need to do something (perhaps the
3029 collection of trace data) every time the target stops. */
3030 if (deprecated_target_wait_loop_hook)
3031 (*deprecated_target_wait_loop_hook) ();
3035 case 'E': /* Error of some sort. */
3036 warning ("Remote failure reply: %s", buf);
3038 case 'F': /* File-I/O request. */
3039 remote_fileio_request (buf);
3041 case 'T': /* Status with PC, SP, FP, ... */
3044 char regs[MAX_REGISTER_SIZE];
3046 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3047 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3049 n... = register number
3050 r... = register contents
3052 p = &buf[3]; /* after Txx */
3061 /* If the packet contains a register number, save it
3062 in pnum and set p1 to point to the character
3063 following it. Otherwise p1 points to p. */
3065 /* If this packet is an awatch packet, don't parse the 'a'
3066 as a register number. */
3068 if (!strncmp (p, "awatch", strlen ("awatch")) != 0)
3070 /* Read the register number. */
3071 pnum = strtol (p, &p_temp, 16);
3072 p1 = (unsigned char *) p_temp;
3077 if (p1 == p) /* No register number present here. */
3079 p1 = (unsigned char *) strchr (p, ':');
3081 error ("Malformed packet(a) (missing colon): %s\n\
3084 if (strncmp (p, "thread", p1 - p) == 0)
3086 p_temp = unpack_varlen_hex (++p1, &thread_num);
3087 record_currthread (thread_num);
3088 p = (unsigned char *) p_temp;
3090 else if ((strncmp (p, "watch", p1 - p) == 0)
3091 || (strncmp (p, "rwatch", p1 - p) == 0)
3092 || (strncmp (p, "awatch", p1 - p) == 0))
3094 remote_stopped_by_watchpoint_p = 1;
3095 p = unpack_varlen_hex (++p1, &addr);
3096 remote_watch_data_address = (CORE_ADDR)addr;
3100 /* Silently skip unknown optional info. */
3101 p_temp = (unsigned char *) strchr (p1 + 1, ';');
3109 struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
3112 error ("Malformed packet(b) (missing colon): %s\n\
3117 error ("Remote sent bad register number %ld: %s\n\
3121 fieldsize = hex2bin (p, regs,
3122 register_size (current_gdbarch,
3125 if (fieldsize < register_size (current_gdbarch,
3127 warning ("Remote reply is too short: %s", buf);
3128 regcache_raw_supply (current_regcache, reg->regnum, regs);
3132 error ("Remote register badly formatted: %s\nhere: %s",
3137 case 'S': /* Old style status, just signal only. */
3138 status->kind = TARGET_WAITKIND_STOPPED;
3139 status->value.sig = (enum target_signal)
3140 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3144 thread_num = strtol ((const char *) &buf[4], NULL, 16);
3145 record_currthread (thread_num);
3148 case 'W': /* Target exited. */
3150 /* The remote process exited. */
3151 status->kind = TARGET_WAITKIND_EXITED;
3152 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
3156 status->kind = TARGET_WAITKIND_SIGNALLED;
3157 status->value.sig = (enum target_signal)
3158 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3162 case 'O': /* Console output. */
3163 remote_console_output (buf + 1);
3164 /* Return immediately to the event loop. The event loop will
3165 still be waiting on the inferior afterwards. */
3166 status->kind = TARGET_WAITKIND_IGNORE;
3169 if (last_sent_signal != TARGET_SIGNAL_0)
3171 /* Zero length reply means that we tried 'S' or 'C' and
3172 the remote system doesn't support it. */
3173 target_terminal_ours_for_output ();
3175 ("Can't send signals to this remote system. %s not sent.\n",
3176 target_signal_to_name (last_sent_signal));
3177 last_sent_signal = TARGET_SIGNAL_0;
3178 target_terminal_inferior ();
3180 strcpy ((char *) buf, last_sent_step ? "s" : "c");
3181 putpkt ((char *) buf);
3184 /* else fallthrough */
3186 warning ("Invalid remote reply: %s", buf);
3191 if (thread_num != -1)
3193 return pid_to_ptid (thread_num);
3195 return inferior_ptid;
3198 /* Number of bytes of registers this stub implements. */
3200 static int register_bytes_found;
3202 /* Read the remote registers into the block REGS. */
3203 /* Currently we just read all the registers, so we don't use regnum. */
3206 fetch_register_using_p (int regnum)
3208 struct remote_state *rs = get_remote_state ();
3209 char *buf = alloca (rs->remote_packet_size), *p;
3210 char regp[MAX_REGISTER_SIZE];
3215 p += hexnumstr (p, regnum);
3217 remote_send (buf, rs->remote_packet_size);
3219 /* If the stub didn't recognize the packet, or if we got an error,
3221 if (buf[0] == '\0' || buf[0] == 'E')
3224 /* If this register is unfetchable, tell the regcache. */
3227 regcache_raw_supply (current_regcache, regnum, NULL);
3228 set_register_cached (regnum, -1);
3232 /* Otherwise, parse and supply the value. */
3239 error ("fetch_register_using_p: early buf termination");
3243 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
3246 regcache_raw_supply (current_regcache, regnum, regp);
3251 remote_fetch_registers (int regnum)
3253 struct remote_state *rs = get_remote_state ();
3254 char *buf = alloca (rs->remote_packet_size);
3257 char *regs = alloca (rs->sizeof_g_packet);
3259 set_thread (PIDGET (inferior_ptid), 1);
3263 struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
3264 gdb_assert (reg != NULL);
3265 if (!reg->in_g_packet)
3266 internal_error (__FILE__, __LINE__,
3267 "Attempt to fetch a non G-packet register when this "
3268 "remote.c does not support the p-packet.");
3270 switch (remote_protocol_p.support)
3272 case PACKET_DISABLE:
3275 if (fetch_register_using_p (regnum))
3278 error ("Protocol error: p packet not recognized by stub");
3279 case PACKET_SUPPORT_UNKNOWN:
3280 if (fetch_register_using_p (regnum))
3282 /* The stub recognized the 'p' packet. Remember this. */
3283 remote_protocol_p.support = PACKET_ENABLE;
3288 /* The stub does not support the 'P' packet. Use 'G'
3289 instead, and don't try using 'P' in the future (it
3290 will just waste our time). */
3291 remote_protocol_p.support = PACKET_DISABLE;
3297 remote_send (buf, (rs->remote_packet_size));
3299 /* Save the size of the packet sent to us by the target. Its used
3300 as a heuristic when determining the max size of packets that the
3301 target can safely receive. */
3302 if ((rs->actual_register_packet_size) == 0)
3303 (rs->actual_register_packet_size) = strlen (buf);
3305 /* Unimplemented registers read as all bits zero. */
3306 memset (regs, 0, rs->sizeof_g_packet);
3308 /* We can get out of synch in various cases. If the first character
3309 in the buffer is not a hex character, assume that has happened
3310 and try to fetch another packet to read. */
3311 while ((buf[0] < '0' || buf[0] > '9')
3312 && (buf[0] < 'a' || buf[0] > 'f')
3313 && buf[0] != 'x') /* New: unavailable register value. */
3316 fprintf_unfiltered (gdb_stdlog,
3317 "Bad register packet; fetching a new packet\n");
3318 getpkt (buf, (rs->remote_packet_size), 0);
3321 /* Reply describes registers byte by byte, each byte encoded as two
3322 hex characters. Suck them all up, then supply them to the
3323 register cacheing/storage mechanism. */
3326 for (i = 0; i < rs->sizeof_g_packet; i++)
3332 warning ("Remote reply is of odd length: %s", buf);
3333 /* Don't change register_bytes_found in this case, and don't
3334 print a second warning. */
3337 if (p[0] == 'x' && p[1] == 'x')
3338 regs[i] = 0; /* 'x' */
3340 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
3344 if (i != register_bytes_found)
3346 register_bytes_found = i;
3347 if (REGISTER_BYTES_OK_P ()
3348 && !REGISTER_BYTES_OK (i))
3349 warning ("Remote reply is too short: %s", buf);
3355 for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
3357 struct packet_reg *r = &rs->regs[i];
3360 if (r->offset * 2 >= strlen (buf))
3361 /* A short packet that didn't include the register's
3362 value, this implies that the register is zero (and
3363 not that the register is unavailable). Supply that
3365 regcache_raw_supply (current_regcache, r->regnum, NULL);
3366 else if (buf[r->offset * 2] == 'x')
3368 gdb_assert (r->offset * 2 < strlen (buf));
3369 /* The register isn't available, mark it as such (at
3370 the same time setting the value to zero). */
3371 regcache_raw_supply (current_regcache, r->regnum, NULL);
3372 set_register_cached (i, -1);
3375 regcache_raw_supply (current_regcache, r->regnum,
3382 /* Prepare to store registers. Since we may send them all (using a
3383 'G' request), we have to read out the ones we don't want to change
3387 remote_prepare_to_store (void)
3389 struct remote_state *rs = get_remote_state ();
3391 char buf[MAX_REGISTER_SIZE];
3393 /* Make sure the entire registers array is valid. */
3394 switch (remote_protocol_P.support)
3396 case PACKET_DISABLE:
3397 case PACKET_SUPPORT_UNKNOWN:
3398 /* Make sure all the necessary registers are cached. */
3399 for (i = 0; i < NUM_REGS; i++)
3400 if (rs->regs[i].in_g_packet)
3401 regcache_raw_read (current_regcache, rs->regs[i].regnum, buf);
3408 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3409 packet was not recognized. */
3412 store_register_using_P (int regnum)
3414 struct remote_state *rs = get_remote_state ();
3415 struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
3416 /* Try storing a single register. */
3417 char *buf = alloca (rs->remote_packet_size);
3418 char regp[MAX_REGISTER_SIZE];
3422 sprintf (buf, "P%s=", phex_nz (reg->pnum, 0));
3423 p = buf + strlen (buf);
3424 regcache_raw_collect (current_regcache, reg->regnum, regp);
3425 bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
3426 remote_send (buf, rs->remote_packet_size);
3428 return buf[0] != '\0';
3432 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3433 contents of the register cache buffer. FIXME: ignores errors. */
3436 remote_store_registers (int regnum)
3438 struct remote_state *rs = get_remote_state ();
3444 set_thread (PIDGET (inferior_ptid), 1);
3448 switch (remote_protocol_P.support)
3450 case PACKET_DISABLE:
3453 if (store_register_using_P (regnum))
3456 error ("Protocol error: P packet not recognized by stub");
3457 case PACKET_SUPPORT_UNKNOWN:
3458 if (store_register_using_P (regnum))
3460 /* The stub recognized the 'P' packet. Remember this. */
3461 remote_protocol_P.support = PACKET_ENABLE;
3466 /* The stub does not support the 'P' packet. Use 'G'
3467 instead, and don't try using 'P' in the future (it
3468 will just waste our time). */
3469 remote_protocol_P.support = PACKET_DISABLE;
3475 /* Extract all the registers in the regcache copying them into a
3479 regs = alloca (rs->sizeof_g_packet);
3480 memset (regs, rs->sizeof_g_packet, 0);
3481 for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
3483 struct packet_reg *r = &rs->regs[i];
3485 regcache_raw_collect (current_regcache, r->regnum, regs + r->offset);
3489 /* Command describes registers byte by byte,
3490 each byte encoded as two hex characters. */
3491 buf = alloca (rs->remote_packet_size);
3494 /* remote_prepare_to_store insures that register_bytes_found gets set. */
3495 bin2hex (regs, p, register_bytes_found);
3496 remote_send (buf, (rs->remote_packet_size));
3500 /* Return the number of hex digits in num. */
3503 hexnumlen (ULONGEST num)
3507 for (i = 0; num != 0; i++)
3513 /* Set BUF to the minimum number of hex digits representing NUM. */
3516 hexnumstr (char *buf, ULONGEST num)
3518 int len = hexnumlen (num);
3519 return hexnumnstr (buf, num, len);
3523 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3526 hexnumnstr (char *buf, ULONGEST num, int width)
3532 for (i = width - 1; i >= 0; i--)
3534 buf[i] = "0123456789abcdef"[(num & 0xf)];
3541 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3544 remote_address_masked (CORE_ADDR addr)
3546 if (remote_address_size > 0
3547 && remote_address_size < (sizeof (ULONGEST) * 8))
3549 /* Only create a mask when that mask can safely be constructed
3550 in a ULONGEST variable. */
3552 mask = (mask << remote_address_size) - 1;
3558 /* Determine whether the remote target supports binary downloading.
3559 This is accomplished by sending a no-op memory write of zero length
3560 to the target at the specified address. It does not suffice to send
3561 the whole packet, since many stubs strip the eighth bit and
3562 subsequently compute a wrong checksum, which causes real havoc with
3565 NOTE: This can still lose if the serial line is not eight-bit
3566 clean. In cases like this, the user should clear "remote
3570 check_binary_download (CORE_ADDR addr)
3572 struct remote_state *rs = get_remote_state ();
3573 switch (remote_protocol_binary_download.support)
3575 case PACKET_DISABLE:
3579 case PACKET_SUPPORT_UNKNOWN:
3581 char *buf = alloca (rs->remote_packet_size);
3586 p += hexnumstr (p, (ULONGEST) addr);
3588 p += hexnumstr (p, (ULONGEST) 0);
3592 putpkt_binary (buf, (int) (p - buf));
3593 getpkt (buf, (rs->remote_packet_size), 0);
3598 fprintf_unfiltered (gdb_stdlog,
3599 "binary downloading NOT suppported by target\n");
3600 remote_protocol_binary_download.support = PACKET_DISABLE;
3605 fprintf_unfiltered (gdb_stdlog,
3606 "binary downloading suppported by target\n");
3607 remote_protocol_binary_download.support = PACKET_ENABLE;
3614 /* Write memory data directly to the remote machine.
3615 This does not inform the data cache; the data cache uses this.
3616 MEMADDR is the address in the remote memory space.
3617 MYADDR is the address of the buffer in our space.
3618 LEN is the number of bytes.
3620 Returns number of bytes transferred, or 0 (setting errno) for
3621 error. Only transfer a single packet. */
3624 remote_write_bytes (CORE_ADDR memaddr, char *myaddr, int len)
3628 unsigned char *plen;
3634 unsigned char *payload_start;
3636 /* Verify that the target can support a binary download. */
3637 check_binary_download (memaddr);
3639 /* Compute the size, and then allocate space for the largest
3640 possible packet. Include space for an extra trailing NULL. */
3641 sizeof_buf = get_memory_write_packet_size () + 1;
3642 buf = alloca (sizeof_buf);
3644 /* Compute the size of the actual payload by subtracting out the
3645 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
3646 payload_size = (get_memory_write_packet_size () - (strlen ("$M,:#NN")
3647 + hexnumlen (memaddr)
3648 + hexnumlen (len)));
3650 /* Construct the packet header: "[MX]<memaddr>,<len>:". */
3652 /* Append "[XM]". Compute a best guess of the number of bytes
3653 actually transfered. */
3655 switch (remote_protocol_binary_download.support)
3659 /* Best guess at number of bytes that will fit. */
3660 todo = min (len, payload_size);
3662 case PACKET_DISABLE:
3664 /* Num bytes that will fit. */
3665 todo = min (len, payload_size / 2);
3667 case PACKET_SUPPORT_UNKNOWN:
3668 internal_error (__FILE__, __LINE__,
3669 "remote_write_bytes: bad internal state");
3671 internal_error (__FILE__, __LINE__, "bad switch");
3674 /* Append "<memaddr>". */
3675 memaddr = remote_address_masked (memaddr);
3676 p += hexnumstr (p, (ULONGEST) memaddr);
3681 /* Append <len>. Retain the location/size of <len>. It may need to
3682 be adjusted once the packet body has been created. */
3684 plenlen = hexnumstr (p, (ULONGEST) todo);
3691 /* Append the packet body. */
3693 switch (remote_protocol_binary_download.support)
3696 /* Binary mode. Send target system values byte by byte, in
3697 increasing byte addresses. Only escape certain critical
3700 (nr_bytes < todo) && (p - payload_start) < payload_size;
3703 switch (myaddr[nr_bytes] & 0xff)
3708 /* These must be escaped. */
3710 *p++ = (myaddr[nr_bytes] & 0xff) ^ 0x20;
3713 *p++ = myaddr[nr_bytes] & 0xff;
3717 if (nr_bytes < todo)
3719 /* Escape chars have filled up the buffer prematurely,
3720 and we have actually sent fewer bytes than planned.
3721 Fix-up the length field of the packet. Use the same
3722 number of characters as before. */
3723 plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
3724 *plen = ':'; /* overwrite \0 from hexnumnstr() */
3727 case PACKET_DISABLE:
3728 /* Normal mode: Send target system values byte by byte, in
3729 increasing byte addresses. Each byte is encoded as a two hex
3731 nr_bytes = bin2hex (myaddr, p, todo);
3734 case PACKET_SUPPORT_UNKNOWN:
3735 internal_error (__FILE__, __LINE__,
3736 "remote_write_bytes: bad internal state");
3738 internal_error (__FILE__, __LINE__, "bad switch");
3741 putpkt_binary (buf, (int) (p - buf));
3742 getpkt (buf, sizeof_buf, 0);
3746 /* There is no correspondance between what the remote protocol
3747 uses for errors and errno codes. We would like a cleaner way
3748 of representing errors (big enough to include errno codes,
3749 bfd_error codes, and others). But for now just return EIO. */
3754 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
3755 fewer bytes than we'd planned. */
3759 /* Read memory data directly from the remote machine.
3760 This does not use the data cache; the data cache uses this.
3761 MEMADDR is the address in the remote memory space.
3762 MYADDR is the address of the buffer in our space.
3763 LEN is the number of bytes.
3765 Returns number of bytes transferred, or 0 for error. */
3767 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
3768 remote targets) shouldn't attempt to read the entire buffer.
3769 Instead it should read a single packet worth of data and then
3770 return the byte size of that packet to the caller. The caller (its
3771 caller and its callers caller ;-) already contains code for
3772 handling partial reads. */
3775 remote_read_bytes (CORE_ADDR memaddr, char *myaddr, int len)
3778 int max_buf_size; /* Max size of packet output buffer. */
3782 /* Create a buffer big enough for this packet. */
3783 max_buf_size = get_memory_read_packet_size ();
3784 sizeof_buf = max_buf_size + 1; /* Space for trailing NULL. */
3785 buf = alloca (sizeof_buf);
3794 todo = min (len, max_buf_size / 2); /* num bytes that will fit */
3796 /* construct "m"<memaddr>","<len>" */
3797 /* sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); */
3798 memaddr = remote_address_masked (memaddr);
3801 p += hexnumstr (p, (ULONGEST) memaddr);
3803 p += hexnumstr (p, (ULONGEST) todo);
3807 getpkt (buf, sizeof_buf, 0);
3810 && isxdigit (buf[1]) && isxdigit (buf[2])
3813 /* There is no correspondance between what the remote
3814 protocol uses for errors and errno codes. We would like
3815 a cleaner way of representing errors (big enough to
3816 include errno codes, bfd_error codes, and others). But
3817 for now just return EIO. */
3822 /* Reply describes memory byte by byte,
3823 each byte encoded as two hex characters. */
3826 if ((i = hex2bin (p, myaddr, todo)) < todo)
3828 /* Reply is short. This means that we were able to read
3829 only part of what we wanted to. */
3830 return i + (origlen - len);
3839 /* Read or write LEN bytes from inferior memory at MEMADDR,
3840 transferring to or from debugger address BUFFER. Write to inferior
3841 if SHOULD_WRITE is nonzero. Returns length of data written or
3842 read; 0 for error. TARGET is unused. */
3845 remote_xfer_memory (CORE_ADDR mem_addr, char *buffer, int mem_len,
3846 int should_write, struct mem_attrib *attrib,
3847 struct target_ops *target)
3849 CORE_ADDR targ_addr;
3853 /* Should this be the selected frame? */
3854 gdbarch_remote_translate_xfer_address (current_gdbarch,
3857 &targ_addr, &targ_len);
3862 res = remote_write_bytes (targ_addr, buffer, targ_len);
3864 res = remote_read_bytes (targ_addr, buffer, targ_len);
3870 remote_files_info (struct target_ops *ignore)
3872 puts_filtered ("Debugging a target over a serial line.\n");
3875 /* Stuff for dealing with the packets which are part of this protocol.
3876 See comment at top of file for details. */
3878 /* Read a single character from the remote end, masking it down to 7
3882 readchar (int timeout)
3886 ch = serial_readchar (remote_desc, timeout);
3891 switch ((enum serial_rc) ch)
3894 target_mourn_inferior ();
3895 error ("Remote connection closed");
3898 perror_with_name ("Remote communication error");
3900 case SERIAL_TIMEOUT:
3906 /* Send the command in BUF to the remote machine, and read the reply
3907 into BUF. Report an error if we get an error reply. */
3910 remote_send (char *buf,
3914 getpkt (buf, sizeof_buf, 0);
3917 error ("Remote failure reply: %s", buf);
3920 /* Display a null-terminated packet on stdout, for debugging, using C
3924 print_packet (char *buf)
3926 puts_filtered ("\"");
3927 fputstr_filtered (buf, '"', gdb_stdout);
3928 puts_filtered ("\"");
3934 return putpkt_binary (buf, strlen (buf));
3937 /* Send a packet to the remote machine, with error checking. The data
3938 of the packet is in BUF. The string in BUF can be at most
3939 (rs->remote_packet_size) - 5 to account for the $, # and checksum,
3940 and for a possible /0 if we are debugging (remote_debug) and want
3941 to print the sent packet as a string. */
3944 putpkt_binary (char *buf, int cnt)
3946 struct remote_state *rs = get_remote_state ();
3948 unsigned char csum = 0;
3949 char *buf2 = alloca (cnt + 6);
3950 long sizeof_junkbuf = (rs->remote_packet_size);
3951 char *junkbuf = alloca (sizeof_junkbuf);
3957 /* Copy the packet into buffer BUF2, encapsulating it
3958 and giving it a checksum. */
3963 for (i = 0; i < cnt; i++)
3969 *p++ = tohex ((csum >> 4) & 0xf);
3970 *p++ = tohex (csum & 0xf);
3972 /* Send it over and over until we get a positive ack. */
3976 int started_error_output = 0;
3981 fprintf_unfiltered (gdb_stdlog, "Sending packet: ");
3982 fputstrn_unfiltered (buf2, p - buf2, 0, gdb_stdlog);
3983 fprintf_unfiltered (gdb_stdlog, "...");
3984 gdb_flush (gdb_stdlog);
3986 if (serial_write (remote_desc, buf2, p - buf2))
3987 perror_with_name ("putpkt: write failed");
3989 /* Read until either a timeout occurs (-2) or '+' is read. */
3992 ch = readchar (remote_timeout);
4000 case SERIAL_TIMEOUT:
4002 if (started_error_output)
4004 putchar_unfiltered ('\n');
4005 started_error_output = 0;
4014 fprintf_unfiltered (gdb_stdlog, "Ack\n");
4018 fprintf_unfiltered (gdb_stdlog, "Nak\n");
4019 case SERIAL_TIMEOUT:
4023 break; /* Retransmit buffer. */
4027 fprintf_unfiltered (gdb_stdlog,
4028 "Packet instead of Ack, ignoring it\n");
4029 /* It's probably an old response sent because an ACK
4030 was lost. Gobble up the packet and ack it so it
4031 doesn't get retransmitted when we resend this
4033 read_frame (junkbuf, sizeof_junkbuf);
4034 serial_write (remote_desc, "+", 1);
4035 continue; /* Now, go look for +. */
4040 if (!started_error_output)
4042 started_error_output = 1;
4043 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
4045 fputc_unfiltered (ch & 0177, gdb_stdlog);
4049 break; /* Here to retransmit. */
4053 /* This is wrong. If doing a long backtrace, the user should be
4054 able to get out next time we call QUIT, without anything as
4055 violent as interrupt_query. If we want to provide a way out of
4056 here without getting to the next QUIT, it should be based on
4057 hitting ^C twice as in remote_wait. */
4067 /* Come here after finding the start of the frame. Collect the rest
4068 into BUF, verifying the checksum, length, and handling run-length
4069 compression. No more than sizeof_buf-1 characters are read so that
4070 the buffer can be NUL terminated.
4072 Returns -1 on error, number of characters in buffer (ignoring the
4073 trailing NULL) on success. (could be extended to return one of the
4074 SERIAL status indications). */
4077 read_frame (char *buf,
4089 /* ASSERT (bc < sizeof_buf - 1) - space for trailing NULL. */
4090 c = readchar (remote_timeout);
4093 case SERIAL_TIMEOUT:
4095 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
4099 fputs_filtered ("Saw new packet start in middle of old one\n",
4101 return -1; /* Start a new packet, count retries. */
4104 unsigned char pktcsum;
4110 check_0 = readchar (remote_timeout);
4112 check_1 = readchar (remote_timeout);
4114 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
4117 fputs_filtered ("Timeout in checksum, retrying\n",
4121 else if (check_0 < 0 || check_1 < 0)
4124 fputs_filtered ("Communication error in checksum\n",
4129 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
4130 if (csum == pktcsum)
4135 fprintf_filtered (gdb_stdlog,
4136 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4138 fputs_filtered (buf, gdb_stdlog);
4139 fputs_filtered ("\n", gdb_stdlog);
4141 /* Number of characters in buffer ignoring trailing
4145 case '*': /* Run length encoding. */
4150 c = readchar (remote_timeout);
4152 repeat = c - ' ' + 3; /* Compute repeat count. */
4154 /* The character before ``*'' is repeated. */
4156 if (repeat > 0 && repeat <= 255
4158 && bc + repeat - 1 < sizeof_buf - 1)
4160 memset (&buf[bc], buf[bc - 1], repeat);
4166 printf_filtered ("Repeat count %d too large for buffer: ",
4168 puts_filtered (buf);
4169 puts_filtered ("\n");
4173 if (bc < sizeof_buf - 1)
4181 puts_filtered ("Remote packet too long: ");
4182 puts_filtered (buf);
4183 puts_filtered ("\n");
4190 /* Read a packet from the remote machine, with error checking, and
4191 store it in BUF. If FOREVER, wait forever rather than timing out;
4192 this is used (in synchronous mode) to wait for a target that is is
4193 executing user code to stop. */
4194 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4195 don't have to change all the calls to getpkt to deal with the
4196 return value, because at the moment I don't know what the right
4197 thing to do it for those. */
4205 timed_out = getpkt_sane (buf, sizeof_buf, forever);
4209 /* Read a packet from the remote machine, with error checking, and
4210 store it in BUF. If FOREVER, wait forever rather than timing out;
4211 this is used (in synchronous mode) to wait for a target that is is
4212 executing user code to stop. If FOREVER == 0, this function is
4213 allowed to time out gracefully and return an indication of this to
4216 getpkt_sane (char *buf,
4225 strcpy (buf, "timeout");
4229 timeout = watchdog > 0 ? watchdog : -1;
4233 timeout = remote_timeout;
4237 for (tries = 1; tries <= MAX_TRIES; tries++)
4239 /* This can loop forever if the remote side sends us characters
4240 continuously, but if it pauses, we'll get a zero from
4241 readchar because of timeout. Then we'll count that as a
4244 /* Note that we will only wait forever prior to the start of a
4245 packet. After that, we expect characters to arrive at a
4246 brisk pace. They should show up within remote_timeout
4251 c = readchar (timeout);
4253 if (c == SERIAL_TIMEOUT)
4255 if (forever) /* Watchdog went off? Kill the target. */
4258 target_mourn_inferior ();
4259 error ("Watchdog has expired. Target detached.\n");
4262 fputs_filtered ("Timed out.\n", gdb_stdlog);
4268 /* We've found the start of a packet, now collect the data. */
4270 val = read_frame (buf, sizeof_buf);
4276 fprintf_unfiltered (gdb_stdlog, "Packet received: ");
4277 fputstr_unfiltered (buf, 0, gdb_stdlog);
4278 fprintf_unfiltered (gdb_stdlog, "\n");
4280 serial_write (remote_desc, "+", 1);
4284 /* Try the whole thing again. */
4286 serial_write (remote_desc, "-", 1);
4289 /* We have tried hard enough, and just can't receive the packet.
4292 printf_unfiltered ("Ignoring packet error, continuing...\n");
4293 serial_write (remote_desc, "+", 1);
4300 /* For some mysterious reason, wait_for_inferior calls kill instead of
4301 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4305 target_mourn_inferior ();
4309 /* Use catch_errors so the user can quit from gdb even when we aren't on
4310 speaking terms with the remote system. */
4311 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
4313 /* Don't wait for it to die. I'm not really sure it matters whether
4314 we do or not. For the existing stubs, kill is a noop. */
4315 target_mourn_inferior ();
4318 /* Async version of remote_kill. */
4320 remote_async_kill (void)
4322 /* Unregister the file descriptor from the event loop. */
4323 if (target_is_async_p ())
4324 serial_async (remote_desc, NULL, 0);
4326 /* For some mysterious reason, wait_for_inferior calls kill instead of
4327 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4331 target_mourn_inferior ();
4335 /* Use catch_errors so the user can quit from gdb even when we
4336 aren't on speaking terms with the remote system. */
4337 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
4339 /* Don't wait for it to die. I'm not really sure it matters whether
4340 we do or not. For the existing stubs, kill is a noop. */
4341 target_mourn_inferior ();
4347 remote_mourn_1 (&remote_ops);
4351 remote_async_mourn (void)
4353 remote_mourn_1 (&remote_async_ops);
4357 extended_remote_mourn (void)
4359 /* We do _not_ want to mourn the target like this; this will
4360 remove the extended remote target from the target stack,
4361 and the next time the user says "run" it'll fail.
4363 FIXME: What is the right thing to do here? */
4365 remote_mourn_1 (&extended_remote_ops);
4369 /* Worker function for remote_mourn. */
4371 remote_mourn_1 (struct target_ops *target)
4373 unpush_target (target);
4374 generic_mourn_inferior ();
4377 /* In the extended protocol we want to be able to do things like
4378 "run" and have them basically work as expected. So we need
4379 a special create_inferior function.
4381 FIXME: One day add support for changing the exec file
4382 we're debugging, arguments and an environment. */
4385 extended_remote_create_inferior (char *exec_file, char *args,
4386 char **env, int from_tty)
4388 /* Rip out the breakpoints; we'll reinsert them after restarting
4389 the remote server. */
4390 remove_breakpoints ();
4392 /* Now restart the remote server. */
4393 extended_remote_restart ();
4395 /* Now put the breakpoints back in. This way we're safe if the
4396 restart function works via a unix fork on the remote side. */
4397 insert_breakpoints ();
4399 /* Clean up from the last time we were running. */
4400 clear_proceed_status ();
4402 /* Let the remote process run. */
4403 proceed (-1, TARGET_SIGNAL_0, 0);
4406 /* Async version of extended_remote_create_inferior. */
4408 extended_remote_async_create_inferior (char *exec_file, char *args,
4409 char **env, int from_tty)
4411 /* Rip out the breakpoints; we'll reinsert them after restarting
4412 the remote server. */
4413 remove_breakpoints ();
4415 /* If running asynchronously, register the target file descriptor
4416 with the event loop. */
4417 if (target_can_async_p ())
4418 target_async (inferior_event_handler, 0);
4420 /* Now restart the remote server. */
4421 extended_remote_restart ();
4423 /* Now put the breakpoints back in. This way we're safe if the
4424 restart function works via a unix fork on the remote side. */
4425 insert_breakpoints ();
4427 /* Clean up from the last time we were running. */
4428 clear_proceed_status ();
4430 /* Let the remote process run. */
4431 proceed (-1, TARGET_SIGNAL_0, 0);
4435 /* On some machines, e.g. 68k, we may use a different breakpoint
4436 instruction than other targets; in those use
4437 DEPRECATED_REMOTE_BREAKPOINT instead of just BREAKPOINT_FROM_PC.
4438 Also, bi-endian targets may define
4439 DEPRECATED_LITTLE_REMOTE_BREAKPOINT and
4440 DEPRECATED_BIG_REMOTE_BREAKPOINT. If none of these are defined, we
4441 just call the standard routines that are in mem-break.c. */
4443 /* NOTE: cagney/2003-06-08: This is silly. A remote and simulator
4444 target should use an identical BREAKPOINT_FROM_PC. As for native,
4445 the ARCH-OS-tdep.c code can override the default. */
4447 #if defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && defined (DEPRECATED_BIG_REMOTE_BREAKPOINT) && !defined(DEPRECATED_REMOTE_BREAKPOINT)
4448 #define DEPRECATED_REMOTE_BREAKPOINT
4451 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4453 /* If the target isn't bi-endian, just pretend it is. */
4454 #if !defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && !defined (DEPRECATED_BIG_REMOTE_BREAKPOINT)
4455 #define DEPRECATED_LITTLE_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
4456 #define DEPRECATED_BIG_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
4459 static unsigned char big_break_insn[] = DEPRECATED_BIG_REMOTE_BREAKPOINT;
4460 static unsigned char little_break_insn[] = DEPRECATED_LITTLE_REMOTE_BREAKPOINT;
4462 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4464 /* Insert a breakpoint on targets that don't have any better
4465 breakpoint support. We read the contents of the target location
4466 and stash it, then overwrite it with a breakpoint instruction.
4467 ADDR is the target location in the target machine. CONTENTS_CACHE
4468 is a pointer to memory allocated for saving the target contents.
4469 It is guaranteed by the caller to be long enough to save the number
4470 of bytes returned by BREAKPOINT_FROM_PC. */
4473 remote_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
4475 struct remote_state *rs = get_remote_state ();
4476 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4481 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
4482 If it succeeds, then set the support to PACKET_ENABLE. If it
4483 fails, and the user has explicitly requested the Z support then
4484 report an error, otherwise, mark it disabled and go on. */
4486 if (remote_protocol_Z[Z_PACKET_SOFTWARE_BP].support != PACKET_DISABLE)
4488 char *buf = alloca (rs->remote_packet_size);
4491 addr = remote_address_masked (addr);
4495 p += hexnumstr (p, (ULONGEST) addr);
4496 BREAKPOINT_FROM_PC (&addr, &bp_size);
4497 sprintf (p, ",%d", bp_size);
4500 getpkt (buf, (rs->remote_packet_size), 0);
4502 switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_SOFTWARE_BP]))
4508 case PACKET_UNKNOWN:
4513 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4514 val = target_read_memory (addr, contents_cache, sizeof big_break_insn);
4518 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
4519 val = target_write_memory (addr, (char *) big_break_insn,
4520 sizeof big_break_insn);
4522 val = target_write_memory (addr, (char *) little_break_insn,
4523 sizeof little_break_insn);
4528 return memory_insert_breakpoint (addr, contents_cache);
4529 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4533 remote_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
4535 struct remote_state *rs = get_remote_state ();
4538 if (remote_protocol_Z[Z_PACKET_SOFTWARE_BP].support != PACKET_DISABLE)
4540 char *buf = alloca (rs->remote_packet_size);
4547 addr = remote_address_masked (addr);
4548 p += hexnumstr (p, (ULONGEST) addr);
4549 BREAKPOINT_FROM_PC (&addr, &bp_size);
4550 sprintf (p, ",%d", bp_size);
4553 getpkt (buf, (rs->remote_packet_size), 0);
4555 return (buf[0] == 'E');
4558 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4559 return target_write_memory (addr, contents_cache, sizeof big_break_insn);
4561 return memory_remove_breakpoint (addr, contents_cache);
4562 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4566 watchpoint_to_Z_packet (int type)
4580 internal_error (__FILE__, __LINE__,
4581 "hw_bp_to_z: bad watchpoint type %d", type);
4586 remote_insert_watchpoint (CORE_ADDR addr, int len, int type)
4588 struct remote_state *rs = get_remote_state ();
4589 char *buf = alloca (rs->remote_packet_size);
4591 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
4593 if (remote_protocol_Z[packet].support == PACKET_DISABLE)
4594 error ("Can't set hardware watchpoints without the '%s' (%s) packet\n",
4595 remote_protocol_Z[packet].name,
4596 remote_protocol_Z[packet].title);
4598 sprintf (buf, "Z%x,", packet);
4599 p = strchr (buf, '\0');
4600 addr = remote_address_masked (addr);
4601 p += hexnumstr (p, (ULONGEST) addr);
4602 sprintf (p, ",%x", len);
4605 getpkt (buf, (rs->remote_packet_size), 0);
4607 switch (packet_ok (buf, &remote_protocol_Z[packet]))
4610 case PACKET_UNKNOWN:
4615 internal_error (__FILE__, __LINE__,
4616 "remote_insert_watchpoint: reached end of function");
4621 remote_remove_watchpoint (CORE_ADDR addr, int len, int type)
4623 struct remote_state *rs = get_remote_state ();
4624 char *buf = alloca (rs->remote_packet_size);
4626 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
4628 if (remote_protocol_Z[packet].support == PACKET_DISABLE)
4629 error ("Can't clear hardware watchpoints without the '%s' (%s) packet\n",
4630 remote_protocol_Z[packet].name,
4631 remote_protocol_Z[packet].title);
4633 sprintf (buf, "z%x,", packet);
4634 p = strchr (buf, '\0');
4635 addr = remote_address_masked (addr);
4636 p += hexnumstr (p, (ULONGEST) addr);
4637 sprintf (p, ",%x", len);
4639 getpkt (buf, (rs->remote_packet_size), 0);
4641 switch (packet_ok (buf, &remote_protocol_Z[packet]))
4644 case PACKET_UNKNOWN:
4649 internal_error (__FILE__, __LINE__,
4650 "remote_remove_watchpoint: reached end of function");
4654 int remote_hw_watchpoint_limit = -1;
4655 int remote_hw_breakpoint_limit = -1;
4658 remote_check_watch_resources (int type, int cnt, int ot)
4660 if (type == bp_hardware_breakpoint)
4662 if (remote_hw_breakpoint_limit == 0)
4664 else if (remote_hw_breakpoint_limit < 0)
4666 else if (cnt <= remote_hw_breakpoint_limit)
4671 if (remote_hw_watchpoint_limit == 0)
4673 else if (remote_hw_watchpoint_limit < 0)
4677 else if (cnt <= remote_hw_watchpoint_limit)
4684 remote_stopped_by_watchpoint (void)
4686 return remote_stopped_by_watchpoint_p;
4689 extern int stepped_after_stopped_by_watchpoint;
4692 remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
4695 if (remote_stopped_by_watchpoint ()
4696 || stepped_after_stopped_by_watchpoint)
4698 *addr_p = remote_watch_data_address;
4707 remote_insert_hw_breakpoint (CORE_ADDR addr, char *shadow)
4710 struct remote_state *rs = get_remote_state ();
4711 char *buf = alloca (rs->remote_packet_size);
4714 /* The length field should be set to the size of a breakpoint
4717 BREAKPOINT_FROM_PC (&addr, &len);
4719 if (remote_protocol_Z[Z_PACKET_HARDWARE_BP].support == PACKET_DISABLE)
4720 error ("Can't set hardware breakpoint without the '%s' (%s) packet\n",
4721 remote_protocol_Z[Z_PACKET_HARDWARE_BP].name,
4722 remote_protocol_Z[Z_PACKET_HARDWARE_BP].title);
4728 addr = remote_address_masked (addr);
4729 p += hexnumstr (p, (ULONGEST) addr);
4730 sprintf (p, ",%x", len);
4733 getpkt (buf, (rs->remote_packet_size), 0);
4735 switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_HARDWARE_BP]))
4738 case PACKET_UNKNOWN:
4743 internal_error (__FILE__, __LINE__,
4744 "remote_insert_hw_breakpoint: reached end of function");
4749 remote_remove_hw_breakpoint (CORE_ADDR addr, char *shadow)
4752 struct remote_state *rs = get_remote_state ();
4753 char *buf = alloca (rs->remote_packet_size);
4756 /* The length field should be set to the size of a breakpoint
4759 BREAKPOINT_FROM_PC (&addr, &len);
4761 if (remote_protocol_Z[Z_PACKET_HARDWARE_BP].support == PACKET_DISABLE)
4762 error ("Can't clear hardware breakpoint without the '%s' (%s) packet\n",
4763 remote_protocol_Z[Z_PACKET_HARDWARE_BP].name,
4764 remote_protocol_Z[Z_PACKET_HARDWARE_BP].title);
4770 addr = remote_address_masked (addr);
4771 p += hexnumstr (p, (ULONGEST) addr);
4772 sprintf (p, ",%x", len);
4775 getpkt (buf, (rs->remote_packet_size), 0);
4777 switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_HARDWARE_BP]))
4780 case PACKET_UNKNOWN:
4785 internal_error (__FILE__, __LINE__,
4786 "remote_remove_hw_breakpoint: reached end of function");
4789 /* Some targets are only capable of doing downloads, and afterwards
4790 they switch to the remote serial protocol. This function provides
4791 a clean way to get from the download target to the remote target.
4792 It's basically just a wrapper so that we don't have to expose any
4793 of the internal workings of remote.c.
4795 Prior to calling this routine, you should shutdown the current
4796 target code, else you will get the "A program is being debugged
4797 already..." message. Usually a call to pop_target() suffices. */
4800 push_remote_target (char *name, int from_tty)
4802 printf_filtered ("Switching to remote protocol\n");
4803 remote_open (name, from_tty);
4806 /* Table used by the crc32 function to calcuate the checksum. */
4808 static unsigned long crc32_table[256] =
4811 static unsigned long
4812 crc32 (unsigned char *buf, int len, unsigned int crc)
4814 if (!crc32_table[1])
4816 /* Initialize the CRC table and the decoding table. */
4820 for (i = 0; i < 256; i++)
4822 for (c = i << 24, j = 8; j > 0; --j)
4823 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
4830 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
4836 /* compare-sections command
4838 With no arguments, compares each loadable section in the exec bfd
4839 with the same memory range on the target, and reports mismatches.
4840 Useful for verifying the image on the target against the exec file.
4841 Depends on the target understanding the new "qCRC:" request. */
4843 /* FIXME: cagney/1999-10-26: This command should be broken down into a
4844 target method (target verify memory) and generic version of the
4845 actual command. This will allow other high-level code (especially
4846 generic_load()) to make use of this target functionality. */
4849 compare_sections_command (char *args, int from_tty)
4851 struct remote_state *rs = get_remote_state ();
4853 unsigned long host_crc, target_crc;
4854 extern bfd *exec_bfd;
4855 struct cleanup *old_chain;
4858 const char *sectname;
4859 char *buf = alloca (rs->remote_packet_size);
4866 error ("command cannot be used without an exec file");
4867 if (!current_target.to_shortname ||
4868 strcmp (current_target.to_shortname, "remote") != 0)
4869 error ("command can only be used with remote target");
4871 for (s = exec_bfd->sections; s; s = s->next)
4873 if (!(s->flags & SEC_LOAD))
4874 continue; /* skip non-loadable section */
4876 size = bfd_get_section_size (s);
4878 continue; /* skip zero-length section */
4880 sectname = bfd_get_section_name (exec_bfd, s);
4881 if (args && strcmp (args, sectname) != 0)
4882 continue; /* not the section selected by user */
4884 matched = 1; /* do this section */
4886 /* FIXME: assumes lma can fit into long. */
4887 sprintf (buf, "qCRC:%lx,%lx", (long) lma, (long) size);
4890 /* Be clever; compute the host_crc before waiting for target
4892 sectdata = xmalloc (size);
4893 old_chain = make_cleanup (xfree, sectdata);
4894 bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
4895 host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff);
4897 getpkt (buf, (rs->remote_packet_size), 0);
4899 error ("target memory fault, section %s, range 0x%s -- 0x%s",
4900 sectname, paddr (lma), paddr (lma + size));
4902 error ("remote target does not support this operation");
4904 for (target_crc = 0, tmp = &buf[1]; *tmp; tmp++)
4905 target_crc = target_crc * 16 + fromhex (*tmp);
4907 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
4908 sectname, paddr (lma), paddr (lma + size));
4909 if (host_crc == target_crc)
4910 printf_filtered ("matched.\n");
4913 printf_filtered ("MIS-MATCHED!\n");
4917 do_cleanups (old_chain);
4920 warning ("One or more sections of the remote executable does not match\n\
4921 the loaded file\n");
4922 if (args && !matched)
4923 printf_filtered ("No loaded section named '%s'.\n", args);
4927 remote_xfer_partial (struct target_ops *ops, enum target_object object,
4928 const char *annex, void *readbuf, const void *writebuf,
4929 ULONGEST offset, LONGEST len)
4931 struct remote_state *rs = get_remote_state ();
4933 char *buf2 = alloca (rs->remote_packet_size);
4934 char *p2 = &buf2[0];
4937 /* Handle memory using remote_xfer_memory. */
4938 if (object == TARGET_OBJECT_MEMORY)
4943 if (writebuf != NULL)
4945 void *buffer = xmalloc (len);
4946 struct cleanup *cleanup = make_cleanup (xfree, buffer);
4947 memcpy (buffer, writebuf, len);
4948 xfered = remote_xfer_memory (offset, buffer, len, 1, NULL, ops);
4949 do_cleanups (cleanup);
4952 xfered = remote_xfer_memory (offset, readbuf, len, 0, NULL, ops);
4956 else if (xfered == 0 && errno == 0)
4962 /* Only handle reads. */
4963 if (writebuf != NULL || readbuf == NULL)
4966 /* Map pre-existing objects onto letters. DO NOT do this for new
4967 objects!!! Instead specify new query packets. */
4970 case TARGET_OBJECT_KOD:
4973 case TARGET_OBJECT_AVR:
4977 case TARGET_OBJECT_AUXV:
4978 if (remote_protocol_qPart_auxv.support != PACKET_DISABLE)
4980 unsigned int total = 0;
4983 LONGEST n = min ((rs->remote_packet_size - 2) / 2, len);
4984 snprintf (buf2, rs->remote_packet_size,
4985 "qPart:auxv:read::%s,%s",
4986 phex_nz (offset, sizeof offset),
4987 phex_nz (n, sizeof n));
4990 return total > 0 ? total : i;
4992 getpkt (buf2, rs->remote_packet_size, 0);
4993 if (packet_ok (buf2, &remote_protocol_qPart_auxv) != PACKET_OK)
4994 return total > 0 ? total : -1;
4995 if (buf2[0] == 'O' && buf2[1] == 'K' && buf2[2] == '\0')
4996 break; /* Got EOF indicator. */
4997 /* Got some data. */
4998 i = hex2bin (buf2, readbuf, len);
5001 readbuf = (void *) ((char *) readbuf + i);
5015 /* Note: a zero OFFSET and LEN can be used to query the minimum
5017 if (offset == 0 && len == 0)
5018 return (rs->remote_packet_size);
5019 /* Minimum outbuf size is (rs->remote_packet_size) - if bufsiz is
5020 not large enough let the caller. */
5021 if (len < (rs->remote_packet_size))
5023 len = rs->remote_packet_size;
5025 /* Except for querying the minimum buffer size, target must be open. */
5027 error ("remote query is only available after target open");
5029 gdb_assert (annex != NULL);
5030 gdb_assert (readbuf != NULL);
5035 /* We used one buffer char for the remote protocol q command and
5036 another for the query type. As the remote protocol encapsulation
5037 uses 4 chars plus one extra in case we are debugging
5038 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5041 while (annex[i] && (i < ((rs->remote_packet_size) - 8)))
5043 /* Bad caller may have sent forbidden characters. */
5044 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
5049 gdb_assert (annex[i] == '\0');
5055 getpkt (readbuf, len, 0);
5057 return strlen (readbuf);
5061 remote_rcmd (char *command,
5062 struct ui_file *outbuf)
5064 struct remote_state *rs = get_remote_state ();
5066 char *buf = alloca (rs->remote_packet_size);
5070 error ("remote rcmd is only available after target open");
5072 /* Send a NULL command across as an empty command. */
5073 if (command == NULL)
5076 /* The query prefix. */
5077 strcpy (buf, "qRcmd,");
5078 p = strchr (buf, '\0');
5080 if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > (rs->remote_packet_size))
5081 error ("\"monitor\" command ``%s'' is too long\n", command);
5083 /* Encode the actual command. */
5084 bin2hex (command, p, 0);
5086 if (putpkt (buf) < 0)
5087 error ("Communication problem with target\n");
5089 /* get/display the response */
5092 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5094 getpkt (buf, (rs->remote_packet_size), 0);
5096 error ("Target does not support this command\n");
5097 if (buf[0] == 'O' && buf[1] != 'K')
5099 remote_console_output (buf + 1); /* 'O' message from stub. */
5102 if (strcmp (buf, "OK") == 0)
5104 if (strlen (buf) == 3 && buf[0] == 'E'
5105 && isdigit (buf[1]) && isdigit (buf[2]))
5107 error ("Protocol error with Rcmd");
5109 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
5111 char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
5112 fputc_unfiltered (c, outbuf);
5119 packet_command (char *args, int from_tty)
5121 struct remote_state *rs = get_remote_state ();
5122 char *buf = alloca (rs->remote_packet_size);
5125 error ("command can only be used with remote target");
5128 error ("remote-packet command requires packet text as argument");
5130 puts_filtered ("sending: ");
5131 print_packet (args);
5132 puts_filtered ("\n");
5135 getpkt (buf, (rs->remote_packet_size), 0);
5136 puts_filtered ("received: ");
5138 puts_filtered ("\n");
5142 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5144 static void display_thread_info (struct gdb_ext_thread_info *info);
5146 static void threadset_test_cmd (char *cmd, int tty);
5148 static void threadalive_test (char *cmd, int tty);
5150 static void threadlist_test_cmd (char *cmd, int tty);
5152 int get_and_display_threadinfo (threadref *ref);
5154 static void threadinfo_test_cmd (char *cmd, int tty);
5156 static int thread_display_step (threadref *ref, void *context);
5158 static void threadlist_update_test_cmd (char *cmd, int tty);
5160 static void init_remote_threadtests (void);
5162 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
5165 threadset_test_cmd (char *cmd, int tty)
5167 int sample_thread = SAMPLE_THREAD;
5169 printf_filtered ("Remote threadset test\n");
5170 set_thread (sample_thread, 1);
5175 threadalive_test (char *cmd, int tty)
5177 int sample_thread = SAMPLE_THREAD;
5179 if (remote_thread_alive (pid_to_ptid (sample_thread)))
5180 printf_filtered ("PASS: Thread alive test\n");
5182 printf_filtered ("FAIL: Thread alive test\n");
5185 void output_threadid (char *title, threadref *ref);
5188 output_threadid (char *title, threadref *ref)
5192 pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */
5194 printf_filtered ("%s %s\n", title, (&hexid[0]));
5198 threadlist_test_cmd (char *cmd, int tty)
5201 threadref nextthread;
5202 int done, result_count;
5203 threadref threadlist[3];
5205 printf_filtered ("Remote Threadlist test\n");
5206 if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
5207 &result_count, &threadlist[0]))
5208 printf_filtered ("FAIL: threadlist test\n");
5211 threadref *scan = threadlist;
5212 threadref *limit = scan + result_count;
5214 while (scan < limit)
5215 output_threadid (" thread ", scan++);
5220 display_thread_info (struct gdb_ext_thread_info *info)
5222 output_threadid ("Threadid: ", &info->threadid);
5223 printf_filtered ("Name: %s\n ", info->shortname);
5224 printf_filtered ("State: %s\n", info->display);
5225 printf_filtered ("other: %s\n\n", info->more_display);
5229 get_and_display_threadinfo (threadref *ref)
5233 struct gdb_ext_thread_info threadinfo;
5235 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
5236 | TAG_MOREDISPLAY | TAG_DISPLAY;
5237 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
5238 display_thread_info (&threadinfo);
5243 threadinfo_test_cmd (char *cmd, int tty)
5245 int athread = SAMPLE_THREAD;
5249 int_to_threadref (&thread, athread);
5250 printf_filtered ("Remote Threadinfo test\n");
5251 if (!get_and_display_threadinfo (&thread))
5252 printf_filtered ("FAIL cannot get thread info\n");
5256 thread_display_step (threadref *ref, void *context)
5258 /* output_threadid(" threadstep ",ref); *//* simple test */
5259 return get_and_display_threadinfo (ref);
5263 threadlist_update_test_cmd (char *cmd, int tty)
5265 printf_filtered ("Remote Threadlist update test\n");
5266 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
5270 init_remote_threadtests (void)
5272 add_com ("tlist", class_obscure, threadlist_test_cmd,
5273 "Fetch and print the remote list of thread identifiers, one pkt only");
5274 add_com ("tinfo", class_obscure, threadinfo_test_cmd,
5275 "Fetch and display info about one thread");
5276 add_com ("tset", class_obscure, threadset_test_cmd,
5277 "Test setting to a different thread");
5278 add_com ("tupd", class_obscure, threadlist_update_test_cmd,
5279 "Iterate through updating all remote thread info");
5280 add_com ("talive", class_obscure, threadalive_test,
5281 " Remote thread alive test ");
5286 /* Convert a thread ID to a string. Returns the string in a static
5290 remote_pid_to_str (ptid_t ptid)
5292 static char buf[30];
5294 sprintf (buf, "Thread %d", PIDGET (ptid));
5299 init_remote_ops (void)
5301 remote_ops.to_shortname = "remote";
5302 remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
5304 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5305 Specify the serial device it is connected to\n\
5306 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
5307 remote_ops.to_open = remote_open;
5308 remote_ops.to_close = remote_close;
5309 remote_ops.to_detach = remote_detach;
5310 remote_ops.to_disconnect = remote_disconnect;
5311 remote_ops.to_resume = remote_resume;
5312 remote_ops.to_wait = remote_wait;
5313 remote_ops.to_fetch_registers = remote_fetch_registers;
5314 remote_ops.to_store_registers = remote_store_registers;
5315 remote_ops.to_prepare_to_store = remote_prepare_to_store;
5316 remote_ops.deprecated_xfer_memory = remote_xfer_memory;
5317 remote_ops.to_files_info = remote_files_info;
5318 remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
5319 remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
5320 remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
5321 remote_ops.to_stopped_data_address = remote_stopped_data_address;
5322 remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
5323 remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
5324 remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
5325 remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
5326 remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
5327 remote_ops.to_kill = remote_kill;
5328 remote_ops.to_load = generic_load;
5329 remote_ops.to_mourn_inferior = remote_mourn;
5330 remote_ops.to_thread_alive = remote_thread_alive;
5331 remote_ops.to_find_new_threads = remote_threads_info;
5332 remote_ops.to_pid_to_str = remote_pid_to_str;
5333 remote_ops.to_extra_thread_info = remote_threads_extra_info;
5334 remote_ops.to_stop = remote_stop;
5335 remote_ops.to_xfer_partial = remote_xfer_partial;
5336 remote_ops.to_rcmd = remote_rcmd;
5337 remote_ops.to_stratum = process_stratum;
5338 remote_ops.to_has_all_memory = 1;
5339 remote_ops.to_has_memory = 1;
5340 remote_ops.to_has_stack = 1;
5341 remote_ops.to_has_registers = 1;
5342 remote_ops.to_has_execution = 1;
5343 remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
5344 remote_ops.to_magic = OPS_MAGIC;
5347 /* Set up the extended remote vector by making a copy of the standard
5348 remote vector and adding to it. */
5351 init_extended_remote_ops (void)
5353 extended_remote_ops = remote_ops;
5355 extended_remote_ops.to_shortname = "extended-remote";
5356 extended_remote_ops.to_longname =
5357 "Extended remote serial target in gdb-specific protocol";
5358 extended_remote_ops.to_doc =
5359 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5360 Specify the serial device it is connected to (e.g. /dev/ttya).",
5361 extended_remote_ops.to_open = extended_remote_open;
5362 extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
5363 extended_remote_ops.to_mourn_inferior = extended_remote_mourn;
5367 remote_can_async_p (void)
5369 /* We're async whenever the serial device is. */
5370 return (current_target.to_async_mask_value) && serial_can_async_p (remote_desc);
5374 remote_is_async_p (void)
5376 /* We're async whenever the serial device is. */
5377 return (current_target.to_async_mask_value) && serial_is_async_p (remote_desc);
5380 /* Pass the SERIAL event on and up to the client. One day this code
5381 will be able to delay notifying the client of an event until the
5382 point where an entire packet has been received. */
5384 static void (*async_client_callback) (enum inferior_event_type event_type,
5386 static void *async_client_context;
5387 static serial_event_ftype remote_async_serial_handler;
5390 remote_async_serial_handler (struct serial *scb, void *context)
5392 /* Don't propogate error information up to the client. Instead let
5393 the client find out about the error by querying the target. */
5394 async_client_callback (INF_REG_EVENT, async_client_context);
5398 remote_async (void (*callback) (enum inferior_event_type event_type,
5399 void *context), void *context)
5401 if (current_target.to_async_mask_value == 0)
5402 internal_error (__FILE__, __LINE__,
5403 "Calling remote_async when async is masked");
5405 if (callback != NULL)
5407 serial_async (remote_desc, remote_async_serial_handler, NULL);
5408 async_client_callback = callback;
5409 async_client_context = context;
5412 serial_async (remote_desc, NULL, NULL);
5415 /* Target async and target extended-async.
5417 This are temporary targets, until it is all tested. Eventually
5418 async support will be incorporated int the usual 'remote'
5422 init_remote_async_ops (void)
5424 remote_async_ops.to_shortname = "async";
5425 remote_async_ops.to_longname =
5426 "Remote serial target in async version of the gdb-specific protocol";
5427 remote_async_ops.to_doc =
5428 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5429 Specify the serial device it is connected to (e.g. /dev/ttya).";
5430 remote_async_ops.to_open = remote_async_open;
5431 remote_async_ops.to_close = remote_close;
5432 remote_async_ops.to_detach = remote_detach;
5433 remote_async_ops.to_disconnect = remote_disconnect;
5434 remote_async_ops.to_resume = remote_async_resume;
5435 remote_async_ops.to_wait = remote_async_wait;
5436 remote_async_ops.to_fetch_registers = remote_fetch_registers;
5437 remote_async_ops.to_store_registers = remote_store_registers;
5438 remote_async_ops.to_prepare_to_store = remote_prepare_to_store;
5439 remote_async_ops.deprecated_xfer_memory = remote_xfer_memory;
5440 remote_async_ops.to_files_info = remote_files_info;
5441 remote_async_ops.to_insert_breakpoint = remote_insert_breakpoint;
5442 remote_async_ops.to_remove_breakpoint = remote_remove_breakpoint;
5443 remote_async_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
5444 remote_async_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
5445 remote_async_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
5446 remote_async_ops.to_insert_watchpoint = remote_insert_watchpoint;
5447 remote_async_ops.to_remove_watchpoint = remote_remove_watchpoint;
5448 remote_async_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
5449 remote_async_ops.to_stopped_data_address = remote_stopped_data_address;
5450 remote_async_ops.to_terminal_inferior = remote_async_terminal_inferior;
5451 remote_async_ops.to_terminal_ours = remote_async_terminal_ours;
5452 remote_async_ops.to_kill = remote_async_kill;
5453 remote_async_ops.to_load = generic_load;
5454 remote_async_ops.to_mourn_inferior = remote_async_mourn;
5455 remote_async_ops.to_thread_alive = remote_thread_alive;
5456 remote_async_ops.to_find_new_threads = remote_threads_info;
5457 remote_async_ops.to_pid_to_str = remote_pid_to_str;
5458 remote_async_ops.to_extra_thread_info = remote_threads_extra_info;
5459 remote_async_ops.to_stop = remote_stop;
5460 remote_async_ops.to_xfer_partial = remote_xfer_partial;
5461 remote_async_ops.to_rcmd = remote_rcmd;
5462 remote_async_ops.to_stratum = process_stratum;
5463 remote_async_ops.to_has_all_memory = 1;
5464 remote_async_ops.to_has_memory = 1;
5465 remote_async_ops.to_has_stack = 1;
5466 remote_async_ops.to_has_registers = 1;
5467 remote_async_ops.to_has_execution = 1;
5468 remote_async_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
5469 remote_async_ops.to_can_async_p = remote_can_async_p;
5470 remote_async_ops.to_is_async_p = remote_is_async_p;
5471 remote_async_ops.to_async = remote_async;
5472 remote_async_ops.to_async_mask_value = 1;
5473 remote_async_ops.to_magic = OPS_MAGIC;
5476 /* Set up the async extended remote vector by making a copy of the standard
5477 remote vector and adding to it. */
5480 init_extended_async_remote_ops (void)
5482 extended_async_remote_ops = remote_async_ops;
5484 extended_async_remote_ops.to_shortname = "extended-async";
5485 extended_async_remote_ops.to_longname =
5486 "Extended remote serial target in async gdb-specific protocol";
5487 extended_async_remote_ops.to_doc =
5488 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
5489 Specify the serial device it is connected to (e.g. /dev/ttya).",
5490 extended_async_remote_ops.to_open = extended_remote_async_open;
5491 extended_async_remote_ops.to_create_inferior = extended_remote_async_create_inferior;
5492 extended_async_remote_ops.to_mourn_inferior = extended_remote_mourn;
5496 set_remote_cmd (char *args, int from_tty)
5501 show_remote_cmd (char *args, int from_tty)
5503 /* FIXME: cagney/2002-06-15: This function should iterate over
5504 remote_show_cmdlist for a list of sub commands to show. */
5505 show_remote_protocol_Z_packet_cmd (args, from_tty, NULL);
5506 show_remote_protocol_P_packet_cmd (args, from_tty, NULL);
5507 show_remote_protocol_p_packet_cmd (args, from_tty, NULL);
5508 show_remote_protocol_qSymbol_packet_cmd (args, from_tty, NULL);
5509 show_remote_protocol_vcont_packet_cmd (args, from_tty, NULL);
5510 show_remote_protocol_binary_download_cmd (args, from_tty, NULL);
5511 show_remote_protocol_qPart_auxv_packet_cmd (args, from_tty, NULL);
5515 build_remote_gdbarch_data (void)
5517 remote_address_size = TARGET_ADDR_BIT;
5520 /* Saved pointer to previous owner of the new_objfile event. */
5521 static void (*remote_new_objfile_chain) (struct objfile *);
5523 /* Function to be called whenever a new objfile (shlib) is detected. */
5525 remote_new_objfile (struct objfile *objfile)
5527 if (remote_desc != 0) /* Have a remote connection. */
5529 remote_check_symbols (objfile);
5531 /* Call predecessor on chain, if any. */
5532 if (remote_new_objfile_chain != 0 &&
5534 remote_new_objfile_chain (objfile);
5538 _initialize_remote (void)
5540 static struct cmd_list_element *remote_set_cmdlist;
5541 static struct cmd_list_element *remote_show_cmdlist;
5542 struct cmd_list_element *tmpcmd;
5544 /* architecture specific data */
5545 remote_gdbarch_data_handle =
5546 gdbarch_data_register_post_init (init_remote_state);
5548 /* Old tacky stuff. NOTE: This comes after the remote protocol so
5549 that the remote protocol has been initialized. */
5550 DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size);
5551 deprecated_register_gdbarch_swap (NULL, 0, build_remote_gdbarch_data);
5554 add_target (&remote_ops);
5556 init_extended_remote_ops ();
5557 add_target (&extended_remote_ops);
5559 init_remote_async_ops ();
5560 add_target (&remote_async_ops);
5562 init_extended_async_remote_ops ();
5563 add_target (&extended_async_remote_ops);
5565 /* Hook into new objfile notification. */
5566 remote_new_objfile_chain = deprecated_target_new_objfile_hook;
5567 deprecated_target_new_objfile_hook = remote_new_objfile;
5570 init_remote_threadtests ();
5573 /* set/show remote ... */
5575 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, "\
5576 Remote protocol specific variables\n\
5577 Configure various remote-protocol specific variables such as\n\
5578 the packets being used",
5579 &remote_set_cmdlist, "set remote ",
5580 0 /* allow-unknown */, &setlist);
5581 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, "\
5582 Remote protocol specific variables\n\
5583 Configure various remote-protocol specific variables such as\n\
5584 the packets being used",
5585 &remote_show_cmdlist, "show remote ",
5586 0 /* allow-unknown */, &showlist);
5588 add_cmd ("compare-sections", class_obscure, compare_sections_command,
5589 "Compare section data on target to the exec file.\n\
5590 Argument is a single section name (default: all loaded sections).",
5593 add_cmd ("packet", class_maintenance, packet_command,
5594 "Send an arbitrary packet to a remote target.\n\
5595 maintenance packet TEXT\n\
5596 If GDB is talking to an inferior via the GDB serial protocol, then\n\
5597 this command sends the string TEXT to the inferior, and displays the\n\
5598 response packet. GDB supplies the initial `$' character, and the\n\
5599 terminating `#' character and checksum.",
5602 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, "\
5603 Set whether to send break if interrupted.", "\
5604 Show whether to send break if interrupted.", "\
5605 If set, a break, instead of a cntrl-c, is sent to the remote target.", "\
5606 Whether to send break if interrupted is %s.",
5608 &setlist, &showlist);
5610 /* Install commands for configuring memory read/write packets. */
5612 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size,
5613 "Set the maximum number of bytes per memory write packet (deprecated).\n",
5615 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size,
5616 "Show the maximum number of bytes per memory write packet (deprecated).\n",
5618 add_cmd ("memory-write-packet-size", no_class,
5619 set_memory_write_packet_size,
5620 "Set the maximum number of bytes per memory-write packet.\n"
5621 "Specify the number of bytes in a packet or 0 (zero) for the\n"
5622 "default packet size. The actual limit is further reduced\n"
5623 "dependent on the target. Specify ``fixed'' to disable the\n"
5624 "further restriction and ``limit'' to enable that restriction\n",
5625 &remote_set_cmdlist);
5626 add_cmd ("memory-read-packet-size", no_class,
5627 set_memory_read_packet_size,
5628 "Set the maximum number of bytes per memory-read packet.\n"
5629 "Specify the number of bytes in a packet or 0 (zero) for the\n"
5630 "default packet size. The actual limit is further reduced\n"
5631 "dependent on the target. Specify ``fixed'' to disable the\n"
5632 "further restriction and ``limit'' to enable that restriction\n",
5633 &remote_set_cmdlist);
5634 add_cmd ("memory-write-packet-size", no_class,
5635 show_memory_write_packet_size,
5636 "Show the maximum number of bytes per memory-write packet.\n",
5637 &remote_show_cmdlist);
5638 add_cmd ("memory-read-packet-size", no_class,
5639 show_memory_read_packet_size,
5640 "Show the maximum number of bytes per memory-read packet.\n",
5641 &remote_show_cmdlist);
5643 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class,
5644 &remote_hw_watchpoint_limit, "\
5645 Set the maximum number of target hardware watchpoints.", "\
5646 Show the maximum number of target hardware watchpoints.", "\
5647 Specify a negative limit for unlimited.", "\
5648 The maximum number of target hardware watchpoints is %s.",
5650 &remote_set_cmdlist, &remote_show_cmdlist);
5651 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class,
5652 &remote_hw_breakpoint_limit, "\
5653 Set the maximum number of target hardware breakpoints.", "\
5654 Show the maximum number of target hardware breakpoints.", "\
5655 Specify a negative limit for unlimited.", "\
5656 The maximum number of target hardware breakpoints is %s.",
5658 &remote_set_cmdlist, &remote_show_cmdlist);
5660 deprecated_add_show_from_set
5661 (add_set_cmd ("remoteaddresssize", class_obscure,
5662 var_integer, (char *) &remote_address_size,
5663 "Set the maximum size of the address (in bits) \
5664 in a memory packet.\n",
5668 add_packet_config_cmd (&remote_protocol_binary_download,
5669 "X", "binary-download",
5670 set_remote_protocol_binary_download_cmd,
5671 show_remote_protocol_binary_download_cmd,
5672 &remote_set_cmdlist, &remote_show_cmdlist,
5675 /* XXXX - should ``set remotebinarydownload'' be retained for
5677 deprecated_add_show_from_set
5678 (add_set_cmd ("remotebinarydownload", no_class,
5679 var_boolean, (char *) &remote_binary_download,
5680 "Set binary downloads.\n", &setlist),
5684 add_packet_config_cmd (&remote_protocol_vcont,
5685 "vCont", "verbose-resume",
5686 set_remote_protocol_vcont_packet_cmd,
5687 show_remote_protocol_vcont_packet_cmd,
5688 &remote_set_cmdlist, &remote_show_cmdlist,
5691 add_packet_config_cmd (&remote_protocol_qSymbol,
5692 "qSymbol", "symbol-lookup",
5693 set_remote_protocol_qSymbol_packet_cmd,
5694 show_remote_protocol_qSymbol_packet_cmd,
5695 &remote_set_cmdlist, &remote_show_cmdlist,
5698 add_packet_config_cmd (&remote_protocol_P,
5699 "P", "set-register",
5700 set_remote_protocol_P_packet_cmd,
5701 show_remote_protocol_P_packet_cmd,
5702 &remote_set_cmdlist, &remote_show_cmdlist,
5705 add_packet_config_cmd (&remote_protocol_p,
5706 "p", "fetch-register",
5707 set_remote_protocol_p_packet_cmd,
5708 show_remote_protocol_p_packet_cmd,
5709 &remote_set_cmdlist, &remote_show_cmdlist,
5712 add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP],
5713 "Z0", "software-breakpoint",
5714 set_remote_protocol_Z_software_bp_packet_cmd,
5715 show_remote_protocol_Z_software_bp_packet_cmd,
5716 &remote_set_cmdlist, &remote_show_cmdlist,
5719 add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_HARDWARE_BP],
5720 "Z1", "hardware-breakpoint",
5721 set_remote_protocol_Z_hardware_bp_packet_cmd,
5722 show_remote_protocol_Z_hardware_bp_packet_cmd,
5723 &remote_set_cmdlist, &remote_show_cmdlist,
5726 add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_WRITE_WP],
5727 "Z2", "write-watchpoint",
5728 set_remote_protocol_Z_write_wp_packet_cmd,
5729 show_remote_protocol_Z_write_wp_packet_cmd,
5730 &remote_set_cmdlist, &remote_show_cmdlist,
5733 add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_READ_WP],
5734 "Z3", "read-watchpoint",
5735 set_remote_protocol_Z_read_wp_packet_cmd,
5736 show_remote_protocol_Z_read_wp_packet_cmd,
5737 &remote_set_cmdlist, &remote_show_cmdlist,
5740 add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_ACCESS_WP],
5741 "Z4", "access-watchpoint",
5742 set_remote_protocol_Z_access_wp_packet_cmd,
5743 show_remote_protocol_Z_access_wp_packet_cmd,
5744 &remote_set_cmdlist, &remote_show_cmdlist,
5747 add_packet_config_cmd (&remote_protocol_qPart_auxv,
5748 "qPart_auxv", "read-aux-vector",
5749 set_remote_protocol_qPart_auxv_packet_cmd,
5750 show_remote_protocol_qPart_auxv_packet_cmd,
5751 &remote_set_cmdlist, &remote_show_cmdlist,
5754 /* Keep the old ``set remote Z-packet ...'' working. */
5755 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
5756 &remote_Z_packet_detect, "\
5757 Set use of remote protocol `Z' packets", "\
5758 Show use of remote protocol `Z' packets ", "\
5759 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
5761 Use of remote protocol `Z' packets is %s",
5762 set_remote_protocol_Z_packet_cmd,
5763 show_remote_protocol_Z_packet_cmd,
5764 &remote_set_cmdlist, &remote_show_cmdlist);
5766 /* Eventually initialize fileio. See fileio.c */
5767 initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);