* gdbarch.sh (make_corefile_notes): New architecture callback.

[deliverable/binutils-gdb.git] / gdb / inf-ttrace.c

diff --git a/gdb/inf-ttrace.c b/gdb/inf-ttrace.c
index 7e3e79ac75db8c5c18b9526b89c3d4830ff8073e..e82309d672fbd07ed7ea1846e5b12b689b8aba6f 100644 (file)
--- a/gdb/inf-ttrace.c
+++ b/gdb/inf-ttrace.c
@@ -1,12 +1,12 @@
 /* Low-level child interface to ttrace.
 
 /* Low-level child interface to ttrace.
 

-   Copyright 2004 Free Software Foundation, Inc.
+   Copyright (C) 2004-2012 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -15,9 +15,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License

-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include "defs.h"
 
 
 #include "defs.h"
 


@@ -29,19 +27,18 @@
 #include "gdbcore.h"
 #include "gdbthread.h"
 #include "inferior.h"
 #include "gdbcore.h"
 #include "gdbthread.h"
 #include "inferior.h"

-#include "observer.h"
+#include "terminal.h"

 #include "target.h"
 
 #include "gdb_assert.h"
 #include "gdb_string.h"
 #include <sys/mman.h>
 #include <sys/ttrace.h>
 #include "target.h"
 
 #include "gdb_assert.h"
 #include "gdb_string.h"
 #include <sys/mman.h>
 #include <sys/ttrace.h>

+#include <signal.h>

 
 #include "inf-child.h"
 #include "inf-ttrace.h"
 
 
 #include "inf-child.h"
 #include "inf-ttrace.h"
 

-/* HACK: Save the ttrace ops returned by inf_ttrace_target.  */
-static struct target_ops *ttrace_ops_hack;

 \f
 
 /* HP-UX uses a threading model where each user-space thread
 \f
 
 /* HP-UX uses a threading model where each user-space thread


@@ -79,6 +76,11 @@ struct inf_ttrace_page_dict
   int count;                   /* Number of pages in this dictionary.  */
 } inf_ttrace_page_dict;
 
   int count;                   /* Number of pages in this dictionary.  */
 } inf_ttrace_page_dict;
 

+struct inf_ttrace_private_thread_info
+{
+  int dying;
+};
+

 /* Number of lwps that are currently in a system call.  */
 static int inf_ttrace_num_lwps_in_syscall;
 
 /* Number of lwps that are currently in a system call.  */
 static int inf_ttrace_num_lwps_in_syscall;
 


@@ -311,7 +313,8 @@ inf_ttrace_disable_page_protections (pid_t pid)
    type TYPE.  */
 
 static int
    type TYPE.  */
 
 static int

-inf_ttrace_insert_watchpoint (CORE_ADDR addr, int len, int type)
+inf_ttrace_insert_watchpoint (CORE_ADDR addr, int len, int type,
+                             struct expression *cond)

 {
   const int pagesize = inf_ttrace_page_dict.pagesize;
   pid_t pid = ptid_get_pid (inferior_ptid);
 {
   const int pagesize = inf_ttrace_page_dict.pagesize;
   pid_t pid = ptid_get_pid (inferior_ptid);


@@ -334,7 +337,8 @@ inf_ttrace_insert_watchpoint (CORE_ADDR addr, int len, int type)
    type TYPE.  */
 
 static int
    type TYPE.  */
 
 static int

-inf_ttrace_remove_watchpoint (CORE_ADDR addr, int len, int type)
+inf_ttrace_remove_watchpoint (CORE_ADDR addr, int len, int type,
+                             struct expression *cond)

 {
   const int pagesize = inf_ttrace_page_dict.pagesize;
   pid_t pid = ptid_get_pid (inferior_ptid);
 {
   const int pagesize = inf_ttrace_page_dict.pagesize;
   pid_t pid = ptid_get_pid (inferior_ptid);


@@ -360,7 +364,7 @@ inf_ttrace_can_use_hw_breakpoint (int type, int len, int ot)
 }
 
 static int
 }
 
 static int

-inf_ttrace_region_size_ok_for_hw_watchpoint (int len)
+inf_ttrace_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)

 {
   return 1;
 }
 {
   return 1;
 }


@@ -397,6 +401,147 @@ inf_ttrace_stopped_by_watchpoint (void)
 }
 \f
 
 }
 \f
 

+/* When tracking a vfork(2), we cannot detach from the parent until
+   after the child has called exec(3) or has exited.  If we are still
+   attached to the parent, this variable will be set to the process ID
+   of the parent.  Otherwise it will be set to zero.  */
+static pid_t inf_ttrace_vfork_ppid = -1;
+
+static int
+inf_ttrace_follow_fork (struct target_ops *ops, int follow_child)
+{
+  pid_t pid, fpid;
+  lwpid_t lwpid, flwpid;
+  ttstate_t tts;
+  struct thread_info *tp = inferior_thread ();
+
+  gdb_assert (tp->pending_follow.kind == TARGET_WAITKIND_FORKED
+             || tp->pending_follow.kind == TARGET_WAITKIND_VFORKED);
+
+  pid = ptid_get_pid (inferior_ptid);
+  lwpid = ptid_get_lwp (inferior_ptid);
+
+  /* Get all important details that core GDB doesn't (and shouldn't)
+     know about.  */
+  if (ttrace (TT_LWP_GET_STATE, pid, lwpid,
+             (uintptr_t)&tts, sizeof tts, 0) == -1)
+    perror_with_name (("ttrace"));
+
+  gdb_assert (tts.tts_event == TTEVT_FORK || tts.tts_event == TTEVT_VFORK);
+
+  if (tts.tts_u.tts_fork.tts_isparent)
+    {
+      pid = tts.tts_pid;
+      lwpid = tts.tts_lwpid;
+      fpid = tts.tts_u.tts_fork.tts_fpid;
+      flwpid = tts.tts_u.tts_fork.tts_flwpid;
+    }
+  else
+    {
+      pid = tts.tts_u.tts_fork.tts_fpid;
+      lwpid = tts.tts_u.tts_fork.tts_flwpid;
+      fpid = tts.tts_pid;
+      flwpid = tts.tts_lwpid;
+    }
+
+  if (follow_child)
+    {
+      struct inferior *inf;
+      struct inferior *parent_inf;
+
+      parent_inf = find_inferior_pid (pid);
+
+      inferior_ptid = ptid_build (fpid, flwpid, 0);
+      inf = add_inferior (fpid);
+      inf->attach_flag = parent_inf->attach_flag;
+      inf->pspace = parent_inf->pspace;
+      inf->aspace = parent_inf->aspace;
+      copy_terminal_info (inf, parent_inf);
+      detach_breakpoints (pid);
+
+      target_terminal_ours ();
+      fprintf_unfiltered (gdb_stdlog,
+                         _("Attaching after fork to child process %ld.\n"),
+                         (long)fpid);
+    }
+  else
+    {
+      inferior_ptid = ptid_build (pid, lwpid, 0);
+      detach_breakpoints (fpid);
+
+      target_terminal_ours ();
+      fprintf_unfiltered (gdb_stdlog,
+                         _("Detaching after fork from child process %ld.\n"),
+                         (long)fpid);
+    }
+
+  if (tts.tts_event == TTEVT_VFORK)
+    {
+      gdb_assert (!tts.tts_u.tts_fork.tts_isparent);
+
+      if (follow_child)
+       {
+         /* We can't detach from the parent yet.  */
+         inf_ttrace_vfork_ppid = pid;
+
+         reattach_breakpoints (fpid);
+       }
+      else
+       {
+         if (ttrace (TT_PROC_DETACH, fpid, 0, 0, 0, 0) == -1)
+           perror_with_name (("ttrace"));
+
+         /* Wait till we get the TTEVT_VFORK event in the parent.
+            This indicates that the child has called exec(3) or has
+            exited and that the parent is ready to be traced again.  */
+         if (ttrace_wait (pid, lwpid, TTRACE_WAITOK, &tts, sizeof tts) == -1)
+           perror_with_name (("ttrace_wait"));
+         gdb_assert (tts.tts_event == TTEVT_VFORK);
+         gdb_assert (tts.tts_u.tts_fork.tts_isparent);
+
+         reattach_breakpoints (pid);
+       }
+    }
+  else
+    {
+      gdb_assert (tts.tts_u.tts_fork.tts_isparent);
+
+      if (follow_child)
+       {
+         if (ttrace (TT_PROC_DETACH, pid, 0, 0, 0, 0) == -1)
+           perror_with_name (("ttrace"));
+       }
+      else
+       {
+         if (ttrace (TT_PROC_DETACH, fpid, 0, 0, 0, 0) == -1)
+           perror_with_name (("ttrace"));
+       }
+    }
+
+  if (follow_child)
+    {
+      struct thread_info *ti;
+
+      /* The child will start out single-threaded.  */
+      inf_ttrace_num_lwps = 1;
+      inf_ttrace_num_lwps_in_syscall = 0;
+
+      /* Delete parent.  */
+      delete_thread_silent (ptid_build (pid, lwpid, 0));
+      detach_inferior (pid);
+
+      /* Add child thread.  inferior_ptid was already set above.  */
+      ti = add_thread_silent (inferior_ptid);
+      ti->private =
+       xmalloc (sizeof (struct inf_ttrace_private_thread_info));
+      memset (ti->private, 0,
+             sizeof (struct inf_ttrace_private_thread_info));
+    }
+
+  return 0;
+}
+\f
+

 /* File descriptors for pipes used as semaphores during initial
    startup of an inferior.  */
 static int inf_ttrace_pfd1[2];
 /* File descriptors for pipes used as semaphores during initial
    startup of an inferior.  */
 static int inf_ttrace_pfd1[2];


@@ -451,7 +596,7 @@ inf_ttrace_me (void)
 /* Start tracing PID.  */
 
 static void
 /* Start tracing PID.  */
 
 static void

-inf_ttrace_him (int pid)
+inf_ttrace_him (struct target_ops *ops, int pid)

 {
   struct cleanup *old_chain = make_cleanup (do_cleanup_pfds, 0);
   ttevent_t tte;
 {
   struct cleanup *old_chain = make_cleanup (do_cleanup_pfds, 0);
   ttevent_t tte;


@@ -463,12 +608,12 @@ inf_ttrace_him (int pid)
 
   /* Set the initial event mask.  */
   memset (&tte, 0, sizeof (tte));
 
   /* Set the initial event mask.  */
   memset (&tte, 0, sizeof (tte));

-  tte.tte_events |= TTEVT_EXEC | TTEVT_EXIT;
+  tte.tte_events |= TTEVT_EXEC | TTEVT_EXIT | TTEVT_FORK | TTEVT_VFORK;

   tte.tte_events |= TTEVT_LWP_CREATE | TTEVT_LWP_EXIT | TTEVT_LWP_TERMINATE;
 #ifdef TTEVT_BPT_SSTEP
   tte.tte_events |= TTEVT_BPT_SSTEP;
 #endif
   tte.tte_events |= TTEVT_LWP_CREATE | TTEVT_LWP_EXIT | TTEVT_LWP_TERMINATE;
 #ifdef TTEVT_BPT_SSTEP
   tte.tte_events |= TTEVT_BPT_SSTEP;
 #endif

-  tte.tte_opts = TTEO_NOSTRCCHLD;
+  tte.tte_opts |= TTEO_PROC_INHERIT;

   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
              (uintptr_t)&tte, sizeof tte, 0) == -1)
     perror_with_name (("ttrace"));
   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
              (uintptr_t)&tte, sizeof tte, 0) == -1)
     perror_with_name (("ttrace"));


@@ -479,14 +624,7 @@ inf_ttrace_him (int pid)
 
   do_cleanups (old_chain);
 
 
   do_cleanups (old_chain);
 

-  push_target (ttrace_ops_hack);
-
-  /* On some targets, there must be some explicit synchronization
-     between the parent and child processes after the debugger forks,
-     and before the child execs the debuggee program.  This call
-     basically gives permission for the child to exec.  */
-
-  target_acknowledge_created_inferior (pid);
+  push_target (ops);

 
   /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
      be 1 or 2 depending on whether we're starting without or with a
 
   /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
      be 1 or 2 depending on whether we're starting without or with a


@@ -499,40 +637,25 @@ inf_ttrace_him (int pid)
 }
 
 static void
 }
 
 static void

-inf_ttrace_create_inferior (char *exec_file, char *allargs, char **env,
-                           int from_tty)
+inf_ttrace_create_inferior (struct target_ops *ops, char *exec_file, 
+                           char *allargs, char **env, int from_tty)

 {
 {

+  int pid;
+

   gdb_assert (inf_ttrace_num_lwps == 0);
   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
   gdb_assert (inf_ttrace_page_dict.count == 0);
   gdb_assert (inf_ttrace_reenable_page_protections == 0);
   gdb_assert (inf_ttrace_num_lwps == 0);
   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
   gdb_assert (inf_ttrace_page_dict.count == 0);
   gdb_assert (inf_ttrace_reenable_page_protections == 0);

+  gdb_assert (inf_ttrace_vfork_ppid == -1);

 
 

-  fork_inferior (exec_file, allargs, env, inf_ttrace_me, inf_ttrace_him,
-                inf_ttrace_prepare, NULL);
-
-  /* We are at the first instruction we care about.  */
-  observer_notify_inferior_created (&current_target, from_tty);
-
-  /* Pedal to the metal...  */
-  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
-}
-
-static void
-inf_ttrace_kill_inferior (void)
-{
-  pid_t pid = ptid_get_pid (inferior_ptid);
-
-  if (pid == 0)
-    return;
+  pid = fork_inferior (exec_file, allargs, env, inf_ttrace_me, NULL,
+                      inf_ttrace_prepare, NULL, NULL);

 
 

-  if (ttrace (TT_PROC_EXIT, pid, 0, 0, 0, 0) == -1)
-    perror_with_name (("ttrace"));
-  /* ??? Is it necessary to call ttrace_wait() here?  */
-  target_mourn_inferior ();
+  inf_ttrace_him (ops, pid);

 }
 
 static void
 }
 
 static void

-inf_ttrace_mourn_inferior (void)
+inf_ttrace_mourn_inferior (struct target_ops *ops)

 {
   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
   int bucket;
 {
   const int num_buckets = ARRAY_SIZE (inf_ttrace_page_dict.buckets);
   int bucket;


@@ -555,32 +678,73 @@ inf_ttrace_mourn_inferior (void)
     }
   inf_ttrace_page_dict.count = 0;
 
     }
   inf_ttrace_page_dict.count = 0;
 

-  unpush_target (ttrace_ops_hack);
+  unpush_target (ops);

   generic_mourn_inferior ();
 }
 
   generic_mourn_inferior ();
 }
 

+/* Assuming we just attached the debugger to a new inferior, create
+   a new thread_info structure for each thread, and add it to our
+   list of threads.  */
+

 static void
 static void

-inf_ttrace_attach (char *args, int from_tty)
+inf_ttrace_create_threads_after_attach (int pid)
+{
+  int status;
+  ptid_t ptid;
+  ttstate_t tts;
+  struct thread_info *ti;
+
+  status = ttrace (TT_PROC_GET_FIRST_LWP_STATE, pid, 0,
+                  (uintptr_t) &tts, sizeof (ttstate_t), 0);
+  if (status < 0)
+    perror_with_name (_("TT_PROC_GET_FIRST_LWP_STATE ttrace call failed"));
+  gdb_assert (tts.tts_pid == pid);
+
+  /* Add the stopped thread.  */
+  ptid = ptid_build (pid, tts.tts_lwpid, 0);
+  ti = add_thread (ptid);
+  ti->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info));
+  inf_ttrace_num_lwps++;
+
+  /* We use the "first stopped thread" as the currently active thread.  */
+  inferior_ptid = ptid;
+
+  /* Iterative over all the remaining threads.  */
+
+  for (;;)
+    {
+      ptid_t ptid;
+
+      status = ttrace (TT_PROC_GET_NEXT_LWP_STATE, pid, 0,
+                      (uintptr_t) &tts, sizeof (ttstate_t), 0);
+      if (status < 0)
+       perror_with_name (_("TT_PROC_GET_NEXT_LWP_STATE ttrace call failed"));
+      if (status == 0)
+        break;  /* End of list.  */
+
+      ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
+      ti = add_thread (ptid);
+      ti->private = xzalloc (sizeof (struct inf_ttrace_private_thread_info));
+      inf_ttrace_num_lwps++;
+    }
+}
+
+static void
+inf_ttrace_attach (struct target_ops *ops, char *args, int from_tty)

 {
   char *exec_file;
   pid_t pid;
 {
   char *exec_file;
   pid_t pid;

-  char *dummy;

   ttevent_t tte;
   ttevent_t tte;

+  struct inferior *inf;

 
 

-  if (!args)
-    error_no_arg (_("process-id to attach"));
-
-  dummy = args;
-  pid = strtol (args, &dummy, 0);
-  if (pid == 0 && args == dummy)
-    error (_("Illegal process-id: %s."), args);
+  pid = parse_pid_to_attach (args);

 
   if (pid == getpid ())                /* Trying to masturbate?  */
     error (_("I refuse to debug myself!"));
 
   if (from_tty)
     {
 
   if (pid == getpid ())                /* Trying to masturbate?  */
     error (_("I refuse to debug myself!"));
 
   if (from_tty)
     {

-      exec_file = (char *) get_exec_file (0);
+      exec_file = get_exec_file (0);

 
       if (exec_file)
        printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
 
       if (exec_file)
        printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,


@@ -594,36 +758,37 @@ inf_ttrace_attach (char *args, int from_tty)
 
   gdb_assert (inf_ttrace_num_lwps == 0);
   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
 
   gdb_assert (inf_ttrace_num_lwps == 0);
   gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);

+  gdb_assert (inf_ttrace_vfork_ppid == -1);

 
   if (ttrace (TT_PROC_ATTACH, pid, 0, TT_KILL_ON_EXIT, TT_VERSION, 0) == -1)
     perror_with_name (("ttrace"));
 
   if (ttrace (TT_PROC_ATTACH, pid, 0, TT_KILL_ON_EXIT, TT_VERSION, 0) == -1)
     perror_with_name (("ttrace"));

-  attach_flag = 1;
+
+  inf = current_inferior ();
+  inferior_appeared (inf, pid);
+  inf->attach_flag = 1;

 
   /* Set the initial event mask.  */
   memset (&tte, 0, sizeof (tte));
 
   /* Set the initial event mask.  */
   memset (&tte, 0, sizeof (tte));

-  tte.tte_events |= TTEVT_EXEC | TTEVT_EXIT;
+  tte.tte_events |= TTEVT_EXEC | TTEVT_EXIT | TTEVT_FORK | TTEVT_VFORK;

   tte.tte_events |= TTEVT_LWP_CREATE | TTEVT_LWP_EXIT | TTEVT_LWP_TERMINATE;
 #ifdef TTEVT_BPT_SSTEP
   tte.tte_events |= TTEVT_BPT_SSTEP;
 #endif
   tte.tte_events |= TTEVT_LWP_CREATE | TTEVT_LWP_EXIT | TTEVT_LWP_TERMINATE;
 #ifdef TTEVT_BPT_SSTEP
   tte.tte_events |= TTEVT_BPT_SSTEP;
 #endif

-  tte.tte_opts = TTEO_NOSTRCCHLD;
+  tte.tte_opts |= TTEO_PROC_INHERIT;

   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
              (uintptr_t)&tte, sizeof tte, 0) == -1)
     perror_with_name (("ttrace"));
 
   if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
              (uintptr_t)&tte, sizeof tte, 0) == -1)
     perror_with_name (("ttrace"));
 

-  inferior_ptid = pid_to_ptid (pid);
-  push_target (ttrace_ops_hack);
+  push_target (ops);

 
 

-  /* Do this first, before anything has had a chance to query the
-     inferior's symbol table or similar.  */
-  observer_notify_inferior_created (&current_target, from_tty);
+  inf_ttrace_create_threads_after_attach (pid);

 }
 
 static void
 }
 
 static void

-inf_ttrace_detach (char *args, int from_tty)
+inf_ttrace_detach (struct target_ops *ops, char *args, int from_tty)

 {
 {

-  int sig = 0;

   pid_t pid = ptid_get_pid (inferior_ptid);
   pid_t pid = ptid_get_pid (inferior_ptid);

+  int sig = 0;

 
   if (from_tty)
     {
 
   if (from_tty)
     {


@@ -642,76 +807,165 @@ inf_ttrace_detach (char *args, int from_tty)
   if (ttrace (TT_PROC_DETACH, pid, 0, 0, sig, 0) == -1)
     perror_with_name (("ttrace"));
 
   if (ttrace (TT_PROC_DETACH, pid, 0, 0, sig, 0) == -1)
     perror_with_name (("ttrace"));
 

+  if (inf_ttrace_vfork_ppid != -1)
+    {
+      if (ttrace (TT_PROC_DETACH, inf_ttrace_vfork_ppid, 0, 0, 0, 0) == -1)
+       perror_with_name (("ttrace"));
+      inf_ttrace_vfork_ppid = -1;
+    }
+

   inf_ttrace_num_lwps = 0;
   inf_ttrace_num_lwps_in_syscall = 0;
 
   inf_ttrace_num_lwps = 0;
   inf_ttrace_num_lwps_in_syscall = 0;
 

-  unpush_target (ttrace_ops_hack);

   inferior_ptid = null_ptid;
   inferior_ptid = null_ptid;

+  detach_inferior (pid);
+
+  unpush_target (ops);

 }
 
 }
 

-static int
-inf_ttrace_resume_callback (struct thread_info *info, void *arg)
+static void
+inf_ttrace_kill (struct target_ops *ops)

 {
 {

-  if (!ptid_equal (info->ptid, inferior_ptid))
+  pid_t pid = ptid_get_pid (inferior_ptid);
+
+  if (pid == 0)
+    return;
+
+  if (ttrace (TT_PROC_EXIT, pid, 0, 0, 0, 0) == -1)
+    perror_with_name (("ttrace"));
+  /* ??? Is it necessary to call ttrace_wait() here?  */
+
+  if (inf_ttrace_vfork_ppid != -1)

     {
     {

-      pid_t pid = ptid_get_pid (info->ptid);
-      lwpid_t lwpid = ptid_get_lwp (info->ptid);
+      if (ttrace (TT_PROC_DETACH, inf_ttrace_vfork_ppid, 0, 0, 0, 0) == -1)
+       perror_with_name (("ttrace"));
+      inf_ttrace_vfork_ppid = -1;
+    }
+
+  target_mourn_inferior ();
+}
+
+/* Check is a dying thread is dead by now, and delete it from GDBs
+   thread list if so.  */
+static int
+inf_ttrace_delete_dead_threads_callback (struct thread_info *info, void *arg)
+{
+  lwpid_t lwpid;
+  struct inf_ttrace_private_thread_info *p;
+
+  if (is_exited (info->ptid))
+    return 0;
+
+  lwpid = ptid_get_lwp (info->ptid);
+  p = (struct inf_ttrace_private_thread_info *) info->private;
+
+  /* Check if an lwp that was dying is still there or not.  */
+  if (p->dying && (kill (lwpid, 0) == -1))
+    /* It's gone now.  */
+    delete_thread (info->ptid);
+
+  return 0;
+}
+
+/* Resume the lwp pointed to by INFO, with REQUEST, and pass it signal
+   SIG.  */
+
+static void
+inf_ttrace_resume_lwp (struct thread_info *info, ttreq_t request, int sig)
+{
+  pid_t pid = ptid_get_pid (info->ptid);
+  lwpid_t lwpid = ptid_get_lwp (info->ptid);

 
 

-      if (ttrace (TT_LWP_CONTINUE, pid, lwpid, TT_NOPC, 0, 0) == -1)
+  if (ttrace (request, pid, lwpid, TT_NOPC, sig, 0) == -1)
+    {
+      struct inf_ttrace_private_thread_info *p
+       = (struct inf_ttrace_private_thread_info *) info->private;
+      if (p->dying && errno == EPROTO)
+       /* This is expected, it means the dying lwp is really gone
+          by now.  If ttrace had an event to inform the debugger
+          the lwp is really gone, this wouldn't be needed.  */
+       delete_thread (info->ptid);
+      else
+       /* This was really unexpected.  */

        perror_with_name (("ttrace"));
     }
        perror_with_name (("ttrace"));
     }

+}
+
+/* Callback for iterate_over_threads.  */
+
+static int
+inf_ttrace_resume_callback (struct thread_info *info, void *arg)
+{
+  if (!ptid_equal (info->ptid, inferior_ptid) && !is_exited (info->ptid))
+    inf_ttrace_resume_lwp (info, TT_LWP_CONTINUE, 0);

 
   return 0;
 }
 
 static void
 
   return 0;
 }
 
 static void

-inf_ttrace_resume (ptid_t ptid, int step, enum target_signal signal)
+inf_ttrace_resume (struct target_ops *ops,
+                  ptid_t ptid, int step, enum target_signal signal)

 {
 {

-  pid_t pid = ptid_get_pid (ptid);
-  lwpid_t lwpid = ptid_get_lwp (ptid);
+  int resume_all;

   ttreq_t request = step ? TT_LWP_SINGLE : TT_LWP_CONTINUE;
   int sig = target_signal_to_host (signal);
   ttreq_t request = step ? TT_LWP_SINGLE : TT_LWP_CONTINUE;
   int sig = target_signal_to_host (signal);

+  struct thread_info *info;

 
 

-  if (pid == -1)
-    {
-      pid = ptid_get_pid (inferior_ptid);
-      lwpid = ptid_get_lwp (inferior_ptid);
-    }
+  /* A specific PTID means `step only this process id'.  */
+  resume_all = (ptid_equal (ptid, minus_one_ptid));

 
 

-  if (ttrace (request, pid, lwpid, TT_NOPC, sig, 0) == -1)
-    perror_with_name (("ttrace"));
+  /* If resuming all threads, it's the current thread that should be
+     handled specially.  */
+  if (resume_all)
+    ptid = inferior_ptid;

 
 

-  if (ptid_equal (ptid, minus_one_ptid) && inf_ttrace_num_lwps > 0)
-    {
-      /* Let all the other threads run too.  */
-      iterate_over_threads (inf_ttrace_resume_callback, NULL);
-    }
+  info = find_thread_ptid (ptid);
+  inf_ttrace_resume_lwp (info, request, sig);
+
+  if (resume_all)
+    /* Let all the other threads run too.  */
+    iterate_over_threads (inf_ttrace_resume_callback, NULL);

 }
 
 static ptid_t
 }
 
 static ptid_t

-inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+inf_ttrace_wait (struct target_ops *ops,
+                ptid_t ptid, struct target_waitstatus *ourstatus, int options)

 {
   pid_t pid = ptid_get_pid (ptid);
   lwpid_t lwpid = ptid_get_lwp (ptid);
   ttstate_t tts;
 {
   pid_t pid = ptid_get_pid (ptid);
   lwpid_t lwpid = ptid_get_lwp (ptid);
   ttstate_t tts;

+  struct thread_info *ti;
+  ptid_t related_ptid;

 
   /* Until proven otherwise.  */
   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 
   if (pid == -1)
 
   /* Until proven otherwise.  */
   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 
   if (pid == -1)

-    pid = 0;
+    pid = lwpid = 0;

 
 

-  gdb_assert (lwpid == 0 || pid != 0);
+  gdb_assert (pid != 0 || lwpid == 0);

 
   do
     {
       set_sigint_trap ();
 
   do
     {
       set_sigint_trap ();

-      set_sigio_trap ();

 
       if (ttrace_wait (pid, lwpid, TTRACE_WAITOK, &tts, sizeof tts) == -1)
        perror_with_name (("ttrace_wait"));
 
 
       if (ttrace_wait (pid, lwpid, TTRACE_WAITOK, &tts, sizeof tts) == -1)
        perror_with_name (("ttrace_wait"));
 

-      clear_sigio_trap ();
+      if (tts.tts_event == TTEVT_VFORK && tts.tts_u.tts_fork.tts_isparent)
+       {
+         if (inf_ttrace_vfork_ppid != -1)
+           {
+             gdb_assert (inf_ttrace_vfork_ppid == tts.tts_pid);
+
+             if (ttrace (TT_PROC_DETACH, tts.tts_pid, 0, 0, 0, 0) == -1)
+               perror_with_name (("ttrace"));
+             inf_ttrace_vfork_ppid = -1;
+           }
+
+         tts.tts_event = TTEVT_NONE;
+       }
+

       clear_sigint_trap ();
     }
   while (tts.tts_event == TTEVT_NONE);
       clear_sigint_trap ();
     }
   while (tts.tts_event == TTEVT_NONE);


@@ -726,6 +980,30 @@ inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 
   ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
 
 
   ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
 

+  if (inf_ttrace_num_lwps == 0)
+    {
+      struct thread_info *ti;
+
+      inf_ttrace_num_lwps = 1;
+
+      /* This is the earliest we hear about the lwp member of
+        INFERIOR_PTID, after an attach or fork_inferior.  */
+      gdb_assert (ptid_get_lwp (inferior_ptid) == 0);
+
+      /* We haven't set the private member on the main thread yet.  Do
+        it now.  */
+      ti = find_thread_ptid (inferior_ptid);
+      gdb_assert (ti != NULL && ti->private == NULL);
+      ti->private =
+       xmalloc (sizeof (struct inf_ttrace_private_thread_info));
+      memset (ti->private, 0,
+             sizeof (struct inf_ttrace_private_thread_info));
+
+      /* Notify the core that this ptid changed.  This changes
+        inferior_ptid as well.  */
+      thread_change_ptid (inferior_ptid, ptid);
+    }
+

   switch (tts.tts_event)
     {
 #ifdef TTEVT_BPT_SSTEP
   switch (tts.tts_event)
     {
 #ifdef TTEVT_BPT_SSTEP


@@ -737,9 +1015,20 @@ inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 #endif
 
     case TTEVT_EXEC:
 #endif
 
     case TTEVT_EXEC:

-      /* Make it look like a breakpoint.  */
-      ourstatus->kind = TARGET_WAITKIND_STOPPED;
-      ourstatus->value.sig = TARGET_SIGNAL_TRAP;
+      ourstatus->kind = TARGET_WAITKIND_EXECD;
+      ourstatus->value.execd_pathname =
+       xmalloc (tts.tts_u.tts_exec.tts_pathlen + 1);
+      if (ttrace (TT_PROC_GET_PATHNAME, tts.tts_pid, 0,
+                 (uintptr_t)ourstatus->value.execd_pathname,
+                 tts.tts_u.tts_exec.tts_pathlen, 0) == -1)
+       perror_with_name (("ttrace"));
+      ourstatus->value.execd_pathname[tts.tts_u.tts_exec.tts_pathlen] = 0;
+
+      /* At this point, all inserted breakpoints are gone.  Doing this
+        as soon as we detect an exec prevents the badness of deleting
+        a breakpoint writing the current "shadow contents" to lift
+        the bp.  That shadow is NOT valid after an exec.  */
+      mark_breakpoints_out ();

       break;
 
     case TTEVT_EXIT:
       break;
 
     case TTEVT_EXIT:


@@ -747,38 +1036,92 @@ inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
       inf_ttrace_num_lwps = 0;
       break;
 
       inf_ttrace_num_lwps = 0;
       break;
 

+    case TTEVT_FORK:
+      related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
+                                tts.tts_u.tts_fork.tts_flwpid, 0);
+
+      ourstatus->kind = TARGET_WAITKIND_FORKED;
+      ourstatus->value.related_pid = related_ptid;
+
+      /* Make sure the other end of the fork is stopped too.  */
+      if (ttrace_wait (tts.tts_u.tts_fork.tts_fpid,
+                      tts.tts_u.tts_fork.tts_flwpid,
+                      TTRACE_WAITOK, &tts, sizeof tts) == -1)
+       perror_with_name (("ttrace_wait"));
+
+      gdb_assert (tts.tts_event == TTEVT_FORK);
+      if (tts.tts_u.tts_fork.tts_isparent)
+       {
+         related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
+                                    tts.tts_u.tts_fork.tts_flwpid, 0);
+         ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
+         ourstatus->value.related_pid = related_ptid;
+       }
+      break;
+
+    case TTEVT_VFORK:
+      gdb_assert (!tts.tts_u.tts_fork.tts_isparent);
+
+      related_ptid = ptid_build (tts.tts_u.tts_fork.tts_fpid,
+                                tts.tts_u.tts_fork.tts_flwpid, 0);
+
+      ourstatus->kind = TARGET_WAITKIND_VFORKED;
+      ourstatus->value.related_pid = related_ptid;
+
+      /* HACK: To avoid touching the parent during the vfork, switch
+        away from it.  */
+      inferior_ptid = ptid;
+      break;
+

     case TTEVT_LWP_CREATE:
       lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
       ptid = ptid_build (tts.tts_pid, lwpid, 0);
     case TTEVT_LWP_CREATE:
       lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
       ptid = ptid_build (tts.tts_pid, lwpid, 0);

-      if (inf_ttrace_num_lwps == 0)
-       {
-         /* Now that we're going to be multi-threaded, add the
-            origional thread to the list first.  */
-         add_thread (ptid_build (tts.tts_pid, tts.tts_lwpid, 0));
-         inf_ttrace_num_lwps++;
-       }
-      printf_filtered (_("[New %s]\n"), target_pid_to_str (ptid));
-      add_thread (ptid);
+      ti = add_thread (ptid);
+      ti->private =
+       xmalloc (sizeof (struct inf_ttrace_private_thread_info));
+      memset (ti->private, 0,
+             sizeof (struct inf_ttrace_private_thread_info));

       inf_ttrace_num_lwps++;
       ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
       inf_ttrace_num_lwps++;
       ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);

-      break;
+      /* Let the lwp_create-caller thread continue.  */
+      ttrace (TT_LWP_CONTINUE, ptid_get_pid (ptid),
+              ptid_get_lwp (ptid), TT_NOPC, 0, 0);
+      /* Return without stopping the whole process.  */
+      ourstatus->kind = TARGET_WAITKIND_IGNORE;
+      return ptid;

 
     case TTEVT_LWP_EXIT:
 
     case TTEVT_LWP_EXIT:

-      printf_filtered(_("[%s exited]\n"), target_pid_to_str (ptid));
-      delete_thread (ptid);
+      if (print_thread_events)
+       printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid));
+      ti = find_thread_ptid (ptid);
+      gdb_assert (ti != NULL);
+      ((struct inf_ttrace_private_thread_info *)ti->private)->dying = 1;

       inf_ttrace_num_lwps--;
       inf_ttrace_num_lwps--;

-      /* If we don't return -1 here, core GDB will re-add the thread.  */
-      ptid = minus_one_ptid;
-      break;
+      /* Let the thread really exit.  */
+      ttrace (TT_LWP_CONTINUE, ptid_get_pid (ptid),
+              ptid_get_lwp (ptid), TT_NOPC, 0, 0);
+      /* Return without stopping the whole process.  */
+      ourstatus->kind = TARGET_WAITKIND_IGNORE;
+      return ptid;

 
     case TTEVT_LWP_TERMINATE:
       lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
       ptid = ptid_build (tts.tts_pid, lwpid, 0);
 
     case TTEVT_LWP_TERMINATE:
       lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
       ptid = ptid_build (tts.tts_pid, lwpid, 0);

-      printf_filtered(_("[%s has been terminated]\n"), target_pid_to_str (ptid));
-      delete_thread (ptid);
+      if (print_thread_events)
+       printf_unfiltered(_("[%s has been terminated]\n"),
+                         target_pid_to_str (ptid));
+      ti = find_thread_ptid (ptid);
+      gdb_assert (ti != NULL);
+      ((struct inf_ttrace_private_thread_info *)ti->private)->dying = 1;

       inf_ttrace_num_lwps--;
       inf_ttrace_num_lwps--;

+
+      /* Resume the lwp_terminate-caller thread.  */

       ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
       ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);

-      break;
+      ttrace (TT_LWP_CONTINUE, ptid_get_pid (ptid),
+              ptid_get_lwp (ptid), TT_NOPC, 0, 0);
+      /* Return without stopping the whole process.  */
+      ourstatus->kind = TARGET_WAITKIND_IGNORE;
+      return ptid;

 
     case TTEVT_SIGNAL:
       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 
     case TTEVT_SIGNAL:
       ourstatus->kind = TARGET_WAITKIND_STOPPED;


@@ -796,7 +1139,7 @@ inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
          inf_ttrace_disable_page_protections (tts.tts_pid);
        }
       ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
          inf_ttrace_disable_page_protections (tts.tts_pid);
        }
       ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;

-      ourstatus->value.syscall_id = tts.tts_scno;
+      ourstatus->value.syscall_number = tts.tts_scno;

       break;
 
     case TTEVT_SYSCALL_RETURN:
       break;
 
     case TTEVT_SYSCALL_RETURN:


@@ -811,7 +1154,7 @@ inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
          inf_ttrace_num_lwps_in_syscall--;
        }
       ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
          inf_ttrace_num_lwps_in_syscall--;
        }
       ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;

-      ourstatus->value.syscall_id = tts.tts_scno;
+      ourstatus->value.syscall_number = tts.tts_scno;

       break;
 
     default:
       break;
 
     default:


@@ -823,10 +1166,15 @@ inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
   if (ttrace (TT_PROC_STOP, tts.tts_pid, 0, 0, 0, 0) == -1)
     perror_with_name (("ttrace"));
 
   if (ttrace (TT_PROC_STOP, tts.tts_pid, 0, 0, 0, 0) == -1)
     perror_with_name (("ttrace"));
 

-  /* HACK: Twiddle INFERIOR_PTID such that the initial thread of a
-     process isn't recognized as a new thread.  */
-  if (ptid_get_lwp (inferior_ptid) == 0)
-    inferior_ptid = ptid;
+  /* Now that the whole process is stopped, check if any dying thread
+     is really dead by now.  If a dying thread is still alive, it will
+     be stopped too, and will still show up in `info threads', tagged
+     with "(Exiting)".  We could make `info threads' prune dead
+     threads instead via inf_ttrace_thread_alive, but doing this here
+     has the advantage that a frontend is notificed sooner of thread
+     exits.  Note that a dying lwp is still alive, it still has to be
+     resumed, like any other lwp.  */
+  iterate_over_threads (inf_ttrace_delete_dead_threads_callback, NULL);

 
   return ptid;
 }
 
   return ptid;
 }


@@ -863,8 +1211,9 @@ inf_ttrace_xfer_memory (CORE_ADDR addr, ULONGEST len,
 
 static LONGEST
 inf_ttrace_xfer_partial (struct target_ops *ops, enum target_object object,
 
 static LONGEST
 inf_ttrace_xfer_partial (struct target_ops *ops, enum target_object object,

-                        const char *annex, void *readbuf,
-                        const void *writebuf, ULONGEST offset, LONGEST len)
+                        const char *annex, gdb_byte *readbuf,
+                        const gdb_byte *writebuf,
+                        ULONGEST offset, LONGEST len)

 {
   switch (object)
     {
 {
   switch (object)
     {


@@ -890,61 +1239,85 @@ inf_ttrace_xfer_partial (struct target_ops *ops, enum target_object object,
 static void
 inf_ttrace_files_info (struct target_ops *ignore)
 {
 static void
 inf_ttrace_files_info (struct target_ops *ignore)
 {

-  printf_unfiltered (_("\tUsing the running image of %s %s.\n"),
-                    attach_flag ? "attached" : "child",
-                    target_pid_to_str (inferior_ptid));
+  struct inferior *inf = current_inferior ();
+  printf_filtered (_("\tUsing the running image of %s %s.\n"),
+                  inf->attach_flag ? "attached" : "child",
+                  target_pid_to_str (inferior_ptid));

 }
 
 static int
 }
 
 static int

-inf_ttrace_thread_alive (ptid_t ptid)
+inf_ttrace_thread_alive (struct target_ops *ops, ptid_t ptid)

 {
   return 1;
 }
 
 {
   return 1;
 }
 

+/* Return a string describing the state of the thread specified by
+   INFO.  */
+

 static char *
 static char *

-inf_ttrace_pid_to_str (ptid_t ptid)
+inf_ttrace_extra_thread_info (struct thread_info *info)

 {
 {

-  if (inf_ttrace_num_lwps > 0)
-    {
-      pid_t pid = ptid_get_pid (ptid);
-      lwpid_t lwpid = ptid_get_lwp (ptid);
-      static char buf[128];
-      int size;
-
-      size = snprintf (buf, sizeof buf, "process %ld, lwp %ld",
-                      (long)pid, (long)lwpid);
-      gdb_assert (size < sizeof buf);
-      return buf;
-    }
+  struct inf_ttrace_private_thread_info* private =
+    (struct inf_ttrace_private_thread_info *) info->private;

 
 

-  return normal_pid_to_str (ptid);
+  if (private != NULL && private->dying)
+    return "Exiting";
+
+  return NULL;
+}
+
+static char *
+inf_ttrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+  pid_t pid = ptid_get_pid (ptid);
+  lwpid_t lwpid = ptid_get_lwp (ptid);
+  static char buf[128];
+
+  if (lwpid == 0)
+    xsnprintf (buf, sizeof buf, "process %ld",
+              (long) pid);
+  else
+    xsnprintf (buf, sizeof buf, "process %ld, lwp %ld",
+              (long) pid, (long) lwpid);
+  return buf;

 }
 \f
 
 }
 \f
 

+/* Implement the get_ada_task_ptid target_ops method.  */
+
+static ptid_t
+inf_ttrace_get_ada_task_ptid (long lwp, long thread)
+{
+  return ptid_build (ptid_get_pid (inferior_ptid), lwp, 0);
+}
+
+\f

 struct target_ops *
 inf_ttrace_target (void)
 {
   struct target_ops *t = inf_child_target ();
 
 struct target_ops *
 inf_ttrace_target (void)
 {
   struct target_ops *t = inf_child_target ();
 

-  t->to_create_inferior = inf_ttrace_create_inferior;
-  t->to_kill = inf_ttrace_kill_inferior;
-  t->to_mourn_inferior = inf_ttrace_mourn_inferior;

   t->to_attach = inf_ttrace_attach;
   t->to_detach = inf_ttrace_detach;
   t->to_resume = inf_ttrace_resume;
   t->to_wait = inf_ttrace_wait;
   t->to_attach = inf_ttrace_attach;
   t->to_detach = inf_ttrace_detach;
   t->to_resume = inf_ttrace_resume;
   t->to_wait = inf_ttrace_wait;

-  t->to_xfer_partial = inf_ttrace_xfer_partial;

   t->to_files_info = inf_ttrace_files_info;
   t->to_files_info = inf_ttrace_files_info;

-  t->to_thread_alive = inf_ttrace_thread_alive;
-  t->to_pid_to_str = inf_ttrace_pid_to_str;

   t->to_can_use_hw_breakpoint = inf_ttrace_can_use_hw_breakpoint;
   t->to_can_use_hw_breakpoint = inf_ttrace_can_use_hw_breakpoint;

-  t->to_region_size_ok_for_hw_watchpoint =
-    inf_ttrace_region_size_ok_for_hw_watchpoint;

   t->to_insert_watchpoint = inf_ttrace_insert_watchpoint;
   t->to_remove_watchpoint = inf_ttrace_remove_watchpoint;
   t->to_stopped_by_watchpoint = inf_ttrace_stopped_by_watchpoint;
   t->to_insert_watchpoint = inf_ttrace_insert_watchpoint;
   t->to_remove_watchpoint = inf_ttrace_remove_watchpoint;
   t->to_stopped_by_watchpoint = inf_ttrace_stopped_by_watchpoint;

+  t->to_region_ok_for_hw_watchpoint =
+    inf_ttrace_region_ok_for_hw_watchpoint;
+  t->to_kill = inf_ttrace_kill;
+  t->to_create_inferior = inf_ttrace_create_inferior;
+  t->to_follow_fork = inf_ttrace_follow_fork;
+  t->to_mourn_inferior = inf_ttrace_mourn_inferior;
+  t->to_thread_alive = inf_ttrace_thread_alive;
+  t->to_extra_thread_info = inf_ttrace_extra_thread_info;
+  t->to_pid_to_str = inf_ttrace_pid_to_str;
+  t->to_xfer_partial = inf_ttrace_xfer_partial;
+  t->to_get_ada_task_ptid = inf_ttrace_get_ada_task_ptid;

 
 

-  ttrace_ops_hack = t;

   return t;
 }
 #endif
   return t;
 }
 #endif