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
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>
69 #ifndef HAVE_SOCKLEN_T
70 typedef int socklen_t
;
74 # define INVALID_DESCRIPTOR INVALID_SOCKET
76 # define INVALID_DESCRIPTOR -1
79 /* A cache entry for a successfully looked-up symbol. */
84 struct sym_cache
*next
;
87 /* The symbol cache. */
88 static struct sym_cache
*symbol_cache
;
90 /* If this flag has been set, assume cache misses are
92 int all_symbols_looked_up
;
95 struct ui_file
*gdb_stdlog
;
97 static int remote_desc
= INVALID_DESCRIPTOR
;
99 /* FIXME headerize? */
100 extern int using_threads
;
101 extern int debug_threads
;
103 /* If true, then GDB has requested noack mode. */
105 /* If true, then we tell GDB to use noack mode by default. */
106 int transport_is_reliable
= 0;
109 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
110 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
113 /* Open a connection to a remote debugger.
114 NAME is the filename used for communication. */
117 remote_open (char *name
)
119 #if defined(F_SETFL) && defined (FASYNC)
120 int save_fcntl_flags
;
124 port_str
= strchr (name
, ':');
125 if (port_str
== NULL
)
128 error ("Only <host>:<port> is supported on this platform.");
132 if (stat (name
, &statbuf
) == 0
133 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
134 remote_desc
= open (name
, O_RDWR
);
142 perror_with_name ("Could not open remote device");
146 struct termios termios
;
147 tcgetattr (remote_desc
, &termios
);
152 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
153 termios
.c_cflag
|= CLOCAL
| CS8
;
154 termios
.c_cc
[VMIN
] = 1;
155 termios
.c_cc
[VTIME
] = 0;
157 tcsetattr (remote_desc
, TCSANOW
, &termios
);
163 struct termio termio
;
164 ioctl (remote_desc
, TCGETA
, &termio
);
169 termio
.c_cflag
&= ~(CSIZE
| PARENB
);
170 termio
.c_cflag
|= CLOCAL
| CS8
;
171 termio
.c_cc
[VMIN
] = 1;
172 termio
.c_cc
[VTIME
] = 0;
174 ioctl (remote_desc
, TCSETA
, &termio
);
182 ioctl (remote_desc
, TIOCGETP
, &sg
);
184 ioctl (remote_desc
, TIOCSETP
, &sg
);
188 fprintf (stderr
, "Remote debugging using %s\n", name
);
189 #endif /* USE_WIN32API */
191 transport_is_reliable
= 0;
196 static int winsock_initialized
;
199 struct sockaddr_in sockaddr
;
204 port
= strtoul (port_str
+ 1, &port_end
, 10);
205 if (port_str
[1] == '\0' || *port_end
!= '\0')
206 fatal ("Bad port argument: %s", name
);
209 if (!winsock_initialized
)
213 WSAStartup (MAKEWORD (1, 0), &wsad
);
214 winsock_initialized
= 1;
218 tmp_desc
= socket (PF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
220 perror_with_name ("Can't open socket");
222 /* Allow rapid reuse of this port. */
224 setsockopt (tmp_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
227 sockaddr
.sin_family
= PF_INET
;
228 sockaddr
.sin_port
= htons (port
);
229 sockaddr
.sin_addr
.s_addr
= INADDR_ANY
;
231 if (bind (tmp_desc
, (struct sockaddr
*) &sockaddr
, sizeof (sockaddr
))
232 || listen (tmp_desc
, 1))
233 perror_with_name ("Can't bind address");
235 /* If port is zero, a random port will be selected, and the
236 fprintf below needs to know what port was selected. */
239 socklen_t len
= sizeof (sockaddr
);
240 if (getsockname (tmp_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0
241 || len
< sizeof (sockaddr
))
242 perror_with_name ("Can't determine port");
243 port
= ntohs (sockaddr
.sin_port
);
246 fprintf (stderr
, "Listening on port %d\n", port
);
249 tmp
= sizeof (sockaddr
);
250 remote_desc
= accept (tmp_desc
, (struct sockaddr
*) &sockaddr
, &tmp
);
251 if (remote_desc
== -1)
252 perror_with_name ("Accept failed");
254 /* Enable TCP keep alive process. */
256 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
257 (char *) &tmp
, sizeof (tmp
));
259 /* Tell TCP not to delay small packets. This greatly speeds up
260 interactive response. */
262 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
263 (char *) &tmp
, sizeof (tmp
));
267 close (tmp_desc
); /* No longer need this */
269 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
270 exits when the remote side dies. */
272 closesocket (tmp_desc
); /* No longer need this */
275 /* Convert IP address to string. */
276 fprintf (stderr
, "Remote debugging from host %s\n",
277 inet_ntoa (sockaddr
.sin_addr
));
279 transport_is_reliable
= 1;
282 #if defined(F_SETFL) && defined (FASYNC)
283 save_fcntl_flags
= fcntl (remote_desc
, F_GETFL
, 0);
284 fcntl (remote_desc
, F_SETFL
, save_fcntl_flags
| FASYNC
);
285 #if defined (F_SETOWN)
286 fcntl (remote_desc
, F_SETOWN
, getpid ());
290 /* Register the event loop handler. */
291 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
297 delete_file_handler (remote_desc
);
300 closesocket (remote_desc
);
306 /* Convert hex digit A to a number. */
311 if (a
>= '0' && a
<= '9')
313 else if (a
>= 'a' && a
<= 'f')
316 error ("Reply contains invalid hex digit");
321 unhexify (char *bin
, const char *hex
, int count
)
325 for (i
= 0; i
< count
; i
++)
327 if (hex
[0] == 0 || hex
[1] == 0)
329 /* Hex string is short, or of uneven length.
330 Return the count that has been converted so far. */
333 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
340 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
347 for (i
= 0; i
< len
; i
++)
351 addr
= addr
| (fromhex (ch
) & 0x0f);
357 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
362 while (*end
!= '\0' && *end
!= ';')
365 decode_address (addrp
, start
, end
- start
);
372 /* Convert number NIB to a hex digit. */
380 return 'a' + nib
- 10;
384 hexify (char *hex
, const char *bin
, int count
)
388 /* May use a length, or a nul-terminated string as input. */
390 count
= strlen (bin
);
392 for (i
= 0; i
< count
; i
++)
394 *hex
++ = tohex ((*bin
>> 4) & 0xf);
395 *hex
++ = tohex (*bin
++ & 0xf);
401 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
402 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
403 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
404 (which may be more than *OUT_LEN due to escape characters). The
405 total number of bytes in the output buffer will be at most
409 remote_escape_output (const gdb_byte
*buffer
, int len
,
410 gdb_byte
*out_buf
, int *out_len
,
413 int input_index
, output_index
;
416 for (input_index
= 0; input_index
< len
; input_index
++)
418 gdb_byte b
= buffer
[input_index
];
420 if (b
== '$' || b
== '#' || b
== '}' || b
== '*')
422 /* These must be escaped. */
423 if (output_index
+ 2 > out_maxlen
)
425 out_buf
[output_index
++] = '}';
426 out_buf
[output_index
++] = b
^ 0x20;
430 if (output_index
+ 1 > out_maxlen
)
432 out_buf
[output_index
++] = b
;
436 *out_len
= input_index
;
440 /* Convert BUFFER, escaped data LEN bytes long, into binary data
441 in OUT_BUF. Return the number of bytes written to OUT_BUF.
442 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
444 This function reverses remote_escape_output. It allows more
445 escaped characters than that function does, in particular because
446 '*' must be escaped to avoid the run-length encoding processing
447 in reading packets. */
450 remote_unescape_input (const gdb_byte
*buffer
, int len
,
451 gdb_byte
*out_buf
, int out_maxlen
)
453 int input_index
, output_index
;
458 for (input_index
= 0; input_index
< len
; input_index
++)
460 gdb_byte b
= buffer
[input_index
];
462 if (output_index
+ 1 > out_maxlen
)
463 error ("Received too much data from the target.");
467 out_buf
[output_index
++] = b
^ 0x20;
473 out_buf
[output_index
++] = b
;
477 error ("Unmatched escape character in target response.");
482 /* Look for a sequence of characters which can be run-length encoded.
483 If there are any, update *CSUM and *P. Otherwise, output the
484 single character. Return the number of characters consumed. */
487 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
491 /* Always output the character. */
495 /* Don't go past '~'. */
499 for (n
= 1; n
< remaining
; n
++)
500 if (buf
[n
] != buf
[0])
503 /* N is the index of the first character not the same as buf[0].
504 buf[0] is counted twice, so by decrementing N, we get the number
505 of characters the RLE sequence will replace. */
511 /* Skip the frame characters. The manual says to skip '+' and '-'
512 also, but there's no reason to. Unfortunately these two unusable
513 characters double the encoded length of a four byte zero
515 while (n
+ 29 == '$' || n
+ 29 == '#')
526 /* Send a packet to the remote machine, with error checking.
527 The data of the packet is in BUF, and the length of the
528 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
531 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
534 unsigned char csum
= 0;
539 buf2
= xmalloc (PBUFSIZ
);
541 /* Copy the packet into buffer BUF2, encapsulating it
542 and giving it a checksum. */
550 for (i
= 0; i
< cnt
;)
551 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
554 *p
++ = tohex ((csum
>> 4) & 0xf);
555 *p
++ = tohex (csum
& 0xf);
559 /* Send it over and over until we get a positive ack. */
565 if (write (remote_desc
, buf2
, p
- buf2
) != p
- buf2
)
567 perror ("putpkt(write)");
572 if (noack_mode
|| is_notif
)
574 /* Don't expect an ack then. */
578 fprintf (stderr
, "putpkt (\"%s\"); [notif]\n", buf2
);
580 fprintf (stderr
, "putpkt (\"%s\"); [noack mode]\n", buf2
);
588 fprintf (stderr
, "putpkt (\"%s\"); [looking for ack]\n", buf2
);
591 cc
= read (remote_desc
, buf3
, 1);
594 fprintf (stderr
, "[received '%c' (0x%x)]\n", buf3
[0], buf3
[0]);
601 fprintf (stderr
, "putpkt(read): Got EOF\n");
603 perror ("putpkt(read)");
609 /* Check for an input interrupt while we're here. */
610 if (buf3
[0] == '\003' && current_inferior
!= NULL
)
611 (*the_target
->request_interrupt
) ();
613 while (buf3
[0] != '+');
616 return 1; /* Success! */
620 putpkt_binary (char *buf
, int cnt
)
622 return putpkt_binary_1 (buf
, cnt
, 0);
625 /* Send a packet to the remote machine, with error checking. The data
626 of the packet is in BUF, and the packet should be a NUL-terminated
627 string. Returns >= 0 on success, -1 otherwise. */
632 return putpkt_binary (buf
, strlen (buf
));
636 putpkt_notif (char *buf
)
638 return putpkt_binary_1 (buf
, strlen (buf
), 1);
641 /* Come here when we get an input interrupt from the remote side. This
642 interrupt should only be active while we are waiting for the child to do
643 something. About the only thing that should come through is a ^C, which
644 will cause us to request child interruption. */
647 input_interrupt (int unused
)
650 struct timeval immediate
= { 0, 0 };
652 /* Protect against spurious interrupts. This has been observed to
653 be a problem under NetBSD 1.4 and 1.5. */
656 FD_SET (remote_desc
, &readset
);
657 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
662 cc
= read (remote_desc
, &c
, 1);
664 if (cc
!= 1 || c
!= '\003' || current_inferior
== NULL
)
666 fprintf (stderr
, "input_interrupt, count = %d c = %d ('%c')\n",
671 (*the_target
->request_interrupt
) ();
675 /* Check if the remote side sent us an interrupt request (^C). */
677 check_remote_input_interrupt_request (void)
679 /* This function may be called before establishing communications,
680 therefore we need to validate the remote descriptor. */
682 if (remote_desc
== INVALID_DESCRIPTOR
)
688 /* Asynchronous I/O support. SIGIO must be enabled when waiting, in order to
689 accept Control-C from the client, and must be disabled when talking to
693 unblock_async_io (void)
698 sigemptyset (&sigio_set
);
699 sigaddset (&sigio_set
, SIGIO
);
700 sigprocmask (SIG_UNBLOCK
, &sigio_set
, NULL
);
704 /* Current state of asynchronous I/O. */
705 static int async_io_enabled
;
707 /* Enable asynchronous I/O. */
709 enable_async_io (void)
711 if (async_io_enabled
)
715 signal (SIGIO
, input_interrupt
);
717 async_io_enabled
= 1;
720 /* Disable asynchronous I/O. */
722 disable_async_io (void)
724 if (!async_io_enabled
)
728 signal (SIGIO
, SIG_IGN
);
730 async_io_enabled
= 0;
734 initialize_async_io (void)
736 /* Make sure that async I/O starts disabled. */
737 async_io_enabled
= 1;
740 /* Make sure the signal is unblocked. */
744 /* Returns next char from remote GDB. -1 if error. */
749 static unsigned char buf
[BUFSIZ
];
750 static int bufcnt
= 0;
751 static unsigned char *bufp
;
756 bufcnt
= read (remote_desc
, buf
, sizeof (buf
));
761 fprintf (stderr
, "readchar: Got EOF\n");
773 /* Read a packet from the remote machine, with error checking,
774 and store it in BUF. Returns length of packet, or negative if error. */
780 unsigned char csum
, c1
, c2
;
794 fprintf (stderr
, "[getpkt: discarding char '%c']\n", c
);
815 c1
= fromhex (readchar ());
816 c2
= fromhex (readchar ());
818 if (csum
== (c1
<< 4) + c2
)
823 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s [no-ack-mode, Bad medium?]\n",
824 (c1
<< 4) + c2
, csum
, buf
);
825 /* Not much we can do, GDB wasn't expecting an ack/nac. */
829 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
830 (c1
<< 4) + c2
, csum
, buf
);
831 write (remote_desc
, "-", 1);
838 fprintf (stderr
, "getpkt (\"%s\"); [sending ack] \n", buf
);
842 write (remote_desc
, "+", 1);
846 fprintf (stderr
, "[sent ack]\n");
854 fprintf (stderr
, "getpkt (\"%s\"); [no ack sent] \n", buf
);
871 write_enn (char *buf
)
873 /* Some day, we should define the meanings of the error codes... */
881 convert_int_to_ascii (unsigned char *from
, char *to
, int n
)
888 nib
= ((ch
& 0xf0) >> 4) & 0x0f;
898 convert_ascii_to_int (char *from
, unsigned char *to
, int n
)
903 nib1
= fromhex (*from
++);
904 nib2
= fromhex (*from
++);
905 *to
++ = (((nib1
& 0x0f) << 4) & 0xf0) | (nib2
& 0x0f);
910 outreg (int regno
, char *buf
)
912 if ((regno
>> 12) != 0)
913 *buf
++ = tohex ((regno
>> 12) & 0xf);
914 if ((regno
>> 8) != 0)
915 *buf
++ = tohex ((regno
>> 8) & 0xf);
916 *buf
++ = tohex ((regno
>> 4) & 0xf);
917 *buf
++ = tohex (regno
& 0xf);
919 collect_register_as_string (regno
, buf
);
920 buf
+= 2 * register_size (regno
);
927 new_thread_notify (int id
)
931 /* The `n' response is not yet part of the remote protocol. Do nothing. */
935 if (server_waiting
== 0)
938 sprintf (own_buf
, "n%x", id
);
945 dead_thread_notify (int id
)
949 /* The `x' response is not yet part of the remote protocol. Do nothing. */
953 sprintf (own_buf
, "x%x", id
);
960 prepare_resume_reply (char *buf
, unsigned long ptid
,
961 struct target_waitstatus
*status
)
964 fprintf (stderr
, "Writing resume reply for %lu:%d\n\n",
967 switch (status
->kind
)
969 case TARGET_WAITKIND_STOPPED
:
971 struct thread_info
*saved_inferior
;
974 sprintf (buf
, "T%02x", status
->value
.sig
);
977 regp
= gdbserver_expedite_regs
;
979 saved_inferior
= current_inferior
;
981 current_inferior
= gdb_id_to_thread (ptid
);
983 if (the_target
->stopped_by_watchpoint
!= NULL
984 && (*the_target
->stopped_by_watchpoint
) ())
989 strncpy (buf
, "watch:", 6);
992 addr
= (*the_target
->stopped_data_address
) ();
994 /* Convert each byte of the address into two hexadecimal
995 chars. Note that we take sizeof (void *) instead of
996 sizeof (addr); this is to avoid sending a 64-bit
997 address to a 32-bit GDB. */
998 for (i
= sizeof (void *) * 2; i
> 0; i
--)
999 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1005 buf
= outreg (find_regno (*regp
), buf
);
1009 /* Formerly, if the debugger had not used any thread features
1010 we would not burden it with a thread status response. This
1011 was for the benefit of GDB 4.13 and older. However, in
1012 recent GDB versions the check (``if (cont_thread != 0)'')
1013 does not have the desired effect because of sillyness in
1014 the way that the remote protocol handles specifying a
1015 thread. Since thread support relies on qSymbol support
1016 anyway, assume GDB can handle threads. */
1018 if (using_threads
&& !disable_packet_Tthread
)
1020 /* This if (1) ought to be unnecessary. But remote_wait
1021 in GDB will claim this event belongs to inferior_ptid
1022 if we do not specify a thread, and there's no way for
1023 gdbserver to know what inferior_ptid is. */
1024 if (1 || general_thread
!= ptid
)
1026 /* In non-stop, don't change the general thread behind
1029 general_thread
= ptid
;
1030 sprintf (buf
, "thread:%lx;", ptid
);
1031 buf
+= strlen (buf
);
1037 strcpy (buf
, "library:;");
1038 buf
+= strlen (buf
);
1042 current_inferior
= saved_inferior
;
1045 case TARGET_WAITKIND_EXITED
:
1046 sprintf (buf
, "W%02x", status
->value
.integer
);
1048 case TARGET_WAITKIND_SIGNALLED
:
1049 sprintf (buf
, "X%02x", status
->value
.sig
);
1052 error ("unhandled waitkind");
1058 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1062 *mem_addr_ptr
= *len_ptr
= 0;
1064 while ((ch
= from
[i
++]) != ',')
1066 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1067 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1070 for (j
= 0; j
< 4; j
++)
1072 if ((ch
= from
[i
++]) == 0)
1074 *len_ptr
= *len_ptr
<< 4;
1075 *len_ptr
|= fromhex (ch
) & 0x0f;
1080 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1085 *mem_addr_ptr
= *len_ptr
= 0;
1087 while ((ch
= from
[i
++]) != ',')
1089 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1090 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1093 while ((ch
= from
[i
++]) != ':')
1095 *len_ptr
= *len_ptr
<< 4;
1096 *len_ptr
|= fromhex (ch
) & 0x0f;
1099 convert_ascii_to_int (&from
[i
++], to
, *len_ptr
);
1103 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1104 unsigned int *len_ptr
, unsigned char *to
)
1108 *mem_addr_ptr
= *len_ptr
= 0;
1110 while ((ch
= from
[i
++]) != ',')
1112 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1113 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1116 while ((ch
= from
[i
++]) != ':')
1118 *len_ptr
= *len_ptr
<< 4;
1119 *len_ptr
|= fromhex (ch
) & 0x0f;
1122 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1123 to
, *len_ptr
) != *len_ptr
)
1129 /* Decode a qXfer write request. */
1131 decode_xfer_write (char *buf
, int packet_len
, char **annex
, CORE_ADDR
*offset
,
1132 unsigned int *len
, unsigned char *data
)
1136 /* Extract and NUL-terminate the annex. */
1138 while (*buf
&& *buf
!= ':')
1144 /* Extract the offset. */
1146 while ((ch
= *buf
++) != ':')
1148 *offset
= *offset
<< 4;
1149 *offset
|= fromhex (ch
) & 0x0f;
1152 /* Get encoded data. */
1153 packet_len
-= buf
- *annex
;
1154 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1159 /* Decode the parameters of a qSearch:memory packet. */
1162 decode_search_memory_packet (const char *buf
, int packet_len
,
1163 CORE_ADDR
*start_addrp
,
1164 CORE_ADDR
*search_space_lenp
,
1165 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1167 const char *p
= buf
;
1169 p
= decode_address_to_semicolon (start_addrp
, p
);
1170 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1171 packet_len
-= p
- buf
;
1172 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1173 pattern
, packet_len
);
1177 /* Ask GDB for the address of NAME, and return it in ADDRP if found.
1178 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1181 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
)
1183 char own_buf
[266], *p
, *q
;
1185 struct sym_cache
*sym
;
1187 /* Check the cache first. */
1188 for (sym
= symbol_cache
; sym
; sym
= sym
->next
)
1189 if (strcmp (name
, sym
->name
) == 0)
1195 /* If we've passed the call to thread_db_look_up_symbols, then
1196 anything not in the cache must not exist; we're not interested
1197 in any libraries loaded after that point, only in symbols in
1198 libpthread.so. It might not be an appropriate time to look
1199 up a symbol, e.g. while we're trying to fetch registers. */
1200 if (all_symbols_looked_up
)
1203 /* Send the request. */
1204 strcpy (own_buf
, "qSymbol:");
1205 hexify (own_buf
+ strlen ("qSymbol:"), name
, strlen (name
));
1206 if (putpkt (own_buf
) < 0)
1209 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1210 len
= getpkt (own_buf
);
1214 /* We ought to handle pretty much any packet at this point while we
1215 wait for the qSymbol "response". That requires re-entering the
1216 main loop. For now, this is an adequate approximation; allow
1217 GDB to read from memory while it figures out the address of the
1219 while (own_buf
[0] == 'm')
1222 unsigned char *mem_buf
;
1223 unsigned int mem_len
;
1225 decode_m_packet (&own_buf
[1], &mem_addr
, &mem_len
);
1226 mem_buf
= xmalloc (mem_len
);
1227 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1228 convert_int_to_ascii (mem_buf
, own_buf
, mem_len
);
1230 write_enn (own_buf
);
1232 if (putpkt (own_buf
) < 0)
1234 len
= getpkt (own_buf
);
1239 if (strncmp (own_buf
, "qSymbol:", strlen ("qSymbol:")) != 0)
1241 warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf
);
1245 p
= own_buf
+ strlen ("qSymbol:");
1247 while (*q
&& *q
!= ':')
1250 /* Make sure we found a value for the symbol. */
1251 if (p
== q
|| *q
== '\0')
1254 decode_address (addrp
, p
, q
- p
);
1256 /* Save the symbol in our cache. */
1257 sym
= xmalloc (sizeof (*sym
));
1258 sym
->name
= xstrdup (name
);
1260 sym
->next
= symbol_cache
;
1267 monitor_output (const char *msg
)
1269 char *buf
= xmalloc (strlen (msg
) * 2 + 2);
1272 hexify (buf
+ 1, msg
, 0);
1278 /* Return a malloc allocated string with special characters from TEXT
1279 replaced by entity references. */
1282 xml_escape_text (const char *text
)
1287 /* Compute the length of the result. */
1288 for (i
= 0, special
= 0; text
[i
] != '\0'; i
++)
1306 /* Expand the result. */
1307 result
= xmalloc (i
+ special
+ 1);
1308 for (i
= 0, special
= 0; text
[i
] != '\0'; i
++)
1312 strcpy (result
+ i
+ special
, "'");
1316 strcpy (result
+ i
+ special
, """);
1320 strcpy (result
+ i
+ special
, "&");
1324 strcpy (result
+ i
+ special
, "<");
1328 strcpy (result
+ i
+ special
, ">");
1332 result
[i
+ special
] = text
[i
];
1335 result
[i
+ special
] = '\0';
1341 buffer_grow (struct buffer
*buffer
, const char *data
, size_t size
)
1344 size_t new_buffer_size
;
1349 new_buffer_size
= buffer
->buffer_size
;
1351 if (new_buffer_size
== 0)
1352 new_buffer_size
= 1;
1354 while (buffer
->used_size
+ size
> new_buffer_size
)
1355 new_buffer_size
*= 2;
1356 new_buffer
= realloc (buffer
->buffer
, new_buffer_size
);
1359 memcpy (new_buffer
+ buffer
->used_size
, data
, size
);
1360 buffer
->buffer
= new_buffer
;
1361 buffer
->buffer_size
= new_buffer_size
;
1362 buffer
->used_size
+= size
;
1366 buffer_free (struct buffer
*buffer
)
1371 free (buffer
->buffer
);
1372 buffer
->buffer
= NULL
;
1373 buffer
->buffer_size
= 0;
1374 buffer
->used_size
= 0;
1378 buffer_init (struct buffer
*buffer
)
1380 memset (buffer
, 0, sizeof (*buffer
));
1384 buffer_finish (struct buffer
*buffer
)
1386 char *ret
= buffer
->buffer
;
1387 buffer
->buffer
= NULL
;
1388 buffer
->buffer_size
= 0;
1389 buffer
->used_size
= 0;
1394 buffer_xml_printf (struct buffer
*buffer
, const char *format
, ...)
1401 va_start (ap
, format
);
1404 for (f
= format
; *f
; f
++)
1413 char *a
= va_arg (ap
, char *);
1414 buffer_grow (buffer
, prev
, f
- prev
- 1);
1415 p
= xml_escape_text (a
);
1416 buffer_grow_str (buffer
, p
);
1428 buffer_grow_str (buffer
, prev
);