X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbserver%2Fremote-utils.c;h=768d2e9711d87c9538d5d963b06e3d145af9e429;hb=28170b88cc8b40fdea2b065dafe6e1872a47ee4e;hp=164ce6a853a91b538be2b21d2a30ef287c85ec0f;hpb=363a6e9f2c3fe1e25f8fa986347948897f189f39;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c index 164ce6a853..768d2e9711 100644 --- a/gdb/gdbserver/remote-utils.c +++ b/gdb/gdbserver/remote-utils.c @@ -1,7 +1,5 @@ /* Remote utility routines for the remote server for GDB. - Copyright (C) 1986, 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, - 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 - Free Software Foundation, Inc. + Copyright (C) 1986-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -21,8 +19,11 @@ #include "server.h" #include "terminal.h" #include "target.h" -#include -#include +#include "gdbthread.h" +#include "tdesc.h" +#include "dll.h" +#include "rsp-low.h" +#include #if HAVE_SYS_IOCTL_H #include #endif @@ -50,17 +51,12 @@ #if HAVE_FCNTL_H #include #endif -#include -#if HAVE_UNISTD_H +#include "gdb_sys_time.h" #include -#endif #if HAVE_ARPA_INET_H #include #endif #include -#if HAVE_ERRNO_H -#include -#endif #if USE_WIN32API #include @@ -74,6 +70,8 @@ typedef int socklen_t; #endif +#ifndef IN_PROCESS_AGENT + #if USE_WIN32API # define INVALID_DESCRIPTOR INVALID_SOCKET #else @@ -105,8 +103,10 @@ struct sym_cache int remote_debug = 0; struct ui_file *gdb_stdlog; -static int remote_desc = INVALID_DESCRIPTOR; -static int listen_desc = INVALID_DESCRIPTOR; +static int remote_is_stdio = 0; + +static gdb_fildes_t remote_desc = INVALID_DESCRIPTOR; +static gdb_fildes_t listen_desc = INVALID_DESCRIPTOR; /* FIXME headerize? */ extern int using_threads; @@ -128,6 +128,14 @@ gdb_connected (void) return remote_desc != INVALID_DESCRIPTOR; } +/* Return true if the remote connection is over stdio. */ + +int +remote_connection_is_stdio (void) +{ + return remote_is_stdio; +} + static void enable_async_notification (int fd) { @@ -149,7 +157,7 @@ handle_accept_event (int err, gdb_client_data client_data) socklen_t tmp; if (debug_threads) - fprintf (stderr, "handling possible accept event\n"); + debug_printf ("handling possible accept event\n"); tmp = sizeof (sockaddr); remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &tmp); @@ -168,14 +176,21 @@ handle_accept_event (int err, gdb_client_data client_data) (char *) &tmp, sizeof (tmp)); #ifndef USE_WIN32API - close (listen_desc); /* No longer need this */ - signal (SIGPIPE, SIG_IGN); /* If we don't do this, then gdbserver simply exits when the remote side dies. */ +#endif + + if (run_once) + { +#ifndef USE_WIN32API + close (listen_desc); /* No longer need this */ #else - closesocket (listen_desc); /* No longer need this */ + closesocket (listen_desc); /* No longer need this */ #endif + } + /* Even if !RUN_ONCE no longer notice new connections. Still keep the + descriptor open for add_file_handler to wait for a new connection. */ delete_file_handler (listen_desc); /* Convert IP address to string. */ @@ -198,6 +213,73 @@ handle_accept_event (int err, gdb_client_data client_data) return 0; } +/* Prepare for a later connection to a remote debugger. + NAME is the filename used for communication. */ + +void +remote_prepare (char *name) +{ + char *port_str; +#ifdef USE_WIN32API + static int winsock_initialized; +#endif + int port; + struct sockaddr_in sockaddr; + socklen_t tmp; + char *port_end; + + remote_is_stdio = 0; + if (strcmp (name, STDIO_CONNECTION_NAME) == 0) + { + /* We need to record fact that we're using stdio sooner than the + call to remote_open so start_inferior knows the connection is + via stdio. */ + remote_is_stdio = 1; + transport_is_reliable = 1; + return; + } + + port_str = strchr (name, ':'); + if (port_str == NULL) + { + transport_is_reliable = 0; + return; + } + + port = strtoul (port_str + 1, &port_end, 10); + if (port_str[1] == '\0' || *port_end != '\0') + error ("Bad port argument: %s", name); + +#ifdef USE_WIN32API + if (!winsock_initialized) + { + WSADATA wsad; + + WSAStartup (MAKEWORD (1, 0), &wsad); + winsock_initialized = 1; + } +#endif + + listen_desc = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP); + if (listen_desc == -1) + perror_with_name ("Can't open socket"); + + /* Allow rapid reuse of this port. */ + tmp = 1; + setsockopt (listen_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp, + sizeof (tmp)); + + sockaddr.sin_family = PF_INET; + sockaddr.sin_port = htons (port); + sockaddr.sin_addr.s_addr = INADDR_ANY; + + if (bind (listen_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr)) + || listen (listen_desc, 1)) + perror_with_name ("Can't bind address"); + + transport_is_reliable = 1; +} + /* Open a connection to a remote debugger. NAME is the filename used for communication. */ @@ -207,11 +289,27 @@ remote_open (char *name) char *port_str; port_str = strchr (name, ':'); +#ifdef USE_WIN32API if (port_str == NULL) + error ("Only : is supported on this platform."); +#endif + + if (strcmp (name, STDIO_CONNECTION_NAME) == 0) + { + fprintf (stderr, "Remote debugging using stdio\n"); + + /* Use stdin as the handle of the connection. + We only select on reads, for example. */ + remote_desc = fileno (stdin); + + enable_async_notification (remote_desc); + + /* Register the event loop handler. */ + add_file_handler (remote_desc, handle_serial_event, NULL); + } +#ifndef USE_WIN32API + else if (port_str == NULL) { -#ifdef USE_WIN32API - error ("Only : is supported on this platform."); -#else struct stat statbuf; if (stat (name, &statbuf) == 0 @@ -272,73 +370,30 @@ remote_open (char *name) fprintf (stderr, "Remote debugging using %s\n", name); - transport_is_reliable = 0; - enable_async_notification (remote_desc); /* Register the event loop handler. */ add_file_handler (remote_desc, handle_serial_event, NULL); -#endif /* USE_WIN32API */ } +#endif /* USE_WIN32API */ else { -#ifdef USE_WIN32API - static int winsock_initialized; -#endif int port; + socklen_t len; struct sockaddr_in sockaddr; - socklen_t tmp; - char *port_end; - port = strtoul (port_str + 1, &port_end, 10); - if (port_str[1] == '\0' || *port_end != '\0') - fatal ("Bad port argument: %s", name); - -#ifdef USE_WIN32API - if (!winsock_initialized) - { - WSADATA wsad; - - WSAStartup (MAKEWORD (1, 0), &wsad); - winsock_initialized = 1; - } -#endif - - listen_desc = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP); - if (listen_desc == -1) - perror_with_name ("Can't open socket"); - - /* Allow rapid reuse of this port. */ - tmp = 1; - setsockopt (listen_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp, - sizeof (tmp)); - - sockaddr.sin_family = PF_INET; - sockaddr.sin_port = htons (port); - sockaddr.sin_addr.s_addr = INADDR_ANY; - - if (bind (listen_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr)) - || listen (listen_desc, 1)) - perror_with_name ("Can't bind address"); - - /* If port is zero, a random port will be selected, and the - fprintf below needs to know what port was selected. */ - if (port == 0) - { - socklen_t len = sizeof (sockaddr); - if (getsockname (listen_desc, (struct sockaddr *) &sockaddr, &len) < 0 - || len < sizeof (sockaddr)) - perror_with_name ("Can't determine port"); - port = ntohs (sockaddr.sin_port); - } + len = sizeof (sockaddr); + if (getsockname (listen_desc, + (struct sockaddr *) &sockaddr, &len) < 0 + || len < sizeof (sockaddr)) + perror_with_name ("Can't determine port"); + port = ntohs (sockaddr.sin_port); fprintf (stderr, "Listening on port %d\n", port); fflush (stderr); /* Register the event loop handler. */ add_file_handler (listen_desc, handle_accept_event, NULL); - - transport_is_reliable = 1; } } @@ -347,71 +402,25 @@ remote_close (void) { delete_file_handler (remote_desc); +#ifndef USE_WIN32API + /* Remove SIGIO handler. */ + signal (SIGIO, SIG_IGN); +#endif + #ifdef USE_WIN32API closesocket (remote_desc); #else - close (remote_desc); + if (! remote_connection_is_stdio ()) + close (remote_desc); #endif remote_desc = INVALID_DESCRIPTOR; reset_readchar (); } -/* Convert hex digit A to a number. */ - -static int -fromhex (int a) -{ - if (a >= '0' && a <= '9') - return a - '0'; - else if (a >= 'a' && a <= 'f') - return a - 'a' + 10; - else - error ("Reply contains invalid hex digit"); - return 0; -} - -static const char hexchars[] = "0123456789abcdef"; - -static int -ishex (int ch, int *val) -{ - if ((ch >= 'a') && (ch <= 'f')) - { - *val = ch - 'a' + 10; - return 1; - } - if ((ch >= 'A') && (ch <= 'F')) - { - *val = ch - 'A' + 10; - return 1; - } - if ((ch >= '0') && (ch <= '9')) - { - *val = ch - '0'; - return 1; - } - return 0; -} - -int -unhexify (char *bin, const char *hex, int count) -{ - int i; +#endif - for (i = 0; i < count; i++) - { - if (hex[0] == 0 || hex[1] == 0) - { - /* Hex string is short, or of uneven length. - Return the count that has been converted so far. */ - return i; - } - *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]); - hex += 2; - } - return i; -} +#ifndef IN_PROCESS_AGENT void decode_address (CORE_ADDR *addrp, const char *start, int len) @@ -446,115 +455,9 @@ decode_address_to_semicolon (CORE_ADDR *addrp, const char *start) return end; } -/* Convert number NIB to a hex digit. */ - -static int -tohex (int nib) -{ - if (nib < 10) - return '0' + nib; - else - return 'a' + nib - 10; -} - -int -hexify (char *hex, const char *bin, int count) -{ - int i; - - /* May use a length, or a nul-terminated string as input. */ - if (count == 0) - count = strlen (bin); - - for (i = 0; i < count; i++) - { - *hex++ = tohex ((*bin >> 4) & 0xf); - *hex++ = tohex (*bin++ & 0xf); - } - *hex = 0; - return i; -} - -/* Convert BUFFER, binary data at least LEN bytes long, into escaped - binary data in OUT_BUF. Set *OUT_LEN to the length of the data - encoded in OUT_BUF, and return the number of bytes in OUT_BUF - (which may be more than *OUT_LEN due to escape characters). The - total number of bytes in the output buffer will be at most - OUT_MAXLEN. */ - -int -remote_escape_output (const gdb_byte *buffer, int len, - gdb_byte *out_buf, int *out_len, - int out_maxlen) -{ - int input_index, output_index; - - output_index = 0; - for (input_index = 0; input_index < len; input_index++) - { - gdb_byte b = buffer[input_index]; - - if (b == '$' || b == '#' || b == '}' || b == '*') - { - /* These must be escaped. */ - if (output_index + 2 > out_maxlen) - break; - out_buf[output_index++] = '}'; - out_buf[output_index++] = b ^ 0x20; - } - else - { - if (output_index + 1 > out_maxlen) - break; - out_buf[output_index++] = b; - } - } - - *out_len = input_index; - return output_index; -} - -/* Convert BUFFER, escaped data LEN bytes long, into binary data - in OUT_BUF. Return the number of bytes written to OUT_BUF. - Raise an error if the total number of bytes exceeds OUT_MAXLEN. - - This function reverses remote_escape_output. It allows more - escaped characters than that function does, in particular because - '*' must be escaped to avoid the run-length encoding processing - in reading packets. */ - -static int -remote_unescape_input (const gdb_byte *buffer, int len, - gdb_byte *out_buf, int out_maxlen) -{ - int input_index, output_index; - int escaped; - - output_index = 0; - escaped = 0; - for (input_index = 0; input_index < len; input_index++) - { - gdb_byte b = buffer[input_index]; - - if (output_index + 1 > out_maxlen) - error ("Received too much data from the target."); - - if (escaped) - { - out_buf[output_index++] = b ^ 0x20; - escaped = 0; - } - else if (b == '}') - escaped = 1; - else - out_buf[output_index++] = b; - } - - if (escaped) - error ("Unmatched escape character in target response."); +#endif - return output_index; -} +#ifndef IN_PROCESS_AGENT /* Look for a sequence of characters which can be run-length encoded. If there are any, update *CSUM and *P. Otherwise, output the @@ -600,22 +503,9 @@ try_rle (char *buf, int remaining, unsigned char *csum, char **p) return n + 1; } -char * -unpack_varlen_hex (char *buff, /* packet to parse */ - ULONGEST *result) -{ - int nibble; - ULONGEST retval = 0; +#endif - while (ishex (*buff, &nibble)) - { - buff++; - retval = retval << 4; - retval |= nibble & 0x0f; - } - *result = retval; - return buff; -} +#ifndef IN_PROCESS_AGENT /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */ @@ -641,12 +531,12 @@ write_ptid (char *buf, ptid_t ptid) return buf; } -ULONGEST +static ULONGEST hex_or_minus_one (char *buf, char **obuf) { ULONGEST ret; - if (strncmp (buf, "-1", 2) == 0) + if (startswith (buf, "-1")) { ret = (ULONGEST) -1; buf += 2; @@ -688,15 +578,42 @@ read_ptid (char *buf, char **obuf) /* No multi-process. Just a tid. */ tid = hex_or_minus_one (p, &pp); - /* Since the stub is not sending a process id, then default to - what's in the current inferior. */ - pid = ptid_get_pid (((struct inferior_list_entry *) current_inferior)->id); + /* Since GDB is not sending a process id (multi-process extensions + are off), then there's only one process. Default to the first in + the list. */ + pid = pid_of (get_first_process ()); if (obuf) *obuf = pp; return ptid_build (pid, tid, 0); } +/* Write COUNT bytes in BUF to the client. + The result is the number of bytes written or -1 if error. + This may return less than COUNT. */ + +static int +write_prim (const void *buf, int count) +{ + if (remote_connection_is_stdio ()) + return write (fileno (stdout), buf, count); + else + return write (remote_desc, buf, count); +} + +/* Read COUNT bytes from the client and store in BUF. + The result is the number of bytes read or -1 if error. + This may return less than COUNT. */ + +static int +read_prim (void *buf, int count) +{ + if (remote_connection_is_stdio ()) + return read (fileno (stdin), buf, count); + else + return read (remote_desc, buf, count); +} + /* Send a packet to the remote machine, with error checking. The data of the packet is in BUF, and the length of the packet is in CNT. Returns >= 0 on success, -1 otherwise. */ @@ -710,7 +627,7 @@ putpkt_binary_1 (char *buf, int cnt, int is_notif) char *p; int cc; - buf2 = xmalloc (PBUFSIZ); + buf2 = (char *) xmalloc (strlen ("$") + cnt + strlen ("#nn") + 1); /* Copy the packet into buffer BUF2, encapsulating it and giving it a checksum. */ @@ -734,7 +651,7 @@ putpkt_binary_1 (char *buf, int cnt, int is_notif) do { - if (write (remote_desc, buf2, p - buf2) != p - buf2) + if (write_prim (buf2, p - buf2) != p - buf2) { perror ("putpkt(write)"); free (buf2); @@ -776,7 +693,7 @@ putpkt_binary_1 (char *buf, int cnt, int is_notif) } /* Check for an input interrupt while we're here. */ - if (cc == '\003' && current_inferior != NULL) + if (cc == '\003' && current_thread != NULL) (*the_target->request_interrupt) (); } while (cc != '+'); @@ -829,12 +746,20 @@ input_interrupt (int unused) int cc; char c = 0; - cc = read (remote_desc, &c, 1); + cc = read_prim (&c, 1); - if (cc != 1 || c != '\003' || current_inferior == NULL) + if (cc == 0) { - fprintf (stderr, "input_interrupt, count = %d c = %d ('%c')\n", - cc, c, c); + fprintf (stderr, "client connection closed\n"); + return; + } + else if (cc != 1 || c != '\003') + { + fprintf (stderr, "input_interrupt, count = %d c = %d ", cc, c); + if (isprint (c)) + fprintf (stderr, "('%c')\n", c); + else + fprintf (stderr, "('\\x%02x')\n", c & 0xff); return; } @@ -855,19 +780,19 @@ check_remote_input_interrupt_request (void) input_interrupt (0); } -/* Asynchronous I/O support. SIGIO must be enabled when waiting, in order to - accept Control-C from the client, and must be disabled when talking to - the client. */ +/* Asynchronous I/O support. SIGIO must be unblocked when waiting, + in order to accept Control-C from the client, and must be blocked + when talking to the client. */ static void -unblock_async_io (void) +block_unblock_async_io (int block) { #ifndef USE_WIN32API sigset_t sigio_set; sigemptyset (&sigio_set); sigaddset (&sigio_set, SIGIO); - sigprocmask (SIG_UNBLOCK, &sigio_set, NULL); + sigprocmask (block ? SIG_BLOCK : SIG_UNBLOCK, &sigio_set, NULL); #endif } @@ -903,9 +828,8 @@ enable_async_io (void) if (async_io_enabled) return; -#ifndef USE_WIN32API - signal (SIGIO, input_interrupt); -#endif + block_unblock_async_io (0); + async_io_enabled = 1; #ifdef __QNX__ nto_comctrl (1); @@ -919,9 +843,8 @@ disable_async_io (void) if (!async_io_enabled) return; -#ifndef USE_WIN32API - signal (SIGIO, SIG_IGN); -#endif + block_unblock_async_io (1); + async_io_enabled = 0; #ifdef __QNX__ nto_comctrl (0); @@ -932,12 +855,14 @@ disable_async_io (void) void initialize_async_io (void) { - /* Make sure that async I/O starts disabled. */ + /* Make sure that async I/O starts blocked. */ async_io_enabled = 1; disable_async_io (); - /* Make sure the signal is unblocked. */ - unblock_async_io (); + /* Install the signal handler. */ +#ifndef USE_WIN32API + signal (SIGIO, input_interrupt); +#endif } /* Internal buffer used by readchar. @@ -957,12 +882,15 @@ readchar (void) if (readchar_bufcnt == 0) { - readchar_bufcnt = read (remote_desc, readchar_buf, sizeof (readchar_buf)); + readchar_bufcnt = read_prim (readchar_buf, sizeof (readchar_buf)); if (readchar_bufcnt <= 0) { if (readchar_bufcnt == 0) - fprintf (stderr, "readchar: Got EOF\n"); + { + if (remote_debug) + fprintf (stderr, "readchar: Got EOF\n"); + } else perror ("readchar"); @@ -1036,6 +964,15 @@ getpkt (char *buf) while (1) { c = readchar (); + + /* The '\003' may appear before or after each packet, so + check for an input interrupt. */ + if (c == '\003') + { + (*the_target->request_interrupt) (); + continue; + } + if (c == '$') break; if (remote_debug) @@ -1069,7 +1006,9 @@ getpkt (char *buf) if (noack_mode) { - fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s [no-ack-mode, Bad medium?]\n", + fprintf (stderr, + "Bad checksum, sentsum=0x%x, csum=0x%x, " + "buf=%s [no-ack-mode, Bad medium?]\n", (c1 << 4) + c2, csum, buf); /* Not much we can do, GDB wasn't expecting an ack/nac. */ break; @@ -1077,7 +1016,8 @@ getpkt (char *buf) fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n", (c1 << 4) + c2, csum, buf); - write (remote_desc, "-", 1); + if (write_prim ("-", 1) != 1) + return -1; } if (!noack_mode) @@ -1088,7 +1028,8 @@ getpkt (char *buf) fflush (stderr); } - write (remote_desc, "+", 1); + if (write_prim ("+", 1) != 1) + return -1; if (remote_debug) { @@ -1105,6 +1046,22 @@ getpkt (char *buf) } } + /* The readchar above may have already read a '\003' out of the socket + and moved it to the local buffer. For example, when GDB sends + vCont;c immediately followed by interrupt (see + gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll + resume the inferior and wait. Since we've already moved the '\003' + to the local buffer, SIGIO won't help. In that case, if we don't + check for interrupt after the vCont;c packet, the interrupt character + would stay in the buffer unattended until after the next (unrelated) + stop. */ + while (readchar_bufcnt > 0 && *readchar_bufp == '\003') + { + /* Consume the interrupt character in the buffer. */ + readchar (); + (*the_target->request_interrupt) (); + } + return bp - buf; } @@ -1126,34 +1083,9 @@ write_enn (char *buf) buf[3] = '\0'; } -void -convert_int_to_ascii (unsigned char *from, char *to, int n) -{ - int nib; - int ch; - while (n--) - { - ch = *from++; - nib = ((ch & 0xf0) >> 4) & 0x0f; - *to++ = tohex (nib); - nib = ch & 0x0f; - *to++ = tohex (nib); - } - *to++ = 0; -} - +#endif -void -convert_ascii_to_int (char *from, unsigned char *to, int n) -{ - int nib1, nib2; - while (n--) - { - nib1 = fromhex (*from++); - nib2 = fromhex (*from++); - *to++ = (((nib1 & 0x0f) << 4) & 0xf0) | (nib2 & 0x0f); - } -} +#ifndef IN_PROCESS_AGENT static char * outreg (struct regcache *regcache, int regno, char *buf) @@ -1166,71 +1098,101 @@ outreg (struct regcache *regcache, int regno, char *buf) *buf++ = tohex (regno & 0xf); *buf++ = ':'; collect_register_as_string (regcache, regno, buf); - buf += 2 * register_size (regno); + buf += 2 * register_size (regcache->tdesc, regno); *buf++ = ';'; return buf; } -void -new_thread_notify (int id) -{ - char own_buf[256]; - - /* The `n' response is not yet part of the remote protocol. Do nothing. */ - if (1) - return; - - if (server_waiting == 0) - return; - - sprintf (own_buf, "n%x", id); - disable_async_io (); - putpkt (own_buf); - enable_async_io (); -} - -void -dead_thread_notify (int id) -{ - char own_buf[256]; - - /* The `x' response is not yet part of the remote protocol. Do nothing. */ - if (1) - return; - - sprintf (own_buf, "x%x", id); - disable_async_io (); - putpkt (own_buf); - enable_async_io (); -} - void prepare_resume_reply (char *buf, ptid_t ptid, struct target_waitstatus *status) { if (debug_threads) - fprintf (stderr, "Writing resume reply for %s:%d\n\n", - target_pid_to_str (ptid), status->kind); + debug_printf ("Writing resume reply for %s:%d\n", + target_pid_to_str (ptid), status->kind); switch (status->kind) { case TARGET_WAITKIND_STOPPED: + case TARGET_WAITKIND_FORKED: + case TARGET_WAITKIND_VFORKED: + case TARGET_WAITKIND_VFORK_DONE: + case TARGET_WAITKIND_EXECD: + case TARGET_WAITKIND_THREAD_CREATED: + case TARGET_WAITKIND_SYSCALL_ENTRY: + case TARGET_WAITKIND_SYSCALL_RETURN: { - struct thread_info *saved_inferior; + struct thread_info *saved_thread; const char **regp; struct regcache *regcache; - sprintf (buf, "T%02x", status->value.sig); + if ((status->kind == TARGET_WAITKIND_FORKED && report_fork_events) + || (status->kind == TARGET_WAITKIND_VFORKED && report_vfork_events)) + { + enum gdb_signal signal = GDB_SIGNAL_TRAP; + const char *event = (status->kind == TARGET_WAITKIND_FORKED + ? "fork" : "vfork"); + + sprintf (buf, "T%02x%s:", signal, event); + buf += strlen (buf); + buf = write_ptid (buf, status->value.related_pid); + strcat (buf, ";"); + } + else if (status->kind == TARGET_WAITKIND_VFORK_DONE && report_vfork_events) + { + enum gdb_signal signal = GDB_SIGNAL_TRAP; + + sprintf (buf, "T%02xvforkdone:;", signal); + } + else if (status->kind == TARGET_WAITKIND_EXECD && report_exec_events) + { + enum gdb_signal signal = GDB_SIGNAL_TRAP; + const char *event = "exec"; + char hexified_pathname[PATH_MAX * 2]; + + sprintf (buf, "T%02x%s:", signal, event); + buf += strlen (buf); + + /* Encode pathname to hexified format. */ + bin2hex ((const gdb_byte *) status->value.execd_pathname, + hexified_pathname, + strlen (status->value.execd_pathname)); + + sprintf (buf, "%s;", hexified_pathname); + xfree (status->value.execd_pathname); + status->value.execd_pathname = NULL; + buf += strlen (buf); + } + else if (status->kind == TARGET_WAITKIND_THREAD_CREATED + && report_thread_events) + { + enum gdb_signal signal = GDB_SIGNAL_TRAP; + + sprintf (buf, "T%02xcreate:;", signal); + } + else if (status->kind == TARGET_WAITKIND_SYSCALL_ENTRY + || status->kind == TARGET_WAITKIND_SYSCALL_RETURN) + { + enum gdb_signal signal = GDB_SIGNAL_TRAP; + const char *event = (status->kind == TARGET_WAITKIND_SYSCALL_ENTRY + ? "syscall_entry" : "syscall_return"); + + sprintf (buf, "T%02x%s:%x;", signal, event, + status->value.syscall_number); + } + else + sprintf (buf, "T%02x", status->value.sig); + buf += strlen (buf); - regp = gdbserver_expedite_regs; + saved_thread = current_thread; - saved_inferior = current_inferior; + current_thread = find_thread_ptid (ptid); - current_inferior = find_thread_ptid (ptid); + regp = current_target_desc ()->expedite_regs; - regcache = get_thread_regcache (current_inferior, 1); + regcache = get_thread_regcache (current_thread, 1); if (the_target->stopped_by_watchpoint != NULL && (*the_target->stopped_by_watchpoint) ()) @@ -1251,10 +1213,20 @@ prepare_resume_reply (char *buf, ptid_t ptid, *buf++ = tohex ((addr >> (i - 1) * 4) & 0xf); *buf++ = ';'; } + else if (swbreak_feature && target_stopped_by_sw_breakpoint ()) + { + sprintf (buf, "swbreak:;"); + buf += strlen (buf); + } + else if (hwbreak_feature && target_stopped_by_hw_breakpoint ()) + { + sprintf (buf, "hwbreak:;"); + buf += strlen (buf); + } while (*regp) { - buf = outreg (regcache, find_regno (*regp), buf); + buf = outreg (regcache, find_regno (regcache->tdesc, *regp), buf); regp ++; } *buf = '\0'; @@ -1287,8 +1259,8 @@ prepare_resume_reply (char *buf, ptid_t ptid, strcat (buf, ";"); buf += strlen (buf); - if (the_target->core_of_thread) - core = (*the_target->core_of_thread) (ptid); + core = target_core_of_thread (ptid); + if (core != -1) { sprintf (buf, "core:"); @@ -1307,7 +1279,7 @@ prepare_resume_reply (char *buf, ptid_t ptid, dlls_changed = 0; } - current_inferior = saved_inferior; + current_thread = saved_thread; } break; case TARGET_WAITKIND_EXITED: @@ -1324,6 +1296,14 @@ prepare_resume_reply (char *buf, ptid_t ptid, else sprintf (buf, "X%02x", status->value.sig); break; + case TARGET_WAITKIND_THREAD_EXITED: + sprintf (buf, "w%x;", status->value.integer); + buf += strlen (buf); + buf = write_ptid (buf, ptid); + break; + case TARGET_WAITKIND_NO_RESUMED: + sprintf (buf, "N"); + break; default: error ("unhandled waitkind"); break; @@ -1354,7 +1334,7 @@ decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr) void decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr, - unsigned char *to) + unsigned char **to_p) { int i = 0; char ch; @@ -1372,12 +1352,15 @@ decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr, *len_ptr |= fromhex (ch) & 0x0f; } - convert_ascii_to_int (&from[i++], to, *len_ptr); + if (*to_p == NULL) + *to_p = (unsigned char *) xmalloc (*len_ptr); + + hex2bin (&from[i++], *to_p, *len_ptr); } int decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr, - unsigned int *len_ptr, unsigned char *to) + unsigned int *len_ptr, unsigned char **to_p) { int i = 0; char ch; @@ -1395,27 +1378,24 @@ decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr, *len_ptr |= fromhex (ch) & 0x0f; } + if (*to_p == NULL) + *to_p = (unsigned char *) xmalloc (*len_ptr); + if (remote_unescape_input ((const gdb_byte *) &from[i], packet_len - i, - to, *len_ptr) != *len_ptr) + *to_p, *len_ptr) != *len_ptr) return -1; return 0; } /* Decode a qXfer write request. */ + int -decode_xfer_write (char *buf, int packet_len, char **annex, CORE_ADDR *offset, +decode_xfer_write (char *buf, int packet_len, CORE_ADDR *offset, unsigned int *len, unsigned char *data) { char ch; - - /* Extract and NUL-terminate the annex. */ - *annex = buf; - while (*buf && *buf != ':') - buf++; - if (*buf == '\0') - return -1; - *buf++ = 0; + char *b = buf; /* Extract the offset. */ *offset = 0; @@ -1426,7 +1406,7 @@ decode_xfer_write (char *buf, int packet_len, char **annex, CORE_ADDR *offset, } /* Get encoded data. */ - packet_len -= buf - *annex; + packet_len -= buf - b; *len = remote_unescape_input ((const gdb_byte *) buf, packet_len, data, packet_len); return 0; @@ -1482,7 +1462,7 @@ clear_symbol_cache (struct sym_cache **symcache_p) int look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb) { - char own_buf[266], *p, *q; + char *p, *q; int len; struct sym_cache *sym; struct process_info *proc; @@ -1504,7 +1484,8 @@ look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb) /* Send the request. */ strcpy (own_buf, "qSymbol:"); - hexify (own_buf + strlen ("qSymbol:"), name, strlen (name)); + bin2hex ((const gdb_byte *) name, own_buf + strlen ("qSymbol:"), + strlen (name)); if (putpkt (own_buf) < 0) return -1; @@ -1516,29 +1497,43 @@ look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb) /* We ought to handle pretty much any packet at this point while we wait for the qSymbol "response". That requires re-entering the main loop. For now, this is an adequate approximation; allow - GDB to read from memory while it figures out the address of the - symbol. */ - while (own_buf[0] == 'm') + GDB to read from memory and handle 'v' packets (for vFile transfers) + while it figures out the address of the symbol. */ + while (1) { - CORE_ADDR mem_addr; - unsigned char *mem_buf; - unsigned int mem_len; - - decode_m_packet (&own_buf[1], &mem_addr, &mem_len); - mem_buf = xmalloc (mem_len); - if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0) - convert_int_to_ascii (mem_buf, own_buf, mem_len); + if (own_buf[0] == 'm') + { + CORE_ADDR mem_addr; + unsigned char *mem_buf; + unsigned int mem_len; + + decode_m_packet (&own_buf[1], &mem_addr, &mem_len); + mem_buf = (unsigned char *) xmalloc (mem_len); + if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0) + bin2hex (mem_buf, own_buf, mem_len); + else + write_enn (own_buf); + free (mem_buf); + if (putpkt (own_buf) < 0) + return -1; + } + else if (own_buf[0] == 'v') + { + int new_len = -1; + handle_v_requests (own_buf, len, &new_len); + if (new_len != -1) + putpkt_binary (own_buf, new_len); + else + putpkt (own_buf); + } else - write_enn (own_buf); - free (mem_buf); - if (putpkt (own_buf) < 0) - return -1; + break; len = getpkt (own_buf); if (len < 0) return -1; } - if (strncmp (own_buf, "qSymbol:", strlen ("qSymbol:")) != 0) + if (!startswith (own_buf, "qSymbol:")) { warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf); return -1; @@ -1556,7 +1551,7 @@ look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb) decode_address (addrp, p, q - p); /* Save the symbol in our cache. */ - sym = xmalloc (sizeof (*sym)); + sym = XNEW (struct sym_cache); sym->name = xstrdup (name); sym->addr = *addrp; sym->next = proc->symbol_cache; @@ -1565,178 +1560,111 @@ look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb) return 1; } -void -monitor_output (const char *msg) -{ - char *buf = xmalloc (strlen (msg) * 2 + 2); - - buf[0] = 'O'; - hexify (buf + 1, msg, 0); - - putpkt (buf); - free (buf); -} - -/* Return a malloc allocated string with special characters from TEXT - replaced by entity references. */ +/* Relocate an instruction to execute at a different address. OLDLOC + is the address in the inferior memory where the instruction to + relocate is currently at. On input, TO points to the destination + where we want the instruction to be copied (and possibly adjusted) + to. On output, it points to one past the end of the resulting + instruction(s). The effect of executing the instruction at TO + shall be the same as if executing it at OLDLOC. For example, call + instructions that implicitly push the return address on the stack + should be adjusted to return to the instruction after OLDLOC; + relative branches, and other PC-relative instructions need the + offset adjusted; etc. Returns 0 on success, -1 on failure. */ -char * -xml_escape_text (const char *text) +int +relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc) { - char *result; - int i, special; + int len; + ULONGEST written = 0; - /* Compute the length of the result. */ - for (i = 0, special = 0; text[i] != '\0'; i++) - switch (text[i]) - { - case '\'': - case '\"': - special += 5; - break; - case '&': - special += 4; - break; - case '<': - case '>': - special += 3; - break; - default: - break; - } + /* Send the request. */ + strcpy (own_buf, "qRelocInsn:"); + sprintf (own_buf, "qRelocInsn:%s;%s", paddress (oldloc), + paddress (*to)); + if (putpkt (own_buf) < 0) + return -1; - /* Expand the result. */ - result = xmalloc (i + special + 1); - for (i = 0, special = 0; text[i] != '\0'; i++) - switch (text[i]) - { - case '\'': - strcpy (result + i + special, "'"); - special += 5; - break; - case '\"': - strcpy (result + i + special, """); - special += 5; - break; - case '&': - strcpy (result + i + special, "&"); - special += 4; - break; - case '<': - strcpy (result + i + special, "<"); - special += 3; - break; - case '>': - strcpy (result + i + special, ">"); - special += 3; - break; - default: - result[i + special] = text[i]; - break; - } - result[i + special] = '\0'; + /* FIXME: Eventually add buffer overflow checking (to getpkt?) */ + len = getpkt (own_buf); + if (len < 0) + return -1; - return result; -} + /* We ought to handle pretty much any packet at this point while we + wait for the qRelocInsn "response". That requires re-entering + the main loop. For now, this is an adequate approximation; allow + GDB to access memory. */ + while (own_buf[0] == 'm' || own_buf[0] == 'M' || own_buf[0] == 'X') + { + CORE_ADDR mem_addr; + unsigned char *mem_buf = NULL; + unsigned int mem_len; -void -buffer_grow (struct buffer *buffer, const char *data, size_t size) -{ - char *new_buffer; - size_t new_buffer_size; + if (own_buf[0] == 'm') + { + decode_m_packet (&own_buf[1], &mem_addr, &mem_len); + mem_buf = (unsigned char *) xmalloc (mem_len); + if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0) + bin2hex (mem_buf, own_buf, mem_len); + else + write_enn (own_buf); + } + else if (own_buf[0] == 'X') + { + if (decode_X_packet (&own_buf[1], len - 1, &mem_addr, + &mem_len, &mem_buf) < 0 + || write_inferior_memory (mem_addr, mem_buf, mem_len) != 0) + write_enn (own_buf); + else + write_ok (own_buf); + } + else + { + decode_M_packet (&own_buf[1], &mem_addr, &mem_len, &mem_buf); + if (write_inferior_memory (mem_addr, mem_buf, mem_len) == 0) + write_ok (own_buf); + else + write_enn (own_buf); + } + free (mem_buf); + if (putpkt (own_buf) < 0) + return -1; + len = getpkt (own_buf); + if (len < 0) + return -1; + } - if (size == 0) - return; + if (own_buf[0] == 'E') + { + warning ("An error occurred while relocating an instruction: %s\n", + own_buf); + return -1; + } - new_buffer_size = buffer->buffer_size; + if (!startswith (own_buf, "qRelocInsn:")) + { + warning ("Malformed response to qRelocInsn, ignoring: %s\n", + own_buf); + return -1; + } - if (new_buffer_size == 0) - new_buffer_size = 1; + unpack_varlen_hex (own_buf + strlen ("qRelocInsn:"), &written); - while (buffer->used_size + size > new_buffer_size) - new_buffer_size *= 2; - new_buffer = realloc (buffer->buffer, new_buffer_size); - if (!new_buffer) - abort (); - memcpy (new_buffer + buffer->used_size, data, size); - buffer->buffer = new_buffer; - buffer->buffer_size = new_buffer_size; - buffer->used_size += size; + *to += written; + return 0; } void -buffer_free (struct buffer *buffer) +monitor_output (const char *msg) { - if (!buffer) - return; - - free (buffer->buffer); - buffer->buffer = NULL; - buffer->buffer_size = 0; - buffer->used_size = 0; -} + int len = strlen (msg); + char *buf = (char *) xmalloc (len * 2 + 2); -void -buffer_init (struct buffer *buffer) -{ - memset (buffer, 0, sizeof (*buffer)); -} + buf[0] = 'O'; + bin2hex ((const gdb_byte *) msg, buf + 1, len); -char* -buffer_finish (struct buffer *buffer) -{ - char *ret = buffer->buffer; - buffer->buffer = NULL; - buffer->buffer_size = 0; - buffer->used_size = 0; - return ret; + putpkt (buf); + free (buf); } -void -buffer_xml_printf (struct buffer *buffer, const char *format, ...) -{ - va_list ap; - const char *f; - const char *prev; - int percent = 0; - - va_start (ap, format); - - prev = format; - for (f = format; *f; f++) - { - if (percent) - { - switch (*f) - { - case 's': - { - char *p; - char *a = va_arg (ap, char *); - buffer_grow (buffer, prev, f - prev - 1); - p = xml_escape_text (a); - buffer_grow_str (buffer, p); - free (p); - prev = f + 1; - } - break; - case 'd': - { - int i = va_arg (ap, int); - char b[sizeof ("4294967295")]; - - buffer_grow (buffer, prev, f - prev - 1); - sprintf (b, "%d", i); - buffer_grow_str (buffer, b); - prev = f + 1; - } - } - percent = 0; - } - else if (*f == '%') - percent = 1; - } - - buffer_grow_str (buffer, prev); - va_end (ap); -} +#endif