1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986, 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include <sys/ioctl.h>
33 #include <netinet/in.h>
36 #include <sys/socket.h>
41 #if HAVE_NETINET_TCP_H
42 #include <netinet/tcp.h>
45 #include <sys/ioctl.h>
58 #include <arpa/inet.h>
70 #include <sys/iomgr.h>
73 #ifndef HAVE_SOCKLEN_T
74 typedef int socklen_t
;
77 #ifndef IN_PROCESS_AGENT
80 # define INVALID_DESCRIPTOR INVALID_SOCKET
82 # define INVALID_DESCRIPTOR -1
85 /* Extra value for readchar_callback. */
87 /* The callback is currently not scheduled. */
91 /* Status of the readchar callback.
92 Either NOT_SCHEDULED or the callback id. */
93 static int readchar_callback
= NOT_SCHEDULED
;
95 static int readchar (void);
96 static void reset_readchar (void);
97 static void reschedule (void);
99 /* A cache entry for a successfully looked-up symbol. */
104 struct sym_cache
*next
;
107 int remote_debug
= 0;
108 struct ui_file
*gdb_stdlog
;
110 static gdb_fildes_t remote_desc
= INVALID_DESCRIPTOR
;
111 static gdb_fildes_t listen_desc
= INVALID_DESCRIPTOR
;
113 /* FIXME headerize? */
114 extern int using_threads
;
115 extern int debug_threads
;
117 /* If true, then GDB has requested noack mode. */
119 /* If true, then we tell GDB to use noack mode by default. */
120 int transport_is_reliable
= 0;
123 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
124 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
130 return remote_desc
!= INVALID_DESCRIPTOR
;
134 enable_async_notification (int fd
)
136 #if defined(F_SETFL) && defined (FASYNC)
137 int save_fcntl_flags
;
139 save_fcntl_flags
= fcntl (fd
, F_GETFL
, 0);
140 fcntl (fd
, F_SETFL
, save_fcntl_flags
| FASYNC
);
141 #if defined (F_SETOWN)
142 fcntl (fd
, F_SETOWN
, getpid ());
148 handle_accept_event (int err
, gdb_client_data client_data
)
150 struct sockaddr_in sockaddr
;
154 fprintf (stderr
, "handling possible accept event\n");
156 tmp
= sizeof (sockaddr
);
157 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &tmp
);
158 if (remote_desc
== -1)
159 perror_with_name ("Accept failed");
161 /* Enable TCP keep alive process. */
163 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
164 (char *) &tmp
, sizeof (tmp
));
166 /* Tell TCP not to delay small packets. This greatly speeds up
167 interactive response. */
169 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
170 (char *) &tmp
, sizeof (tmp
));
173 close (listen_desc
); /* No longer need this */
175 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
176 exits when the remote side dies. */
178 closesocket (listen_desc
); /* No longer need this */
181 delete_file_handler (listen_desc
);
183 /* Convert IP address to string. */
184 fprintf (stderr
, "Remote debugging from host %s\n",
185 inet_ntoa (sockaddr
.sin_addr
));
187 enable_async_notification (remote_desc
);
189 /* Register the event loop handler. */
190 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
192 /* We have a new GDB connection now. If we were disconnected
193 tracing, there's a window where the target could report a stop
194 event to the event loop, and since we have a connection now, we'd
195 try to send vStopped notifications to GDB. But, don't do that
196 until GDB as selected all-stop/non-stop, and has queried the
197 threads' status ('?'). */
203 /* Open a connection to a remote debugger.
204 NAME is the filename used for communication. */
207 remote_open (char *name
)
211 port_str
= strchr (name
, ':');
212 if (port_str
== NULL
)
215 error ("Only <host>:<port> is supported on this platform.");
219 if (stat (name
, &statbuf
) == 0
220 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
221 remote_desc
= open (name
, O_RDWR
);
229 perror_with_name ("Could not open remote device");
233 struct termios termios
;
234 tcgetattr (remote_desc
, &termios
);
239 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
240 termios
.c_cflag
|= CLOCAL
| CS8
;
241 termios
.c_cc
[VMIN
] = 1;
242 termios
.c_cc
[VTIME
] = 0;
244 tcsetattr (remote_desc
, TCSANOW
, &termios
);
250 struct termio termio
;
251 ioctl (remote_desc
, TCGETA
, &termio
);
256 termio
.c_cflag
&= ~(CSIZE
| PARENB
);
257 termio
.c_cflag
|= CLOCAL
| CS8
;
258 termio
.c_cc
[VMIN
] = 1;
259 termio
.c_cc
[VTIME
] = 0;
261 ioctl (remote_desc
, TCSETA
, &termio
);
269 ioctl (remote_desc
, TIOCGETP
, &sg
);
271 ioctl (remote_desc
, TIOCSETP
, &sg
);
275 fprintf (stderr
, "Remote debugging using %s\n", name
);
277 transport_is_reliable
= 0;
279 enable_async_notification (remote_desc
);
281 /* Register the event loop handler. */
282 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
283 #endif /* USE_WIN32API */
288 static int winsock_initialized
;
291 struct sockaddr_in sockaddr
;
295 port
= strtoul (port_str
+ 1, &port_end
, 10);
296 if (port_str
[1] == '\0' || *port_end
!= '\0')
297 fatal ("Bad port argument: %s", name
);
300 if (!winsock_initialized
)
304 WSAStartup (MAKEWORD (1, 0), &wsad
);
305 winsock_initialized
= 1;
309 listen_desc
= socket (PF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
310 if (listen_desc
== -1)
311 perror_with_name ("Can't open socket");
313 /* Allow rapid reuse of this port. */
315 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
318 sockaddr
.sin_family
= PF_INET
;
319 sockaddr
.sin_port
= htons (port
);
320 sockaddr
.sin_addr
.s_addr
= INADDR_ANY
;
322 if (bind (listen_desc
, (struct sockaddr
*) &sockaddr
, sizeof (sockaddr
))
323 || listen (listen_desc
, 1))
324 perror_with_name ("Can't bind address");
326 /* If port is zero, a random port will be selected, and the
327 fprintf below needs to know what port was selected. */
330 socklen_t len
= sizeof (sockaddr
);
331 if (getsockname (listen_desc
,
332 (struct sockaddr
*) &sockaddr
, &len
) < 0
333 || len
< sizeof (sockaddr
))
334 perror_with_name ("Can't determine port");
335 port
= ntohs (sockaddr
.sin_port
);
338 fprintf (stderr
, "Listening on port %d\n", port
);
341 /* Register the event loop handler. */
342 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
344 transport_is_reliable
= 1;
351 delete_file_handler (remote_desc
);
354 closesocket (remote_desc
);
358 remote_desc
= INVALID_DESCRIPTOR
;
363 /* Convert hex digit A to a number. */
368 if (a
>= '0' && a
<= '9')
370 else if (a
>= 'a' && a
<= 'f')
373 error ("Reply contains invalid hex digit");
379 static const char hexchars
[] = "0123456789abcdef";
382 ishex (int ch
, int *val
)
384 if ((ch
>= 'a') && (ch
<= 'f'))
386 *val
= ch
- 'a' + 10;
389 if ((ch
>= 'A') && (ch
<= 'F'))
391 *val
= ch
- 'A' + 10;
394 if ((ch
>= '0') && (ch
<= '9'))
402 #ifndef IN_PROCESS_AGENT
405 unhexify (char *bin
, const char *hex
, int count
)
409 for (i
= 0; i
< count
; i
++)
411 if (hex
[0] == 0 || hex
[1] == 0)
413 /* Hex string is short, or of uneven length.
414 Return the count that has been converted so far. */
417 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
424 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
431 for (i
= 0; i
< len
; i
++)
435 addr
= addr
| (fromhex (ch
) & 0x0f);
441 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
446 while (*end
!= '\0' && *end
!= ';')
449 decode_address (addrp
, start
, end
- start
);
458 /* Convert number NIB to a hex digit. */
466 return 'a' + nib
- 10;
469 #ifndef IN_PROCESS_AGENT
472 hexify (char *hex
, const char *bin
, int count
)
476 /* May use a length, or a nul-terminated string as input. */
478 count
= strlen (bin
);
480 for (i
= 0; i
< count
; i
++)
482 *hex
++ = tohex ((*bin
>> 4) & 0xf);
483 *hex
++ = tohex (*bin
++ & 0xf);
489 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
490 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
491 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
492 (which may be more than *OUT_LEN due to escape characters). The
493 total number of bytes in the output buffer will be at most
497 remote_escape_output (const gdb_byte
*buffer
, int len
,
498 gdb_byte
*out_buf
, int *out_len
,
501 int input_index
, output_index
;
504 for (input_index
= 0; input_index
< len
; input_index
++)
506 gdb_byte b
= buffer
[input_index
];
508 if (b
== '$' || b
== '#' || b
== '}' || b
== '*')
510 /* These must be escaped. */
511 if (output_index
+ 2 > out_maxlen
)
513 out_buf
[output_index
++] = '}';
514 out_buf
[output_index
++] = b
^ 0x20;
518 if (output_index
+ 1 > out_maxlen
)
520 out_buf
[output_index
++] = b
;
524 *out_len
= input_index
;
528 /* Convert BUFFER, escaped data LEN bytes long, into binary data
529 in OUT_BUF. Return the number of bytes written to OUT_BUF.
530 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
532 This function reverses remote_escape_output. It allows more
533 escaped characters than that function does, in particular because
534 '*' must be escaped to avoid the run-length encoding processing
535 in reading packets. */
538 remote_unescape_input (const gdb_byte
*buffer
, int len
,
539 gdb_byte
*out_buf
, int out_maxlen
)
541 int input_index
, output_index
;
546 for (input_index
= 0; input_index
< len
; input_index
++)
548 gdb_byte b
= buffer
[input_index
];
550 if (output_index
+ 1 > out_maxlen
)
551 error ("Received too much data from the target.");
555 out_buf
[output_index
++] = b
^ 0x20;
561 out_buf
[output_index
++] = b
;
565 error ("Unmatched escape character in target response.");
570 /* Look for a sequence of characters which can be run-length encoded.
571 If there are any, update *CSUM and *P. Otherwise, output the
572 single character. Return the number of characters consumed. */
575 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
579 /* Always output the character. */
583 /* Don't go past '~'. */
587 for (n
= 1; n
< remaining
; n
++)
588 if (buf
[n
] != buf
[0])
591 /* N is the index of the first character not the same as buf[0].
592 buf[0] is counted twice, so by decrementing N, we get the number
593 of characters the RLE sequence will replace. */
599 /* Skip the frame characters. The manual says to skip '+' and '-'
600 also, but there's no reason to. Unfortunately these two unusable
601 characters double the encoded length of a four byte zero
603 while (n
+ 29 == '$' || n
+ 29 == '#')
617 unpack_varlen_hex (char *buff
, /* packet to parse */
623 while (ishex (*buff
, &nibble
))
626 retval
= retval
<< 4;
627 retval
|= nibble
& 0x0f;
633 #ifndef IN_PROCESS_AGENT
635 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
638 write_ptid (char *buf
, ptid_t ptid
)
644 pid
= ptid_get_pid (ptid
);
646 buf
+= sprintf (buf
, "p-%x.", -pid
);
648 buf
+= sprintf (buf
, "p%x.", pid
);
650 tid
= ptid_get_lwp (ptid
);
652 buf
+= sprintf (buf
, "-%x", -tid
);
654 buf
+= sprintf (buf
, "%x", tid
);
660 hex_or_minus_one (char *buf
, char **obuf
)
664 if (strncmp (buf
, "-1", 2) == 0)
670 buf
= unpack_varlen_hex (buf
, &ret
);
678 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
679 passed the last parsed char. Returns null_ptid on error. */
681 read_ptid (char *buf
, char **obuf
)
685 ULONGEST pid
= 0, tid
= 0;
689 /* Multi-process ptid. */
690 pp
= unpack_varlen_hex (p
+ 1, &pid
);
692 error ("invalid remote ptid: %s\n", p
);
696 tid
= hex_or_minus_one (p
, &pp
);
700 return ptid_build (pid
, tid
, 0);
703 /* No multi-process. Just a tid. */
704 tid
= hex_or_minus_one (p
, &pp
);
706 /* Since the stub is not sending a process id, then default to
707 what's in the current inferior. */
708 pid
= ptid_get_pid (((struct inferior_list_entry
*) current_inferior
)->id
);
712 return ptid_build (pid
, tid
, 0);
715 /* Send a packet to the remote machine, with error checking.
716 The data of the packet is in BUF, and the length of the
717 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
720 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
723 unsigned char csum
= 0;
728 buf2
= xmalloc (PBUFSIZ
);
730 /* Copy the packet into buffer BUF2, encapsulating it
731 and giving it a checksum. */
739 for (i
= 0; i
< cnt
;)
740 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
743 *p
++ = tohex ((csum
>> 4) & 0xf);
744 *p
++ = tohex (csum
& 0xf);
748 /* Send it over and over until we get a positive ack. */
752 if (write (remote_desc
, buf2
, p
- buf2
) != p
- buf2
)
754 perror ("putpkt(write)");
759 if (noack_mode
|| is_notif
)
761 /* Don't expect an ack then. */
765 fprintf (stderr
, "putpkt (\"%s\"); [notif]\n", buf2
);
767 fprintf (stderr
, "putpkt (\"%s\"); [noack mode]\n", buf2
);
775 fprintf (stderr
, "putpkt (\"%s\"); [looking for ack]\n", buf2
);
789 fprintf (stderr
, "[received '%c' (0x%x)]\n", cc
, cc
);
793 /* Check for an input interrupt while we're here. */
794 if (cc
== '\003' && current_inferior
!= NULL
)
795 (*the_target
->request_interrupt
) ();
800 return 1; /* Success! */
804 putpkt_binary (char *buf
, int cnt
)
806 return putpkt_binary_1 (buf
, cnt
, 0);
809 /* Send a packet to the remote machine, with error checking. The data
810 of the packet is in BUF, and the packet should be a NUL-terminated
811 string. Returns >= 0 on success, -1 otherwise. */
816 return putpkt_binary (buf
, strlen (buf
));
820 putpkt_notif (char *buf
)
822 return putpkt_binary_1 (buf
, strlen (buf
), 1);
825 /* Come here when we get an input interrupt from the remote side. This
826 interrupt should only be active while we are waiting for the child to do
827 something. Thus this assumes readchar:bufcnt is 0.
828 About the only thing that should come through is a ^C, which
829 will cause us to request child interruption. */
832 input_interrupt (int unused
)
835 struct timeval immediate
= { 0, 0 };
837 /* Protect against spurious interrupts. This has been observed to
838 be a problem under NetBSD 1.4 and 1.5. */
841 FD_SET (remote_desc
, &readset
);
842 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
847 cc
= read (remote_desc
, &c
, 1);
849 if (cc
!= 1 || c
!= '\003' || current_inferior
== NULL
)
851 fprintf (stderr
, "input_interrupt, count = %d c = %d ('%c')\n",
856 (*the_target
->request_interrupt
) ();
860 /* Check if the remote side sent us an interrupt request (^C). */
862 check_remote_input_interrupt_request (void)
864 /* This function may be called before establishing communications,
865 therefore we need to validate the remote descriptor. */
867 if (remote_desc
== INVALID_DESCRIPTOR
)
873 /* Asynchronous I/O support. SIGIO must be enabled when waiting, in order to
874 accept Control-C from the client, and must be disabled when talking to
878 unblock_async_io (void)
883 sigemptyset (&sigio_set
);
884 sigaddset (&sigio_set
, SIGIO
);
885 sigprocmask (SIG_UNBLOCK
, &sigio_set
, NULL
);
891 nto_comctrl (int enable
)
893 struct sigevent event
;
897 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
898 event
.sigev_signo
= SIGIO
;
899 event
.sigev_code
= 0;
900 event
.sigev_value
.sival_ptr
= NULL
;
901 event
.sigev_priority
= -1;
902 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
906 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
911 /* Current state of asynchronous I/O. */
912 static int async_io_enabled
;
914 /* Enable asynchronous I/O. */
916 enable_async_io (void)
918 if (async_io_enabled
)
922 signal (SIGIO
, input_interrupt
);
924 async_io_enabled
= 1;
930 /* Disable asynchronous I/O. */
932 disable_async_io (void)
934 if (!async_io_enabled
)
938 signal (SIGIO
, SIG_IGN
);
940 async_io_enabled
= 0;
948 initialize_async_io (void)
950 /* Make sure that async I/O starts disabled. */
951 async_io_enabled
= 1;
954 /* Make sure the signal is unblocked. */
958 /* Internal buffer used by readchar.
959 These are global to readchar because reschedule_remote needs to be
960 able to tell whether the buffer is empty. */
962 static unsigned char readchar_buf
[BUFSIZ
];
963 static int readchar_bufcnt
= 0;
964 static unsigned char *readchar_bufp
;
966 /* Returns next char from remote GDB. -1 if error. */
973 if (readchar_bufcnt
== 0)
975 readchar_bufcnt
= read (remote_desc
, readchar_buf
,
976 sizeof (readchar_buf
));
978 if (readchar_bufcnt
<= 0)
980 if (readchar_bufcnt
== 0)
981 fprintf (stderr
, "readchar: Got EOF\n");
988 readchar_bufp
= readchar_buf
;
992 ch
= *readchar_bufp
++;
997 /* Reset the readchar state machine. */
1000 reset_readchar (void)
1002 readchar_bufcnt
= 0;
1003 if (readchar_callback
!= NOT_SCHEDULED
)
1005 delete_callback_event (readchar_callback
);
1006 readchar_callback
= NOT_SCHEDULED
;
1010 /* Process remaining data in readchar_buf. */
1013 process_remaining (void *context
)
1017 /* This is a one-shot event. */
1018 readchar_callback
= NOT_SCHEDULED
;
1020 if (readchar_bufcnt
> 0)
1021 res
= handle_serial_event (0, NULL
);
1028 /* If there is still data in the buffer, queue another event to process it,
1029 we can't sleep in select yet. */
1034 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
1035 readchar_callback
= append_callback_event (process_remaining
, NULL
);
1038 /* Read a packet from the remote machine, with error checking,
1039 and store it in BUF. Returns length of packet, or negative if error. */
1045 unsigned char csum
, c1
, c2
;
1059 fprintf (stderr
, "[getpkt: discarding char '%c']\n", c
);
1080 c1
= fromhex (readchar ());
1081 c2
= fromhex (readchar ());
1083 if (csum
== (c1
<< 4) + c2
)
1089 "Bad checksum, sentsum=0x%x, csum=0x%x, "
1090 "buf=%s [no-ack-mode, Bad medium?]\n",
1091 (c1
<< 4) + c2
, csum
, buf
);
1092 /* Not much we can do, GDB wasn't expecting an ack/nac. */
1096 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
1097 (c1
<< 4) + c2
, csum
, buf
);
1098 if (write (remote_desc
, "-", 1) != 1)
1106 fprintf (stderr
, "getpkt (\"%s\"); [sending ack] \n", buf
);
1110 if (write (remote_desc
, "+", 1) != 1)
1115 fprintf (stderr
, "[sent ack]\n");
1123 fprintf (stderr
, "getpkt (\"%s\"); [no ack sent] \n", buf
);
1132 write_ok (char *buf
)
1140 write_enn (char *buf
)
1142 /* Some day, we should define the meanings of the error codes... */
1152 convert_int_to_ascii (const unsigned char *from
, char *to
, int n
)
1159 nib
= ((ch
& 0xf0) >> 4) & 0x0f;
1160 *to
++ = tohex (nib
);
1162 *to
++ = tohex (nib
);
1167 #ifndef IN_PROCESS_AGENT
1170 convert_ascii_to_int (const char *from
, unsigned char *to
, int n
)
1175 nib1
= fromhex (*from
++);
1176 nib2
= fromhex (*from
++);
1177 *to
++ = (((nib1
& 0x0f) << 4) & 0xf0) | (nib2
& 0x0f);
1182 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1184 if ((regno
>> 12) != 0)
1185 *buf
++ = tohex ((regno
>> 12) & 0xf);
1186 if ((regno
>> 8) != 0)
1187 *buf
++ = tohex ((regno
>> 8) & 0xf);
1188 *buf
++ = tohex ((regno
>> 4) & 0xf);
1189 *buf
++ = tohex (regno
& 0xf);
1191 collect_register_as_string (regcache
, regno
, buf
);
1192 buf
+= 2 * register_size (regno
);
1199 new_thread_notify (int id
)
1203 /* The `n' response is not yet part of the remote protocol. Do nothing. */
1207 if (server_waiting
== 0)
1210 sprintf (own_buf
, "n%x", id
);
1211 disable_async_io ();
1217 dead_thread_notify (int id
)
1221 /* The `x' response is not yet part of the remote protocol. Do nothing. */
1225 sprintf (own_buf
, "x%x", id
);
1226 disable_async_io ();
1232 prepare_resume_reply (char *buf
, ptid_t ptid
,
1233 struct target_waitstatus
*status
)
1236 fprintf (stderr
, "Writing resume reply for %s:%d\n\n",
1237 target_pid_to_str (ptid
), status
->kind
);
1239 switch (status
->kind
)
1241 case TARGET_WAITKIND_STOPPED
:
1243 struct thread_info
*saved_inferior
;
1245 struct regcache
*regcache
;
1247 sprintf (buf
, "T%02x", status
->value
.sig
);
1248 buf
+= strlen (buf
);
1250 regp
= gdbserver_expedite_regs
;
1252 saved_inferior
= current_inferior
;
1254 current_inferior
= find_thread_ptid (ptid
);
1256 regcache
= get_thread_regcache (current_inferior
, 1);
1258 if (the_target
->stopped_by_watchpoint
!= NULL
1259 && (*the_target
->stopped_by_watchpoint
) ())
1264 strncpy (buf
, "watch:", 6);
1267 addr
= (*the_target
->stopped_data_address
) ();
1269 /* Convert each byte of the address into two hexadecimal
1270 chars. Note that we take sizeof (void *) instead of
1271 sizeof (addr); this is to avoid sending a 64-bit
1272 address to a 32-bit GDB. */
1273 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1274 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1280 buf
= outreg (regcache
, find_regno (*regp
), buf
);
1285 /* Formerly, if the debugger had not used any thread features
1286 we would not burden it with a thread status response. This
1287 was for the benefit of GDB 4.13 and older. However, in
1288 recent GDB versions the check (``if (cont_thread != 0)'')
1289 does not have the desired effect because of sillyness in
1290 the way that the remote protocol handles specifying a
1291 thread. Since thread support relies on qSymbol support
1292 anyway, assume GDB can handle threads. */
1294 if (using_threads
&& !disable_packet_Tthread
)
1296 /* This if (1) ought to be unnecessary. But remote_wait
1297 in GDB will claim this event belongs to inferior_ptid
1298 if we do not specify a thread, and there's no way for
1299 gdbserver to know what inferior_ptid is. */
1300 if (1 || !ptid_equal (general_thread
, ptid
))
1303 /* In non-stop, don't change the general thread behind
1306 general_thread
= ptid
;
1307 sprintf (buf
, "thread:");
1308 buf
+= strlen (buf
);
1309 buf
= write_ptid (buf
, ptid
);
1311 buf
+= strlen (buf
);
1313 if (the_target
->core_of_thread
)
1314 core
= (*the_target
->core_of_thread
) (ptid
);
1317 sprintf (buf
, "core:");
1318 buf
+= strlen (buf
);
1319 sprintf (buf
, "%x", core
);
1321 buf
+= strlen (buf
);
1328 strcpy (buf
, "library:;");
1329 buf
+= strlen (buf
);
1333 current_inferior
= saved_inferior
;
1336 case TARGET_WAITKIND_EXITED
:
1338 sprintf (buf
, "W%x;process:%x",
1339 status
->value
.integer
, ptid_get_pid (ptid
));
1341 sprintf (buf
, "W%02x", status
->value
.integer
);
1343 case TARGET_WAITKIND_SIGNALLED
:
1345 sprintf (buf
, "X%x;process:%x",
1346 status
->value
.sig
, ptid_get_pid (ptid
));
1348 sprintf (buf
, "X%02x", status
->value
.sig
);
1351 error ("unhandled waitkind");
1357 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1361 *mem_addr_ptr
= *len_ptr
= 0;
1363 while ((ch
= from
[i
++]) != ',')
1365 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1366 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1369 for (j
= 0; j
< 4; j
++)
1371 if ((ch
= from
[i
++]) == 0)
1373 *len_ptr
= *len_ptr
<< 4;
1374 *len_ptr
|= fromhex (ch
) & 0x0f;
1379 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1380 unsigned char **to_p
)
1384 *mem_addr_ptr
= *len_ptr
= 0;
1386 while ((ch
= from
[i
++]) != ',')
1388 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1389 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1392 while ((ch
= from
[i
++]) != ':')
1394 *len_ptr
= *len_ptr
<< 4;
1395 *len_ptr
|= fromhex (ch
) & 0x0f;
1399 *to_p
= xmalloc (*len_ptr
);
1401 convert_ascii_to_int (&from
[i
++], *to_p
, *len_ptr
);
1405 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1406 unsigned int *len_ptr
, unsigned char **to_p
)
1410 *mem_addr_ptr
= *len_ptr
= 0;
1412 while ((ch
= from
[i
++]) != ',')
1414 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1415 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1418 while ((ch
= from
[i
++]) != ':')
1420 *len_ptr
= *len_ptr
<< 4;
1421 *len_ptr
|= fromhex (ch
) & 0x0f;
1425 *to_p
= xmalloc (*len_ptr
);
1427 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1428 *to_p
, *len_ptr
) != *len_ptr
)
1434 /* Decode a qXfer write request. */
1437 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1438 unsigned int *len
, unsigned char *data
)
1443 /* Extract the offset. */
1445 while ((ch
= *buf
++) != ':')
1447 *offset
= *offset
<< 4;
1448 *offset
|= fromhex (ch
) & 0x0f;
1451 /* Get encoded data. */
1452 packet_len
-= buf
- b
;
1453 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1458 /* Decode the parameters of a qSearch:memory packet. */
1461 decode_search_memory_packet (const char *buf
, int packet_len
,
1462 CORE_ADDR
*start_addrp
,
1463 CORE_ADDR
*search_space_lenp
,
1464 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1466 const char *p
= buf
;
1468 p
= decode_address_to_semicolon (start_addrp
, p
);
1469 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1470 packet_len
-= p
- buf
;
1471 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1472 pattern
, packet_len
);
1477 free_sym_cache (struct sym_cache
*sym
)
1487 clear_symbol_cache (struct sym_cache
**symcache_p
)
1489 struct sym_cache
*sym
, *next
;
1491 /* Check the cache first. */
1492 for (sym
= *symcache_p
; sym
; sym
= next
)
1495 free_sym_cache (sym
);
1501 /* Get the address of NAME, and return it in ADDRP if found. if
1502 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1503 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1506 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1508 char own_buf
[266], *p
, *q
;
1510 struct sym_cache
*sym
;
1511 struct process_info
*proc
;
1513 proc
= current_process ();
1515 /* Check the cache first. */
1516 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1517 if (strcmp (name
, sym
->name
) == 0)
1523 /* It might not be an appropriate time to look up a symbol,
1524 e.g. while we're trying to fetch registers. */
1528 /* Send the request. */
1529 strcpy (own_buf
, "qSymbol:");
1530 hexify (own_buf
+ strlen ("qSymbol:"), name
, strlen (name
));
1531 if (putpkt (own_buf
) < 0)
1534 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1535 len
= getpkt (own_buf
);
1539 /* We ought to handle pretty much any packet at this point while we
1540 wait for the qSymbol "response". That requires re-entering the
1541 main loop. For now, this is an adequate approximation; allow
1542 GDB to read from memory while it figures out the address of the
1544 while (own_buf
[0] == 'm')
1547 unsigned char *mem_buf
;
1548 unsigned int mem_len
;
1550 decode_m_packet (&own_buf
[1], &mem_addr
, &mem_len
);
1551 mem_buf
= xmalloc (mem_len
);
1552 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1553 convert_int_to_ascii (mem_buf
, own_buf
, mem_len
);
1555 write_enn (own_buf
);
1557 if (putpkt (own_buf
) < 0)
1559 len
= getpkt (own_buf
);
1564 if (strncmp (own_buf
, "qSymbol:", strlen ("qSymbol:")) != 0)
1566 warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf
);
1570 p
= own_buf
+ strlen ("qSymbol:");
1572 while (*q
&& *q
!= ':')
1575 /* Make sure we found a value for the symbol. */
1576 if (p
== q
|| *q
== '\0')
1579 decode_address (addrp
, p
, q
- p
);
1581 /* Save the symbol in our cache. */
1582 sym
= xmalloc (sizeof (*sym
));
1583 sym
->name
= xstrdup (name
);
1585 sym
->next
= proc
->symbol_cache
;
1586 proc
->symbol_cache
= sym
;
1591 /* Relocate an instruction to execute at a different address. OLDLOC
1592 is the address in the inferior memory where the instruction to
1593 relocate is currently at. On input, TO points to the destination
1594 where we want the instruction to be copied (and possibly adjusted)
1595 to. On output, it points to one past the end of the resulting
1596 instruction(s). The effect of executing the instruction at TO
1597 shall be the same as if executing it at FROM. For example, call
1598 instructions that implicitly push the return address on the stack
1599 should be adjusted to return to the instruction after OLDLOC;
1600 relative branches, and other PC-relative instructions need the
1601 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1604 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1608 ULONGEST written
= 0;
1610 /* Send the request. */
1611 strcpy (own_buf
, "qRelocInsn:");
1612 sprintf (own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1614 if (putpkt (own_buf
) < 0)
1617 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1618 len
= getpkt (own_buf
);
1622 /* We ought to handle pretty much any packet at this point while we
1623 wait for the qRelocInsn "response". That requires re-entering
1624 the main loop. For now, this is an adequate approximation; allow
1625 GDB to access memory. */
1626 while (own_buf
[0] == 'm' || own_buf
[0] == 'M' || own_buf
[0] == 'X')
1629 unsigned char *mem_buf
= NULL
;
1630 unsigned int mem_len
;
1632 if (own_buf
[0] == 'm')
1634 decode_m_packet (&own_buf
[1], &mem_addr
, &mem_len
);
1635 mem_buf
= xmalloc (mem_len
);
1636 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1637 convert_int_to_ascii (mem_buf
, own_buf
, mem_len
);
1639 write_enn (own_buf
);
1641 else if (own_buf
[0] == 'X')
1643 if (decode_X_packet (&own_buf
[1], len
- 1, &mem_addr
,
1644 &mem_len
, &mem_buf
) < 0
1645 || write_inferior_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1646 write_enn (own_buf
);
1652 decode_M_packet (&own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1653 if (write_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1656 write_enn (own_buf
);
1659 if (putpkt (own_buf
) < 0)
1661 len
= getpkt (own_buf
);
1666 if (own_buf
[0] == 'E')
1668 warning ("An error occurred while relocating an instruction: %s\n",
1673 if (strncmp (own_buf
, "qRelocInsn:", strlen ("qRelocInsn:")) != 0)
1675 warning ("Malformed response to qRelocInsn, ignoring: %s\n",
1680 unpack_varlen_hex (own_buf
+ strlen ("qRelocInsn:"), &written
);
1687 monitor_output (const char *msg
)
1689 char *buf
= xmalloc (strlen (msg
) * 2 + 2);
1692 hexify (buf
+ 1, msg
, 0);
1698 /* Return a malloc allocated string with special characters from TEXT
1699 replaced by entity references. */
1702 xml_escape_text (const char *text
)
1707 /* Compute the length of the result. */
1708 for (i
= 0, special
= 0; text
[i
] != '\0'; i
++)
1726 /* Expand the result. */
1727 result
= xmalloc (i
+ special
+ 1);
1728 for (i
= 0, special
= 0; text
[i
] != '\0'; i
++)
1732 strcpy (result
+ i
+ special
, "'");
1736 strcpy (result
+ i
+ special
, """);
1740 strcpy (result
+ i
+ special
, "&");
1744 strcpy (result
+ i
+ special
, "<");
1748 strcpy (result
+ i
+ special
, ">");
1752 result
[i
+ special
] = text
[i
];
1755 result
[i
+ special
] = '\0';
1761 buffer_grow (struct buffer
*buffer
, const char *data
, size_t size
)
1764 size_t new_buffer_size
;
1769 new_buffer_size
= buffer
->buffer_size
;
1771 if (new_buffer_size
== 0)
1772 new_buffer_size
= 1;
1774 while (buffer
->used_size
+ size
> new_buffer_size
)
1775 new_buffer_size
*= 2;
1776 new_buffer
= realloc (buffer
->buffer
, new_buffer_size
);
1779 memcpy (new_buffer
+ buffer
->used_size
, data
, size
);
1780 buffer
->buffer
= new_buffer
;
1781 buffer
->buffer_size
= new_buffer_size
;
1782 buffer
->used_size
+= size
;
1786 buffer_free (struct buffer
*buffer
)
1791 free (buffer
->buffer
);
1792 buffer
->buffer
= NULL
;
1793 buffer
->buffer_size
= 0;
1794 buffer
->used_size
= 0;
1798 buffer_init (struct buffer
*buffer
)
1800 memset (buffer
, 0, sizeof (*buffer
));
1804 buffer_finish (struct buffer
*buffer
)
1806 char *ret
= buffer
->buffer
;
1807 buffer
->buffer
= NULL
;
1808 buffer
->buffer_size
= 0;
1809 buffer
->used_size
= 0;
1814 buffer_xml_printf (struct buffer
*buffer
, const char *format
, ...)
1821 va_start (ap
, format
);
1824 for (f
= format
; *f
; f
++)
1833 char *a
= va_arg (ap
, char *);
1834 buffer_grow (buffer
, prev
, f
- prev
- 1);
1835 p
= xml_escape_text (a
);
1836 buffer_grow_str (buffer
, p
);
1843 int i
= va_arg (ap
, int);
1844 char b
[sizeof ("4294967295")];
1846 buffer_grow (buffer
, prev
, f
- prev
- 1);
1847 sprintf (b
, "%d", i
);
1848 buffer_grow_str (buffer
, b
);
1858 buffer_grow_str (buffer
, prev
);