1 /* Remote target communications for serial-line targets in custom GDB protocol
2 Copyright 1988, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* Remote communication protocol.
23 A debug packet whose contents are <data>
24 is encapsulated for transmission in the form:
26 $ <data> # CSUM1 CSUM2
28 <data> must be ASCII alphanumeric and cannot include characters
29 '$' or '#'. If <data> starts with two characters followed by
30 ':', then the existing stubs interpret this as a sequence number.
32 CSUM1 and CSUM2 are ascii hex representation of an 8-bit
33 checksum of <data>, the most significant nibble is sent first.
34 the hex digits 0-9,a-f are used.
36 Receiver responds with:
38 + - if CSUM is correct and ready for next packet
39 - - if CSUM is incorrect
42 Most values are encoded in ascii hex digits. Signal numbers are according
43 to the numbering in target.h.
47 set thread Hct... Set thread for subsequent operations.
48 c = 'c' for thread used in step and
49 continue; t... can be -1 for all
51 c = 'g' for thread used in other
52 operations. If zero, pick a thread,
58 reply XX....X Each byte of register data
59 is described by two hex digits.
60 Registers are in the internal order
61 for GDB, and the bytes in a register
62 are in the same order the machine uses.
65 write regs GXX..XX Each byte of register data
66 is described by two hex digits.
70 write reg Pn...=r... Write register n... with value r...,
71 which contains two hex digits for each
72 byte in the register (target byte
76 (not supported by all stubs).
78 read mem mAA..AA,LLLL AA..AA is address, LLLL is length.
79 reply XX..XX XX..XX is mem contents
80 Can be fewer bytes than requested
81 if able to read only part of the data.
84 write mem MAA..AA,LLLL:XX..XX
86 LLLL is number of bytes,
89 ENN for an error (this includes the case
90 where only part of the data was
93 write mem XAA..AA,LLLL:XX..XX
94 (binary) AA..AA is address,
95 LLLL is number of bytes,
100 continue cAA..AA AA..AA is address to resume
101 If AA..AA is omitted,
102 resume at same address.
104 step sAA..AA AA..AA is address to resume
105 If AA..AA is omitted,
106 resume at same address.
108 continue with Csig;AA..AA Continue with signal sig (hex signal
109 signal number). If ;AA..AA is omitted,
110 resume at same address.
112 step with Ssig;AA..AA Like 'C' but step not continue.
115 last signal ? Reply the current reason for stopping.
116 This is the same reply as is generated
117 for step or cont : SAA where AA is the
122 There is no immediate reply to step or cont.
123 The reply comes when the machine stops.
124 It is SAA AA is the signal number.
126 or... TAAn...:r...;n...:r...;n...:r...;
128 n... = register number (hex)
129 r... = register contents
131 r... = thread process ID. This is
133 n... = other string not starting
134 with valid hex digit.
135 gdb should ignore this n,r pair
136 and go on to the next. This way
137 we can extend the protocol.
138 or... WAA The process exited, and AA is
139 the exit status. This is only
140 applicable for certains sorts of
142 or... XAA The process terminated with signal
144 or... OXX..XX XX..XX is hex encoding of ASCII data. This
145 can happen at any time while the
146 program is running and the debugger
147 should continue to wait for
150 thread alive TXX Find out if the thread XX is alive.
151 reply OK thread is still alive
154 remote restart RXX Restart the remote server
156 extended ops ! Use the extended remote protocol.
157 Sticky -- only needs to be set once.
161 toggle debug d toggle debug flag (see 386 & 68k stubs)
162 reset r reset -- see sparc stub.
163 reserved <other> On other requests, the stub should
164 ignore the request and send an empty
165 response ($#<checksum>). This way
166 we can extend the protocol and GDB
167 can tell whether the stub it is
168 talking to uses the old or the new.
169 search tAA:PP,MM Search backwards starting at address
170 AA for a match with pattern PP and
171 mask MM. PP and MM are 4 bytes.
172 Not supported by all stubs.
174 general query qXXXX Request info about XXXX.
175 general set QXXXX=yyyy Set value of XXXX to yyyy.
176 query sect offs qOffsets Get section offsets. Reply is
177 Text=xxx;Data=yyy;Bss=zzz
179 Responses can be run-length encoded to save space. A '*' means that
180 the next character is an ASCII encoding giving a repeat count which
181 stands for that many repititions of the character preceding the '*'.
182 The encoding is n+29, yielding a printable character where n >=3
183 (which is where rle starts to win). Don't use an n > 126.
186 "0* " means the same as "0000". */
189 #include "gdb_string.h"
193 #include "inferior.h"
198 /*#include "terminal.h"*/
200 #include "objfiles.h"
201 #include "gdb-stabs.h"
202 #include "gdbthread.h"
208 #include <sys/types.h>
214 /* Prototypes for local functions */
216 static int remote_write_bytes PARAMS ((CORE_ADDR memaddr,
217 char *myaddr, int len));
219 static int remote_read_bytes PARAMS ((CORE_ADDR memaddr,
220 char *myaddr, int len));
222 static void remote_files_info PARAMS ((struct target_ops *ignore));
224 static int remote_xfer_memory PARAMS ((CORE_ADDR memaddr, char * myaddr,
225 int len, int should_write,
226 struct target_ops * target));
228 static void remote_prepare_to_store PARAMS ((void));
230 static void remote_fetch_registers PARAMS ((int regno));
232 static void remote_resume PARAMS ((int pid, int step,
233 enum target_signal siggnal));
235 static int remote_start_remote PARAMS ((PTR));
237 static void remote_open PARAMS ((char *name, int from_tty));
239 static void extended_remote_open PARAMS ((char *name, int from_tty));
241 static void remote_open_1 PARAMS ((char *, int, struct target_ops *,
244 static void remote_close PARAMS ((int quitting));
246 static void remote_store_registers PARAMS ((int regno));
248 static void remote_mourn PARAMS ((void));
250 static void extended_remote_restart PARAMS ((void));
252 static void extended_remote_mourn PARAMS ((void));
254 static void extended_remote_create_inferior PARAMS ((char *, char *, char **));
256 static void remote_mourn_1 PARAMS ((struct target_ops *));
258 static void remote_send PARAMS ((char *buf));
260 static int readchar PARAMS ((int timeout));
262 static int remote_wait PARAMS ((int pid, struct target_waitstatus * status));
264 static void remote_kill PARAMS ((void));
266 static int tohex PARAMS ((int nib));
268 static void remote_detach PARAMS ((char *args, int from_tty));
270 static void remote_interrupt PARAMS ((int signo));
272 static void remote_interrupt_twice PARAMS ((int signo));
274 static void interrupt_query PARAMS ((void));
276 static void set_thread PARAMS ((int, int));
278 static int remote_thread_alive PARAMS ((int));
280 static void get_offsets PARAMS ((void));
282 static int read_frame PARAMS ((char *));
284 static int remote_insert_breakpoint PARAMS ((CORE_ADDR, char *));
286 static int remote_remove_breakpoint PARAMS ((CORE_ADDR, char *));
288 static int hexnumlen PARAMS ((ULONGEST num));
290 static void init_remote_ops PARAMS ((void));
292 static void init_extended_remote_ops PARAMS ((void));
294 static void remote_stop PARAMS ((void));
296 static int ishex PARAMS ((int ch, int *val));
298 static int stubhex PARAMS ((int ch));
300 static int remote_query PARAMS ((int/*char*/, char *, char *, int *));
302 static int hexnumstr PARAMS ((char *, ULONGEST));
304 static CORE_ADDR remote_address_masked PARAMS ((CORE_ADDR));
306 static void print_packet PARAMS ((char *));
308 static unsigned long crc32 PARAMS ((unsigned char *, int, unsigned int));
310 static void compare_sections_command PARAMS ((char *, int));
312 static void packet_command PARAMS ((char *, int));
314 static int stub_unpack_int PARAMS ((char *buff, int fieldlength));
316 char *unpack_varlen_hex PARAMS ((char *buff, int *result));
318 static char *unpack_nibble PARAMS ((char *buf, int *val));
320 static char *pack_nibble PARAMS ((char *buf, int nibble));
322 static char *pack_hex_byte PARAMS ((char *pkt, int/*unsigned char*/ byte));
324 static char *unpack_byte PARAMS ((char *buf, int *value));
326 static char *pack_int PARAMS ((char *buf, int value));
328 static char *unpack_int PARAMS ((char *buf, int *value));
330 static char *unpack_string PARAMS ((char *src, char *dest, int length));
332 static char *pack_threadid PARAMS ((char *pkt, threadref *id));
334 static char *unpack_threadid PARAMS ((char *inbuf, threadref *id));
336 void int_to_threadref PARAMS ((threadref *id, int value));
338 static int threadref_to_int PARAMS ((threadref *ref));
340 static void copy_threadref PARAMS ((threadref *dest, threadref *src));
342 static int threadmatch PARAMS ((threadref *dest, threadref *src));
344 static char *pack_threadinfo_request PARAMS ((char *pkt, int mode,
347 static int remote_unpack_thread_info_response PARAMS ((char *pkt,
348 threadref *expectedref,
349 struct gdb_ext_thread_info *info));
352 static int remote_get_threadinfo PARAMS ((threadref *threadid,
353 int fieldset, /*TAG mask */
354 struct gdb_ext_thread_info *info));
356 static int adapt_remote_get_threadinfo PARAMS ((gdb_threadref *ref,
358 struct gdb_ext_thread_info *info));
360 static char *pack_threadlist_request PARAMS ((char *pkt, int startflag,
362 threadref *nextthread));
364 static int parse_threadlist_response PARAMS ((char *pkt,
366 threadref *original_echo,
367 threadref *resultlist,
370 static int remote_get_threadlist PARAMS ((int startflag,
371 threadref *nextthread,
375 threadref *threadlist));
377 typedef int (*rmt_thread_action) (threadref *ref, void *context);
379 static int remote_threadlist_iterator PARAMS ((rmt_thread_action stepfunction,
380 void *context, int looplimit));
382 static int remote_newthread_step PARAMS ((threadref *ref, void *context));
384 static int remote_current_thread PARAMS ((int oldpid));
386 int remote_find_new_threads PARAMS ((void));
388 static void record_currthread PARAMS ((int currthread));
390 static void init_remote_threads PARAMS ((void));
392 /* exported functions */
394 extern int fromhex PARAMS ((int a));
396 extern void getpkt PARAMS ((char *buf, int forever));
398 extern int putpkt PARAMS ((char *buf));
400 static int putpkt_binary PARAMS ((char *buf, int cnt));
402 void remote_console_output PARAMS ((char *));
404 static void check_binary_download PARAMS ((CORE_ADDR addr));
406 /* Define the target subroutine names */
408 void open_remote_target PARAMS ((char *, int, struct target_ops *, int));
410 void _initialize_remote PARAMS ((void));
414 static struct target_ops remote_ops;
416 static struct target_ops extended_remote_ops;
418 static struct target_thread_vector remote_thread_vec;
420 /* This was 5 seconds, which is a long time to sit and wait.
421 Unless this is going though some terminal server or multiplexer or
422 other form of hairy serial connection, I would think 2 seconds would
425 /* Changed to allow option to set timeout value.
426 was static int remote_timeout = 2; */
427 extern int remote_timeout;
429 /* This variable chooses whether to send a ^C or a break when the user
430 requests program interruption. Although ^C is usually what remote
431 systems expect, and that is the default here, sometimes a break is
432 preferable instead. */
434 static int remote_break;
436 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
437 remote_open knows that we don't have a file open when the program
439 static serial_t remote_desc = NULL;
441 /* This variable (available to the user via "set remotebinarydownload")
442 dictates whether downloads are sent in binary (via the 'X' packet).
443 We assume that the stub can, and attempt to do it. This will be cleared if
444 the stub does not understand it. This switch is still needed, though
445 in cases when the packet is supported in the stub, but the connection
446 does not allow it (i.e., 7-bit serial connection only). */
447 static int remote_binary_download = 1;
449 /* Have we already checked whether binary downloads work? */
450 static int remote_binary_checked;
452 /* Having this larger than 400 causes us to be incompatible with m68k-stub.c
453 and i386-stub.c. Normally, no one would notice because it only matters
454 for writing large chunks of memory (e.g. in downloads). Also, this needs
455 to be more than 400 if required to hold the registers (see below, where
456 we round it up based on REGISTER_BYTES). */
459 /* Maximum number of bytes to read/write at once. The value here
460 is chosen to fill up a packet (the headers account for the 32). */
461 #define MAXBUFBYTES ((PBUFSIZ-32)/2)
463 /* Round up PBUFSIZ to hold all the registers, at least. */
464 /* The blank line after the #if seems to be required to work around a
465 bug in HP's PA compiler. */
466 #if REGISTER_BYTES > MAXBUFBYTES
469 #define PBUFSIZ (REGISTER_BYTES * 2 + 32)
473 /* This variable sets the number of bytes to be written to the target
474 in a single packet. Normally PBUFSIZ is satisfactory, but some
475 targets need smaller values (perhaps because the receiving end
478 static int remote_write_size = PBUFSIZ;
480 /* This variable sets the number of bits in an address that are to be
481 sent in a memory ("M" or "m") packet. Normally, after stripping
482 leading zeros, the entire address would be sent. This variable
483 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
484 initial implementation of remote.c restricted the address sent in
485 memory packets to ``host::sizeof long'' bytes - (typically 32
486 bits). Consequently, for 64 bit targets, the upper 32 bits of an
487 address was never sent. Since fixing this bug may cause a break in
488 some remote targets this variable is principly provided to
489 facilitate backward compatibility. */
491 static int remote_address_size;
493 /* This is the size (in chars) of the first response to the `g' command. This
494 is used to limit the size of the memory read and write commands to prevent
495 stub buffers from overflowing. The size does not include headers and
496 trailers, it is only the payload size. */
498 static int remote_register_buf_size = 0;
500 /* Should we try the 'P' request? If this is set to one when the stub
501 doesn't support 'P', the only consequence is some unnecessary traffic. */
502 static int stub_supports_P = 1;
504 /* These are pointers to hook functions that may be set in order to
505 modify resume/wait behavior for a particular architecture. */
507 void (*target_resume_hook) PARAMS ((void));
508 void (*target_wait_loop_hook) PARAMS ((void));
512 /* These are the threads which we last sent to the remote system.
513 -1 for all or -2 for not sent yet. */
514 static int general_thread;
515 static int cont_thread;
517 /* Call this function as a result of
518 1) A halt indication (T packet) containing a thread id
519 2) A direct query of currthread
520 3) Successful execution of set thread
524 record_currthread (currthread)
527 #if 0 /* target_wait must not modify inferior_pid! */
528 inferior_pid = currthread;
530 general_thread = currthread;
531 #if 0 /* setting cont_thread has a different meaning
532 from having the target report its thread id. */
533 cont_thread = currthread;
535 /* If this is a new thread, add it to GDB's thread list.
536 If we leave it up to WFI to do this, bad things will happen. */
537 if (!in_thread_list (currthread))
538 add_thread (currthread);
541 #define MAGIC_NULL_PID 42000
549 int state = gen ? general_thread : cont_thread;
555 buf[1] = gen ? 'g' : 'c';
556 if (th == MAGIC_NULL_PID)
562 sprintf (&buf[2], "-%x", -th);
564 sprintf (&buf[2], "%x", th);
573 /* Return nonzero if the thread TH is still alive on the remote system. */
576 remote_thread_alive (th)
583 sprintf (&buf[1], "-%08x", -th);
585 sprintf (&buf[1], "%08x", th);
588 return (buf[0] == 'O' && buf[1] == 'K');
591 /* About these extended threadlist and threadinfo packets. They are
592 variable length packets but, the fields within them are often fixed
593 length. They are redundent enough to send over UDP as is the
594 remote protocol in general. There is a matching unit test module
597 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES*2)
599 /* encode 64 bits in 16 chars of hex */
601 static const char hexchars[] = "0123456789abcdef";
608 if ((ch >= 'a') && (ch <= 'f'))
610 *val = ch - 'a' + 10;
613 if ((ch >= 'A') && (ch <= 'F'))
615 *val = ch - 'A' + 10;
618 if ((ch >= '0') && (ch <= '9'))
630 if (ch >= 'a' && ch <= 'f')
631 return ch - 'a' + 10;
632 if (ch >= '0' && ch <= '9')
634 if (ch >= 'A' && ch <= 'F')
635 return ch - 'A' + 10;
640 stub_unpack_int (buff, fieldlength)
649 nibble = stubhex (*buff++);
653 retval = retval << 4;
659 unpack_varlen_hex (buff, result)
660 char *buff; /* packet to parse */
666 while (ishex (*buff, &nibble))
669 retval = retval << 4;
670 retval |= nibble & 0x0f;
677 unpack_nibble (buf, val)
686 pack_nibble (buf, nibble)
690 *buf++ = hexchars[(nibble & 0x0f)];
695 pack_hex_byte (pkt, byte)
699 *pkt++ = hexchars[(byte >> 4) & 0xf];
700 *pkt++ = hexchars[(byte & 0xf)];
705 unpack_byte (buf, value)
709 *value = stub_unpack_int (buf, 2);
714 pack_int (buf, value)
718 buf = pack_hex_byte (buf, (value >> 24) & 0xff);
719 buf = pack_hex_byte (buf, (value >> 16) & 0xff);
720 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
721 buf = pack_hex_byte (buf, (value & 0xff));
726 unpack_int (buf, value)
730 *value = stub_unpack_int (buf, 8);
734 #if 0 /* currently unused, uncomment when needed */
735 static char *pack_string PARAMS ((char *pkt, char *string));
738 pack_string (pkt, string)
745 len = strlen (string);
747 len = 200; /* Bigger than most GDB packets, junk??? */
748 pkt = pack_hex_byte (pkt, len);
752 if ((ch == '\0') || (ch == '#'))
753 ch = '*'; /* Protect encapsulation */
758 #endif /* 0 (unused) */
761 unpack_string (src, dest, length)
773 pack_threadid (pkt, id)
778 unsigned char *altid;
780 altid = (unsigned char *) id;
781 limit = pkt + BUF_THREAD_ID_SIZE;
783 pkt = pack_hex_byte (pkt, *altid++);
789 unpack_threadid (inbuf, id)
794 char *limit = inbuf + BUF_THREAD_ID_SIZE;
797 altref = (char *) id;
799 while (inbuf < limit)
801 x = stubhex (*inbuf++);
802 y = stubhex (*inbuf++);
803 *altref++ = (x << 4) | y;
808 /* Externally, threadrefs are 64 bits but internally, they are still
809 ints. This is due to a mismatch of specifications. We would like
810 to use 64bit thread references internally. This is an adapter
814 int_to_threadref (id, value)
820 scan = (unsigned char *) id;
826 *scan++ = (value >> 24) & 0xff;
827 *scan++ = (value >> 16) & 0xff;
828 *scan++ = (value >> 8) & 0xff;
829 *scan++ = (value & 0xff);
833 threadref_to_int (ref)
843 value = (value << 8) | ((*scan++) & 0xff);
848 copy_threadref (dest, src)
853 unsigned char *csrc, *cdest;
855 csrc = (unsigned char *) src;
856 cdest = (unsigned char *) dest;
863 threadmatch (dest, src)
867 /* things are broken right now, so just assume we got a match */
869 unsigned char *srcp, *destp;
872 destp = (char *) dest;
876 result &= (*srcp++ == *destp++) ? 1 : 0;
883 threadid:1, # always request threadid
890 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
893 pack_threadinfo_request (pkt, mode, id)
898 *pkt++ = 'q'; /* Info Query */
899 *pkt++ = 'P'; /* process or thread info */
900 pkt = pack_int (pkt, mode); /* mode */
901 pkt = pack_threadid (pkt, id); /* threadid */
902 *pkt = '\0'; /* terminate */
906 /* These values tag the fields in a thread info response packet */
907 /* Tagging the fields allows us to request specific fields and to
908 add more fields as time goes by */
910 #define TAG_THREADID 1 /* Echo the thread identifier */
911 #define TAG_EXISTS 2 /* Is this process defined enough to
912 fetch registers and its stack */
913 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
914 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is */
915 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
919 remote_unpack_thread_info_response (pkt, expectedref, info)
921 threadref *expectedref;
922 struct gdb_ext_thread_info *info;
927 char *limit = pkt + PBUFSIZ; /* plausable parsing limit */
930 /* info->threadid = 0; FIXME: implement zero_threadref */
932 info->display[0] = '\0';
933 info->shortname[0] = '\0';
934 info->more_display[0] = '\0';
936 /* Assume the characters indicating the packet type have been stripped */
937 pkt = unpack_int (pkt, &mask); /* arg mask */
938 pkt = unpack_threadid (pkt, &ref);
941 warning ("Incomplete response to threadinfo request\n");
942 if (!threadmatch (&ref, expectedref))
943 { /* This is an answer to a different request */
944 warning ("ERROR RMT Thread info mismatch\n");
947 copy_threadref (&info->threadid, &ref);
949 /* Loop on tagged fields , try to bail if somthing goes wrong */
951 while ((pkt < limit) && mask && *pkt) /* packets are terminated with nulls */
953 pkt = unpack_int (pkt, &tag); /* tag */
954 pkt = unpack_byte (pkt, &length); /* length */
955 if (!(tag & mask)) /* tags out of synch with mask */
957 warning ("ERROR RMT: threadinfo tag mismatch\n");
961 if (tag == TAG_THREADID)
965 warning ("ERROR RMT: length of threadid is not 16\n");
969 pkt = unpack_threadid (pkt, &ref);
970 mask = mask & ~TAG_THREADID;
973 if (tag == TAG_EXISTS)
975 info->active = stub_unpack_int (pkt, length);
977 mask = mask & ~(TAG_EXISTS);
980 warning ("ERROR RMT: 'exists' length too long\n");
986 if (tag == TAG_THREADNAME)
988 pkt = unpack_string (pkt, &info->shortname[0], length);
989 mask = mask & ~TAG_THREADNAME;
992 if (tag == TAG_DISPLAY)
994 pkt = unpack_string (pkt, &info->display[0], length);
995 mask = mask & ~TAG_DISPLAY;
998 if (tag == TAG_MOREDISPLAY)
1000 pkt = unpack_string (pkt, &info->more_display[0], length);
1001 mask = mask & ~TAG_MOREDISPLAY;
1004 warning ("ERROR RMT: unknown thread info tag\n");
1005 break; /* Not a tag we know about */
1011 remote_get_threadinfo (threadid, fieldset, info)
1012 threadref *threadid;
1013 int fieldset; /* TAG mask */
1014 struct gdb_ext_thread_info *info;
1017 char threadinfo_pkt[PBUFSIZ];
1019 pack_threadinfo_request (threadinfo_pkt, fieldset, threadid);
1020 putpkt (threadinfo_pkt);
1021 getpkt (threadinfo_pkt, 0);
1022 result = remote_unpack_thread_info_response (threadinfo_pkt + 2, threadid,
1027 /* Unfortunately, 61 bit thread-ids are bigger than the internal
1028 representation of a threadid. */
1031 adapt_remote_get_threadinfo (ref, selection, info)
1034 struct gdb_ext_thread_info *info;
1038 int_to_threadref (&lclref, *ref);
1039 return remote_get_threadinfo (&lclref, selection, info);
1042 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1045 pack_threadlist_request (pkt, startflag, threadcount, nextthread)
1049 threadref *nextthread;
1051 *pkt++ = 'q'; /* info query packet */
1052 *pkt++ = 'L'; /* Process LIST or threadLIST request */
1053 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */
1054 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */
1055 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */
1060 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1063 parse_threadlist_response (pkt, result_limit, original_echo, resultlist,
1067 threadref *original_echo;
1068 threadref *resultlist;
1072 int count, resultcount, done;
1075 /* Assume the 'q' and 'M chars have been stripped. */
1076 limit = pkt + (PBUFSIZ - BUF_THREAD_ID_SIZE); /* done parse past here */
1077 pkt = unpack_byte (pkt, &count); /* count field */
1078 pkt = unpack_nibble (pkt, &done);
1079 /* The first threadid is the argument threadid. */
1080 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */
1081 while ((count-- > 0) && (pkt < limit))
1083 pkt = unpack_threadid (pkt, resultlist++);
1084 if (resultcount++ >= result_limit)
1093 remote_get_threadlist (startflag, nextthread, result_limit,
1094 done, result_count, threadlist)
1096 threadref *nextthread;
1100 threadref *threadlist;
1103 static threadref echo_nextthread;
1104 char threadlist_packet[PBUFSIZ];
1105 char t_response[PBUFSIZ];
1108 /* Trancate result limit to be smaller than the packet size */
1109 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= PBUFSIZ)
1110 result_limit = (PBUFSIZ / BUF_THREAD_ID_SIZE) - 2;
1112 pack_threadlist_request (threadlist_packet,
1113 startflag, result_limit, nextthread);
1114 putpkt (threadlist_packet);
1115 getpkt (t_response, 0);
1118 parse_threadlist_response (t_response + 2, result_limit, &echo_nextthread,
1121 if (!threadmatch (&echo_nextthread, nextthread))
1123 /* FIXME: This is a good reason to drop the packet */
1124 /* Possably, there is a duplicate response */
1126 retransmit immediatly - race conditions
1127 retransmit after timeout - yes
1129 wait for packet, then exit
1131 warning ("HMM: threadlist did not echo arg thread, dropping it\n");
1132 return 0; /* I choose simply exiting */
1134 if (*result_count <= 0)
1138 warning ("RMT ERROR : failed to get remote thread list\n");
1141 return result; /* break; */
1143 if (*result_count > result_limit)
1146 warning ("RMT ERROR: threadlist response longer than requested\n");
1152 /* This is the interface between remote and threads, remotes upper interface */
1154 /* remote_find_new_threads retrieves the thread list and for each
1155 thread in the list, looks up the thread in GDB's internal list,
1156 ading the thread if it does not already exist. This involves
1157 getting partial thread lists from the remote target so, polling the
1158 quit_flag is required. */
1161 /* About this many threadisds fit in a packet. */
1163 #define MAXTHREADLISTRESULTS 32
1166 remote_threadlist_iterator (stepfunction, context, looplimit)
1167 rmt_thread_action stepfunction;
1171 int done, i, result_count;
1175 static threadref nextthread;
1176 static threadref resultthreadlist[MAXTHREADLISTRESULTS];
1181 if (loopcount++ > looplimit)
1184 warning ("Remote fetch threadlist -infinite loop-\n");
1187 if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS,
1188 &done, &result_count, resultthreadlist))
1193 /* clear for later iterations */
1195 /* Setup to resume next batch of thread references, set nextthread. */
1196 if (result_count >= 1)
1197 copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
1199 while (result_count--)
1200 if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
1207 remote_newthread_step (ref, context)
1213 pid = threadref_to_int (ref);
1214 if (!in_thread_list (pid))
1216 return 1; /* continue iterator */
1219 #define CRAZY_MAX_THREADS 1000
1222 remote_current_thread (oldpid)
1229 if (buf[0] == 'Q' && buf[1] == 'C')
1230 return strtol (&buf[2], NULL, 16);
1236 remote_find_new_threads ()
1240 ret = remote_threadlist_iterator (remote_newthread_step, 0,
1242 if (inferior_pid == MAGIC_NULL_PID) /* ack ack ack */
1243 inferior_pid = remote_current_thread (inferior_pid);
1247 /* Initialize the thread vector which is used by threads.c */
1248 /* The thread stub is a package, it has an initializer */
1251 init_remote_threads ()
1253 remote_thread_vec.find_new_threads = remote_find_new_threads;
1254 remote_thread_vec.get_thread_info = adapt_remote_get_threadinfo;
1258 /* Restart the remote side; this is an extended protocol operation. */
1261 extended_remote_restart ()
1265 /* Send the restart command; for reasons I don't understand the
1266 remote side really expects a number after the "R". */
1268 sprintf (&buf[1], "%x", 0);
1271 /* Now query for status so this looks just like we restarted
1272 gdbserver from scratch. */
1277 /* Clean up connection to a remote debugger. */
1281 remote_close (quitting)
1285 SERIAL_CLOSE (remote_desc);
1289 /* Query the remote side for the text, data and bss offsets. */
1294 char buf[PBUFSIZ], *ptr;
1296 CORE_ADDR text_addr, data_addr, bss_addr;
1297 struct section_offsets *offs;
1299 putpkt ("qOffsets");
1303 if (buf[0] == '\000')
1304 return; /* Return silently. Stub doesn't support
1308 warning ("Remote failure reply: %s", buf);
1312 /* Pick up each field in turn. This used to be done with scanf, but
1313 scanf will make trouble if CORE_ADDR size doesn't match
1314 conversion directives correctly. The following code will work
1315 with any size of CORE_ADDR. */
1316 text_addr = data_addr = bss_addr = 0;
1320 if (strncmp (ptr, "Text=", 5) == 0)
1323 /* Don't use strtol, could lose on big values. */
1324 while (*ptr && *ptr != ';')
1325 text_addr = (text_addr << 4) + fromhex (*ptr++);
1330 if (!lose && strncmp (ptr, ";Data=", 6) == 0)
1333 while (*ptr && *ptr != ';')
1334 data_addr = (data_addr << 4) + fromhex (*ptr++);
1339 if (!lose && strncmp (ptr, ";Bss=", 5) == 0)
1342 while (*ptr && *ptr != ';')
1343 bss_addr = (bss_addr << 4) + fromhex (*ptr++);
1349 error ("Malformed response to offset query, %s", buf);
1351 if (symfile_objfile == NULL)
1354 offs = (struct section_offsets *) alloca (sizeof (struct section_offsets)
1355 + symfile_objfile->num_sections
1356 * sizeof (offs->offsets));
1357 memcpy (offs, symfile_objfile->section_offsets,
1358 sizeof (struct section_offsets)
1359 + symfile_objfile->num_sections
1360 * sizeof (offs->offsets));
1362 ANOFFSET (offs, SECT_OFF_TEXT) = text_addr;
1364 /* This is a temporary kludge to force data and bss to use the same offsets
1365 because that's what nlmconv does now. The real solution requires changes
1366 to the stub and remote.c that I don't have time to do right now. */
1368 ANOFFSET (offs, SECT_OFF_DATA) = data_addr;
1369 ANOFFSET (offs, SECT_OFF_BSS) = data_addr;
1371 objfile_relocate (symfile_objfile, offs);
1374 /* Stub for catch_errors. */
1377 remote_start_remote (dummy)
1380 immediate_quit = 1; /* Allow user to interrupt it */
1382 /* Ack any packet which the remote side has already sent. */
1383 SERIAL_WRITE (remote_desc, "+", 1);
1385 /* Let the stub know that we want it to return the thread. */
1388 inferior_pid = remote_current_thread (inferior_pid);
1390 get_offsets (); /* Get text, data & bss offsets */
1392 putpkt ("?"); /* initiate a query from remote machine */
1395 start_remote (); /* Initialize gdb process mechanisms */
1399 /* Open a connection to a remote debugger.
1400 NAME is the filename used for communication. */
1403 remote_open (name, from_tty)
1407 remote_open_1 (name, from_tty, &remote_ops, 0);
1410 /* Open a connection to a remote debugger using the extended
1411 remote gdb protocol. NAME is the filename used for communication. */
1414 extended_remote_open (name, from_tty)
1418 remote_open_1 (name, from_tty, &extended_remote_ops, 1/*extended_p*/);
1421 /* Generic code for opening a connection to a remote target. */
1423 static DCACHE *remote_dcache;
1426 remote_open_1 (name, from_tty, target, extended_p)
1429 struct target_ops *target;
1433 error ("To open a remote debug connection, you need to specify what\n\
1434 serial device is attached to the remote system (e.g. /dev/ttya).");
1436 target_preopen (from_tty);
1438 unpush_target (target);
1440 remote_dcache = dcache_init (remote_read_bytes, remote_write_bytes);
1442 remote_desc = SERIAL_OPEN (name);
1444 perror_with_name (name);
1446 if (baud_rate != -1)
1448 if (SERIAL_SETBAUDRATE (remote_desc, baud_rate))
1450 SERIAL_CLOSE (remote_desc);
1451 perror_with_name (name);
1456 SERIAL_RAW (remote_desc);
1458 /* If there is something sitting in the buffer we might take it as a
1459 response to a command, which would be bad. */
1460 SERIAL_FLUSH_INPUT (remote_desc);
1464 puts_filtered ("Remote debugging using ");
1465 puts_filtered (name);
1466 puts_filtered ("\n");
1468 push_target (target); /* Switch to using remote target now */
1470 /* The target vector does not have the thread functions in it yet,
1471 so we use this function to call back into the thread module and
1472 register the thread vector and its contained functions. */
1473 bind_target_thread_vector (&remote_thread_vec);
1475 /* Start out by trying the 'P' request to set registers. We set
1476 this each time that we open a new target so that if the user
1477 switches from one stub to another, we can (if the target is
1478 closed and reopened) cope. */
1479 stub_supports_P = 1;
1481 general_thread = -2;
1484 /* Force remote_write_bytes to check whether target supports
1485 binary downloading. */
1486 remote_binary_checked = 0;
1488 /* Without this, some commands which require an active target (such
1489 as kill) won't work. This variable serves (at least) double duty
1490 as both the pid of the target process (if it has such), and as a
1491 flag indicating that a target is active. These functions should
1492 be split out into seperate variables, especially since GDB will
1493 someday have a notion of debugging several processes. */
1495 inferior_pid = MAGIC_NULL_PID;
1496 /* Start the remote connection; if error (0), discard this target.
1497 In particular, if the user quits, be sure to discard it
1498 (we'd be in an inconsistent state otherwise). */
1499 if (!catch_errors (remote_start_remote, NULL,
1500 "Couldn't establish connection to remote target\n",
1509 /* tell the remote that we're using the extended protocol. */
1516 /* This takes a program previously attached to and detaches it. After
1517 this is done, GDB can be used to debug some other program. We
1518 better not have left any breakpoints in the target program or it'll
1519 die when it hits one. */
1522 remote_detach (args, from_tty)
1529 error ("Argument given to \"detach\" when remotely debugging.");
1531 /* Tell the remote target to detach. */
1537 puts_filtered ("Ending remote debugging.\n");
1540 /* Convert hex digit A to a number. */
1546 if (a >= '0' && a <= '9')
1548 else if (a >= 'a' && a <= 'f')
1549 return a - 'a' + 10;
1550 else if (a >= 'A' && a <= 'F')
1551 return a - 'A' + 10;
1553 error ("Reply contains invalid hex digit %d", a);
1556 /* Convert number NIB to a hex digit. */
1568 /* Tell the remote machine to resume. */
1570 static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
1572 static int last_sent_step;
1575 remote_resume (pid, step, siggnal)
1577 enum target_signal siggnal;
1582 set_thread (0, 0); /* run any thread */
1584 set_thread (pid, 0); /* run this thread */
1586 dcache_flush (remote_dcache);
1588 last_sent_signal = siggnal;
1589 last_sent_step = step;
1591 /* A hook for when we need to do something at the last moment before
1593 if (target_resume_hook)
1594 (*target_resume_hook) ();
1596 if (siggnal != TARGET_SIGNAL_0)
1598 buf[0] = step ? 'S' : 'C';
1599 buf[1] = tohex (((int)siggnal >> 4) & 0xf);
1600 buf[2] = tohex ((int)siggnal & 0xf);
1604 strcpy (buf, step ? "s": "c");
1609 /* Send ^C to target to halt it. Target will respond, and send us a
1612 static void (*ofunc) PARAMS ((int));
1614 /* The command line interface's stop routine. This function is installed
1615 as a signal handler for SIGINT. The first time a user requests a
1616 stop, we call remote_stop to send a break or ^C. If there is no
1617 response from the target (it didn't stop when the user requested it),
1618 we ask the user if he'd like to detach from the target. */
1620 remote_interrupt (signo)
1623 /* If this doesn't work, try more severe steps. */
1624 signal (signo, remote_interrupt_twice);
1627 printf_unfiltered ("remote_interrupt called\n");
1632 /* The user typed ^C twice. */
1635 remote_interrupt_twice (signo)
1638 signal (signo, ofunc);
1640 signal (signo, remote_interrupt);
1643 /* This is the generic stop called via the target vector. When a target
1644 interrupt is requested, either by the command line or the GUI, we
1645 will eventually end up here. */
1649 /* Send a break or a ^C, depending on user preference. */
1651 printf_unfiltered ("remote_stop called\n");
1654 SERIAL_SEND_BREAK (remote_desc);
1656 SERIAL_WRITE (remote_desc, "\003", 1);
1659 /* Ask the user what to do when an interrupt is received. */
1664 target_terminal_ours ();
1666 if (query ("Interrupted while waiting for the program.\n\
1667 Give up (and stop debugging it)? "))
1669 target_mourn_inferior ();
1670 return_to_top_level (RETURN_QUIT);
1673 target_terminal_inferior ();
1676 /* If nonzero, ignore the next kill. */
1681 remote_console_output (msg)
1686 for (p = msg; *p; p +=2)
1689 char c = fromhex (p[0]) * 16 + fromhex (p[1]);
1692 if (target_output_hook)
1693 target_output_hook (tb);
1695 fputs_filtered (tb, gdb_stdout);
1699 /* Wait until the remote machine stops, then return, storing status in
1700 STATUS just as `wait' would. Returns "pid" (though it's not clear
1701 what, if anything, that means in the case of this target). */
1704 remote_wait (pid, status)
1706 struct target_waitstatus *status;
1708 unsigned char buf[PBUFSIZ];
1709 int thread_num = -1;
1711 status->kind = TARGET_WAITKIND_EXITED;
1712 status->value.integer = 0;
1718 ofunc = signal (SIGINT, remote_interrupt);
1719 getpkt ((char *) buf, 1);
1720 signal (SIGINT, ofunc);
1722 /* This is a hook for when we need to do something (perhaps the
1723 collection of trace data) every time the target stops. */
1724 if (target_wait_loop_hook)
1725 (*target_wait_loop_hook) ();
1729 case 'E': /* Error of some sort */
1730 warning ("Remote failure reply: %s", buf);
1732 case 'T': /* Status with PC, SP, FP, ... */
1736 char regs[MAX_REGISTER_RAW_SIZE];
1738 /* Expedited reply, containing Signal, {regno, reg} repeat */
1739 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
1741 n... = register number
1742 r... = register contents
1744 p = &buf[3]; /* after Txx */
1751 /* Read the register number */
1752 regno = strtol ((const char *) p, &p_temp, 16);
1753 p1 = (unsigned char *)p_temp;
1755 if (p1 == p) /* No register number present here */
1757 p1 = (unsigned char *) strchr ((const char *) p, ':');
1759 warning ("Malformed packet(a) (missing colon): %s\n\
1762 if (strncmp ((const char *) p, "thread", p1 - p) == 0)
1764 p_temp = unpack_varlen_hex (++p1, &thread_num);
1765 record_currthread (thread_num);
1766 p = (unsigned char *) p_temp;
1774 warning ("Malformed packet(b) (missing colon): %s\n\
1778 if (regno >= NUM_REGS)
1779 warning ("Remote sent bad register number %ld: %s\n\
1783 for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
1785 if (p[0] == 0 || p[1] == 0)
1786 warning ("Remote reply is too short: %s", buf);
1787 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
1790 supply_register (regno, regs);
1795 warning ("Remote register badly formatted: %s", buf);
1796 warning (" here: %s",p);
1801 case 'S': /* Old style status, just signal only */
1802 status->kind = TARGET_WAITKIND_STOPPED;
1803 status->value.sig = (enum target_signal)
1804 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
1807 case 'W': /* Target exited */
1809 /* The remote process exited. */
1810 status->kind = TARGET_WAITKIND_EXITED;
1811 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
1815 status->kind = TARGET_WAITKIND_SIGNALLED;
1816 status->value.sig = (enum target_signal)
1817 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
1821 case 'O': /* Console output */
1822 remote_console_output (buf + 1);
1825 if (last_sent_signal != TARGET_SIGNAL_0)
1827 /* Zero length reply means that we tried 'S' or 'C' and
1828 the remote system doesn't support it. */
1829 target_terminal_ours_for_output ();
1831 ("Can't send signals to this remote system. %s not sent.\n",
1832 target_signal_to_name (last_sent_signal));
1833 last_sent_signal = TARGET_SIGNAL_0;
1834 target_terminal_inferior ();
1836 strcpy ((char *) buf, last_sent_step ? "s" : "c");
1837 putpkt ((char *) buf);
1840 /* else fallthrough */
1842 warning ("Invalid remote reply: %s", buf);
1847 if (thread_num != -1)
1849 /* Initial thread value can only be acquired via wait, so deal with
1850 this marker which is used before the first thread value is
1852 if (inferior_pid == MAGIC_NULL_PID)
1854 inferior_pid = thread_num;
1855 if (!in_thread_list (inferior_pid))
1856 add_thread (inferior_pid);
1860 return inferior_pid;
1863 /* Number of bytes of registers this stub implements. */
1865 static int register_bytes_found;
1867 /* Read the remote registers into the block REGS. */
1868 /* Currently we just read all the registers, so we don't use regno. */
1872 remote_fetch_registers (regno)
1878 char regs[REGISTER_BYTES];
1880 set_thread (inferior_pid, 1);
1885 if (remote_register_buf_size == 0)
1886 remote_register_buf_size = strlen (buf);
1888 /* Unimplemented registers read as all bits zero. */
1889 memset (regs, 0, REGISTER_BYTES);
1891 /* We can get out of synch in various cases. If the first character
1892 in the buffer is not a hex character, assume that has happened
1893 and try to fetch another packet to read. */
1894 while ((buf[0] < '0' || buf[0] > '9')
1895 && (buf[0] < 'a' || buf[0] > 'f')
1896 && buf[0] != 'x') /* New: unavailable register value */
1899 printf_unfiltered ("Bad register packet; fetching a new packet\n");
1903 /* Reply describes registers byte by byte, each byte encoded as two
1904 hex characters. Suck them all up, then supply them to the
1905 register cacheing/storage mechanism. */
1908 for (i = 0; i < REGISTER_BYTES; i++)
1914 warning ("Remote reply is of odd length: %s", buf);
1915 /* Don't change register_bytes_found in this case, and don't
1916 print a second warning. */
1919 if (p[0] == 'x' && p[1] == 'x')
1920 regs[i] = 0; /* 'x' */
1922 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
1926 if (i != register_bytes_found)
1928 register_bytes_found = i;
1929 #ifdef REGISTER_BYTES_OK
1930 if (!REGISTER_BYTES_OK (i))
1931 warning ("Remote reply is too short: %s", buf);
1936 for (i = 0; i < NUM_REGS; i++)
1938 supply_register (i, ®s[REGISTER_BYTE(i)]);
1939 if (buf[REGISTER_BYTE(i) * 2] == 'x')
1940 register_valid[i] = -1; /* register value not available */
1944 /* Prepare to store registers. Since we may send them all (using a
1945 'G' request), we have to read out the ones we don't want to change
1949 remote_prepare_to_store ()
1951 /* Make sure the entire registers array is valid. */
1952 read_register_bytes (0, (char *)NULL, REGISTER_BYTES);
1955 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1956 of REGISTERS. FIXME: ignores errors. */
1959 remote_store_registers (regno)
1966 set_thread (inferior_pid, 1);
1968 if (regno >= 0 && stub_supports_P)
1970 /* Try storing a single register. */
1973 sprintf (buf, "P%x=", regno);
1974 p = buf + strlen (buf);
1975 regp = ®isters[REGISTER_BYTE (regno)];
1976 for (i = 0; i < REGISTER_RAW_SIZE (regno); ++i)
1978 *p++ = tohex ((regp[i] >> 4) & 0xf);
1979 *p++ = tohex (regp[i] & 0xf);
1985 /* The stub understands the 'P' request. We are done. */
1989 /* The stub does not support the 'P' request. Use 'G' instead,
1990 and don't try using 'P' in the future (it will just waste our
1992 stub_supports_P = 0;
1997 /* Command describes registers byte by byte,
1998 each byte encoded as two hex characters. */
2001 /* remote_prepare_to_store insures that register_bytes_found gets set. */
2002 for (i = 0; i < register_bytes_found; i++)
2004 *p++ = tohex ((registers[i] >> 4) & 0xf);
2005 *p++ = tohex (registers[i] & 0xf);
2012 /* Use of the data cache *used* to be disabled because it loses for looking
2013 at and changing hardware I/O ports and the like. Accepting `volatile'
2014 would perhaps be one way to fix it. Another idea would be to use the
2015 executable file for the text segment (for all SEC_CODE sections?
2016 For all SEC_READONLY sections?). This has problems if you want to
2017 actually see what the memory contains (e.g. self-modifying code,
2018 clobbered memory, user downloaded the wrong thing).
2020 Because it speeds so much up, it's now enabled, if you're playing
2021 with registers you turn it of (set remotecache 0). */
2023 /* Read a word from remote address ADDR and return it.
2024 This goes through the data cache. */
2028 remote_fetch_word (addr)
2031 return dcache_fetch (remote_dcache, addr);
2034 /* Write a word WORD into remote address ADDR.
2035 This goes through the data cache. */
2038 remote_store_word (addr, word)
2042 dcache_poke (remote_dcache, addr, word);
2044 #endif /* 0 (unused?) */
2048 /* Return the number of hex digits in num. */
2056 for (i = 0; num != 0; i++)
2062 /* Set BUF to the hex digits representing NUM. */
2065 hexnumstr (buf, num)
2070 int len = hexnumlen (num);
2074 for (i = len - 1; i >= 0; i--)
2076 buf[i] = "0123456789abcdef" [(num & 0xf)];
2083 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
2086 remote_address_masked (addr)
2089 if (remote_address_size > 0
2090 && remote_address_size < (sizeof (ULONGEST) * 8))
2092 /* Only create a mask when that mask can safely be constructed
2093 in a ULONGEST variable. */
2095 mask = (mask << remote_address_size) - 1;
2101 /* Determine whether the remote target supports binary downloading.
2102 This is accomplished by sending a no-op memory write of zero length
2103 to the target at the specified address. It does not suffice to send
2104 the whole packet, since many stubs strip the eighth bit and subsequently
2105 compute a wrong checksum, which causes real havoc with remote_write_bytes.
2107 NOTE: This can still lose if the serial line is not eight-bit clean. In
2108 cases like this, the user should clear "remotebinarydownload". */
2110 check_binary_download (addr)
2113 if (remote_binary_download && !remote_binary_checked)
2115 char buf[PBUFSIZ], *p;
2116 remote_binary_checked = 1;
2120 p += hexnumstr (p, (ULONGEST) addr);
2122 p += hexnumstr (p, (ULONGEST) 0);
2126 putpkt_binary (buf, (int) (p - buf));
2130 remote_binary_download = 0;
2135 if (remote_binary_download)
2136 printf_unfiltered ("binary downloading suppported by target\n");
2138 printf_unfiltered ("binary downloading NOT suppported by target\n");
2142 /* Write memory data directly to the remote machine.
2143 This does not inform the data cache; the data cache uses this.
2144 MEMADDR is the address in the remote memory space.
2145 MYADDR is the address of the buffer in our space.
2146 LEN is the number of bytes.
2148 Returns number of bytes transferred, or 0 for error. */
2151 remote_write_bytes (memaddr, myaddr, len)
2156 int max_buf_size; /* Max size of packet output buffer */
2159 /* Verify that the target can support a binary download */
2160 check_binary_download (memaddr);
2162 /* Chop the transfer down if necessary */
2164 max_buf_size = min (remote_write_size, PBUFSIZ);
2165 if (remote_register_buf_size != 0)
2166 max_buf_size = min (max_buf_size, remote_register_buf_size);
2168 /* Subtract header overhead from max payload size - $M<memaddr>,<len>:#nn */
2169 max_buf_size -= 2 + hexnumlen (memaddr + len - 1) + 1 + hexnumlen (len) + 4;
2174 unsigned char buf[PBUFSIZ];
2175 unsigned char *p, *plen;
2179 /* construct "M"<memaddr>","<len>":" */
2180 /* sprintf (buf, "M%lx,%x:", (unsigned long) memaddr, todo); */
2181 memaddr = remote_address_masked (memaddr);
2183 if (remote_binary_download)
2186 todo = min (len, max_buf_size);
2191 todo = min (len, max_buf_size / 2); /* num bytes that will fit */
2194 p += hexnumstr (p, (ULONGEST) memaddr);
2197 plen = p; /* remember where len field goes */
2198 p += hexnumstr (p, (ULONGEST) todo);
2202 /* We send target system values byte by byte, in increasing byte
2203 addresses, each byte encoded as two hex characters (or one
2204 binary character). */
2205 if (remote_binary_download)
2209 (i < todo) && (i + escaped) < (max_buf_size - 2);
2212 switch (myaddr[i] & 0xff)
2217 /* These must be escaped */
2220 *p++ = (myaddr[i] & 0xff) ^ 0x20;
2223 *p++ = myaddr[i] & 0xff;
2230 /* Escape chars have filled up the buffer prematurely,
2231 and we have actually sent fewer bytes than planned.
2232 Fix-up the length field of the packet. */
2234 /* FIXME: will fail if new len is a shorter string than
2237 plen += hexnumstr (plen, (ULONGEST) i);
2243 for (i = 0; i < todo; i++)
2245 *p++ = tohex ((myaddr[i] >> 4) & 0xf);
2246 *p++ = tohex (myaddr[i] & 0xf);
2251 putpkt_binary (buf, (int) (p - buf));
2256 /* There is no correspondance between what the remote protocol uses
2257 for errors and errno codes. We would like a cleaner way of
2258 representing errors (big enough to include errno codes, bfd_error
2259 codes, and others). But for now just return EIO. */
2264 /* Increment by i, not by todo, in case escape chars
2265 caused us to send fewer bytes than we'd planned. */
2273 /* Read memory data directly from the remote machine.
2274 This does not use the data cache; the data cache uses this.
2275 MEMADDR is the address in the remote memory space.
2276 MYADDR is the address of the buffer in our space.
2277 LEN is the number of bytes.
2279 Returns number of bytes transferred, or 0 for error. */
2282 remote_read_bytes (memaddr, myaddr, len)
2287 int max_buf_size; /* Max size of packet output buffer */
2290 /* Chop the transfer down if necessary */
2292 max_buf_size = min (remote_write_size, PBUFSIZ);
2293 if (remote_register_buf_size != 0)
2294 max_buf_size = min (max_buf_size, remote_register_buf_size);
2304 todo = min (len, max_buf_size / 2); /* num bytes that will fit */
2306 /* construct "m"<memaddr>","<len>" */
2307 /* sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); */
2308 memaddr = remote_address_masked (memaddr);
2311 p += hexnumstr (p, (ULONGEST) memaddr);
2313 p += hexnumstr (p, (ULONGEST) todo);
2321 /* There is no correspondance between what the remote protocol uses
2322 for errors and errno codes. We would like a cleaner way of
2323 representing errors (big enough to include errno codes, bfd_error
2324 codes, and others). But for now just return EIO. */
2329 /* Reply describes memory byte by byte,
2330 each byte encoded as two hex characters. */
2333 for (i = 0; i < todo; i++)
2335 if (p[0] == 0 || p[1] == 0)
2336 /* Reply is short. This means that we were able to read
2337 only part of what we wanted to. */
2338 return i + (origlen - len);
2339 myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
2349 /* Read or write LEN bytes from inferior memory at MEMADDR,
2350 transferring to or from debugger address MYADDR. Write to inferior
2351 if SHOULD_WRITE is nonzero. Returns length of data written or
2352 read; 0 for error. */
2356 remote_xfer_memory (memaddr, myaddr, len, should_write, target)
2361 struct target_ops *target; /* ignored */
2363 #ifdef REMOTE_TRANSLATE_XFER_ADDRESS
2366 REMOTE_TRANSLATE_XFER_ADDRESS (memaddr, len, targaddr, targlen);
2373 return dcache_xfer_memory (remote_dcache, memaddr, myaddr,
2379 /* Enable after 4.12. */
2382 remote_search (len, data, mask, startaddr, increment, lorange, hirange
2383 addr_found, data_found)
2387 CORE_ADDR startaddr;
2391 CORE_ADDR *addr_found;
2394 if (increment == -4 && len == 4)
2396 long mask_long, data_long;
2397 long data_found_long;
2398 CORE_ADDR addr_we_found;
2400 long returned_long[2];
2403 mask_long = extract_unsigned_integer (mask, len);
2404 data_long = extract_unsigned_integer (data, len);
2405 sprintf (buf, "t%x:%x,%x", startaddr, data_long, mask_long);
2410 /* The stub doesn't support the 't' request. We might want to
2411 remember this fact, but on the other hand the stub could be
2412 switched on us. Maybe we should remember it only until
2413 the next "target remote". */
2414 generic_search (len, data, mask, startaddr, increment, lorange,
2415 hirange, addr_found, data_found);
2420 /* There is no correspondance between what the remote protocol uses
2421 for errors and errno codes. We would like a cleaner way of
2422 representing errors (big enough to include errno codes, bfd_error
2423 codes, and others). But for now just use EIO. */
2424 memory_error (EIO, startaddr);
2427 while (*p != '\0' && *p != ',')
2428 addr_we_found = (addr_we_found << 4) + fromhex (*p++);
2430 error ("Protocol error: short return for search");
2432 data_found_long = 0;
2433 while (*p != '\0' && *p != ',')
2434 data_found_long = (data_found_long << 4) + fromhex (*p++);
2435 /* Ignore anything after this comma, for future extensions. */
2437 if (addr_we_found < lorange || addr_we_found >= hirange)
2443 *addr_found = addr_we_found;
2444 *data_found = store_unsigned_integer (data_we_found, len);
2447 generic_search (len, data, mask, startaddr, increment, lorange,
2448 hirange, addr_found, data_found);
2453 remote_files_info (ignore)
2454 struct target_ops *ignore;
2456 puts_filtered ("Debugging a target over a serial line.\n");
2459 /* Stuff for dealing with the packets which are part of this protocol.
2460 See comment at top of file for details. */
2462 /* Read a single character from the remote end, masking it down to 7 bits. */
2470 ch = SERIAL_READCHAR (remote_desc, timeout);
2475 error ("Remote connection closed");
2477 perror_with_name ("Remote communication error");
2478 case SERIAL_TIMEOUT:
2485 /* Send the command in BUF to the remote machine, and read the reply
2486 into BUF. Report an error if we get an error reply. */
2496 error ("Remote failure reply: %s", buf);
2499 /* Display a null-terminated packet on stdout, for debugging, using C
2506 puts_filtered ("\"");
2508 gdb_printchar (*buf++, gdb_stdout, '"');
2509 puts_filtered ("\"");
2516 return putpkt_binary (buf, strlen (buf));
2519 /* Send a packet to the remote machine, with error checking. The data
2520 of the packet is in BUF. The string in BUF can be at most PBUFSIZ - 5
2521 to account for the $, # and checksum, and for a possible /0 if we are
2522 debugging (remote_debug) and want to print the sent packet as a string */
2525 putpkt_binary (buf, cnt)
2530 unsigned char csum = 0;
2536 /* Copy the packet into buffer BUF2, encapsulating it
2537 and giving it a checksum. */
2539 if (cnt > (int) sizeof (buf2) - 5) /* Prosanity check */
2545 for (i = 0; i < cnt; i++)
2551 *p++ = tohex ((csum >> 4) & 0xf);
2552 *p++ = tohex (csum & 0xf);
2554 /* Send it over and over until we get a positive ack. */
2558 int started_error_output = 0;
2563 printf_unfiltered ("Sending packet: %s...", buf2);
2564 gdb_flush (gdb_stdout);
2566 if (SERIAL_WRITE (remote_desc, buf2, p - buf2))
2567 perror_with_name ("putpkt: write failed");
2569 /* read until either a timeout occurs (-2) or '+' is read */
2572 ch = readchar (remote_timeout);
2579 case SERIAL_TIMEOUT:
2581 if (started_error_output)
2583 putchar_unfiltered ('\n');
2584 started_error_output = 0;
2593 printf_unfiltered ("Ack\n");
2595 case SERIAL_TIMEOUT:
2599 break; /* Retransmit buffer */
2602 char junkbuf[PBUFSIZ];
2604 /* It's probably an old response, and we're out of sync.
2605 Just gobble up the packet and ignore it. */
2606 getpkt (junkbuf, 0);
2607 continue; /* Now, go look for + */
2612 if (!started_error_output)
2614 started_error_output = 1;
2615 printf_unfiltered ("putpkt: Junk: ");
2617 putchar_unfiltered (ch & 0177);
2621 break; /* Here to retransmit */
2625 /* This is wrong. If doing a long backtrace, the user should be
2626 able to get out next time we call QUIT, without anything as
2627 violent as interrupt_query. If we want to provide a way out of
2628 here without getting to the next QUIT, it should be based on
2629 hitting ^C twice as in remote_wait. */
2639 /* Come here after finding the start of the frame. Collect the rest
2640 into BUF, verifying the checksum, length, and handling run-length
2641 compression. Returns 0 on any error, 1 on success. */
2656 c = readchar (remote_timeout);
2660 case SERIAL_TIMEOUT:
2662 puts_filtered ("Timeout in mid-packet, retrying\n");
2666 puts_filtered ("Saw new packet start in middle of old one\n");
2667 return 0; /* Start a new packet, count retries */
2670 unsigned char pktcsum;
2674 pktcsum = fromhex (readchar (remote_timeout)) << 4;
2675 pktcsum |= fromhex (readchar (remote_timeout));
2677 if (csum == pktcsum)
2682 printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
2684 puts_filtered (buf);
2685 puts_filtered ("\n");
2689 case '*': /* Run length encoding */
2691 c = readchar (remote_timeout);
2693 c = c - ' ' + 3; /* Compute repeat count */
2696 if (c > 0 && c < 255 && bp + c - 1 < buf + PBUFSIZ - 1)
2698 memset (bp, *(bp - 1), c);
2704 printf_filtered ("Repeat count %d too large for buffer: ", c);
2705 puts_filtered (buf);
2706 puts_filtered ("\n");
2710 if (bp < buf + PBUFSIZ - 1)
2718 puts_filtered ("Remote packet too long: ");
2719 puts_filtered (buf);
2720 puts_filtered ("\n");
2727 /* Read a packet from the remote machine, with error checking, and
2728 store it in BUF. BUF is expected to be of size PBUFSIZ. If
2729 FOREVER, wait forever rather than timing out; this is used while
2730 the target is executing user code. */
2733 getpkt (buf, forever)
2742 strcpy (buf,"timeout");
2746 timeout = watchdog > 0 ? watchdog : -1;
2750 timeout = remote_timeout;
2754 for (tries = 1; tries <= MAX_TRIES; tries++)
2756 /* This can loop forever if the remote side sends us characters
2757 continuously, but if it pauses, we'll get a zero from readchar
2758 because of timeout. Then we'll count that as a retry. */
2760 /* Note that we will only wait forever prior to the start of a packet.
2761 After that, we expect characters to arrive at a brisk pace. They
2762 should show up within remote_timeout intervals. */
2766 c = readchar (timeout);
2768 if (c == SERIAL_TIMEOUT)
2770 if (forever) /* Watchdog went off. Kill the target. */
2772 target_mourn_inferior ();
2773 error ("Watchdog has expired. Target detached.\n");
2776 puts_filtered ("Timed out.\n");
2782 /* We've found the start of a packet, now collect the data. */
2784 val = read_frame (buf);
2789 fprintf_unfiltered (gdb_stdout, "Packet received: %s\n", buf);
2790 SERIAL_WRITE (remote_desc, "+", 1);
2794 /* Try the whole thing again. */
2796 SERIAL_WRITE (remote_desc, "-", 1);
2799 /* We have tried hard enough, and just can't receive the packet. Give up. */
2801 printf_unfiltered ("Ignoring packet error, continuing...\n");
2802 SERIAL_WRITE (remote_desc, "+", 1);
2808 /* For some mysterious reason, wait_for_inferior calls kill instead of
2809 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
2813 target_mourn_inferior ();
2817 /* Use catch_errors so the user can quit from gdb even when we aren't on
2818 speaking terms with the remote system. */
2819 catch_errors ((catch_errors_ftype*) putpkt, "k", "", RETURN_MASK_ERROR);
2821 /* Don't wait for it to die. I'm not really sure it matters whether
2822 we do or not. For the existing stubs, kill is a noop. */
2823 target_mourn_inferior ();
2829 remote_mourn_1 (&remote_ops);
2833 extended_remote_mourn ()
2835 /* We do _not_ want to mourn the target like this; this will
2836 remove the extended remote target from the target stack,
2837 and the next time the user says "run" it'll fail.
2839 FIXME: What is the right thing to do here? */
2841 remote_mourn_1 (&extended_remote_ops);
2845 /* Worker function for remote_mourn. */
2847 remote_mourn_1 (target)
2848 struct target_ops *target;
2850 unpush_target (target);
2851 generic_mourn_inferior ();
2854 /* In the extended protocol we want to be able to do things like
2855 "run" and have them basically work as expected. So we need
2856 a special create_inferior function.
2858 FIXME: One day add support for changing the exec file
2859 we're debugging, arguments and an environment. */
2862 extended_remote_create_inferior (exec_file, args, env)
2867 /* Rip out the breakpoints; we'll reinsert them after restarting
2868 the remote server. */
2869 remove_breakpoints ();
2871 /* Now restart the remote server. */
2872 extended_remote_restart ();
2874 /* Now put the breakpoints back in. This way we're safe if the
2875 restart function works via a unix fork on the remote side. */
2876 insert_breakpoints ();
2878 /* Clean up from the last time we were running. */
2879 clear_proceed_status ();
2881 /* Let the remote process run. */
2882 proceed (-1, TARGET_SIGNAL_0, 0);
2886 /* On some machines, e.g. 68k, we may use a different breakpoint instruction
2887 than other targets; in those use REMOTE_BREAKPOINT instead of just
2888 BREAKPOINT. Also, bi-endian targets may define LITTLE_REMOTE_BREAKPOINT
2889 and BIG_REMOTE_BREAKPOINT. If none of these are defined, we just call
2890 the standard routines that are in mem-break.c. */
2892 /* FIXME, these ought to be done in a more dynamic fashion. For instance,
2893 the choice of breakpoint instruction affects target program design and
2894 vice versa, and by making it user-tweakable, the special code here
2895 goes away and we need fewer special GDB configurations. */
2897 #if defined (LITTLE_REMOTE_BREAKPOINT) && defined (BIG_REMOTE_BREAKPOINT) && !defined(REMOTE_BREAKPOINT)
2898 #define REMOTE_BREAKPOINT
2901 #ifdef REMOTE_BREAKPOINT
2903 /* If the target isn't bi-endian, just pretend it is. */
2904 #if !defined (LITTLE_REMOTE_BREAKPOINT) && !defined (BIG_REMOTE_BREAKPOINT)
2905 #define LITTLE_REMOTE_BREAKPOINT REMOTE_BREAKPOINT
2906 #define BIG_REMOTE_BREAKPOINT REMOTE_BREAKPOINT
2909 static unsigned char big_break_insn[] = BIG_REMOTE_BREAKPOINT;
2910 static unsigned char little_break_insn[] = LITTLE_REMOTE_BREAKPOINT;
2912 #endif /* REMOTE_BREAKPOINT */
2914 /* Insert a breakpoint on targets that don't have any better breakpoint
2915 support. We read the contents of the target location and stash it,
2916 then overwrite it with a breakpoint instruction. ADDR is the target
2917 location in the target machine. CONTENTS_CACHE is a pointer to
2918 memory allocated for saving the target contents. It is guaranteed
2919 by the caller to be long enough to save sizeof BREAKPOINT bytes (this
2920 is accomplished via BREAKPOINT_MAX). */
2923 remote_insert_breakpoint (addr, contents_cache)
2925 char *contents_cache;
2927 #ifdef REMOTE_BREAKPOINT
2930 val = target_read_memory (addr, contents_cache, sizeof big_break_insn);
2934 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
2935 val = target_write_memory (addr, (char *) big_break_insn,
2936 sizeof big_break_insn);
2938 val = target_write_memory (addr, (char *) little_break_insn,
2939 sizeof little_break_insn);
2944 return memory_insert_breakpoint (addr, contents_cache);
2945 #endif /* REMOTE_BREAKPOINT */
2949 remote_remove_breakpoint (addr, contents_cache)
2951 char *contents_cache;
2953 #ifdef REMOTE_BREAKPOINT
2954 return target_write_memory (addr, contents_cache, sizeof big_break_insn);
2956 return memory_remove_breakpoint (addr, contents_cache);
2957 #endif /* REMOTE_BREAKPOINT */
2960 /* Some targets are only capable of doing downloads, and afterwards
2961 they switch to the remote serial protocol. This function provides
2962 a clean way to get from the download target to the remote target.
2963 It's basically just a wrapper so that we don't have to expose any
2964 of the internal workings of remote.c.
2966 Prior to calling this routine, you should shutdown the current
2967 target code, else you will get the "A program is being debugged
2968 already..." message. Usually a call to pop_target() suffices. */
2971 push_remote_target (name, from_tty)
2975 printf_filtered ("Switching to remote protocol\n");
2976 remote_open (name, from_tty);
2979 /* Other targets want to use the entire remote serial module but with
2980 certain remote_ops overridden. */
2983 open_remote_target (name, from_tty, target, extended_p)
2986 struct target_ops *target;
2989 printf_filtered ("Selecting the %sremote protocol\n",
2990 (extended_p ? "extended-" : ""));
2991 remote_open_1 (name, from_tty, target, extended_p);
2994 /* Table used by the crc32 function to calcuate the checksum. */
2996 static unsigned long crc32_table[256] = {0, 0};
2998 static unsigned long
2999 crc32 (buf, len, crc)
3004 if (! crc32_table[1])
3006 /* Initialize the CRC table and the decoding table. */
3010 for (i = 0; i < 256; i++)
3012 for (c = i << 24, j = 8; j > 0; --j)
3013 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
3020 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
3026 /* compare-sections command
3028 With no arguments, compares each loadable section in the exec bfd
3029 with the same memory range on the target, and reports mismatches.
3030 Useful for verifying the image on the target against the exec file.
3031 Depends on the target understanding the new "qCRC:" request. */
3034 compare_sections_command (args, from_tty)
3039 unsigned long host_crc, target_crc;
3040 extern bfd *exec_bfd;
3041 struct cleanup *old_chain;
3042 char *tmp, *sectdata, *sectname, buf[PBUFSIZ];
3049 error ("command cannot be used without an exec file");
3050 if (!current_target.to_shortname ||
3051 strcmp (current_target.to_shortname, "remote") != 0)
3052 error ("command can only be used with remote target");
3054 for (s = exec_bfd->sections; s; s = s->next)
3056 if (!(s->flags & SEC_LOAD))
3057 continue; /* skip non-loadable section */
3059 size = bfd_get_section_size_before_reloc (s);
3061 continue; /* skip zero-length section */
3063 sectname = (char *) bfd_get_section_name (exec_bfd, s);
3064 if (args && strcmp (args, sectname) != 0)
3065 continue; /* not the section selected by user */
3067 matched = 1; /* do this section */
3069 /* FIXME: assumes lma can fit into long */
3070 sprintf (buf, "qCRC:%lx,%lx", (long) lma, (long) size);
3073 /* be clever; compute the host_crc before waiting for target reply */
3074 sectdata = xmalloc (size);
3075 old_chain = make_cleanup (free, sectdata);
3076 bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
3077 host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff);
3081 error ("target memory fault, section %s, range 0x%08x -- 0x%08x",
3082 sectname, lma, lma + size);
3084 error ("remote target does not support this operation");
3086 for (target_crc = 0, tmp = &buf[1]; *tmp; tmp++)
3087 target_crc = target_crc * 16 + fromhex (*tmp);
3089 printf_filtered ("Section %s, range 0x%08x -- 0x%08x: ",
3090 sectname, lma, lma + size);
3091 if (host_crc == target_crc)
3092 printf_filtered ("matched.\n");
3095 printf_filtered ("MIS-MATCHED!\n");
3099 do_cleanups (old_chain);
3102 warning ("One or more sections of the remote executable does not match\n\
3103 the loaded file\n");
3104 if (args && !matched)
3105 printf_filtered ("No loaded section named '%s'.\n", args);
3109 remote_query (query_type, buf, outbuf, bufsiz)
3117 char *p2 = &buf2[0];
3121 error ("null pointer to remote bufer size specified");
3123 /* minimum outbuf size is PBUFSIZE - if bufsiz is not large enough let
3124 the caller know and return what the minimum size is */
3125 /* Note: a zero bufsiz can be used to query the minimum buffer size */
3126 if ( *bufsiz < PBUFSIZ )
3132 /* except for querying the minimum buffer size, target must be open */
3134 error ("remote query is only available after target open");
3136 /* we only take uppercase letters as query types, at least for now */
3137 if ( (query_type < 'A') || (query_type > 'Z') )
3138 error ("invalid remote query type");
3141 error ("null remote query specified");
3144 error ("remote query requires a buffer to receive data");
3151 /* we used one buffer char for the remote protocol q command and another
3152 for the query type. As the remote protocol encapsulation uses 4 chars
3153 plus one extra in case we are debugging (remote_debug),
3154 we have PBUFZIZ - 7 left to pack the query string */
3156 while ( buf[i] && (i < (PBUFSIZ - 8)) )
3158 /* bad caller may have sent forbidden characters */
3159 if ( (!isprint(buf[i])) || (buf[i] == '$') || (buf[i] == '#') )
3160 error ("illegal characters in query string");
3168 error ("query larger than available buffer");
3171 if ( i < 0 ) return i;
3179 packet_command (args, from_tty)
3186 error ("command can only be used with remote target");
3189 error ("remote-packet command requires packet text as argument");
3191 puts_filtered ("sending: ");
3192 print_packet (args);
3193 puts_filtered ("\n");
3197 puts_filtered ("received: ");
3199 puts_filtered ("\n");
3203 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------------- */
3205 static void display_thread_info PARAMS ((struct gdb_ext_thread_info *info));
3207 static void threadset_test_cmd PARAMS ((char *cmd, int tty));
3209 static void threadalive_test PARAMS ((char *cmd, int tty));
3211 static void threadlist_test_cmd PARAMS ((char *cmd, int tty));
3213 int get_and_display_threadinfo PARAMS ((threadref *ref));
3215 static void threadinfo_test_cmd PARAMS ((char *cmd, int tty));
3217 static int thread_display_step PARAMS ((threadref *ref, void *context));
3219 static void threadlist_update_test_cmd PARAMS ((char *cmd, int tty));
3221 static void init_remote_threadtests PARAMS ((void));
3223 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid */
3226 threadset_test_cmd (cmd, tty)
3230 int sample_thread = SAMPLE_THREAD;
3232 printf_filtered ("Remote threadset test\n");
3233 set_thread (sample_thread, 1);
3238 threadalive_test (cmd, tty)
3242 int sample_thread = SAMPLE_THREAD;
3244 if (remote_thread_alive (sample_thread))
3245 printf_filtered ("PASS: Thread alive test\n");
3247 printf_filtered ("FAIL: Thread alive test\n");
3250 void output_threadid PARAMS ((char *title, threadref * ref));
3253 output_threadid (title, ref)
3259 pack_threadid (&hexid[0], ref); /* Convert threead id into hex */
3261 printf_filtered ("%s %s\n", title, (&hexid[0]));
3265 threadlist_test_cmd (cmd, tty)
3270 threadref nextthread;
3271 int done, result_count;
3272 threadref threadlist[3];
3274 printf_filtered ("Remote Threadlist test\n");
3275 if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
3276 &result_count, &threadlist[0]))
3277 printf_filtered ("FAIL: threadlist test\n");
3280 threadref *scan = threadlist;
3281 threadref *limit = scan + result_count;
3283 while (scan < limit)
3284 output_threadid (" thread ", scan++);
3289 display_thread_info (info)
3290 struct gdb_ext_thread_info *info;
3292 output_threadid ("Threadid: ", &info->threadid);
3293 printf_filtered ("Name: %s\n ", info->shortname);
3294 printf_filtered ("State: %s\n", info->display);
3295 printf_filtered ("other: %s\n\n", info->more_display);
3299 get_and_display_threadinfo (ref)
3304 struct gdb_ext_thread_info threadinfo;
3306 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
3307 | TAG_MOREDISPLAY | TAG_DISPLAY;
3308 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
3309 display_thread_info (&threadinfo);
3314 threadinfo_test_cmd (cmd, tty)
3318 int athread = SAMPLE_THREAD;
3322 int_to_threadref (&thread, athread);
3323 printf_filtered ("Remote Threadinfo test\n");
3324 if (!get_and_display_threadinfo (&thread))
3325 printf_filtered ("FAIL cannot get thread info\n");
3329 thread_display_step (ref, context)
3333 /* output_threadid(" threadstep ",ref); *//* simple test */
3334 return get_and_display_threadinfo (ref);
3338 threadlist_update_test_cmd (cmd, tty)
3342 printf_filtered ("Remote Threadlist update test\n");
3343 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
3347 init_remote_threadtests (void)
3349 add_com ("tlist", class_obscure, threadlist_test_cmd,
3350 "Fetch and print the remote list of thread identifiers, one pkt only");
3351 add_com ("tinfo", class_obscure, threadinfo_test_cmd,
3352 "Fetch and display info about one thread");
3353 add_com ("tset", class_obscure, threadset_test_cmd,
3354 "Test setting to a different thread");
3355 add_com ("tupd", class_obscure, threadlist_update_test_cmd,
3356 "Iterate through updating all remote thread info");
3357 add_com ("talive", class_obscure, threadalive_test,
3358 " Remote thread alive test ");
3366 remote_ops.to_shortname = "remote";
3367 remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
3369 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
3370 Specify the serial device it is connected to (e.g. /dev/ttya).";
3371 remote_ops.to_open = remote_open;
3372 remote_ops.to_close = remote_close;
3373 remote_ops.to_detach = remote_detach;
3374 remote_ops.to_resume = remote_resume;
3375 remote_ops.to_wait = remote_wait;
3376 remote_ops.to_fetch_registers = remote_fetch_registers;
3377 remote_ops.to_store_registers = remote_store_registers;
3378 remote_ops.to_prepare_to_store = remote_prepare_to_store;
3379 remote_ops.to_xfer_memory = remote_xfer_memory;
3380 remote_ops.to_files_info = remote_files_info;
3381 remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
3382 remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
3383 remote_ops.to_kill = remote_kill;
3384 remote_ops.to_load = generic_load;
3385 remote_ops.to_mourn_inferior = remote_mourn;
3386 remote_ops.to_thread_alive = remote_thread_alive;
3387 remote_ops.to_find_new_threads = remote_find_new_threads;
3388 remote_ops.to_stop = remote_stop;
3389 remote_ops.to_query = remote_query;
3390 remote_ops.to_stratum = process_stratum;
3391 remote_ops.to_has_all_memory = 1;
3392 remote_ops.to_has_memory = 1;
3393 remote_ops.to_has_stack = 1;
3394 remote_ops.to_has_registers = 1;
3395 remote_ops.to_has_execution = 1;
3396 remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
3397 remote_ops.to_magic = OPS_MAGIC;
3400 /* Set up the extended remote vector by making a copy of the standard
3401 remote vector and adding to it. */
3404 init_extended_remote_ops ()
3406 extended_remote_ops = remote_ops;
3408 extended_remote_ops.to_shortname = "extended-remote";
3409 extended_remote_ops.to_longname =
3410 "Extended remote serial target in gdb-specific protocol";
3411 extended_remote_ops.to_doc =
3412 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
3413 Specify the serial device it is connected to (e.g. /dev/ttya).",
3414 extended_remote_ops.to_open = extended_remote_open;
3415 extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
3416 extended_remote_ops.to_mourn_inferior = extended_remote_mourn;
3420 _initialize_remote ()
3423 add_target (&remote_ops);
3425 init_extended_remote_ops ();
3426 add_target (&extended_remote_ops);
3427 init_remote_threads ();
3429 init_remote_threadtests ();
3432 add_cmd ("compare-sections", class_obscure, compare_sections_command,
3433 "Compare section data on target to the exec file.\n\
3434 Argument is a single section name (default: all loaded sections).",
3437 add_cmd ("packet", class_maintenance, packet_command,
3438 "Send an arbitrary packet to a remote target.\n\
3439 maintenance packet TEXT\n\
3440 If GDB is talking to an inferior via the GDB serial protocol, then\n\
3441 this command sends the string TEXT to the inferior, and displays the\n\
3442 response packet. GDB supplies the initial `$' character, and the\n\
3443 terminating `#' character and checksum.",
3447 (add_set_cmd ("remotetimeout", no_class,
3448 var_integer, (char *)&remote_timeout,
3449 "Set timeout value for remote read.\n",
3454 (add_set_cmd ("remotebreak", no_class,
3455 var_integer, (char *)&remote_break,
3456 "Set whether to send break if interrupted.\n",
3461 (add_set_cmd ("remotewritesize", no_class,
3462 var_integer, (char *)&remote_write_size,
3463 "Set the maximum number of bytes per memory write packet.\n",
3467 remote_address_size = TARGET_PTR_BIT;
3469 (add_set_cmd ("remoteaddresssize", class_obscure,
3470 var_integer, (char *)&remote_address_size,
3471 "Set the maximum size of the address (in bits) \
3472 in a memory packet.\n",
3477 (add_set_cmd ("remotebinarydownload", no_class,
3478 var_boolean, (char *) &remote_binary_download,
3479 "Set binary downloads.\n", &setlist),