1 /* Remote target communications for serial-line targets in custom GDB protocol
2 Copyright 1988, 1991-2000 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* See the GDB User Guide for details of the GDB remote protocol. */
24 #include "gdb_string.h"
33 /*#include "terminal.h" */
36 #include "gdb-stabs.h"
37 #include "gdbthread.h"
45 #include <sys/types.h>
48 #include "event-loop.h"
49 #include "event-top.h"
55 /* Prototypes for local functions */
56 static void cleanup_sigint_signal_handler (void *dummy);
57 static void initialize_sigint_signal_handler (void);
58 static int getpkt_sane (char *buf, long sizeof_buf, int forever);
60 static void handle_remote_sigint PARAMS ((int));
61 static void handle_remote_sigint_twice PARAMS ((int));
62 static void async_remote_interrupt PARAMS ((gdb_client_data));
63 void async_remote_interrupt_twice PARAMS ((gdb_client_data));
65 static void build_remote_gdbarch_data PARAMS ((void));
67 static int remote_write_bytes (CORE_ADDR memaddr, char *myaddr, int len);
69 static int remote_read_bytes PARAMS ((CORE_ADDR memaddr,
70 char *myaddr, int len));
72 static void remote_files_info PARAMS ((struct target_ops * ignore));
74 static int remote_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr,
75 int len, int should_write,
76 struct target_ops * target));
78 static void remote_prepare_to_store PARAMS ((void));
80 static void remote_fetch_registers PARAMS ((int regno));
82 static void remote_resume PARAMS ((int pid, int step,
83 enum target_signal siggnal));
84 static void remote_async_resume PARAMS ((int pid, int step,
85 enum target_signal siggnal));
86 static int remote_start_remote PARAMS ((PTR));
88 static void remote_open PARAMS ((char *name, int from_tty));
89 static void remote_async_open PARAMS ((char *name, int from_tty));
91 static void extended_remote_open PARAMS ((char *name, int from_tty));
92 static void extended_remote_async_open PARAMS ((char *name, int from_tty));
94 static void remote_open_1 PARAMS ((char *, int, struct target_ops *,
96 static void remote_async_open_1 PARAMS ((char *, int, struct target_ops *,
99 static void remote_close PARAMS ((int quitting));
101 static void remote_store_registers PARAMS ((int regno));
103 static void remote_mourn PARAMS ((void));
104 static void remote_async_mourn PARAMS ((void));
106 static void extended_remote_restart PARAMS ((void));
108 static void extended_remote_mourn PARAMS ((void));
110 static void extended_remote_create_inferior PARAMS ((char *, char *, char **));
111 static void extended_remote_async_create_inferior PARAMS ((char *, char *, char **));
113 static void remote_mourn_1 PARAMS ((struct target_ops *));
115 static void remote_send (char *buf, long sizeof_buf);
117 static int readchar PARAMS ((int timeout));
119 static int remote_wait PARAMS ((int pid, struct target_waitstatus * status));
120 static int remote_async_wait PARAMS ((int pid, struct target_waitstatus * status));
122 static void remote_kill PARAMS ((void));
123 static void remote_async_kill PARAMS ((void));
125 static int tohex PARAMS ((int nib));
127 static void remote_detach PARAMS ((char *args, int from_tty));
128 static void remote_async_detach PARAMS ((char *args, int from_tty));
130 static void remote_interrupt PARAMS ((int signo));
132 static void remote_interrupt_twice PARAMS ((int signo));
134 static void interrupt_query PARAMS ((void));
136 static void set_thread PARAMS ((int, int));
138 static int remote_thread_alive PARAMS ((int));
140 static void get_offsets PARAMS ((void));
142 static long read_frame (char *buf, long sizeof_buf);
144 static int remote_insert_breakpoint PARAMS ((CORE_ADDR, char *));
146 static int remote_remove_breakpoint PARAMS ((CORE_ADDR, char *));
148 static int hexnumlen PARAMS ((ULONGEST num));
150 static void init_remote_ops PARAMS ((void));
152 static void init_extended_remote_ops PARAMS ((void));
154 static void init_remote_cisco_ops PARAMS ((void));
156 static struct target_ops remote_cisco_ops;
158 static void remote_stop PARAMS ((void));
160 static int ishex PARAMS ((int ch, int *val));
162 static int stubhex PARAMS ((int ch));
164 static int remote_query PARAMS ((int /*char */ , char *, char *, int *));
166 static int hexnumstr PARAMS ((char *, ULONGEST));
168 static int hexnumnstr PARAMS ((char *, ULONGEST, int));
170 static CORE_ADDR remote_address_masked PARAMS ((CORE_ADDR));
172 static void print_packet PARAMS ((char *));
174 static unsigned long crc32 PARAMS ((unsigned char *, int, unsigned int));
176 static void compare_sections_command PARAMS ((char *, int));
178 static void packet_command PARAMS ((char *, int));
180 static int stub_unpack_int PARAMS ((char *buff, int fieldlength));
182 static int remote_current_thread PARAMS ((int oldpid));
184 static void remote_find_new_threads PARAMS ((void));
186 static void record_currthread PARAMS ((int currthread));
188 /* exported functions */
190 extern int fromhex PARAMS ((int a));
192 static int putpkt_binary PARAMS ((char *buf, int cnt));
194 static void check_binary_download PARAMS ((CORE_ADDR addr));
196 struct packet_config;
198 static void show_packet_config_cmd PARAMS ((struct packet_config * config));
200 static void set_packet_config_cmd PARAMS ((struct packet_config * config,
201 struct cmd_list_element * c));
203 static void add_packet_config_cmd PARAMS ((struct packet_config * config,
206 void (*set_func) (char *args, int from_tty, struct cmd_list_element * c),
207 void (*show_func) (char *name, int from_tty),
208 struct cmd_list_element **setlist,
209 struct cmd_list_element **showlist));
211 static void init_packet_config PARAMS ((struct packet_config * config));
213 static void set_remote_protocol_P_packet_cmd PARAMS ((char *args,
215 struct cmd_list_element * c));
217 static void show_remote_protocol_P_packet_cmd PARAMS ((char *args,
220 static void set_remote_protocol_Z_packet_cmd PARAMS ((char *args,
222 struct cmd_list_element * c));
224 static void show_remote_protocol_Z_packet_cmd PARAMS ((char *args,
230 /* Define the target subroutine names */
232 void open_remote_target PARAMS ((char *, int, struct target_ops *, int));
234 void _initialize_remote PARAMS ((void));
238 static struct target_ops remote_ops;
240 static struct target_ops extended_remote_ops;
242 /* Temporary target ops. Just like the remote_ops and
243 extended_remote_ops, but with asynchronous support. */
244 static struct target_ops remote_async_ops;
246 static struct target_ops extended_async_remote_ops;
248 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
249 ``forever'' still use the normal timeout mechanism. This is
250 currently used by the ASYNC code to guarentee that target reads
251 during the initial connect always time-out. Once getpkt has been
252 modified to return a timeout indication and, in turn
253 remote_wait()/wait_for_inferior() have gained a timeout parameter
255 static int wait_forever_enabled_p = 1;
258 /* This variable chooses whether to send a ^C or a break when the user
259 requests program interruption. Although ^C is usually what remote
260 systems expect, and that is the default here, sometimes a break is
261 preferable instead. */
263 static int remote_break;
265 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
266 remote_open knows that we don't have a file open when the program
268 static serial_t remote_desc = NULL;
270 /* This is set by the target (thru the 'S' message)
271 to denote that the target is in kernel mode. */
272 static int cisco_kernel_mode = 0;
274 /* This variable sets the number of bits in an address that are to be
275 sent in a memory ("M" or "m") packet. Normally, after stripping
276 leading zeros, the entire address would be sent. This variable
277 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
278 initial implementation of remote.c restricted the address sent in
279 memory packets to ``host::sizeof long'' bytes - (typically 32
280 bits). Consequently, for 64 bit targets, the upper 32 bits of an
281 address was never sent. Since fixing this bug may cause a break in
282 some remote targets this variable is principly provided to
283 facilitate backward compatibility. */
285 static int remote_address_size;
287 /* Tempoary to track who currently owns the terminal. See
288 target_async_terminal_* for more details. */
290 static int remote_async_terminal_ours_p;
293 /* This is the size (in chars) of the first response to the ``g''
294 packet. It is used as a heuristic when determining the maximum
295 size of memory-read and memory-write packets. A target will
296 typically only reserve a buffer large enough to hold the ``g''
297 packet. The size does not include packet overhead (headers and
300 static long actual_register_packet_size;
302 /* This is the maximum size (in chars) of a non read/write packet. It
303 is also used as a cap on the size of read/write packets. */
305 static long remote_packet_size;
307 #define PBUFSIZ (remote_packet_size)
309 /* User configurable variables for the number of characters in a
310 memory read/write packet. MIN (PBUFSIZ, g-packet-size) is the
311 default. Some targets need smaller values (fifo overruns, et.al.)
312 and some users need larger values (speed up transfers). The
313 variables ``preferred_*'' (the user request), ``current_*'' (what
314 was actually set) and ``forced_*'' (Positive - a soft limit,
315 negative - a hard limit). */
317 struct memory_packet_config
324 /* Compute the current size of a read/write packet. Since this makes
325 use of ``actual_register_packet_size'' the computation is dynamic. */
328 get_memory_packet_size (struct memory_packet_config *config)
330 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
331 law?) that some hosts don't cope very well with large alloca()
332 calls. Eventually the alloca() code will be replaced by calls to
333 xmalloc() and make_cleanups() allowing this restriction to either
334 be lifted or removed. */
335 #ifndef MAX_REMOTE_PACKET_SIZE
336 #define MAX_REMOTE_PACKET_SIZE 16384
338 /* NOTE: 16 is just chosen at random. */
339 #ifndef MIN_REMOTE_PACKET_SIZE
340 #define MIN_REMOTE_PACKET_SIZE 16
345 if (config->size <= 0)
346 what_they_get = MAX_REMOTE_PACKET_SIZE;
348 what_they_get = config->size;
352 what_they_get = remote_packet_size;
353 /* Limit the packet to the size specified by the user. */
355 && what_they_get > config->size)
356 what_they_get = config->size;
357 /* Limit it to the size of the targets ``g'' response. */
358 if (actual_register_packet_size > 0
359 && what_they_get > actual_register_packet_size)
360 what_they_get = actual_register_packet_size;
362 if (what_they_get > MAX_REMOTE_PACKET_SIZE)
363 what_they_get = MAX_REMOTE_PACKET_SIZE;
364 if (what_they_get < MIN_REMOTE_PACKET_SIZE)
365 what_they_get = MIN_REMOTE_PACKET_SIZE;
366 return what_they_get;
369 /* Update the size of a read/write packet. If they user wants
370 something really big then do a sanity check. */
373 set_memory_packet_size (char *args, struct memory_packet_config *config)
375 int fixed_p = config->fixed_p;
376 long size = config->size;
378 error ("Argument required (integer, `fixed' or `limited').");
379 else if (strcmp (args, "hard") == 0
380 || strcmp (args, "fixed") == 0)
382 else if (strcmp (args, "soft") == 0
383 || strcmp (args, "limit") == 0)
388 size = strtoul (args, &end, 0);
390 error ("Invalid %s (bad syntax).", config->name);
392 /* Instead of explicitly capping the size of a packet to
393 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
394 instead allowed to set the size to something arbitrarily
396 if (size > MAX_REMOTE_PACKET_SIZE)
397 error ("Invalid %s (too large).", config->name);
401 if (fixed_p && !config->fixed_p)
403 if (! query ("The target may not be able to correctly handle a %s\n"
404 "of %ld bytes. Change the packet size? ",
406 error ("Packet size not changed.");
408 /* Update the config. */
409 config->fixed_p = fixed_p;
414 show_memory_packet_size (struct memory_packet_config *config)
416 printf_filtered ("The %s is %ld. ", config->name, config->size);
418 printf_filtered ("Packets are fixed at %ld bytes.\n",
419 get_memory_packet_size (config));
421 printf_filtered ("Packets are limited to %ld bytes.\n",
422 get_memory_packet_size (config));
425 static struct memory_packet_config memory_write_packet_config =
427 "memory-write-packet-size",
431 set_memory_write_packet_size (char *args, int from_tty)
433 set_memory_packet_size (args, &memory_write_packet_config);
437 show_memory_write_packet_size (char *args, int from_tty)
439 show_memory_packet_size (&memory_write_packet_config);
443 get_memory_write_packet_size (void)
445 return get_memory_packet_size (&memory_write_packet_config);
448 static struct memory_packet_config memory_read_packet_config =
450 "memory-read-packet-size",
454 set_memory_read_packet_size (char *args, int from_tty)
456 set_memory_packet_size (args, &memory_read_packet_config);
460 show_memory_read_packet_size (char *args, int from_tty)
462 show_memory_packet_size (&memory_read_packet_config);
466 get_memory_read_packet_size (void)
468 long size = get_memory_packet_size (&memory_read_packet_config);
469 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
470 extra buffer size argument before the memory read size can be
471 increased beyond PBUFSIZ. */
477 /* Register packet size initialization. Since the bounds change when
478 the architecture changes (namely REGISTER_BYTES) this all needs to
482 register_remote_packet_sizes (void)
484 REGISTER_GDBARCH_SWAP (remote_packet_size);
485 REGISTER_GDBARCH_SWAP (actual_register_packet_size);
489 build_remote_packet_sizes (void)
491 /* Default maximum number of characters in a packet body. Many
492 remote stubs have a hardwired buffer size of 400 bytes
493 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
494 as the maximum packet-size to ensure that the packet and an extra
495 NUL character can always fit in the buffer. This stops GDB
496 trashing stubs that try to squeeze an extra NUL into what is
497 already a full buffer (As of 1999-12-04 that was most stubs. */
498 remote_packet_size = 400 - 1;
499 /* Should REGISTER_BYTES needs more space than the default, adjust
500 the size accordingly. Remember that each byte is encoded as two
501 characters. 32 is the overhead for the packet header /
502 footer. NOTE: cagney/1999-10-26: I suspect that 8
503 (``$NN:G...#NN'') is a better guess, the below has been padded a
505 if (REGISTER_BYTES > ((remote_packet_size - 32) / 2))
506 remote_packet_size = (REGISTER_BYTES * 2 + 32);
508 /* This one is filled in when a ``g'' packet is received. */
509 actual_register_packet_size = 0;
512 /* Generic configuration support for packets the stub optionally
513 supports. Allows the user to specify the use of the packet as well
514 as allowing GDB to auto-detect support in the remote stub. */
518 PACKET_SUPPORT_UNKNOWN = 0,
525 PACKET_AUTO_DETECT = 0,
534 enum packet_detect detect;
535 enum packet_support support;
538 static char packet_support_auto[] = "auto";
539 static char packet_enable[] = "enable";
540 static char packet_disable[] = "disable";
541 static char *packet_support_enums[] =
550 set_packet_config_cmd (config, c)
551 struct packet_config *config;
552 struct cmd_list_element *c;
554 if (config->state == packet_enable)
556 config->detect = PACKET_MANUAL_DETECT;
557 config->support = PACKET_ENABLE;
559 else if (config->state == packet_disable)
561 config->detect = PACKET_MANUAL_DETECT;
562 config->support = PACKET_DISABLE;
564 else if (config->state == packet_support_auto)
566 config->detect = PACKET_AUTO_DETECT;
567 config->support = PACKET_SUPPORT_UNKNOWN;
570 internal_error ("Bad enum value");
574 show_packet_config_cmd (config)
575 struct packet_config *config;
577 char *support = "internal-error";
578 switch (config->support)
584 support = "disabled";
586 case PACKET_SUPPORT_UNKNOWN:
590 switch (config->detect)
592 case PACKET_AUTO_DETECT:
593 printf_filtered ("Support for remote protocol `%s' (%s) packet is auto-detected, currently %s.\n",
594 config->name, config->title, support);
596 case PACKET_MANUAL_DETECT:
597 printf_filtered ("Support for remote protocol `%s' (%s) is currently %s.\n",
598 config->name, config->title, support);
603 add_packet_config_cmd (config, name, title, set_func, show_func,
605 struct packet_config *config;
608 void (*set_func) PARAMS ((char *args, int from_tty,
609 struct cmd_list_element * c));
610 void (*show_func) PARAMS ((char *name, int from_tty));
611 struct cmd_list_element **setlist;
612 struct cmd_list_element **showlist;
614 struct cmd_list_element *c;
619 config->title = title;
620 asprintf (&set_doc, "Set use of remote protocol `%s' (%s) packet",
622 asprintf (&show_doc, "Show current use of remote protocol `%s' (%s) packet",
624 asprintf (&full_name, "%s-packet", name);
625 c = add_set_enum_cmd (full_name,
626 class_obscure, packet_support_enums,
627 (char *) &config->state,
629 c->function.sfunc = set_func;
630 add_cmd (full_name, class_obscure, show_func, show_doc, showlist);
634 init_packet_config (config)
635 struct packet_config *config;
637 switch (config->detect)
639 case PACKET_AUTO_DETECT:
640 config->support = PACKET_SUPPORT_UNKNOWN;
642 case PACKET_MANUAL_DETECT:
643 /* let the user beware */
648 /* Should we try the 'P' (set register) request? */
650 static struct packet_config remote_protocol_P;
653 set_remote_protocol_P_packet_cmd (args, from_tty, c)
656 struct cmd_list_element *c;
658 set_packet_config_cmd (&remote_protocol_P, c);
662 show_remote_protocol_P_packet_cmd (args, from_tty)
666 show_packet_config_cmd (&remote_protocol_P);
669 /* Should we try the 'Z' (set breakpoint) request? */
671 static struct packet_config remote_protocol_Z;
674 set_remote_protocol_Z_packet_cmd (args, from_tty, c)
677 struct cmd_list_element *c;
679 set_packet_config_cmd (&remote_protocol_Z, c);
683 show_remote_protocol_Z_packet_cmd (args, from_tty)
687 show_packet_config_cmd (&remote_protocol_Z);
690 /* Should we try the 'X' (remote binary download) packet?
692 This variable (available to the user via "set remote X-packet")
693 dictates whether downloads are sent in binary (via the 'X' packet).
694 We assume that the stub can, and attempt to do it. This will be
695 cleared if the stub does not understand it. This switch is still
696 needed, though in cases when the packet is supported in the stub,
697 but the connection does not allow it (i.e., 7-bit serial connection
700 static struct packet_config remote_protocol_binary_download;
703 set_remote_protocol_binary_download_cmd (char *args,
705 struct cmd_list_element *c)
707 set_packet_config_cmd (&remote_protocol_binary_download, c);
711 show_remote_protocol_binary_download_cmd (char *args,
714 show_packet_config_cmd (&remote_protocol_binary_download);
718 /* Tokens for use by the asynchronous signal handlers for SIGINT */
719 PTR sigint_remote_twice_token;
720 PTR sigint_remote_token;
722 /* These are pointers to hook functions that may be set in order to
723 modify resume/wait behavior for a particular architecture. */
725 void (*target_resume_hook) PARAMS ((void));
726 void (*target_wait_loop_hook) PARAMS ((void));
730 /* These are the threads which we last sent to the remote system.
731 -1 for all or -2 for not sent yet. */
732 static int general_thread;
733 static int continue_thread;
735 /* Call this function as a result of
736 1) A halt indication (T packet) containing a thread id
737 2) A direct query of currthread
738 3) Successful execution of set thread
742 record_currthread (currthread)
745 general_thread = currthread;
747 /* If this is a new thread, add it to GDB's thread list.
748 If we leave it up to WFI to do this, bad things will happen. */
749 if (!in_thread_list (currthread))
751 add_thread (currthread);
753 ui_out_text (uiout, "[New ");
754 ui_out_text (uiout, target_pid_to_str (currthread));
755 ui_out_text (uiout, "]\n");
757 printf_filtered ("[New %s]\n", target_pid_to_str (currthread));
762 #define MAGIC_NULL_PID 42000
769 char *buf = alloca (PBUFSIZ);
770 int state = gen ? general_thread : continue_thread;
776 buf[1] = gen ? 'g' : 'c';
777 if (th == MAGIC_NULL_PID)
783 sprintf (&buf[2], "-%x", -th);
785 sprintf (&buf[2], "%x", th);
787 getpkt (buf, PBUFSIZ, 0);
791 continue_thread = th;
794 /* Return nonzero if the thread TH is still alive on the remote system. */
797 remote_thread_alive (tid)
803 sprintf (buf, "T-%08x", -tid);
805 sprintf (buf, "T%08x", tid);
807 getpkt (buf, sizeof (buf), 0);
808 return (buf[0] == 'O' && buf[1] == 'K');
811 /* About these extended threadlist and threadinfo packets. They are
812 variable length packets but, the fields within them are often fixed
813 length. They are redundent enough to send over UDP as is the
814 remote protocol in general. There is a matching unit test module
817 #define OPAQUETHREADBYTES 8
819 /* a 64 bit opaque identifier */
820 typedef unsigned char threadref[OPAQUETHREADBYTES];
822 /* WARNING: This threadref data structure comes from the remote O.S., libstub
823 protocol encoding, and remote.c. it is not particularly changable */
825 /* Right now, the internal structure is int. We want it to be bigger.
829 typedef int gdb_threadref; /* internal GDB thread reference */
831 /* gdb_ext_thread_info is an internal GDB data structure which is
832 equivalint to the reply of the remote threadinfo packet */
834 struct gdb_ext_thread_info
836 threadref threadid; /* External form of thread reference */
837 int active; /* Has state interesting to GDB? , regs, stack */
838 char display[256]; /* Brief state display, name, blocked/syspended */
839 char shortname[32]; /* To be used to name threads */
840 char more_display[256]; /* Long info, statistics, queue depth, whatever */
843 /* The volume of remote transfers can be limited by submitting
844 a mask containing bits specifying the desired information.
845 Use a union of these values as the 'selection' parameter to
846 get_thread_info. FIXME: Make these TAG names more thread specific.
849 #define TAG_THREADID 1
851 #define TAG_DISPLAY 4
852 #define TAG_THREADNAME 8
853 #define TAG_MOREDISPLAY 16
855 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES*2)
857 char *unpack_varlen_hex PARAMS ((char *buff, int *result));
859 static char *unpack_nibble PARAMS ((char *buf, int *val));
861 static char *pack_nibble PARAMS ((char *buf, int nibble));
863 static char *pack_hex_byte PARAMS ((char *pkt, int /*unsigned char */ byte));
865 static char *unpack_byte PARAMS ((char *buf, int *value));
867 static char *pack_int PARAMS ((char *buf, int value));
869 static char *unpack_int PARAMS ((char *buf, int *value));
871 static char *unpack_string PARAMS ((char *src, char *dest, int length));
873 static char *pack_threadid PARAMS ((char *pkt, threadref * id));
875 static char *unpack_threadid PARAMS ((char *inbuf, threadref * id));
877 void int_to_threadref PARAMS ((threadref * id, int value));
879 static int threadref_to_int PARAMS ((threadref * ref));
881 static void copy_threadref PARAMS ((threadref * dest, threadref * src));
883 static int threadmatch PARAMS ((threadref * dest, threadref * src));
885 static char *pack_threadinfo_request PARAMS ((char *pkt, int mode,
888 static int remote_unpack_thread_info_response PARAMS ((char *pkt,
889 threadref * expectedref,
890 struct gdb_ext_thread_info * info));
893 static int remote_get_threadinfo PARAMS ((threadref * threadid,
894 int fieldset, /*TAG mask */
895 struct gdb_ext_thread_info * info));
897 static int adapt_remote_get_threadinfo PARAMS ((gdb_threadref * ref,
899 struct gdb_ext_thread_info * info));
901 static char *pack_threadlist_request PARAMS ((char *pkt, int startflag,
903 threadref * nextthread));
905 static int parse_threadlist_response PARAMS ((char *pkt,
907 threadref * original_echo,
908 threadref * resultlist,
911 static int remote_get_threadlist PARAMS ((int startflag,
912 threadref * nextthread,
916 threadref * threadlist));
918 typedef int (*rmt_thread_action) (threadref * ref, void *context);
920 static int remote_threadlist_iterator PARAMS ((rmt_thread_action stepfunction,
921 void *context, int looplimit));
923 static int remote_newthread_step PARAMS ((threadref * ref, void *context));
925 /* encode 64 bits in 16 chars of hex */
927 static const char hexchars[] = "0123456789abcdef";
934 if ((ch >= 'a') && (ch <= 'f'))
936 *val = ch - 'a' + 10;
939 if ((ch >= 'A') && (ch <= 'F'))
941 *val = ch - 'A' + 10;
944 if ((ch >= '0') && (ch <= '9'))
956 if (ch >= 'a' && ch <= 'f')
957 return ch - 'a' + 10;
958 if (ch >= '0' && ch <= '9')
960 if (ch >= 'A' && ch <= 'F')
961 return ch - 'A' + 10;
966 stub_unpack_int (buff, fieldlength)
975 nibble = stubhex (*buff++);
979 retval = retval << 4;
985 unpack_varlen_hex (buff, result)
986 char *buff; /* packet to parse */
992 while (ishex (*buff, &nibble))
995 retval = retval << 4;
996 retval |= nibble & 0x0f;
1003 unpack_nibble (buf, val)
1007 ishex (*buf++, val);
1012 pack_nibble (buf, nibble)
1016 *buf++ = hexchars[(nibble & 0x0f)];
1021 pack_hex_byte (pkt, byte)
1025 *pkt++ = hexchars[(byte >> 4) & 0xf];
1026 *pkt++ = hexchars[(byte & 0xf)];
1031 unpack_byte (buf, value)
1035 *value = stub_unpack_int (buf, 2);
1040 pack_int (buf, value)
1044 buf = pack_hex_byte (buf, (value >> 24) & 0xff);
1045 buf = pack_hex_byte (buf, (value >> 16) & 0xff);
1046 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
1047 buf = pack_hex_byte (buf, (value & 0xff));
1052 unpack_int (buf, value)
1056 *value = stub_unpack_int (buf, 8);
1060 #if 0 /* currently unused, uncomment when needed */
1061 static char *pack_string PARAMS ((char *pkt, char *string));
1064 pack_string (pkt, string)
1071 len = strlen (string);
1073 len = 200; /* Bigger than most GDB packets, junk??? */
1074 pkt = pack_hex_byte (pkt, len);
1078 if ((ch == '\0') || (ch == '#'))
1079 ch = '*'; /* Protect encapsulation */
1084 #endif /* 0 (unused) */
1087 unpack_string (src, dest, length)
1099 pack_threadid (pkt, id)
1104 unsigned char *altid;
1106 altid = (unsigned char *) id;
1107 limit = pkt + BUF_THREAD_ID_SIZE;
1109 pkt = pack_hex_byte (pkt, *altid++);
1115 unpack_threadid (inbuf, id)
1120 char *limit = inbuf + BUF_THREAD_ID_SIZE;
1123 altref = (char *) id;
1125 while (inbuf < limit)
1127 x = stubhex (*inbuf++);
1128 y = stubhex (*inbuf++);
1129 *altref++ = (x << 4) | y;
1134 /* Externally, threadrefs are 64 bits but internally, they are still
1135 ints. This is due to a mismatch of specifications. We would like
1136 to use 64bit thread references internally. This is an adapter
1140 int_to_threadref (id, value)
1144 unsigned char *scan;
1146 scan = (unsigned char *) id;
1152 *scan++ = (value >> 24) & 0xff;
1153 *scan++ = (value >> 16) & 0xff;
1154 *scan++ = (value >> 8) & 0xff;
1155 *scan++ = (value & 0xff);
1159 threadref_to_int (ref)
1163 unsigned char *scan;
1165 scan = (char *) ref;
1169 value = (value << 8) | ((*scan++) & 0xff);
1174 copy_threadref (dest, src)
1179 unsigned char *csrc, *cdest;
1181 csrc = (unsigned char *) src;
1182 cdest = (unsigned char *) dest;
1189 threadmatch (dest, src)
1193 /* things are broken right now, so just assume we got a match */
1195 unsigned char *srcp, *destp;
1197 srcp = (char *) src;
1198 destp = (char *) dest;
1202 result &= (*srcp++ == *destp++) ? 1 : 0;
1209 threadid:1, # always request threadid
1216 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1219 pack_threadinfo_request (pkt, mode, id)
1224 *pkt++ = 'q'; /* Info Query */
1225 *pkt++ = 'P'; /* process or thread info */
1226 pkt = pack_int (pkt, mode); /* mode */
1227 pkt = pack_threadid (pkt, id); /* threadid */
1228 *pkt = '\0'; /* terminate */
1232 /* These values tag the fields in a thread info response packet */
1233 /* Tagging the fields allows us to request specific fields and to
1234 add more fields as time goes by */
1236 #define TAG_THREADID 1 /* Echo the thread identifier */
1237 #define TAG_EXISTS 2 /* Is this process defined enough to
1238 fetch registers and its stack */
1239 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1240 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is */
1241 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1245 remote_unpack_thread_info_response (pkt, expectedref, info)
1247 threadref *expectedref;
1248 struct gdb_ext_thread_info *info;
1253 char *limit = pkt + PBUFSIZ; /* plausable parsing limit */
1256 /* info->threadid = 0; FIXME: implement zero_threadref */
1258 info->display[0] = '\0';
1259 info->shortname[0] = '\0';
1260 info->more_display[0] = '\0';
1262 /* Assume the characters indicating the packet type have been stripped */
1263 pkt = unpack_int (pkt, &mask); /* arg mask */
1264 pkt = unpack_threadid (pkt, &ref);
1267 warning ("Incomplete response to threadinfo request\n");
1268 if (!threadmatch (&ref, expectedref))
1269 { /* This is an answer to a different request */
1270 warning ("ERROR RMT Thread info mismatch\n");
1273 copy_threadref (&info->threadid, &ref);
1275 /* Loop on tagged fields , try to bail if somthing goes wrong */
1277 while ((pkt < limit) && mask && *pkt) /* packets are terminated with nulls */
1279 pkt = unpack_int (pkt, &tag); /* tag */
1280 pkt = unpack_byte (pkt, &length); /* length */
1281 if (!(tag & mask)) /* tags out of synch with mask */
1283 warning ("ERROR RMT: threadinfo tag mismatch\n");
1287 if (tag == TAG_THREADID)
1291 warning ("ERROR RMT: length of threadid is not 16\n");
1295 pkt = unpack_threadid (pkt, &ref);
1296 mask = mask & ~TAG_THREADID;
1299 if (tag == TAG_EXISTS)
1301 info->active = stub_unpack_int (pkt, length);
1303 mask = mask & ~(TAG_EXISTS);
1306 warning ("ERROR RMT: 'exists' length too long\n");
1312 if (tag == TAG_THREADNAME)
1314 pkt = unpack_string (pkt, &info->shortname[0], length);
1315 mask = mask & ~TAG_THREADNAME;
1318 if (tag == TAG_DISPLAY)
1320 pkt = unpack_string (pkt, &info->display[0], length);
1321 mask = mask & ~TAG_DISPLAY;
1324 if (tag == TAG_MOREDISPLAY)
1326 pkt = unpack_string (pkt, &info->more_display[0], length);
1327 mask = mask & ~TAG_MOREDISPLAY;
1330 warning ("ERROR RMT: unknown thread info tag\n");
1331 break; /* Not a tag we know about */
1337 remote_get_threadinfo (threadid, fieldset, info)
1338 threadref *threadid;
1339 int fieldset; /* TAG mask */
1340 struct gdb_ext_thread_info *info;
1343 char *threadinfo_pkt = alloca (PBUFSIZ);
1345 pack_threadinfo_request (threadinfo_pkt, fieldset, threadid);
1346 putpkt (threadinfo_pkt);
1347 getpkt (threadinfo_pkt, PBUFSIZ, 0);
1348 result = remote_unpack_thread_info_response (threadinfo_pkt + 2, threadid,
1353 /* Unfortunately, 61 bit thread-ids are bigger than the internal
1354 representation of a threadid. */
1357 adapt_remote_get_threadinfo (ref, selection, info)
1360 struct gdb_ext_thread_info *info;
1364 int_to_threadref (&lclref, *ref);
1365 return remote_get_threadinfo (&lclref, selection, info);
1368 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1371 pack_threadlist_request (pkt, startflag, threadcount, nextthread)
1375 threadref *nextthread;
1377 *pkt++ = 'q'; /* info query packet */
1378 *pkt++ = 'L'; /* Process LIST or threadLIST request */
1379 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */
1380 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */
1381 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */
1386 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1389 parse_threadlist_response (pkt, result_limit, original_echo, resultlist,
1393 threadref *original_echo;
1394 threadref *resultlist;
1398 int count, resultcount, done;
1401 /* Assume the 'q' and 'M chars have been stripped. */
1402 limit = pkt + (PBUFSIZ - BUF_THREAD_ID_SIZE); /* done parse past here */
1403 pkt = unpack_byte (pkt, &count); /* count field */
1404 pkt = unpack_nibble (pkt, &done);
1405 /* The first threadid is the argument threadid. */
1406 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */
1407 while ((count-- > 0) && (pkt < limit))
1409 pkt = unpack_threadid (pkt, resultlist++);
1410 if (resultcount++ >= result_limit)
1419 remote_get_threadlist (startflag, nextthread, result_limit,
1420 done, result_count, threadlist)
1422 threadref *nextthread;
1426 threadref *threadlist;
1429 static threadref echo_nextthread;
1430 char *threadlist_packet = alloca (PBUFSIZ);
1431 char *t_response = alloca (PBUFSIZ);
1434 /* Trancate result limit to be smaller than the packet size */
1435 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= PBUFSIZ)
1436 result_limit = (PBUFSIZ / BUF_THREAD_ID_SIZE) - 2;
1438 pack_threadlist_request (threadlist_packet,
1439 startflag, result_limit, nextthread);
1440 putpkt (threadlist_packet);
1441 getpkt (t_response, PBUFSIZ, 0);
1444 parse_threadlist_response (t_response + 2, result_limit, &echo_nextthread,
1447 if (!threadmatch (&echo_nextthread, nextthread))
1449 /* FIXME: This is a good reason to drop the packet */
1450 /* Possably, there is a duplicate response */
1452 retransmit immediatly - race conditions
1453 retransmit after timeout - yes
1455 wait for packet, then exit
1457 warning ("HMM: threadlist did not echo arg thread, dropping it\n");
1458 return 0; /* I choose simply exiting */
1460 if (*result_count <= 0)
1464 warning ("RMT ERROR : failed to get remote thread list\n");
1467 return result; /* break; */
1469 if (*result_count > result_limit)
1472 warning ("RMT ERROR: threadlist response longer than requested\n");
1478 /* This is the interface between remote and threads, remotes upper interface */
1480 /* remote_find_new_threads retrieves the thread list and for each
1481 thread in the list, looks up the thread in GDB's internal list,
1482 ading the thread if it does not already exist. This involves
1483 getting partial thread lists from the remote target so, polling the
1484 quit_flag is required. */
1487 /* About this many threadisds fit in a packet. */
1489 #define MAXTHREADLISTRESULTS 32
1492 remote_threadlist_iterator (stepfunction, context, looplimit)
1493 rmt_thread_action stepfunction;
1497 int done, i, result_count;
1501 static threadref nextthread;
1502 static threadref resultthreadlist[MAXTHREADLISTRESULTS];
1507 if (loopcount++ > looplimit)
1510 warning ("Remote fetch threadlist -infinite loop-\n");
1513 if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS,
1514 &done, &result_count, resultthreadlist))
1519 /* clear for later iterations */
1521 /* Setup to resume next batch of thread references, set nextthread. */
1522 if (result_count >= 1)
1523 copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
1525 while (result_count--)
1526 if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
1533 remote_newthread_step (ref, context)
1539 pid = threadref_to_int (ref);
1540 if (!in_thread_list (pid))
1542 return 1; /* continue iterator */
1545 #define CRAZY_MAX_THREADS 1000
1548 remote_current_thread (oldpid)
1551 char *buf = alloca (PBUFSIZ);
1554 getpkt (buf, PBUFSIZ, 0);
1555 if (buf[0] == 'Q' && buf[1] == 'C')
1556 return strtol (&buf[2], NULL, 16);
1561 /* Find new threads for info threads command. */
1564 remote_find_new_threads ()
1566 remote_threadlist_iterator (remote_newthread_step, 0,
1568 if (inferior_pid == MAGIC_NULL_PID) /* ack ack ack */
1569 inferior_pid = remote_current_thread (inferior_pid);
1573 remote_threads_info (void)
1575 char *buf = alloca (PBUFSIZ);
1579 if (remote_desc == 0) /* paranoia */
1580 error ("Command can only be used when connected to the remote target.");
1582 putpkt ("qfThreadInfo");
1584 getpkt (bufp, PBUFSIZ, 0);
1585 if (bufp[0] == '\0') /* q packet not recognized! */
1586 { /* try old jmetzler method */
1587 remote_find_new_threads ();
1590 else /* try new 'q' method */
1591 while (*bufp++ == 'm') /* reply contains one or more TID */
1595 tid = strtol (bufp, &bufp, 16);
1596 if (tid != 0 && !in_thread_list (tid))
1599 while (*bufp++ == ','); /* comma-separated list */
1600 putpkt ("qsThreadInfo");
1602 getpkt (bufp, PBUFSIZ, 0);
1607 /* Restart the remote side; this is an extended protocol operation. */
1610 extended_remote_restart ()
1612 char *buf = alloca (PBUFSIZ);
1614 /* Send the restart command; for reasons I don't understand the
1615 remote side really expects a number after the "R". */
1617 sprintf (&buf[1], "%x", 0);
1620 /* Now query for status so this looks just like we restarted
1621 gdbserver from scratch. */
1623 getpkt (buf, PBUFSIZ, 0);
1626 /* Clean up connection to a remote debugger. */
1630 remote_close (quitting)
1634 SERIAL_CLOSE (remote_desc);
1638 /* Query the remote side for the text, data and bss offsets. */
1643 char *buf = alloca (PBUFSIZ);
1646 CORE_ADDR text_addr, data_addr, bss_addr;
1647 struct section_offsets *offs;
1649 putpkt ("qOffsets");
1651 getpkt (buf, PBUFSIZ, 0);
1653 if (buf[0] == '\000')
1654 return; /* Return silently. Stub doesn't support
1658 warning ("Remote failure reply: %s", buf);
1662 /* Pick up each field in turn. This used to be done with scanf, but
1663 scanf will make trouble if CORE_ADDR size doesn't match
1664 conversion directives correctly. The following code will work
1665 with any size of CORE_ADDR. */
1666 text_addr = data_addr = bss_addr = 0;
1670 if (strncmp (ptr, "Text=", 5) == 0)
1673 /* Don't use strtol, could lose on big values. */
1674 while (*ptr && *ptr != ';')
1675 text_addr = (text_addr << 4) + fromhex (*ptr++);
1680 if (!lose && strncmp (ptr, ";Data=", 6) == 0)
1683 while (*ptr && *ptr != ';')
1684 data_addr = (data_addr << 4) + fromhex (*ptr++);
1689 if (!lose && strncmp (ptr, ";Bss=", 5) == 0)
1692 while (*ptr && *ptr != ';')
1693 bss_addr = (bss_addr << 4) + fromhex (*ptr++);
1699 error ("Malformed response to offset query, %s", buf);
1701 if (symfile_objfile == NULL)
1704 offs = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
1705 memcpy (offs, symfile_objfile->section_offsets, SIZEOF_SECTION_OFFSETS);
1707 ANOFFSET (offs, SECT_OFF_TEXT) = text_addr;
1709 /* This is a temporary kludge to force data and bss to use the same offsets
1710 because that's what nlmconv does now. The real solution requires changes
1711 to the stub and remote.c that I don't have time to do right now. */
1713 ANOFFSET (offs, SECT_OFF_DATA) = data_addr;
1714 ANOFFSET (offs, SECT_OFF_BSS) = data_addr;
1716 objfile_relocate (symfile_objfile, offs);
1720 * Cisco version of section offsets:
1722 * Instead of having GDB query the target for the section offsets,
1723 * Cisco lets the target volunteer the information! It's also in
1724 * a different format, so here are the functions that will decode
1725 * a section offset packet from a Cisco target.
1729 * Function: remote_cisco_section_offsets
1731 * Returns: zero for success, non-zero for failure
1735 remote_cisco_section_offsets (bfd_vma text_addr,
1738 bfd_signed_vma *text_offs,
1739 bfd_signed_vma *data_offs,
1740 bfd_signed_vma *bss_offs)
1742 bfd_vma text_base, data_base, bss_base;
1743 struct minimal_symbol *start;
1749 if (symfile_objfile == NULL)
1750 return -1; /* no can do nothin' */
1752 start = lookup_minimal_symbol ("_start", NULL, NULL);
1754 return -1; /* Can't find "_start" symbol */
1756 data_base = bss_base = 0;
1757 text_base = SYMBOL_VALUE_ADDRESS (start);
1759 abfd = symfile_objfile->obfd;
1760 for (sect = abfd->sections;
1764 p = (unsigned char *) bfd_get_section_name (abfd, sect);
1766 if (strcmp (p + len - 4, "data") == 0) /* ends in "data" */
1767 if (data_base == 0 ||
1768 data_base > bfd_get_section_vma (abfd, sect))
1769 data_base = bfd_get_section_vma (abfd, sect);
1770 if (strcmp (p + len - 3, "bss") == 0) /* ends in "bss" */
1771 if (bss_base == 0 ||
1772 bss_base > bfd_get_section_vma (abfd, sect))
1773 bss_base = bfd_get_section_vma (abfd, sect);
1775 *text_offs = text_addr - text_base;
1776 *data_offs = data_addr - data_base;
1777 *bss_offs = bss_addr - bss_base;
1782 sprintf (tmp, "VMA: text = 0x");
1783 sprintf_vma (tmp + strlen (tmp), text_addr);
1784 sprintf (tmp + strlen (tmp), " data = 0x");
1785 sprintf_vma (tmp + strlen (tmp), data_addr);
1786 sprintf (tmp + strlen (tmp), " bss = 0x");
1787 sprintf_vma (tmp + strlen (tmp), bss_addr);
1788 fprintf_filtered (gdb_stdlog, tmp);
1789 fprintf_filtered (gdb_stdlog,
1790 "Reloc offset: text = 0x%s data = 0x%s bss = 0x%s\n",
1791 paddr_nz (*text_offs),
1792 paddr_nz (*data_offs),
1793 paddr_nz (*bss_offs));
1800 * Function: remote_cisco_objfile_relocate
1802 * Relocate the symbol file for a remote target.
1806 remote_cisco_objfile_relocate (text_off, data_off, bss_off)
1807 bfd_signed_vma text_off;
1808 bfd_signed_vma data_off;
1809 bfd_signed_vma bss_off;
1811 struct section_offsets *offs;
1813 if (text_off != 0 || data_off != 0 || bss_off != 0)
1815 /* FIXME: This code assumes gdb-stabs.h is being used; it's
1816 broken for xcoff, dwarf, sdb-coff, etc. But there is no
1817 simple canonical representation for this stuff. */
1819 offs = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
1820 memcpy (offs, symfile_objfile->section_offsets, SIZEOF_SECTION_OFFSETS);
1822 ANOFFSET (offs, SECT_OFF_TEXT) = text_off;
1823 ANOFFSET (offs, SECT_OFF_DATA) = data_off;
1824 ANOFFSET (offs, SECT_OFF_BSS) = bss_off;
1826 /* First call the standard objfile_relocate. */
1827 objfile_relocate (symfile_objfile, offs);
1829 /* Now we need to fix up the section entries already attached to
1830 the exec target. These entries will control memory transfers
1831 from the exec file. */
1833 exec_set_section_offsets (text_off, data_off, bss_off);
1837 /* Stub for catch_errors. */
1840 remote_start_remote_dummy (void *dummy)
1842 start_remote (); /* Initialize gdb process mechanisms */
1847 remote_start_remote (dummy)
1850 immediate_quit = 1; /* Allow user to interrupt it */
1852 /* Ack any packet which the remote side has already sent. */
1853 SERIAL_WRITE (remote_desc, "+", 1);
1855 /* Let the stub know that we want it to return the thread. */
1858 inferior_pid = remote_current_thread (inferior_pid);
1860 get_offsets (); /* Get text, data & bss offsets */
1862 putpkt ("?"); /* initiate a query from remote machine */
1865 return remote_start_remote_dummy (dummy);
1868 /* Open a connection to a remote debugger.
1869 NAME is the filename used for communication. */
1872 remote_open (name, from_tty)
1876 remote_open_1 (name, from_tty, &remote_ops, 0);
1879 /* Just like remote_open, but with asynchronous support. */
1881 remote_async_open (name, from_tty)
1885 remote_async_open_1 (name, from_tty, &remote_async_ops, 0);
1888 /* Open a connection to a remote debugger using the extended
1889 remote gdb protocol. NAME is the filename used for communication. */
1892 extended_remote_open (name, from_tty)
1896 remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */ );
1899 /* Just like extended_remote_open, but with asynchronous support. */
1901 extended_remote_async_open (name, from_tty)
1905 remote_async_open_1 (name, from_tty, &extended_async_remote_ops, 1 /*extended_p */ );
1908 /* Generic code for opening a connection to a remote target. */
1910 static DCACHE *remote_dcache;
1913 remote_open_1 (name, from_tty, target, extended_p)
1916 struct target_ops *target;
1920 error ("To open a remote debug connection, you need to specify what\n\
1921 serial device is attached to the remote system\n\
1922 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
1924 /* See FIXME above */
1925 wait_forever_enabled_p = 1;
1927 target_preopen (from_tty);
1929 unpush_target (target);
1931 remote_dcache = dcache_init (remote_read_bytes, remote_write_bytes);
1933 remote_desc = SERIAL_OPEN (name);
1935 perror_with_name (name);
1937 if (baud_rate != -1)
1939 if (SERIAL_SETBAUDRATE (remote_desc, baud_rate))
1941 SERIAL_CLOSE (remote_desc);
1942 perror_with_name (name);
1946 SERIAL_RAW (remote_desc);
1948 /* If there is something sitting in the buffer we might take it as a
1949 response to a command, which would be bad. */
1950 SERIAL_FLUSH_INPUT (remote_desc);
1954 puts_filtered ("Remote debugging using ");
1955 puts_filtered (name);
1956 puts_filtered ("\n");
1958 push_target (target); /* Switch to using remote target now */
1960 init_packet_config (&remote_protocol_P);
1961 init_packet_config (&remote_protocol_Z);
1963 general_thread = -2;
1964 continue_thread = -2;
1966 /* Force remote_write_bytes to check whether target supports
1967 binary downloading. */
1968 init_packet_config (&remote_protocol_binary_download);
1970 /* Without this, some commands which require an active target (such
1971 as kill) won't work. This variable serves (at least) double duty
1972 as both the pid of the target process (if it has such), and as a
1973 flag indicating that a target is active. These functions should
1974 be split out into seperate variables, especially since GDB will
1975 someday have a notion of debugging several processes. */
1977 inferior_pid = MAGIC_NULL_PID;
1978 /* Start the remote connection; if error (0), discard this target.
1979 In particular, if the user quits, be sure to discard it
1980 (we'd be in an inconsistent state otherwise). */
1981 if (!catch_errors (remote_start_remote, NULL,
1982 "Couldn't establish connection to remote target\n",
1991 /* tell the remote that we're using the extended protocol. */
1992 char *buf = alloca (PBUFSIZ);
1994 getpkt (buf, PBUFSIZ, 0);
1998 /* Just like remote_open but with asynchronous support. */
2000 remote_async_open_1 (name, from_tty, target, extended_p)
2003 struct target_ops *target;
2007 error ("To open a remote debug connection, you need to specify what\n\
2008 serial device is attached to the remote system\n\
2009 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
2011 target_preopen (from_tty);
2013 unpush_target (target);
2015 remote_dcache = dcache_init (remote_read_bytes, remote_write_bytes);
2017 remote_desc = SERIAL_OPEN (name);
2019 perror_with_name (name);
2021 if (baud_rate != -1)
2023 if (SERIAL_SETBAUDRATE (remote_desc, baud_rate))
2025 SERIAL_CLOSE (remote_desc);
2026 perror_with_name (name);
2030 SERIAL_RAW (remote_desc);
2032 /* If there is something sitting in the buffer we might take it as a
2033 response to a command, which would be bad. */
2034 SERIAL_FLUSH_INPUT (remote_desc);
2038 puts_filtered ("Remote debugging using ");
2039 puts_filtered (name);
2040 puts_filtered ("\n");
2043 push_target (target); /* Switch to using remote target now */
2045 init_packet_config (&remote_protocol_P);
2046 init_packet_config (&remote_protocol_Z);
2048 general_thread = -2;
2049 continue_thread = -2;
2051 /* Force remote_write_bytes to check whether target supports
2052 binary downloading. */
2053 init_packet_config (&remote_protocol_binary_download);
2055 /* Without this, some commands which require an active target (such
2056 as kill) won't work. This variable serves (at least) double duty
2057 as both the pid of the target process (if it has such), and as a
2058 flag indicating that a target is active. These functions should
2059 be split out into seperate variables, especially since GDB will
2060 someday have a notion of debugging several processes. */
2061 inferior_pid = MAGIC_NULL_PID;
2063 /* With this target we start out by owning the terminal. */
2064 remote_async_terminal_ours_p = 1;
2066 /* FIXME: cagney/1999-09-23: During the initial connection it is
2067 assumed that the target is already ready and able to respond to
2068 requests. Unfortunatly remote_start_remote() eventually calls
2069 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2070 around this. Eventually a mechanism that allows
2071 wait_for_inferior() to expect/get timeouts will be
2073 wait_forever_enabled_p = 0;
2075 /* Start the remote connection; if error (0), discard this target.
2076 In particular, if the user quits, be sure to discard it
2077 (we'd be in an inconsistent state otherwise). */
2078 if (!catch_errors (remote_start_remote, NULL,
2079 "Couldn't establish connection to remote target\n",
2083 wait_forever_enabled_p = 1;
2087 wait_forever_enabled_p = 1;
2091 /* tell the remote that we're using the extended protocol. */
2092 char *buf = alloca (PBUFSIZ);
2094 getpkt (buf, PBUFSIZ, 0);
2098 /* This takes a program previously attached to and detaches it. After
2099 this is done, GDB can be used to debug some other program. We
2100 better not have left any breakpoints in the target program or it'll
2101 die when it hits one. */
2104 remote_detach (args, from_tty)
2108 char *buf = alloca (PBUFSIZ);
2111 error ("Argument given to \"detach\" when remotely debugging.");
2113 /* Tell the remote target to detach. */
2115 remote_send (buf, PBUFSIZ);
2119 puts_filtered ("Ending remote debugging.\n");
2123 /* Same as remote_detach, but with async support. */
2125 remote_async_detach (args, from_tty)
2129 char *buf = alloca (PBUFSIZ);
2132 error ("Argument given to \"detach\" when remotely debugging.");
2134 /* Tell the remote target to detach. */
2136 remote_send (buf, PBUFSIZ);
2138 /* Unregister the file descriptor from the event loop. */
2139 if (target_is_async_p ())
2140 SERIAL_ASYNC (remote_desc, NULL, 0);
2144 puts_filtered ("Ending remote debugging.\n");
2147 /* Convert hex digit A to a number. */
2153 if (a >= '0' && a <= '9')
2155 else if (a >= 'a' && a <= 'f')
2156 return a - 'a' + 10;
2157 else if (a >= 'A' && a <= 'F')
2158 return a - 'A' + 10;
2160 error ("Reply contains invalid hex digit %d", a);
2163 /* Convert number NIB to a hex digit. */
2172 return 'a' + nib - 10;
2175 /* Tell the remote machine to resume. */
2177 static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
2179 static int last_sent_step;
2182 remote_resume (pid, step, siggnal)
2184 enum target_signal siggnal;
2186 char *buf = alloca (PBUFSIZ);
2189 set_thread (0, 0); /* run any thread */
2191 set_thread (pid, 0); /* run this thread */
2193 dcache_flush (remote_dcache);
2195 last_sent_signal = siggnal;
2196 last_sent_step = step;
2198 /* A hook for when we need to do something at the last moment before
2200 if (target_resume_hook)
2201 (*target_resume_hook) ();
2203 if (siggnal != TARGET_SIGNAL_0)
2205 buf[0] = step ? 'S' : 'C';
2206 buf[1] = tohex (((int) siggnal >> 4) & 0xf);
2207 buf[2] = tohex ((int) siggnal & 0xf);
2211 strcpy (buf, step ? "s" : "c");
2216 /* Same as remote_resume, but with async support. */
2218 remote_async_resume (pid, step, siggnal)
2220 enum target_signal siggnal;
2222 char *buf = alloca (PBUFSIZ);
2225 set_thread (0, 0); /* run any thread */
2227 set_thread (pid, 0); /* run this thread */
2229 dcache_flush (remote_dcache);
2231 last_sent_signal = siggnal;
2232 last_sent_step = step;
2234 /* A hook for when we need to do something at the last moment before
2236 if (target_resume_hook)
2237 (*target_resume_hook) ();
2239 if (siggnal != TARGET_SIGNAL_0)
2241 buf[0] = step ? 'S' : 'C';
2242 buf[1] = tohex (((int) siggnal >> 4) & 0xf);
2243 buf[2] = tohex ((int) siggnal & 0xf);
2247 strcpy (buf, step ? "s" : "c");
2249 /* We are about to start executing the inferior, let's register it
2250 with the event loop. NOTE: this is the one place where all the
2251 execution commands end up. We could alternatively do this in each
2252 of the execution commands in infcmd.c.*/
2253 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2254 into infcmd.c in order to allow inferior function calls to work
2255 NOT asynchronously. */
2256 if (event_loop_p && target_can_async_p ())
2257 target_async (inferior_event_handler, 0);
2258 /* Tell the world that the target is now executing. */
2259 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2260 this? Instead, should the client of target just assume (for
2261 async targets) that the target is going to start executing? Is
2262 this information already found in the continuation block? */
2263 if (target_is_async_p ())
2264 target_executing = 1;
2269 /* Set up the signal handler for SIGINT, while the target is
2270 executing, ovewriting the 'regular' SIGINT signal handler. */
2272 initialize_sigint_signal_handler ()
2274 sigint_remote_token =
2275 create_async_signal_handler (async_remote_interrupt, NULL);
2276 signal (SIGINT, handle_remote_sigint);
2279 /* Signal handler for SIGINT, while the target is executing. */
2281 handle_remote_sigint (sig)
2284 signal (sig, handle_remote_sigint_twice);
2285 sigint_remote_twice_token =
2286 create_async_signal_handler (async_remote_interrupt_twice, NULL);
2287 mark_async_signal_handler_wrapper (sigint_remote_token);
2290 /* Signal handler for SIGINT, installed after SIGINT has already been
2291 sent once. It will take effect the second time that the user sends
2294 handle_remote_sigint_twice (sig)
2297 signal (sig, handle_sigint);
2298 sigint_remote_twice_token =
2299 create_async_signal_handler (inferior_event_handler_wrapper, NULL);
2300 mark_async_signal_handler_wrapper (sigint_remote_twice_token);
2303 /* Perform the real interruption of the target execution, in response
2306 async_remote_interrupt (arg)
2307 gdb_client_data arg;
2310 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
2315 /* Perform interrupt, if the first attempt did not succeed. Just give
2316 up on the target alltogether. */
2318 async_remote_interrupt_twice (arg)
2319 gdb_client_data arg;
2322 fprintf_unfiltered (gdb_stdlog, "remote_interrupt_twice called\n");
2323 /* Do something only if the target was not killed by the previous
2325 if (target_executing)
2328 signal (SIGINT, handle_remote_sigint);
2332 /* Reinstall the usual SIGINT handlers, after the target has
2335 cleanup_sigint_signal_handler (void *dummy)
2337 signal (SIGINT, handle_sigint);
2338 if (sigint_remote_twice_token)
2339 delete_async_signal_handler ((struct async_signal_handler **) & sigint_remote_twice_token);
2340 if (sigint_remote_token)
2341 delete_async_signal_handler ((struct async_signal_handler **) & sigint_remote_token);
2344 /* Send ^C to target to halt it. Target will respond, and send us a
2346 static void (*ofunc) PARAMS ((int));
2348 /* The command line interface's stop routine. This function is installed
2349 as a signal handler for SIGINT. The first time a user requests a
2350 stop, we call remote_stop to send a break or ^C. If there is no
2351 response from the target (it didn't stop when the user requested it),
2352 we ask the user if he'd like to detach from the target. */
2354 remote_interrupt (signo)
2357 /* If this doesn't work, try more severe steps. */
2358 signal (signo, remote_interrupt_twice);
2361 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
2366 /* The user typed ^C twice. */
2369 remote_interrupt_twice (signo)
2372 signal (signo, ofunc);
2374 signal (signo, remote_interrupt);
2377 /* This is the generic stop called via the target vector. When a target
2378 interrupt is requested, either by the command line or the GUI, we
2379 will eventually end up here. */
2383 /* Send a break or a ^C, depending on user preference. */
2385 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
2388 SERIAL_SEND_BREAK (remote_desc);
2390 SERIAL_WRITE (remote_desc, "\003", 1);
2393 /* Ask the user what to do when an interrupt is received. */
2398 target_terminal_ours ();
2400 if (query ("Interrupted while waiting for the program.\n\
2401 Give up (and stop debugging it)? "))
2403 target_mourn_inferior ();
2404 return_to_top_level (RETURN_QUIT);
2407 target_terminal_inferior ();
2410 /* Enable/disable target terminal ownership. Most targets can use
2411 terminal groups to control terminal ownership. Remote targets are
2412 different in that explicit transfer of ownership to/from GDB/target
2416 remote_async_terminal_inferior (void)
2418 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
2419 sync_execution here. This function should only be called when
2420 GDB is resuming the inferior in the forground. A background
2421 resume (``run&'') should leave GDB in control of the terminal and
2422 consequently should not call this code. */
2423 if (!sync_execution)
2425 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
2426 calls target_terminal_*() idenpotent. The event-loop GDB talking
2427 to an asynchronous target with a synchronous command calls this
2428 function from both event-top.c and infrun.c/infcmd.c. Once GDB
2429 stops trying to transfer the terminal to the target when it
2430 shouldn't this guard can go away. */
2431 if (!remote_async_terminal_ours_p)
2433 delete_file_handler (input_fd);
2434 remote_async_terminal_ours_p = 0;
2435 initialize_sigint_signal_handler ();
2436 /* NOTE: At this point we could also register our selves as the
2437 recipient of all input. Any characters typed could then be
2438 passed on down to the target. */
2442 remote_async_terminal_ours (void)
2444 /* See FIXME in remote_async_terminal_inferior. */
2445 if (!sync_execution)
2447 /* See FIXME in remote_async_terminal_inferior. */
2448 if (remote_async_terminal_ours_p)
2450 cleanup_sigint_signal_handler (NULL);
2451 add_file_handler (input_fd, stdin_event_handler, 0);
2452 remote_async_terminal_ours_p = 1;
2455 /* If nonzero, ignore the next kill. */
2460 remote_console_output (char *msg)
2464 for (p = msg; p[0] && p[1]; p += 2)
2467 char c = fromhex (p[0]) * 16 + fromhex (p[1]);
2470 fputs_unfiltered (tb, gdb_stdtarg);
2472 gdb_flush (gdb_stdtarg);
2475 /* Wait until the remote machine stops, then return,
2476 storing status in STATUS just as `wait' would.
2477 Returns "pid", which in the case of a multi-threaded
2478 remote OS, is the thread-id. */
2481 remote_wait (pid, status)
2483 struct target_waitstatus *status;
2485 unsigned char *buf = alloca (PBUFSIZ);
2486 int thread_num = -1;
2488 status->kind = TARGET_WAITKIND_EXITED;
2489 status->value.integer = 0;
2495 ofunc = signal (SIGINT, remote_interrupt);
2496 getpkt (buf, PBUFSIZ, 1);
2497 signal (SIGINT, ofunc);
2499 /* This is a hook for when we need to do something (perhaps the
2500 collection of trace data) every time the target stops. */
2501 if (target_wait_loop_hook)
2502 (*target_wait_loop_hook) ();
2506 case 'E': /* Error of some sort */
2507 warning ("Remote failure reply: %s", buf);
2509 case 'T': /* Status with PC, SP, FP, ... */
2513 char regs[MAX_REGISTER_RAW_SIZE];
2515 /* Expedited reply, containing Signal, {regno, reg} repeat */
2516 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
2518 n... = register number
2519 r... = register contents
2521 p = &buf[3]; /* after Txx */
2528 /* Read the register number */
2529 regno = strtol ((const char *) p, &p_temp, 16);
2530 p1 = (unsigned char *) p_temp;
2532 if (p1 == p) /* No register number present here */
2534 p1 = (unsigned char *) strchr ((const char *) p, ':');
2536 warning ("Malformed packet(a) (missing colon): %s\n\
2539 if (strncmp ((const char *) p, "thread", p1 - p) == 0)
2541 p_temp = unpack_varlen_hex (++p1, &thread_num);
2542 record_currthread (thread_num);
2543 p = (unsigned char *) p_temp;
2551 warning ("Malformed packet(b) (missing colon): %s\n\
2555 if (regno >= NUM_REGS)
2556 warning ("Remote sent bad register number %ld: %s\n\
2560 for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
2562 if (p[0] == 0 || p[1] == 0)
2563 warning ("Remote reply is too short: %s", buf);
2564 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
2567 supply_register (regno, regs);
2572 warning ("Remote register badly formatted: %s", buf);
2573 warning (" here: %s", p);
2578 case 'S': /* Old style status, just signal only */
2579 status->kind = TARGET_WAITKIND_STOPPED;
2580 status->value.sig = (enum target_signal)
2581 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
2585 /* Export Cisco kernel mode as a convenience variable
2586 (so that it can be used in the GDB prompt if desired). */
2588 if (cisco_kernel_mode == 1)
2589 set_internalvar (lookup_internalvar ("cisco_kernel_mode"),
2590 value_from_string ("PDEBUG-"));
2591 cisco_kernel_mode = 0;
2592 thread_num = strtol ((const char *) &buf[4], NULL, 16);
2593 record_currthread (thread_num);
2595 else if (buf[3] == 'k')
2597 /* Export Cisco kernel mode as a convenience variable
2598 (so that it can be used in the GDB prompt if desired). */
2600 if (cisco_kernel_mode == 1)
2601 set_internalvar (lookup_internalvar ("cisco_kernel_mode"),
2602 value_from_string ("KDEBUG-"));
2603 cisco_kernel_mode = 1;
2606 case 'N': /* Cisco special: status and offsets */
2608 bfd_vma text_addr, data_addr, bss_addr;
2609 bfd_signed_vma text_off, data_off, bss_off;
2612 status->kind = TARGET_WAITKIND_STOPPED;
2613 status->value.sig = (enum target_signal)
2614 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
2616 if (symfile_objfile == NULL)
2618 warning ("Relocation packet received with no symbol file. \
2623 /* Relocate object file. Buffer format is NAATT;DD;BB
2624 * where AA is the signal number, TT is the new text
2625 * address, DD * is the new data address, and BB is the
2626 * new bss address. */
2629 text_addr = strtoul (p, (char **) &p1, 16);
2630 if (p1 == p || *p1 != ';')
2631 warning ("Malformed relocation packet: Packet '%s'", buf);
2633 data_addr = strtoul (p, (char **) &p1, 16);
2634 if (p1 == p || *p1 != ';')
2635 warning ("Malformed relocation packet: Packet '%s'", buf);
2637 bss_addr = strtoul (p, (char **) &p1, 16);
2639 warning ("Malformed relocation packet: Packet '%s'", buf);
2641 if (remote_cisco_section_offsets (text_addr, data_addr, bss_addr,
2642 &text_off, &data_off, &bss_off)
2644 if (text_off != 0 || data_off != 0 || bss_off != 0)
2645 remote_cisco_objfile_relocate (text_off, data_off, bss_off);
2649 case 'W': /* Target exited */
2651 /* The remote process exited. */
2652 status->kind = TARGET_WAITKIND_EXITED;
2653 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
2657 status->kind = TARGET_WAITKIND_SIGNALLED;
2658 status->value.sig = (enum target_signal)
2659 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
2663 case 'O': /* Console output */
2664 remote_console_output (buf + 1);
2667 if (last_sent_signal != TARGET_SIGNAL_0)
2669 /* Zero length reply means that we tried 'S' or 'C' and
2670 the remote system doesn't support it. */
2671 target_terminal_ours_for_output ();
2673 ("Can't send signals to this remote system. %s not sent.\n",
2674 target_signal_to_name (last_sent_signal));
2675 last_sent_signal = TARGET_SIGNAL_0;
2676 target_terminal_inferior ();
2678 strcpy ((char *) buf, last_sent_step ? "s" : "c");
2679 putpkt ((char *) buf);
2682 /* else fallthrough */
2684 warning ("Invalid remote reply: %s", buf);
2689 if (thread_num != -1)
2693 return inferior_pid;
2696 /* Async version of remote_wait. */
2698 remote_async_wait (pid, status)
2700 struct target_waitstatus *status;
2702 unsigned char *buf = alloca (PBUFSIZ);
2703 int thread_num = -1;
2705 status->kind = TARGET_WAITKIND_EXITED;
2706 status->value.integer = 0;
2712 if (!target_is_async_p ())
2713 ofunc = signal (SIGINT, remote_interrupt);
2714 /* FIXME: cagney/1999-09-27: If we're in async mode we should
2715 _never_ wait for ever -> test on target_is_async_p().
2716 However, before we do that we need to ensure that the caller
2717 knows how to take the target into/out of async mode. */
2718 getpkt (buf, PBUFSIZ, wait_forever_enabled_p);
2719 if (!target_is_async_p ())
2720 signal (SIGINT, ofunc);
2722 /* This is a hook for when we need to do something (perhaps the
2723 collection of trace data) every time the target stops. */
2724 if (target_wait_loop_hook)
2725 (*target_wait_loop_hook) ();
2729 case 'E': /* Error of some sort */
2730 warning ("Remote failure reply: %s", buf);
2732 case 'T': /* Status with PC, SP, FP, ... */
2736 char regs[MAX_REGISTER_RAW_SIZE];
2738 /* Expedited reply, containing Signal, {regno, reg} repeat */
2739 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
2741 n... = register number
2742 r... = register contents
2744 p = &buf[3]; /* after Txx */
2751 /* Read the register number */
2752 regno = strtol ((const char *) p, &p_temp, 16);
2753 p1 = (unsigned char *) p_temp;
2755 if (p1 == p) /* No register number present here */
2757 p1 = (unsigned char *) strchr ((const char *) p, ':');
2759 warning ("Malformed packet(a) (missing colon): %s\n\
2762 if (strncmp ((const char *) p, "thread", p1 - p) == 0)
2764 p_temp = unpack_varlen_hex (++p1, &thread_num);
2765 record_currthread (thread_num);
2766 p = (unsigned char *) p_temp;
2774 warning ("Malformed packet(b) (missing colon): %s\n\
2778 if (regno >= NUM_REGS)
2779 warning ("Remote sent bad register number %ld: %s\n\
2783 for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
2785 if (p[0] == 0 || p[1] == 0)
2786 warning ("Remote reply is too short: %s", buf);
2787 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
2790 supply_register (regno, regs);
2795 warning ("Remote register badly formatted: %s", buf);
2796 warning (" here: %s", p);
2801 case 'S': /* Old style status, just signal only */
2802 status->kind = TARGET_WAITKIND_STOPPED;
2803 status->value.sig = (enum target_signal)
2804 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
2808 /* Export Cisco kernel mode as a convenience variable
2809 (so that it can be used in the GDB prompt if desired). */
2811 if (cisco_kernel_mode == 1)
2812 set_internalvar (lookup_internalvar ("cisco_kernel_mode"),
2813 value_from_string ("PDEBUG-"));
2814 cisco_kernel_mode = 0;
2815 thread_num = strtol ((const char *) &buf[4], NULL, 16);
2816 record_currthread (thread_num);
2818 else if (buf[3] == 'k')
2820 /* Export Cisco kernel mode as a convenience variable
2821 (so that it can be used in the GDB prompt if desired). */
2823 if (cisco_kernel_mode == 1)
2824 set_internalvar (lookup_internalvar ("cisco_kernel_mode"),
2825 value_from_string ("KDEBUG-"));
2826 cisco_kernel_mode = 1;
2829 case 'N': /* Cisco special: status and offsets */
2831 bfd_vma text_addr, data_addr, bss_addr;
2832 bfd_signed_vma text_off, data_off, bss_off;
2835 status->kind = TARGET_WAITKIND_STOPPED;
2836 status->value.sig = (enum target_signal)
2837 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
2839 if (symfile_objfile == NULL)
2841 warning ("Relocation packet recieved with no symbol file. \
2846 /* Relocate object file. Buffer format is NAATT;DD;BB
2847 * where AA is the signal number, TT is the new text
2848 * address, DD * is the new data address, and BB is the
2849 * new bss address. */
2852 text_addr = strtoul (p, (char **) &p1, 16);
2853 if (p1 == p || *p1 != ';')
2854 warning ("Malformed relocation packet: Packet '%s'", buf);
2856 data_addr = strtoul (p, (char **) &p1, 16);
2857 if (p1 == p || *p1 != ';')
2858 warning ("Malformed relocation packet: Packet '%s'", buf);
2860 bss_addr = strtoul (p, (char **) &p1, 16);
2862 warning ("Malformed relocation packet: Packet '%s'", buf);
2864 if (remote_cisco_section_offsets (text_addr, data_addr, bss_addr,
2865 &text_off, &data_off, &bss_off)
2867 if (text_off != 0 || data_off != 0 || bss_off != 0)
2868 remote_cisco_objfile_relocate (text_off, data_off, bss_off);
2872 case 'W': /* Target exited */
2874 /* The remote process exited. */
2875 status->kind = TARGET_WAITKIND_EXITED;
2876 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
2880 status->kind = TARGET_WAITKIND_SIGNALLED;
2881 status->value.sig = (enum target_signal)
2882 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
2886 case 'O': /* Console output */
2887 remote_console_output (buf + 1);
2888 /* Return immediately to the event loop. The event loop will
2889 still be waiting on the inferior afterwards. */
2890 status->kind = TARGET_WAITKIND_IGNORE;
2893 if (last_sent_signal != TARGET_SIGNAL_0)
2895 /* Zero length reply means that we tried 'S' or 'C' and
2896 the remote system doesn't support it. */
2897 target_terminal_ours_for_output ();
2899 ("Can't send signals to this remote system. %s not sent.\n",
2900 target_signal_to_name (last_sent_signal));
2901 last_sent_signal = TARGET_SIGNAL_0;
2902 target_terminal_inferior ();
2904 strcpy ((char *) buf, last_sent_step ? "s" : "c");
2905 putpkt ((char *) buf);
2908 /* else fallthrough */
2910 warning ("Invalid remote reply: %s", buf);
2915 if (thread_num != -1)
2919 return inferior_pid;
2922 /* Number of bytes of registers this stub implements. */
2924 static int register_bytes_found;
2926 /* Read the remote registers into the block REGS. */
2927 /* Currently we just read all the registers, so we don't use regno. */
2931 remote_fetch_registers (regno)
2934 char *buf = alloca (PBUFSIZ);
2937 char regs[REGISTER_BYTES];
2939 set_thread (inferior_pid, 1);
2942 remote_send (buf, PBUFSIZ);
2944 /* Save the size of the packet sent to us by the target. Its used
2945 as a heuristic when determining the max size of packets that the
2946 target can safely receive. */
2947 if (actual_register_packet_size == 0)
2948 actual_register_packet_size = strlen (buf);
2950 /* Unimplemented registers read as all bits zero. */
2951 memset (regs, 0, REGISTER_BYTES);
2953 /* We can get out of synch in various cases. If the first character
2954 in the buffer is not a hex character, assume that has happened
2955 and try to fetch another packet to read. */
2956 while ((buf[0] < '0' || buf[0] > '9')
2957 && (buf[0] < 'a' || buf[0] > 'f')
2958 && buf[0] != 'x') /* New: unavailable register value */
2961 fprintf_unfiltered (gdb_stdlog,
2962 "Bad register packet; fetching a new packet\n");
2963 getpkt (buf, PBUFSIZ, 0);
2966 /* Reply describes registers byte by byte, each byte encoded as two
2967 hex characters. Suck them all up, then supply them to the
2968 register cacheing/storage mechanism. */
2971 for (i = 0; i < REGISTER_BYTES; i++)
2977 warning ("Remote reply is of odd length: %s", buf);
2978 /* Don't change register_bytes_found in this case, and don't
2979 print a second warning. */
2982 if (p[0] == 'x' && p[1] == 'x')
2983 regs[i] = 0; /* 'x' */
2985 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
2989 if (i != register_bytes_found)
2991 register_bytes_found = i;
2992 #ifdef REGISTER_BYTES_OK
2993 if (!REGISTER_BYTES_OK (i))
2994 warning ("Remote reply is too short: %s", buf);
2999 for (i = 0; i < NUM_REGS; i++)
3001 supply_register (i, ®s[REGISTER_BYTE (i)]);
3002 if (buf[REGISTER_BYTE (i) * 2] == 'x')
3003 register_valid[i] = -1; /* register value not available */
3007 /* Prepare to store registers. Since we may send them all (using a
3008 'G' request), we have to read out the ones we don't want to change
3012 remote_prepare_to_store ()
3014 /* Make sure the entire registers array is valid. */
3015 switch (remote_protocol_P.support)
3017 case PACKET_DISABLE:
3018 case PACKET_SUPPORT_UNKNOWN:
3019 read_register_bytes (0, (char *) NULL, REGISTER_BYTES);
3026 /* Helper: Attempt to store REGNO using the P packet. Return fail IFF
3027 packet was not recognized. */
3030 store_register_using_P (int regno)
3032 /* Try storing a single register. */
3033 char *buf = alloca (PBUFSIZ);
3038 sprintf (buf, "P%x=", regno);
3039 p = buf + strlen (buf);
3040 regp = ®isters[REGISTER_BYTE (regno)];
3041 for (i = 0; i < REGISTER_RAW_SIZE (regno); ++i)
3043 *p++ = tohex ((regp[i] >> 4) & 0xf);
3044 *p++ = tohex (regp[i] & 0xf);
3047 remote_send (buf, PBUFSIZ);
3049 return buf[0] != '\0';
3053 /* Store register REGNO, or all registers if REGNO == -1, from the contents
3054 of REGISTERS. FIXME: ignores errors. */
3057 remote_store_registers (regno)
3060 char *buf = alloca (PBUFSIZ);
3064 set_thread (inferior_pid, 1);
3068 switch (remote_protocol_P.support)
3070 case PACKET_DISABLE:
3073 if (store_register_using_P (regno))
3076 error ("Protocol error: P packet not recognized by stub");
3077 case PACKET_SUPPORT_UNKNOWN:
3078 if (store_register_using_P (regno))
3080 /* The stub recognized the 'P' packet. Remember this. */
3081 remote_protocol_P.support = PACKET_ENABLE;
3086 /* The stub does not support the 'P' packet. Use 'G'
3087 instead, and don't try using 'P' in the future (it
3088 will just waste our time). */
3089 remote_protocol_P.support = PACKET_DISABLE;
3097 /* Command describes registers byte by byte,
3098 each byte encoded as two hex characters. */
3101 /* remote_prepare_to_store insures that register_bytes_found gets set. */
3102 for (i = 0; i < register_bytes_found; i++)
3104 *p++ = tohex ((registers[i] >> 4) & 0xf);
3105 *p++ = tohex (registers[i] & 0xf);
3109 remote_send (buf, PBUFSIZ);
3112 /* Use of the data cache *used* to be disabled because it loses for looking
3113 at and changing hardware I/O ports and the like. Accepting `volatile'
3114 would perhaps be one way to fix it. Another idea would be to use the
3115 executable file for the text segment (for all SEC_CODE sections?
3116 For all SEC_READONLY sections?). This has problems if you want to
3117 actually see what the memory contains (e.g. self-modifying code,
3118 clobbered memory, user downloaded the wrong thing).
3120 Because it speeds so much up, it's now enabled, if you're playing
3121 with registers you turn it of (set remotecache 0). */
3123 /* Read a word from remote address ADDR and return it.
3124 This goes through the data cache. */
3128 remote_fetch_word (addr)
3131 return dcache_fetch (remote_dcache, addr);
3134 /* Write a word WORD into remote address ADDR.
3135 This goes through the data cache. */
3138 remote_store_word (addr, word)
3142 dcache_poke (remote_dcache, addr, word);
3144 #endif /* 0 (unused?) */
3148 /* Return the number of hex digits in num. */
3156 for (i = 0; num != 0; i++)
3162 /* Set BUF to the minimum number of hex digits representing NUM. */
3165 hexnumstr (buf, num)
3169 int len = hexnumlen (num);
3170 return hexnumnstr (buf, num, len);
3174 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3177 hexnumnstr (buf, num, width)
3186 for (i = width - 1; i >= 0; i--)
3188 buf[i] = "0123456789abcdef"[(num & 0xf)];
3195 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3198 remote_address_masked (addr)
3201 if (remote_address_size > 0
3202 && remote_address_size < (sizeof (ULONGEST) * 8))
3204 /* Only create a mask when that mask can safely be constructed
3205 in a ULONGEST variable. */
3207 mask = (mask << remote_address_size) - 1;
3213 /* Determine whether the remote target supports binary downloading.
3214 This is accomplished by sending a no-op memory write of zero length
3215 to the target at the specified address. It does not suffice to send
3216 the whole packet, since many stubs strip the eighth bit and subsequently
3217 compute a wrong checksum, which causes real havoc with remote_write_bytes.
3219 NOTE: This can still lose if the serial line is not eight-bit
3220 clean. In cases like this, the user should clear "remote
3224 check_binary_download (addr)
3227 switch (remote_protocol_binary_download.support)
3229 case PACKET_DISABLE:
3233 case PACKET_SUPPORT_UNKNOWN:
3235 char *buf = alloca (PBUFSIZ);
3240 p += hexnumstr (p, (ULONGEST) addr);
3242 p += hexnumstr (p, (ULONGEST) 0);
3246 putpkt_binary (buf, (int) (p - buf));
3247 getpkt (buf, PBUFSIZ, 0);
3252 fprintf_unfiltered (gdb_stdlog,
3253 "binary downloading NOT suppported by target\n");
3254 remote_protocol_binary_download.support = PACKET_DISABLE;
3259 fprintf_unfiltered (gdb_stdlog,
3260 "binary downloading suppported by target\n");
3261 remote_protocol_binary_download.support = PACKET_ENABLE;
3268 /* Write memory data directly to the remote machine.
3269 This does not inform the data cache; the data cache uses this.
3270 MEMADDR is the address in the remote memory space.
3271 MYADDR is the address of the buffer in our space.
3272 LEN is the number of bytes.
3274 Returns number of bytes transferred, or 0 (setting errno) for
3275 error. Only transfer a single packet. */
3278 remote_write_bytes (CORE_ADDR memaddr, char *myaddr, int len)
3281 int max_buf_size; /* Max size of packet output buffer */
3283 unsigned char *plen;
3289 /* Verify that the target can support a binary download */
3290 check_binary_download (memaddr);
3292 /* Determine the max packet size. */
3293 max_buf_size = get_memory_write_packet_size ();
3294 sizeof_buf = max_buf_size + 1; /* Space for trailing NUL */
3295 buf = alloca (sizeof_buf);
3297 /* Subtract header overhead from max payload size - $M<memaddr>,<len>:#nn */
3298 max_buf_size -= 2 + hexnumlen (memaddr + len - 1) + 1 + hexnumlen (len) + 4;
3300 /* construct "M"<memaddr>","<len>":" */
3301 /* sprintf (buf, "M%lx,%x:", (unsigned long) memaddr, todo); */
3304 /* Append [XM]. Compute a best guess of the number of bytes
3305 actually transfered. */
3306 switch (remote_protocol_binary_download.support)
3310 /* Best guess at number of bytes that will fit. */
3311 todo = min (len, max_buf_size);
3313 case PACKET_DISABLE:
3315 /* num bytes that will fit */
3316 todo = min (len, max_buf_size / 2);
3318 case PACKET_SUPPORT_UNKNOWN:
3319 internal_error ("remote_write_bytes: bad switch");
3322 /* Append <memaddr> */
3323 memaddr = remote_address_masked (memaddr);
3324 p += hexnumstr (p, (ULONGEST) memaddr);
3327 /* Append <len>. Retain the location/size of <len>. It may
3328 need to be adjusted once the packet body has been created. */
3330 plenlen = hexnumstr (p, (ULONGEST) todo);
3335 /* Append the packet body. */
3336 switch (remote_protocol_binary_download.support)
3339 /* Binary mode. Send target system values byte by byte, in
3340 increasing byte addresses. Only escape certain critical
3343 (nr_bytes < todo) && (p - buf) < (max_buf_size - 2);
3346 switch (myaddr[nr_bytes] & 0xff)
3351 /* These must be escaped */
3353 *p++ = (myaddr[nr_bytes] & 0xff) ^ 0x20;
3356 *p++ = myaddr[nr_bytes] & 0xff;
3360 if (nr_bytes < todo)
3362 /* Escape chars have filled up the buffer prematurely,
3363 and we have actually sent fewer bytes than planned.
3364 Fix-up the length field of the packet. Use the same
3365 number of characters as before. */
3367 plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
3368 *plen = ':'; /* overwrite \0 from hexnumnstr() */
3371 case PACKET_DISABLE:
3372 /* Normal mode: Send target system values byte by byte, in
3373 increasing byte addresses. Each byte is encoded as a two hex
3375 for (nr_bytes = 0; nr_bytes < todo; nr_bytes++)
3377 *p++ = tohex ((myaddr[nr_bytes] >> 4) & 0xf);
3378 *p++ = tohex (myaddr[nr_bytes] & 0xf);
3382 case PACKET_SUPPORT_UNKNOWN:
3383 internal_error ("remote_write_bytes: bad switch");
3386 putpkt_binary (buf, (int) (p - buf));
3387 getpkt (buf, sizeof_buf, 0);
3391 /* There is no correspondance between what the remote protocol
3392 uses for errors and errno codes. We would like a cleaner way
3393 of representing errors (big enough to include errno codes,
3394 bfd_error codes, and others). But for now just return EIO. */
3399 /* Return NR_BYTES, not TODO, in case escape chars caused us to send fewer
3400 bytes than we'd planned. */
3404 /* Read memory data directly from the remote machine.
3405 This does not use the data cache; the data cache uses this.
3406 MEMADDR is the address in the remote memory space.
3407 MYADDR is the address of the buffer in our space.
3408 LEN is the number of bytes.
3410 Returns number of bytes transferred, or 0 for error. */
3412 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
3413 remote targets) shouldn't attempt to read the entire buffer.
3414 Instead it should read a single packet worth of data and then
3415 return the byte size of that packet to the caller. The caller (its
3416 caller and its callers caller ;-) already contains code for
3417 handling partial reads. */
3420 remote_read_bytes (memaddr, myaddr, len)
3426 int max_buf_size; /* Max size of packet output buffer */
3430 /* Create a buffer big enough for this packet. */
3431 max_buf_size = get_memory_read_packet_size ();
3432 sizeof_buf = max_buf_size + 1; /* Space for trailing NUL */
3433 buf = alloca (sizeof_buf);
3442 todo = min (len, max_buf_size / 2); /* num bytes that will fit */
3444 /* construct "m"<memaddr>","<len>" */
3445 /* sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); */
3446 memaddr = remote_address_masked (memaddr);
3449 p += hexnumstr (p, (ULONGEST) memaddr);
3451 p += hexnumstr (p, (ULONGEST) todo);
3455 getpkt (buf, sizeof_buf, 0);
3459 /* There is no correspondance between what the remote protocol uses
3460 for errors and errno codes. We would like a cleaner way of
3461 representing errors (big enough to include errno codes, bfd_error
3462 codes, and others). But for now just return EIO. */
3467 /* Reply describes memory byte by byte,
3468 each byte encoded as two hex characters. */
3471 for (i = 0; i < todo; i++)
3473 if (p[0] == 0 || p[1] == 0)
3474 /* Reply is short. This means that we were able to read
3475 only part of what we wanted to. */
3476 return i + (origlen - len);
3477 myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
3487 /* Read or write LEN bytes from inferior memory at MEMADDR,
3488 transferring to or from debugger address BUFFER. Write to inferior if
3489 SHOULD_WRITE is nonzero. Returns length of data written or read; 0
3492 #ifndef REMOTE_TRANSLATE_XFER_ADDRESS
3493 #define REMOTE_TRANSLATE_XFER_ADDRESS(MEM_ADDR, MEM_LEN, TARG_ADDR, TARG_LEN) \
3494 (*(TARG_ADDR) = (MEM_ADDR), *(TARG_LEN) = (MEM_LEN))
3499 remote_xfer_memory (mem_addr, buffer, mem_len, should_write, target)
3504 struct target_ops *target; /* ignored */
3506 CORE_ADDR targ_addr;
3508 REMOTE_TRANSLATE_XFER_ADDRESS (mem_addr, mem_len, &targ_addr, &targ_len);
3512 return dcache_xfer_memory (remote_dcache, targ_addr, buffer,
3513 targ_len, should_write);
3518 /* Enable after 4.12. */
3521 remote_search (len, data, mask, startaddr, increment, lorange, hirange
3522 addr_found, data_found)
3526 CORE_ADDR startaddr;
3530 CORE_ADDR *addr_found;
3533 if (increment == -4 && len == 4)
3535 long mask_long, data_long;
3536 long data_found_long;
3537 CORE_ADDR addr_we_found;
3538 char *buf = alloca (PBUFSIZ);
3539 long returned_long[2];
3542 mask_long = extract_unsigned_integer (mask, len);
3543 data_long = extract_unsigned_integer (data, len);
3544 sprintf (buf, "t%x:%x,%x", startaddr, data_long, mask_long);
3546 getpkt (buf, PBUFSIZ, 0);
3549 /* The stub doesn't support the 't' request. We might want to
3550 remember this fact, but on the other hand the stub could be
3551 switched on us. Maybe we should remember it only until
3552 the next "target remote". */
3553 generic_search (len, data, mask, startaddr, increment, lorange,
3554 hirange, addr_found, data_found);
3559 /* There is no correspondance between what the remote protocol uses
3560 for errors and errno codes. We would like a cleaner way of
3561 representing errors (big enough to include errno codes, bfd_error
3562 codes, and others). But for now just use EIO. */
3563 memory_error (EIO, startaddr);
3566 while (*p != '\0' && *p != ',')
3567 addr_we_found = (addr_we_found << 4) + fromhex (*p++);
3569 error ("Protocol error: short return for search");
3571 data_found_long = 0;
3572 while (*p != '\0' && *p != ',')
3573 data_found_long = (data_found_long << 4) + fromhex (*p++);
3574 /* Ignore anything after this comma, for future extensions. */
3576 if (addr_we_found < lorange || addr_we_found >= hirange)
3582 *addr_found = addr_we_found;
3583 *data_found = store_unsigned_integer (data_we_found, len);
3586 generic_search (len, data, mask, startaddr, increment, lorange,
3587 hirange, addr_found, data_found);
3592 remote_files_info (ignore)
3593 struct target_ops *ignore;
3595 puts_filtered ("Debugging a target over a serial line.\n");
3598 /* Stuff for dealing with the packets which are part of this protocol.
3599 See comment at top of file for details. */
3601 /* Read a single character from the remote end, masking it down to 7 bits. */
3609 ch = SERIAL_READCHAR (remote_desc, timeout);
3614 switch ((enum serial_rc) ch)
3617 target_mourn_inferior ();
3618 error ("Remote connection closed");
3621 perror_with_name ("Remote communication error");
3623 case SERIAL_TIMEOUT:
3629 /* Send the command in BUF to the remote machine, and read the reply
3630 into BUF. Report an error if we get an error reply. */
3633 remote_send (char *buf,
3637 getpkt (buf, sizeof_buf, 0);
3640 error ("Remote failure reply: %s", buf);
3643 /* Display a null-terminated packet on stdout, for debugging, using C
3650 puts_filtered ("\"");
3651 fputstr_filtered (buf, '"', gdb_stdout);
3652 puts_filtered ("\"");
3659 return putpkt_binary (buf, strlen (buf));
3662 /* Send a packet to the remote machine, with error checking. The data
3663 of the packet is in BUF. The string in BUF can be at most PBUFSIZ - 5
3664 to account for the $, # and checksum, and for a possible /0 if we are
3665 debugging (remote_debug) and want to print the sent packet as a string */
3668 putpkt_binary (buf, cnt)
3673 unsigned char csum = 0;
3674 char *buf2 = alloca (cnt + 6);
3675 long sizeof_junkbuf = PBUFSIZ;
3676 char *junkbuf = alloca (sizeof_junkbuf);
3682 /* Copy the packet into buffer BUF2, encapsulating it
3683 and giving it a checksum. */
3688 for (i = 0; i < cnt; i++)
3694 *p++ = tohex ((csum >> 4) & 0xf);
3695 *p++ = tohex (csum & 0xf);
3697 /* Send it over and over until we get a positive ack. */
3701 int started_error_output = 0;
3706 fprintf_unfiltered (gdb_stdlog, "Sending packet: ");
3707 fputstrn_unfiltered (buf2, p - buf2, 0, gdb_stdlog);
3708 fprintf_unfiltered (gdb_stdlog, "...");
3709 gdb_flush (gdb_stdlog);
3711 if (SERIAL_WRITE (remote_desc, buf2, p - buf2))
3712 perror_with_name ("putpkt: write failed");
3714 /* read until either a timeout occurs (-2) or '+' is read */
3717 ch = readchar (remote_timeout);
3725 case SERIAL_TIMEOUT:
3727 if (started_error_output)
3729 putchar_unfiltered ('\n');
3730 started_error_output = 0;
3739 fprintf_unfiltered (gdb_stdlog, "Ack\n");
3743 fprintf_unfiltered (gdb_stdlog, "Nak\n");
3744 case SERIAL_TIMEOUT:
3748 break; /* Retransmit buffer */
3751 /* It's probably an old response, and we're out of sync.
3752 Just gobble up the packet and ignore it. */
3753 getpkt (junkbuf, sizeof_junkbuf, 0);
3754 continue; /* Now, go look for + */
3759 if (!started_error_output)
3761 started_error_output = 1;
3762 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
3764 fputc_unfiltered (ch & 0177, gdb_stdlog);
3768 break; /* Here to retransmit */
3772 /* This is wrong. If doing a long backtrace, the user should be
3773 able to get out next time we call QUIT, without anything as
3774 violent as interrupt_query. If we want to provide a way out of
3775 here without getting to the next QUIT, it should be based on
3776 hitting ^C twice as in remote_wait. */
3786 static int remote_cisco_mode;
3788 /* Come here after finding the start of the frame. Collect the rest
3789 into BUF, verifying the checksum, length, and handling run-length
3790 compression. No more than sizeof_buf-1 characters are read so that
3791 the buffer can be NUL terminated.
3793 Returns -1 on error, number of characters in buffer (ignoring the
3794 trailing NULL) on success. (could be extended to return one of the
3795 SERIAL status indications). */
3798 read_frame (char *buf,
3810 /* ASSERT (bc < sizeof_buf - 1) - space for trailing NUL */
3811 c = readchar (remote_timeout);
3814 case SERIAL_TIMEOUT:
3816 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
3820 fputs_filtered ("Saw new packet start in middle of old one\n",
3822 return -1; /* Start a new packet, count retries */
3825 unsigned char pktcsum;
3829 pktcsum = fromhex (readchar (remote_timeout)) << 4;
3830 pktcsum |= fromhex (readchar (remote_timeout));
3832 if (csum == pktcsum)
3837 fprintf_filtered (gdb_stdlog,
3838 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
3840 fputs_filtered (buf, gdb_stdlog);
3841 fputs_filtered ("\n", gdb_stdlog);
3843 /* Number of characters in buffer ignoring trailing
3847 case '*': /* Run length encoding */
3852 if (remote_cisco_mode == 0)
3854 c = readchar (remote_timeout);
3856 repeat = c - ' ' + 3; /* Compute repeat count */
3860 /* Cisco's run-length encoding variant uses two
3861 hex chars to represent the repeat count. */
3863 c = readchar (remote_timeout);
3865 repeat = fromhex (c) << 4;
3866 c = readchar (remote_timeout);
3868 repeat += fromhex (c);
3871 /* The character before ``*'' is repeated. */
3873 if (repeat > 0 && repeat <= 255
3875 && bc + repeat < sizeof_buf - 1)
3877 memset (&buf[bc], buf[bc - 1], repeat);
3883 printf_filtered ("Repeat count %d too large for buffer: ", repeat);
3884 puts_filtered (buf);
3885 puts_filtered ("\n");
3889 if (bc < sizeof_buf - 1)
3897 puts_filtered ("Remote packet too long: ");
3898 puts_filtered (buf);
3899 puts_filtered ("\n");
3906 /* Read a packet from the remote machine, with error checking, and
3907 store it in BUF. If FOREVER, wait forever rather than timing out;
3908 this is used (in synchronous mode) to wait for a target that is is
3909 executing user code to stop. */
3910 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
3911 don't have to change all the calls to getpkt to deal with the
3912 return value, because at the moment I don't know what the right
3913 thing to do it for those. */
3921 timed_out = getpkt_sane (buf, sizeof_buf, forever);
3925 /* Read a packet from the remote machine, with error checking, and
3926 store it in BUF. If FOREVER, wait forever rather than timing out;
3927 this is used (in synchronous mode) to wait for a target that is is
3928 executing user code to stop. If FOREVER == 0, this function is
3929 allowed to time out gracefully and return an indication of this to
3932 getpkt_sane (char *buf,
3941 strcpy (buf, "timeout");
3945 timeout = watchdog > 0 ? watchdog : -1;
3949 timeout = remote_timeout;
3953 for (tries = 1; tries <= MAX_TRIES; tries++)
3955 /* This can loop forever if the remote side sends us characters
3956 continuously, but if it pauses, we'll get a zero from readchar
3957 because of timeout. Then we'll count that as a retry. */
3959 /* Note that we will only wait forever prior to the start of a packet.
3960 After that, we expect characters to arrive at a brisk pace. They
3961 should show up within remote_timeout intervals. */
3965 c = readchar (timeout);
3967 if (c == SERIAL_TIMEOUT)
3969 if (forever) /* Watchdog went off? Kill the target. */
3972 target_mourn_inferior ();
3973 error ("Watchdog has expired. Target detached.\n");
3976 fputs_filtered ("Timed out.\n", gdb_stdlog);
3982 /* We've found the start of a packet, now collect the data. */
3984 val = read_frame (buf, sizeof_buf);
3990 fprintf_unfiltered (gdb_stdlog, "Packet received: ");
3991 fputstr_unfiltered (buf, 0, gdb_stdlog);
3992 fprintf_unfiltered (gdb_stdlog, "\n");
3994 SERIAL_WRITE (remote_desc, "+", 1);
3998 /* Try the whole thing again. */
4000 SERIAL_WRITE (remote_desc, "-", 1);
4003 /* We have tried hard enough, and just can't receive the packet. Give up. */
4005 printf_unfiltered ("Ignoring packet error, continuing...\n");
4006 SERIAL_WRITE (remote_desc, "+", 1);
4013 /* For some mysterious reason, wait_for_inferior calls kill instead of
4014 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4018 target_mourn_inferior ();
4022 /* Use catch_errors so the user can quit from gdb even when we aren't on
4023 speaking terms with the remote system. */
4024 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
4026 /* Don't wait for it to die. I'm not really sure it matters whether
4027 we do or not. For the existing stubs, kill is a noop. */
4028 target_mourn_inferior ();
4031 /* Async version of remote_kill. */
4033 remote_async_kill ()
4035 /* Unregister the file descriptor from the event loop. */
4036 if (target_is_async_p ())
4037 SERIAL_ASYNC (remote_desc, NULL, 0);
4039 /* For some mysterious reason, wait_for_inferior calls kill instead of
4040 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4044 target_mourn_inferior ();
4048 /* Use catch_errors so the user can quit from gdb even when we aren't on
4049 speaking terms with the remote system. */
4050 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
4052 /* Don't wait for it to die. I'm not really sure it matters whether
4053 we do or not. For the existing stubs, kill is a noop. */
4054 target_mourn_inferior ();
4060 remote_mourn_1 (&remote_ops);
4064 remote_async_mourn ()
4066 remote_mourn_1 (&remote_async_ops);
4070 extended_remote_mourn ()
4072 /* We do _not_ want to mourn the target like this; this will
4073 remove the extended remote target from the target stack,
4074 and the next time the user says "run" it'll fail.
4076 FIXME: What is the right thing to do here? */
4078 remote_mourn_1 (&extended_remote_ops);
4082 /* Worker function for remote_mourn. */
4084 remote_mourn_1 (target)
4085 struct target_ops *target;
4087 unpush_target (target);
4088 generic_mourn_inferior ();
4091 /* In the extended protocol we want to be able to do things like
4092 "run" and have them basically work as expected. So we need
4093 a special create_inferior function.
4095 FIXME: One day add support for changing the exec file
4096 we're debugging, arguments and an environment. */
4099 extended_remote_create_inferior (exec_file, args, env)
4104 /* Rip out the breakpoints; we'll reinsert them after restarting
4105 the remote server. */
4106 remove_breakpoints ();
4108 /* Now restart the remote server. */
4109 extended_remote_restart ();
4111 /* Now put the breakpoints back in. This way we're safe if the
4112 restart function works via a unix fork on the remote side. */
4113 insert_breakpoints ();
4115 /* Clean up from the last time we were running. */
4116 clear_proceed_status ();
4118 /* Let the remote process run. */
4119 proceed (-1, TARGET_SIGNAL_0, 0);
4122 /* Async version of extended_remote_create_inferior. */
4124 extended_remote_async_create_inferior (exec_file, args, env)
4129 /* Rip out the breakpoints; we'll reinsert them after restarting
4130 the remote server. */
4131 remove_breakpoints ();
4133 /* If running asynchronously, register the target file descriptor
4134 with the event loop. */
4135 if (event_loop_p && target_can_async_p ())
4136 target_async (inferior_event_handler, 0);
4138 /* Now restart the remote server. */
4139 extended_remote_restart ();
4141 /* Now put the breakpoints back in. This way we're safe if the
4142 restart function works via a unix fork on the remote side. */
4143 insert_breakpoints ();
4145 /* Clean up from the last time we were running. */
4146 clear_proceed_status ();
4148 /* Let the remote process run. */
4149 proceed (-1, TARGET_SIGNAL_0, 0);
4153 /* On some machines, e.g. 68k, we may use a different breakpoint instruction
4154 than other targets; in those use REMOTE_BREAKPOINT instead of just
4155 BREAKPOINT. Also, bi-endian targets may define LITTLE_REMOTE_BREAKPOINT
4156 and BIG_REMOTE_BREAKPOINT. If none of these are defined, we just call
4157 the standard routines that are in mem-break.c. */
4159 /* FIXME, these ought to be done in a more dynamic fashion. For instance,
4160 the choice of breakpoint instruction affects target program design and
4161 vice versa, and by making it user-tweakable, the special code here
4162 goes away and we need fewer special GDB configurations. */
4164 #if defined (LITTLE_REMOTE_BREAKPOINT) && defined (BIG_REMOTE_BREAKPOINT) && !defined(REMOTE_BREAKPOINT)
4165 #define REMOTE_BREAKPOINT
4168 #ifdef REMOTE_BREAKPOINT
4170 /* If the target isn't bi-endian, just pretend it is. */
4171 #if !defined (LITTLE_REMOTE_BREAKPOINT) && !defined (BIG_REMOTE_BREAKPOINT)
4172 #define LITTLE_REMOTE_BREAKPOINT REMOTE_BREAKPOINT
4173 #define BIG_REMOTE_BREAKPOINT REMOTE_BREAKPOINT
4176 static unsigned char big_break_insn[] = BIG_REMOTE_BREAKPOINT;
4177 static unsigned char little_break_insn[] = LITTLE_REMOTE_BREAKPOINT;
4179 #endif /* REMOTE_BREAKPOINT */
4181 /* Insert a breakpoint on targets that don't have any better breakpoint
4182 support. We read the contents of the target location and stash it,
4183 then overwrite it with a breakpoint instruction. ADDR is the target
4184 location in the target machine. CONTENTS_CACHE is a pointer to
4185 memory allocated for saving the target contents. It is guaranteed
4186 by the caller to be long enough to save sizeof BREAKPOINT bytes (this
4187 is accomplished via BREAKPOINT_MAX). */
4190 remote_insert_breakpoint (addr, contents_cache)
4192 char *contents_cache;
4194 #ifdef REMOTE_BREAKPOINT
4199 /* Try the "Z" packet if it is not already disabled.
4200 If it succeeds, then set the support to PACKET_ENABLE.
4201 If it fails, and the user has explicitly requested the Z support
4202 then report an error, otherwise, mark it disabled and go on. */
4204 if ((remote_protocol_Z.support == PACKET_ENABLE)
4205 || (remote_protocol_Z.support == PACKET_SUPPORT_UNKNOWN))
4207 char *buf = alloca (PBUFSIZ);
4210 addr = remote_address_masked (addr);
4214 p += hexnumstr (p, (ULONGEST) addr);
4215 BREAKPOINT_FROM_PC (&addr, &bp_size);
4216 sprintf (p, ",%d", bp_size);
4219 getpkt (buf, PBUFSIZ, 0);
4223 remote_protocol_Z.support = PACKET_ENABLE;
4224 return (buf[0] == 'E');
4227 /* The stub does not support the 'Z' request. If the user has
4228 explicitly requested the Z support, or if the stub previously
4229 said it supported the packet, this is an error,
4230 otherwise, mark it disabled. */
4232 else if (remote_protocol_Z.support == PACKET_ENABLE)
4234 error ("Protocol error: Z packet not recognized by stub");
4238 remote_protocol_Z.support = PACKET_DISABLE;
4242 #ifdef REMOTE_BREAKPOINT
4243 val = target_read_memory (addr, contents_cache, sizeof big_break_insn);
4247 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
4248 val = target_write_memory (addr, (char *) big_break_insn,
4249 sizeof big_break_insn);
4251 val = target_write_memory (addr, (char *) little_break_insn,
4252 sizeof little_break_insn);
4257 return memory_insert_breakpoint (addr, contents_cache);
4258 #endif /* REMOTE_BREAKPOINT */
4262 remote_remove_breakpoint (addr, contents_cache)
4264 char *contents_cache;
4268 if ((remote_protocol_Z.support == PACKET_ENABLE)
4269 || (remote_protocol_Z.support == PACKET_SUPPORT_UNKNOWN))
4271 char *buf = alloca (PBUFSIZ);
4278 addr = remote_address_masked (addr);
4279 p += hexnumstr (p, (ULONGEST) addr);
4280 BREAKPOINT_FROM_PC (&addr, &bp_size);
4281 sprintf (p, ",%d", bp_size);
4284 getpkt (buf, PBUFSIZ, 0);
4286 return (buf[0] == 'E');
4289 #ifdef REMOTE_BREAKPOINT
4290 return target_write_memory (addr, contents_cache, sizeof big_break_insn);
4292 return memory_remove_breakpoint (addr, contents_cache);
4293 #endif /* REMOTE_BREAKPOINT */
4296 #ifdef TARGET_HAS_HARDWARE_WATCHPOINTS
4298 remote_insert_watchpoint (addr, len, type)
4303 char *buf = alloca (PBUFSIZ);
4306 if (remote_protocol_Z.support == PACKET_DISABLE)
4307 error ("Can't set hardware watchpoints without the 'Z' packet\n");
4309 sprintf (buf, "Z%x,", type + 2 );
4310 p = strchr (buf, '\0');
4311 addr = remote_address_masked (addr);
4312 p += hexnumstr (p, (ULONGEST) addr);
4313 sprintf (p, ",%x", len);
4316 getpkt (buf, PBUFSIZ, 0);
4318 if (buf[0] == '\0' || buf [0] == 'E')
4325 remote_remove_watchpoint (addr, len, type)
4330 char *buf = alloca (PBUFSIZ);
4333 sprintf (buf, "z%x,", type + 2 );
4334 p = strchr (buf, '\0');
4335 addr = remote_address_masked (addr);
4336 p += hexnumstr (p, (ULONGEST) addr);
4337 sprintf (p, ",%x", len);
4339 getpkt (buf, PBUFSIZ, 0);
4341 if (buf[0] == '\0' || buf [0] == 'E')
4348 remote_insert_hw_breakpoint (addr, len)
4352 char *buf = alloca (PBUFSIZ);
4355 if (remote_protocol_Z.support == PACKET_DISABLE)
4356 error ("Can't set hardware breakpoints without the 'Z' packet\n");
4362 addr = remote_address_masked (addr);
4363 p += hexnumstr (p, (ULONGEST) addr);
4367 getpkt (buf, PBUFSIZ, 0);
4369 if (buf[0] == '\0' || buf [0] == 'E')
4376 remote_remove_hw_breakpoint (addr, len)
4380 char *buf = alloca (PBUFSIZ);
4387 addr = remote_address_masked (addr);
4388 p += hexnumstr (p, (ULONGEST) addr);
4392 getpkt (buf, PBUFSIZ, 0);
4394 if (buf[0] == '\0' || buf [0] == 'E')
4401 /* Some targets are only capable of doing downloads, and afterwards
4402 they switch to the remote serial protocol. This function provides
4403 a clean way to get from the download target to the remote target.
4404 It's basically just a wrapper so that we don't have to expose any
4405 of the internal workings of remote.c.
4407 Prior to calling this routine, you should shutdown the current
4408 target code, else you will get the "A program is being debugged
4409 already..." message. Usually a call to pop_target() suffices. */
4412 push_remote_target (name, from_tty)
4416 printf_filtered ("Switching to remote protocol\n");
4417 remote_open (name, from_tty);
4420 /* Other targets want to use the entire remote serial module but with
4421 certain remote_ops overridden. */
4424 open_remote_target (name, from_tty, target, extended_p)
4427 struct target_ops *target;
4430 printf_filtered ("Selecting the %sremote protocol\n",
4431 (extended_p ? "extended-" : ""));
4432 remote_open_1 (name, from_tty, target, extended_p);
4435 /* Table used by the crc32 function to calcuate the checksum. */
4437 static unsigned long crc32_table[256] =
4440 static unsigned long
4441 crc32 (buf, len, crc)
4446 if (!crc32_table[1])
4448 /* Initialize the CRC table and the decoding table. */
4452 for (i = 0; i < 256; i++)
4454 for (c = i << 24, j = 8; j > 0; --j)
4455 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
4462 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
4468 /* compare-sections command
4470 With no arguments, compares each loadable section in the exec bfd
4471 with the same memory range on the target, and reports mismatches.
4472 Useful for verifying the image on the target against the exec file.
4473 Depends on the target understanding the new "qCRC:" request. */
4475 /* FIXME: cagney/1999-10-26: This command should be broken down into a
4476 target method (target verify memory) and generic version of the
4477 actual command. This will allow other high-level code (especially
4478 generic_load()) to make use of this target functionality. */
4481 compare_sections_command (args, from_tty)
4486 unsigned long host_crc, target_crc;
4487 extern bfd *exec_bfd;
4488 struct cleanup *old_chain;
4492 char *buf = alloca (PBUFSIZ);
4499 error ("command cannot be used without an exec file");
4500 if (!current_target.to_shortname ||
4501 strcmp (current_target.to_shortname, "remote") != 0)
4502 error ("command can only be used with remote target");
4504 for (s = exec_bfd->sections; s; s = s->next)
4506 if (!(s->flags & SEC_LOAD))
4507 continue; /* skip non-loadable section */
4509 size = bfd_get_section_size_before_reloc (s);
4511 continue; /* skip zero-length section */
4513 sectname = (char *) bfd_get_section_name (exec_bfd, s);
4514 if (args && strcmp (args, sectname) != 0)
4515 continue; /* not the section selected by user */
4517 matched = 1; /* do this section */
4519 /* FIXME: assumes lma can fit into long */
4520 sprintf (buf, "qCRC:%lx,%lx", (long) lma, (long) size);
4523 /* be clever; compute the host_crc before waiting for target reply */
4524 sectdata = xmalloc (size);
4525 old_chain = make_cleanup (free, sectdata);
4526 bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
4527 host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff);
4529 getpkt (buf, PBUFSIZ, 0);
4531 error ("target memory fault, section %s, range 0x%08x -- 0x%08x",
4532 sectname, lma, lma + size);
4534 error ("remote target does not support this operation");
4536 for (target_crc = 0, tmp = &buf[1]; *tmp; tmp++)
4537 target_crc = target_crc * 16 + fromhex (*tmp);
4539 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
4540 sectname, paddr (lma), paddr (lma + size));
4541 if (host_crc == target_crc)
4542 printf_filtered ("matched.\n");
4545 printf_filtered ("MIS-MATCHED!\n");
4549 do_cleanups (old_chain);
4552 warning ("One or more sections of the remote executable does not match\n\
4553 the loaded file\n");
4554 if (args && !matched)
4555 printf_filtered ("No loaded section named '%s'.\n", args);
4559 remote_query (query_type, buf, outbuf, bufsiz)
4566 char *buf2 = alloca (PBUFSIZ);
4567 char *p2 = &buf2[0];
4570 error ("null pointer to remote bufer size specified");
4572 /* minimum outbuf size is PBUFSIZ - if bufsiz is not large enough let
4573 the caller know and return what the minimum size is */
4574 /* Note: a zero bufsiz can be used to query the minimum buffer size */
4575 if (*bufsiz < PBUFSIZ)
4581 /* except for querying the minimum buffer size, target must be open */
4583 error ("remote query is only available after target open");
4585 /* we only take uppercase letters as query types, at least for now */
4586 if ((query_type < 'A') || (query_type > 'Z'))
4587 error ("invalid remote query type");
4590 error ("null remote query specified");
4593 error ("remote query requires a buffer to receive data");
4600 /* we used one buffer char for the remote protocol q command and another
4601 for the query type. As the remote protocol encapsulation uses 4 chars
4602 plus one extra in case we are debugging (remote_debug),
4603 we have PBUFZIZ - 7 left to pack the query string */
4605 while (buf[i] && (i < (PBUFSIZ - 8)))
4607 /* bad caller may have sent forbidden characters */
4608 if ((!isprint (buf[i])) || (buf[i] == '$') || (buf[i] == '#'))
4609 error ("illegal characters in query string");
4617 error ("query larger than available buffer");
4623 getpkt (outbuf, *bufsiz, 0);
4629 remote_rcmd (char *command,
4630 struct ui_file *outbuf)
4633 char *buf = alloca (PBUFSIZ);
4637 error ("remote rcmd is only available after target open");
4639 /* Send a NULL command across as an empty command */
4640 if (command == NULL)
4643 /* The query prefix */
4644 strcpy (buf, "qRcmd,");
4645 p = strchr (buf, '\0');
4647 if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > PBUFSIZ)
4648 error ("\"monitor\" command ``%s'' is too long\n", command);
4650 /* Encode the actual command */
4651 for (i = 0; command[i]; i++)
4653 *p++ = tohex ((command[i] >> 4) & 0xf);
4654 *p++ = tohex (command[i] & 0xf);
4658 if (putpkt (buf) < 0)
4659 error ("Communication problem with target\n");
4661 /* get/display the response */
4664 /* XXX - see also tracepoint.c:remote_get_noisy_reply() */
4666 getpkt (buf, PBUFSIZ, 0);
4668 error ("Target does not support this command\n");
4669 if (buf[0] == 'O' && buf[1] != 'K')
4671 remote_console_output (buf + 1); /* 'O' message from stub */
4674 if (strcmp (buf, "OK") == 0)
4676 if (strlen (buf) == 3 && buf[0] == 'E'
4677 && isdigit (buf[1]) && isdigit (buf[2]))
4679 error ("Protocol error with Rcmd");
4681 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
4683 char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
4684 fputc_unfiltered (c, outbuf);
4691 packet_command (args, from_tty)
4695 char *buf = alloca (PBUFSIZ);
4698 error ("command can only be used with remote target");
4701 error ("remote-packet command requires packet text as argument");
4703 puts_filtered ("sending: ");
4704 print_packet (args);
4705 puts_filtered ("\n");
4708 getpkt (buf, PBUFSIZ, 0);
4709 puts_filtered ("received: ");
4711 puts_filtered ("\n");
4715 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------------- */
4717 static void display_thread_info PARAMS ((struct gdb_ext_thread_info * info));
4719 static void threadset_test_cmd PARAMS ((char *cmd, int tty));
4721 static void threadalive_test PARAMS ((char *cmd, int tty));
4723 static void threadlist_test_cmd PARAMS ((char *cmd, int tty));
4725 int get_and_display_threadinfo PARAMS ((threadref * ref));
4727 static void threadinfo_test_cmd PARAMS ((char *cmd, int tty));
4729 static int thread_display_step PARAMS ((threadref * ref, void *context));
4731 static void threadlist_update_test_cmd PARAMS ((char *cmd, int tty));
4733 static void init_remote_threadtests PARAMS ((void));
4735 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid */
4738 threadset_test_cmd (cmd, tty)
4742 int sample_thread = SAMPLE_THREAD;
4744 printf_filtered ("Remote threadset test\n");
4745 set_thread (sample_thread, 1);
4750 threadalive_test (cmd, tty)
4754 int sample_thread = SAMPLE_THREAD;
4756 if (remote_thread_alive (sample_thread))
4757 printf_filtered ("PASS: Thread alive test\n");
4759 printf_filtered ("FAIL: Thread alive test\n");
4762 void output_threadid PARAMS ((char *title, threadref * ref));
4765 output_threadid (title, ref)
4771 pack_threadid (&hexid[0], ref); /* Convert threead id into hex */
4773 printf_filtered ("%s %s\n", title, (&hexid[0]));
4777 threadlist_test_cmd (cmd, tty)
4782 threadref nextthread;
4783 int done, result_count;
4784 threadref threadlist[3];
4786 printf_filtered ("Remote Threadlist test\n");
4787 if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
4788 &result_count, &threadlist[0]))
4789 printf_filtered ("FAIL: threadlist test\n");
4792 threadref *scan = threadlist;
4793 threadref *limit = scan + result_count;
4795 while (scan < limit)
4796 output_threadid (" thread ", scan++);
4801 display_thread_info (info)
4802 struct gdb_ext_thread_info *info;
4804 output_threadid ("Threadid: ", &info->threadid);
4805 printf_filtered ("Name: %s\n ", info->shortname);
4806 printf_filtered ("State: %s\n", info->display);
4807 printf_filtered ("other: %s\n\n", info->more_display);
4811 get_and_display_threadinfo (ref)
4816 struct gdb_ext_thread_info threadinfo;
4818 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
4819 | TAG_MOREDISPLAY | TAG_DISPLAY;
4820 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
4821 display_thread_info (&threadinfo);
4826 threadinfo_test_cmd (cmd, tty)
4830 int athread = SAMPLE_THREAD;
4834 int_to_threadref (&thread, athread);
4835 printf_filtered ("Remote Threadinfo test\n");
4836 if (!get_and_display_threadinfo (&thread))
4837 printf_filtered ("FAIL cannot get thread info\n");
4841 thread_display_step (ref, context)
4845 /* output_threadid(" threadstep ",ref); *//* simple test */
4846 return get_and_display_threadinfo (ref);
4850 threadlist_update_test_cmd (cmd, tty)
4854 printf_filtered ("Remote Threadlist update test\n");
4855 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
4859 init_remote_threadtests (void)
4861 add_com ("tlist", class_obscure, threadlist_test_cmd,
4862 "Fetch and print the remote list of thread identifiers, one pkt only");
4863 add_com ("tinfo", class_obscure, threadinfo_test_cmd,
4864 "Fetch and display info about one thread");
4865 add_com ("tset", class_obscure, threadset_test_cmd,
4866 "Test setting to a different thread");
4867 add_com ("tupd", class_obscure, threadlist_update_test_cmd,
4868 "Iterate through updating all remote thread info");
4869 add_com ("talive", class_obscure, threadalive_test,
4870 " Remote thread alive test ");
4878 remote_ops.to_shortname = "remote";
4879 remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
4881 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
4882 Specify the serial device it is connected to\n\
4883 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
4884 remote_ops.to_open = remote_open;
4885 remote_ops.to_close = remote_close;
4886 remote_ops.to_detach = remote_detach;
4887 remote_ops.to_resume = remote_resume;
4888 remote_ops.to_wait = remote_wait;
4889 remote_ops.to_fetch_registers = remote_fetch_registers;
4890 remote_ops.to_store_registers = remote_store_registers;
4891 remote_ops.to_prepare_to_store = remote_prepare_to_store;
4892 remote_ops.to_xfer_memory = remote_xfer_memory;
4893 remote_ops.to_files_info = remote_files_info;
4894 remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
4895 remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
4896 remote_ops.to_kill = remote_kill;
4897 remote_ops.to_load = generic_load;
4898 remote_ops.to_mourn_inferior = remote_mourn;
4899 remote_ops.to_thread_alive = remote_thread_alive;
4900 remote_ops.to_find_new_threads = remote_threads_info;
4901 remote_ops.to_stop = remote_stop;
4902 remote_ops.to_query = remote_query;
4903 remote_ops.to_rcmd = remote_rcmd;
4904 remote_ops.to_stratum = process_stratum;
4905 remote_ops.to_has_all_memory = 1;
4906 remote_ops.to_has_memory = 1;
4907 remote_ops.to_has_stack = 1;
4908 remote_ops.to_has_registers = 1;
4909 remote_ops.to_has_execution = 1;
4910 remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
4911 remote_ops.to_magic = OPS_MAGIC;
4914 /* Set up the extended remote vector by making a copy of the standard
4915 remote vector and adding to it. */
4918 init_extended_remote_ops ()
4920 extended_remote_ops = remote_ops;
4922 extended_remote_ops.to_shortname = "extended-remote";
4923 extended_remote_ops.to_longname =
4924 "Extended remote serial target in gdb-specific protocol";
4925 extended_remote_ops.to_doc =
4926 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
4927 Specify the serial device it is connected to (e.g. /dev/ttya).",
4928 extended_remote_ops.to_open = extended_remote_open;
4929 extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
4930 extended_remote_ops.to_mourn_inferior = extended_remote_mourn;
4934 * Command: info remote-process
4936 * This implements Cisco's version of the "info proc" command.
4938 * This query allows the target stub to return an arbitrary string
4939 * (or strings) giving arbitrary information about the target process.
4940 * This is optional; the target stub isn't required to implement it.
4942 * Syntax: qfProcessInfo request first string
4943 * qsProcessInfo request subsequent string
4944 * reply: 'O'<hex-encoded-string>
4945 * 'l' last reply (empty)
4949 remote_info_process (char *args, int from_tty)
4951 char *buf = alloca (PBUFSIZ);
4953 if (remote_desc == 0)
4954 error ("Command can only be used when connected to the remote target.");
4956 putpkt ("qfProcessInfo");
4957 getpkt (buf, PBUFSIZ, 0);
4959 return; /* Silently: target does not support this feature. */
4962 error ("info proc: target error.");
4964 while (buf[0] == 'O') /* Capitol-O packet */
4966 remote_console_output (&buf[1]);
4967 putpkt ("qsProcessInfo");
4968 getpkt (buf, PBUFSIZ, 0);
4977 remote_cisco_open (char *name, int from_tty)
4981 "To open a remote debug connection, you need to specify what \n\
4982 device is attached to the remote system (e.g. host:port).");
4984 /* See FIXME above */
4985 wait_forever_enabled_p = 1;
4987 target_preopen (from_tty);
4989 unpush_target (&remote_cisco_ops);
4991 remote_dcache = dcache_init (remote_read_bytes, remote_write_bytes);
4993 remote_desc = SERIAL_OPEN (name);
4995 perror_with_name (name);
4998 * If a baud rate was specified on the gdb command line it will
4999 * be greater than the initial value of -1. If it is, use it otherwise
5003 baud_rate = (baud_rate > 0) ? baud_rate : 9600;
5004 if (SERIAL_SETBAUDRATE (remote_desc, baud_rate))
5006 SERIAL_CLOSE (remote_desc);
5007 perror_with_name (name);
5010 SERIAL_RAW (remote_desc);
5012 /* If there is something sitting in the buffer we might take it as a
5013 response to a command, which would be bad. */
5014 SERIAL_FLUSH_INPUT (remote_desc);
5018 puts_filtered ("Remote debugging using ");
5019 puts_filtered (name);
5020 puts_filtered ("\n");
5023 remote_cisco_mode = 1;
5025 push_target (&remote_cisco_ops); /* Switch to using cisco target now */
5027 init_packet_config (&remote_protocol_P);
5028 init_packet_config (&remote_protocol_Z);
5030 general_thread = -2;
5031 continue_thread = -2;
5033 /* Force remote_write_bytes to check whether target supports
5034 binary downloading. */
5035 init_packet_config (&remote_protocol_binary_download);
5037 /* Without this, some commands which require an active target (such
5038 as kill) won't work. This variable serves (at least) double duty
5039 as both the pid of the target process (if it has such), and as a
5040 flag indicating that a target is active. These functions should
5041 be split out into seperate variables, especially since GDB will
5042 someday have a notion of debugging several processes. */
5043 inferior_pid = MAGIC_NULL_PID;
5045 /* Start the remote connection; if error (0), discard this target. */
5047 if (!catch_errors (remote_start_remote_dummy, (char *) 0,
5048 "Couldn't establish connection to remote target\n",
5057 remote_cisco_close (int quitting)
5059 remote_cisco_mode = 0;
5060 remote_close (quitting);
5067 remote_mourn_1 (&remote_cisco_ops);
5079 /* shared between readsocket() and readtty() */
5080 static char *tty_input;
5082 static int escape_count;
5083 static int echo_check;
5084 extern int quit_flag;
5091 /* Loop until the socket doesn't have any more data */
5093 while ((data = readchar (0)) >= 0)
5095 /* Check for the escape sequence */
5098 /* If this is the fourth escape, get out */
5099 if (++escape_count == 4)
5104 { /* This is a '|', but not the fourth in a row.
5105 Continue without echoing it. If it isn't actually
5106 one of four in a row, it'll be echoed later. */
5113 /* Ensure any pending '|'s are flushed. */
5115 for (; escape_count > 0; escape_count--)
5119 if (data == '\r') /* If this is a return character, */
5120 continue; /* - just supress it. */
5122 if (echo_check != -1) /* Check for echo of user input. */
5124 if (tty_input[echo_check] == data)
5126 echo_check++; /* Character matched user input: */
5127 continue; /* Continue without echoing it. */
5129 else if ((data == '\n') && (tty_input[echo_check] == '\r'))
5130 { /* End of the line (and of echo checking). */
5131 echo_check = -1; /* No more echo supression */
5132 continue; /* Continue without echoing. */
5135 { /* Failed check for echo of user input.
5136 We now have some suppressed output to flush! */
5139 for (j = 0; j < echo_check; j++)
5140 putchar (tty_input[j]);
5144 putchar (data); /* Default case: output the char. */
5147 if (data == SERIAL_TIMEOUT) /* Timeout returned from readchar. */
5148 return READ_MORE; /* Try to read some more */
5150 return FATAL_ERROR; /* Trouble, bail out */
5158 /* First, read a buffer full from the terminal */
5159 tty_bytecount = read (fileno (stdin), tty_input, sizeof (tty_input) - 1);
5160 if (tty_bytecount == -1)
5162 perror ("readtty: read failed");
5166 /* Remove a quoted newline. */
5167 if (tty_input[tty_bytecount - 1] == '\n' &&
5168 tty_input[tty_bytecount - 2] == '\\') /* line ending in backslash */
5170 tty_input[--tty_bytecount] = 0; /* remove newline */
5171 tty_input[--tty_bytecount] = 0; /* remove backslash */
5174 /* Turn trailing newlines into returns */
5175 if (tty_input[tty_bytecount - 1] == '\n')
5176 tty_input[tty_bytecount - 1] = '\r';
5178 /* If the line consists of a ~, enter debugging mode. */
5179 if ((tty_input[0] == '~') && (tty_bytecount == 2))
5182 /* Make this a zero terminated string and write it out */
5183 tty_input[tty_bytecount] = 0;
5184 if (SERIAL_WRITE (remote_desc, tty_input, tty_bytecount))
5186 perror_with_name ("readtty: write failed");
5196 fd_set input; /* file descriptors for select */
5197 int tablesize; /* max number of FDs for select */
5201 extern int escape_count; /* global shared by readsocket */
5202 extern int echo_check; /* ditto */
5207 tablesize = 8 * sizeof (input);
5211 /* Check for anything from our socket - doesn't block. Note that
5212 this must be done *before* the select as there may be
5213 buffered I/O waiting to be processed. */
5215 if ((status = readsocket ()) == FATAL_ERROR)
5217 error ("Debugging terminated by communications error");
5219 else if (status != READ_MORE)
5224 fflush (stdout); /* Flush output before blocking */
5226 /* Now block on more socket input or TTY input */
5229 FD_SET (fileno (stdin), &input);
5230 FD_SET (DEPRECATED_SERIAL_FD (remote_desc), &input);
5232 status = select (tablesize, &input, 0, 0, 0);
5233 if ((status == -1) && (errno != EINTR))
5235 error ("Communications error on select %d", errno);
5238 /* Handle Control-C typed */
5242 if ((++quit_count) == 2)
5244 if (query ("Interrupt GDB? "))
5246 printf_filtered ("Interrupted by user.\n");
5247 return_to_top_level (RETURN_QUIT);
5254 SERIAL_SEND_BREAK (remote_desc);
5256 SERIAL_WRITE (remote_desc, "\003", 1);
5261 /* Handle console input */
5263 if (FD_ISSET (fileno (stdin), &input))
5267 status = readtty ();
5268 if (status == READ_MORE)
5271 return status; /* telnet session ended */
5277 remote_cisco_wait (int pid, struct target_waitstatus *status)
5279 if (minitelnet () != ENTER_DEBUG)
5281 error ("Debugging session terminated by protocol error");
5284 return remote_wait (pid, status);
5288 init_remote_cisco_ops ()
5290 remote_cisco_ops.to_shortname = "cisco";
5291 remote_cisco_ops.to_longname = "Remote serial target in cisco-specific protocol";
5292 remote_cisco_ops.to_doc =
5293 "Use a remote machine via TCP, using a cisco-specific protocol.\n\
5294 Specify the serial device it is connected to (e.g. host:2020).";
5295 remote_cisco_ops.to_open = remote_cisco_open;
5296 remote_cisco_ops.to_close = remote_cisco_close;
5297 remote_cisco_ops.to_detach = remote_detach;
5298 remote_cisco_ops.to_resume = remote_resume;
5299 remote_cisco_ops.to_wait = remote_cisco_wait;
5300 remote_cisco_ops.to_fetch_registers = remote_fetch_registers;
5301 remote_cisco_ops.to_store_registers = remote_store_registers;
5302 remote_cisco_ops.to_prepare_to_store = remote_prepare_to_store;
5303 remote_cisco_ops.to_xfer_memory = remote_xfer_memory;
5304 remote_cisco_ops.to_files_info = remote_files_info;
5305 remote_cisco_ops.to_insert_breakpoint = remote_insert_breakpoint;
5306 remote_cisco_ops.to_remove_breakpoint = remote_remove_breakpoint;
5307 remote_cisco_ops.to_kill = remote_kill;
5308 remote_cisco_ops.to_load = generic_load;
5309 remote_cisco_ops.to_mourn_inferior = remote_cisco_mourn;
5310 remote_cisco_ops.to_thread_alive = remote_thread_alive;
5311 remote_cisco_ops.to_find_new_threads = remote_threads_info;
5312 remote_cisco_ops.to_stratum = process_stratum;
5313 remote_cisco_ops.to_has_all_memory = 1;
5314 remote_cisco_ops.to_has_memory = 1;
5315 remote_cisco_ops.to_has_stack = 1;
5316 remote_cisco_ops.to_has_registers = 1;
5317 remote_cisco_ops.to_has_execution = 1;
5318 remote_cisco_ops.to_magic = OPS_MAGIC;
5322 remote_can_async_p (void)
5324 /* We're async whenever the serial device is. */
5325 return (current_target.to_async_mask_value) && SERIAL_CAN_ASYNC_P (remote_desc);
5329 remote_is_async_p (void)
5331 /* We're async whenever the serial device is. */
5332 return (current_target.to_async_mask_value) && SERIAL_IS_ASYNC_P (remote_desc);
5335 /* Pass the SERIAL event on and up to the client. One day this code
5336 will be able to delay notifying the client of an event until the
5337 point where an entire packet has been received. */
5339 static void (*async_client_callback) (enum inferior_event_type event_type, void *context);
5340 static void *async_client_context;
5341 static serial_event_ftype remote_async_serial_handler;
5344 remote_async_serial_handler (serial_t scb, void *context)
5346 /* Don't propogate error information up to the client. Instead let
5347 the client find out about the error by querying the target. */
5348 async_client_callback (INF_REG_EVENT, async_client_context);
5352 remote_async (void (*callback) (enum inferior_event_type event_type, void *context), void *context)
5354 if (current_target.to_async_mask_value == 0)
5355 internal_error ("Calling remote_async when async is masked");
5357 if (callback != NULL)
5359 SERIAL_ASYNC (remote_desc, remote_async_serial_handler, NULL);
5360 async_client_callback = callback;
5361 async_client_context = context;
5364 SERIAL_ASYNC (remote_desc, NULL, NULL);
5367 /* Target async and target extended-async.
5369 This are temporary targets, until it is all tested. Eventually
5370 async support will be incorporated int the usual 'remote'
5374 init_remote_async_ops (void)
5376 remote_async_ops.to_shortname = "async";
5377 remote_async_ops.to_longname = "Remote serial target in async version of the gdb-specific protocol";
5378 remote_async_ops.to_doc =
5379 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5380 Specify the serial device it is connected to (e.g. /dev/ttya).";
5381 remote_async_ops.to_open = remote_async_open;
5382 remote_async_ops.to_close = remote_close;
5383 remote_async_ops.to_detach = remote_async_detach;
5384 remote_async_ops.to_resume = remote_async_resume;
5385 remote_async_ops.to_wait = remote_async_wait;
5386 remote_async_ops.to_fetch_registers = remote_fetch_registers;
5387 remote_async_ops.to_store_registers = remote_store_registers;
5388 remote_async_ops.to_prepare_to_store = remote_prepare_to_store;
5389 remote_async_ops.to_xfer_memory = remote_xfer_memory;
5390 remote_async_ops.to_files_info = remote_files_info;
5391 remote_async_ops.to_insert_breakpoint = remote_insert_breakpoint;
5392 remote_async_ops.to_remove_breakpoint = remote_remove_breakpoint;
5393 remote_async_ops.to_terminal_inferior = remote_async_terminal_inferior;
5394 remote_async_ops.to_terminal_ours = remote_async_terminal_ours;
5395 remote_async_ops.to_kill = remote_async_kill;
5396 remote_async_ops.to_load = generic_load;
5397 remote_async_ops.to_mourn_inferior = remote_async_mourn;
5398 remote_async_ops.to_thread_alive = remote_thread_alive;
5399 remote_async_ops.to_find_new_threads = remote_threads_info;
5400 remote_async_ops.to_stop = remote_stop;
5401 remote_async_ops.to_query = remote_query;
5402 remote_async_ops.to_rcmd = remote_rcmd;
5403 remote_async_ops.to_stratum = process_stratum;
5404 remote_async_ops.to_has_all_memory = 1;
5405 remote_async_ops.to_has_memory = 1;
5406 remote_async_ops.to_has_stack = 1;
5407 remote_async_ops.to_has_registers = 1;
5408 remote_async_ops.to_has_execution = 1;
5409 remote_async_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
5410 remote_async_ops.to_can_async_p = remote_can_async_p;
5411 remote_async_ops.to_is_async_p = remote_is_async_p;
5412 remote_async_ops.to_async = remote_async;
5413 remote_async_ops.to_async_mask_value = 1;
5414 remote_async_ops.to_magic = OPS_MAGIC;
5417 /* Set up the async extended remote vector by making a copy of the standard
5418 remote vector and adding to it. */
5421 init_extended_async_remote_ops (void)
5423 extended_async_remote_ops = remote_async_ops;
5425 extended_async_remote_ops.to_shortname = "extended-async";
5426 extended_async_remote_ops.to_longname =
5427 "Extended remote serial target in async gdb-specific protocol";
5428 extended_async_remote_ops.to_doc =
5429 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
5430 Specify the serial device it is connected to (e.g. /dev/ttya).",
5431 extended_async_remote_ops.to_open = extended_remote_async_open;
5432 extended_async_remote_ops.to_create_inferior = extended_remote_async_create_inferior;
5433 extended_async_remote_ops.to_mourn_inferior = extended_remote_mourn;
5437 set_remote_cmd (char *args, int from_tty)
5444 build_remote_gdbarch_data ()
5446 build_remote_packet_sizes ();
5449 tty_input = xmalloc (PBUFSIZ);
5450 remote_address_size = TARGET_PTR_BIT;
5454 _initialize_remote ()
5456 static struct cmd_list_element *remote_set_cmdlist;
5457 static struct cmd_list_element *remote_show_cmdlist;
5458 struct cmd_list_element *tmpcmd;
5460 /* architecture specific data */
5461 build_remote_gdbarch_data ();
5462 register_gdbarch_swap (&tty_input, sizeof (&tty_input), NULL);
5463 register_remote_packet_sizes ();
5464 register_gdbarch_swap (&remote_address_size,
5465 sizeof (&remote_address_size), NULL);
5466 register_gdbarch_swap (NULL, 0, build_remote_gdbarch_data);
5469 add_target (&remote_ops);
5471 init_extended_remote_ops ();
5472 add_target (&extended_remote_ops);
5474 init_remote_async_ops ();
5475 add_target (&remote_async_ops);
5477 init_extended_async_remote_ops ();
5478 add_target (&extended_async_remote_ops);
5480 init_remote_cisco_ops ();
5481 add_target (&remote_cisco_ops);
5484 init_remote_threadtests ();
5487 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, "\
5488 Remote protocol specific variables\n\
5489 Configure various remote-protocol specific variables such as\n\
5490 the packets being used",
5491 &remote_set_cmdlist, "set remote ",
5492 0/*allow-unknown*/, &setlist);
5493 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, "\
5494 Remote protocol specific variables\n\
5495 Configure various remote-protocol specific variables such as\n\
5496 the packets being used",
5497 &remote_show_cmdlist, "show remote ",
5498 0/*allow-unknown*/, &showlist);
5500 add_cmd ("compare-sections", class_obscure, compare_sections_command,
5501 "Compare section data on target to the exec file.\n\
5502 Argument is a single section name (default: all loaded sections).",
5505 add_cmd ("packet", class_maintenance, packet_command,
5506 "Send an arbitrary packet to a remote target.\n\
5507 maintenance packet TEXT\n\
5508 If GDB is talking to an inferior via the GDB serial protocol, then\n\
5509 this command sends the string TEXT to the inferior, and displays the\n\
5510 response packet. GDB supplies the initial `$' character, and the\n\
5511 terminating `#' character and checksum.",
5515 (add_set_cmd ("remotebreak", no_class,
5516 var_boolean, (char *) &remote_break,
5517 "Set whether to send break if interrupted.\n",
5521 /* Install commands for configuring memory read/write packets. */
5523 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size,
5524 "Set the maximum number of bytes per memory write packet (deprecated).\n",
5526 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size,
5527 "Show the maximum number of bytes per memory write packet (deprecated).\n",
5529 add_cmd ("memory-write-packet-size", no_class,
5530 set_memory_write_packet_size,
5531 "Set the maximum number of bytes per memory-write packet.\n"
5532 "Specify the number of bytes in a packet or 0 (zero) for the\n"
5533 "default packet size. The actual limit is further reduced\n"
5534 "dependent on the target. Specify ``fixed'' to disable the\n"
5535 "further restriction and ``limit'' to enable that restriction\n",
5536 &remote_set_cmdlist);
5537 add_cmd ("memory-read-packet-size", no_class,
5538 set_memory_read_packet_size,
5539 "Set the maximum number of bytes per memory-read packet.\n"
5540 "Specify the number of bytes in a packet or 0 (zero) for the\n"
5541 "default packet size. The actual limit is further reduced\n"
5542 "dependent on the target. Specify ``fixed'' to disable the\n"
5543 "further restriction and ``limit'' to enable that restriction\n",
5544 &remote_set_cmdlist);
5545 add_cmd ("memory-write-packet-size", no_class,
5546 show_memory_write_packet_size,
5547 "Show the maximum number of bytes per memory-write packet.\n",
5548 &remote_show_cmdlist);
5549 add_cmd ("memory-read-packet-size", no_class,
5550 show_memory_read_packet_size,
5551 "Show the maximum number of bytes per memory-read packet.\n",
5552 &remote_show_cmdlist);
5555 (add_set_cmd ("remoteaddresssize", class_obscure,
5556 var_integer, (char *) &remote_address_size,
5557 "Set the maximum size of the address (in bits) \
5558 in a memory packet.\n",
5562 add_packet_config_cmd (&remote_protocol_binary_download,
5563 "X", "binary-download",
5564 set_remote_protocol_binary_download_cmd,
5565 show_remote_protocol_binary_download_cmd,
5566 &remote_set_cmdlist, &remote_show_cmdlist);
5568 /* XXXX - should ``set remotebinarydownload'' be retained for
5571 (add_set_cmd ("remotebinarydownload", no_class,
5572 var_boolean, (char *) &remote_binary_download,
5573 "Set binary downloads.\n", &setlist),
5577 add_info ("remote-process", remote_info_process,
5578 "Query the remote system for process info.");
5580 add_packet_config_cmd (&remote_protocol_P, "P", "set-register",
5581 set_remote_protocol_P_packet_cmd,
5582 show_remote_protocol_P_packet_cmd,
5583 &remote_set_cmdlist, &remote_show_cmdlist);
5585 add_packet_config_cmd (&remote_protocol_Z, "Z", "breakpoint",
5586 set_remote_protocol_Z_packet_cmd,
5587 show_remote_protocol_Z_packet_cmd,
5588 &remote_set_cmdlist, &remote_show_cmdlist);