Implement TARGET_WAITKIND_NO_RESUMED in the remote protocol

[deliverable/binutils-gdb.git] / gdb / gdbserver / remote-utils.c

diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c
index 1de86beecfbf22128ea7c08841bb64a3c6d71c0f..77280f7c11eb84759d50c1bb544a342367a2a8a4 100644 (file)
--- a/gdb/gdbserver/remote-utils.c
+++ b/gdb/gdbserver/remote-utils.c
@@ -51,7 +51,7 @@
 #if HAVE_FCNTL_H
 #include <fcntl.h>
 #endif
-#include <sys/time.h>
+#include "gdb_sys_time.h"
 #include <unistd.h>
 #if HAVE_ARPA_INET_H
 #include <arpa/inet.h>
@@ -573,9 +573,10 @@ 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 (current_ptid);
+  /* 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;
@@ -621,7 +622,7 @@ putpkt_binary_1 (char *buf, int cnt, int is_notif)
   char *p;
   int cc;
 
-  buf2 = xmalloc (strlen ("$") + cnt + strlen ("#nn") + 1);
+  buf2 = (char *) xmalloc (strlen ("$") + cnt + strlen ("#nn") + 1);
 
   /* Copy the packet into buffer BUF2, encapsulating it
      and giving it a checksum.  */
@@ -747,7 +748,7 @@ input_interrupt (int unused)
          fprintf (stderr, "client connection closed\n");
          return;
        }
-      else if (cc != 1 || c != '\003' || current_thread == NULL)
+      else if (cc != 1 || c != '\003')
        {
          fprintf (stderr, "input_interrupt, count = %d c = %d ", cc, c);
          if (isprint (c))
@@ -1114,12 +1115,63 @@ prepare_resume_reply (char *buf, ptid_t ptid,
   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:
       {
        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
+         sprintf (buf, "T%02x", status->value.sig);
+
        buf += strlen (buf);
 
        saved_thread = current_thread;
@@ -1232,6 +1284,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;
@@ -1281,7 +1341,7 @@ decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr,
     }
 
   if (*to_p == NULL)
-    *to_p = xmalloc (*len_ptr);
+    *to_p = (unsigned char *) xmalloc (*len_ptr);
 
   hex2bin (&from[i++], *to_p, *len_ptr);
 }
@@ -1307,7 +1367,7 @@ decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr,
     }
 
   if (*to_p == NULL)
-    *to_p = xmalloc (*len_ptr);
+    *to_p = (unsigned char *) xmalloc (*len_ptr);
 
   if (remote_unescape_input ((const gdb_byte *) &from[i], packet_len - i,
                             *to_p, *len_ptr) != *len_ptr)
@@ -1434,7 +1494,7 @@ look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb)
       unsigned int mem_len;
 
       decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
-      mem_buf = xmalloc (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
@@ -1465,7 +1525,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;
@@ -1518,7 +1578,7 @@ relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc)
       if (own_buf[0] == 'm')
        {
          decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
-         mem_buf = xmalloc (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
@@ -1573,7 +1633,7 @@ void
 monitor_output (const char *msg)
 {
   int len = strlen (msg);
-  char *buf = xmalloc (len * 2 + 2);
+  char *buf = (char *) xmalloc (len * 2 + 2);
 
   buf[0] = 'O';
   bin2hex ((const gdb_byte *) msg, buf + 1, len);