gdb

[deliverable/binutils-gdb.git] / gdb / linux-nat.c

diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index 741d5f81d95bb83043cf1ade7d448c3e966ae3b6..641a619727cce8ba78d616294c9367f38751685d 100644 (file)
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -943,18 +943,36 @@ linux_child_insert_fork_catchpoint (int pid)
   return !linux_supports_tracefork (pid);
 }
 
+static int
+linux_child_remove_fork_catchpoint (int pid)
+{
+  return 0;
+}
+
 static int
 linux_child_insert_vfork_catchpoint (int pid)
 {
   return !linux_supports_tracefork (pid);
 }
 
+static int
+linux_child_remove_vfork_catchpoint (int pid)
+{
+  return 0;
+}
+
 static int
 linux_child_insert_exec_catchpoint (int pid)
 {
   return !linux_supports_tracefork (pid);
 }
 
+static int
+linux_child_remove_exec_catchpoint (int pid)
+{
+  return 0;
+}
+
 static int
 linux_child_set_syscall_catchpoint (int pid, int needed, int any_count,
                                    int table_size, int *table)
@@ -1041,6 +1059,26 @@ restore_child_signals_mask (sigset_t *prev_mask)
 {
   sigprocmask (SIG_SETMASK, prev_mask, NULL);
 }
+
+/* Mask of signals to pass directly to the inferior.  */
+static sigset_t pass_mask;
+
+/* Update signals to pass to the inferior.  */
+static void
+linux_nat_pass_signals (int numsigs, unsigned char *pass_signals)
+{
+  int signo;
+
+  sigemptyset (&pass_mask);
+
+  for (signo = 1; signo < NSIG; signo++)
+    {
+      int target_signo = target_signal_from_host (signo);
+      if (target_signo < numsigs && pass_signals[target_signo])
+        sigaddset (&pass_mask, signo);
+    }
+}
+
 \f
 
 /* Prototypes for local functions.  */
@@ -1438,7 +1476,10 @@ lin_lwp_attach_lwp (ptid_t ptid)
 
       status = linux_nat_post_attach_wait (ptid, 0, &cloned, &signalled);
       if (!WIFSTOPPED (status))
-       return -1;
+       {
+         restore_child_signals_mask (&prev_mask);
+         return -1;
+       }
 
       lp = add_lwp (ptid);
       lp->stopped = 1;
@@ -1506,6 +1547,9 @@ linux_nat_create_inferior (struct target_ops *ops,
     }
 #endif /* HAVE_PERSONALITY */
 
+  /* Make sure we report all signals during startup.  */
+  linux_nat_pass_signals (0, NULL);
+
   linux_ops->to_create_inferior (ops, exec_file, allargs, env, from_tty);
 
 #ifdef HAVE_PERSONALITY
@@ -1527,6 +1571,9 @@ linux_nat_attach (struct target_ops *ops, char *args, int from_tty)
   int status;
   ptid_t ptid;
 
+  /* Make sure we report all signals during attach.  */
+  linux_nat_pass_signals (0, NULL);
+
   linux_ops->to_attach (ops, args, from_tty);
 
   /* The ptrace base target adds the main thread with (pid,0,0)
@@ -1885,19 +1932,9 @@ linux_nat_resume (struct target_ops *ops,
 
   if (lp->status && WIFSTOPPED (lp->status))
     {
-      enum target_signal saved_signo;
-      struct inferior *inf;
-
-      inf = find_inferior_pid (ptid_get_pid (lp->ptid));
-      gdb_assert (inf);
-      saved_signo = target_signal_from_host (WSTOPSIG (lp->status));
-
-      /* Defer to common code if we're gaining control of the
-        inferior.  */
-      if (inf->control.stop_soon == NO_STOP_QUIETLY
-         && signal_stop_state (saved_signo) == 0
-         && signal_print_state (saved_signo) == 0
-         && signal_pass_state (saved_signo) == 1)
+      if (!lp->step
+         && WSTOPSIG (lp->status)
+         && sigismember (&pass_mask, WSTOPSIG (lp->status)))
        {
          if (debug_linux_nat)
            fprintf_unfiltered (gdb_stdlog,
@@ -1907,7 +1944,7 @@ linux_nat_resume (struct target_ops *ops,
          /* FIXME: What should we do if we are supposed to continue
             this thread with a signal?  */
          gdb_assert (signo == TARGET_SIGNAL_0);
-         signo = saved_signo;
+         signo = target_signal_from_host (WSTOPSIG (lp->status));
          lp->status = 0;
        }
     }
@@ -3553,20 +3590,11 @@ retry:
   if (WIFSTOPPED (status))
     {
       enum target_signal signo = target_signal_from_host (WSTOPSIG (status));
-      struct inferior *inf;
-
-      inf = find_inferior_pid (ptid_get_pid (lp->ptid));
-      gdb_assert (inf);
 
-      /* Defer to common code if we get a signal while
-        single-stepping, since that may need special care, e.g. to
-        skip the signal handler, or, if we're gaining control of the
-        inferior.  */
+      /* When using hardware single-step, we need to report every signal.
+        Otherwise, signals in pass_mask may be short-circuited.  */
       if (!lp->step
-         && inf->control.stop_soon == NO_STOP_QUIETLY
-         && signal_stop_state (signo) == 0
-         && signal_print_state (signo) == 0
-         && signal_pass_state (signo) == 1)
+         && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status)))
        {
          /* FIMXE: kettenis/2001-06-06: Should we resume all threads
             here?  It is not clear we should.  GDB may not expect
@@ -5207,8 +5235,11 @@ static void
 linux_target_install_ops (struct target_ops *t)
 {
   t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
+  t->to_remove_fork_catchpoint = linux_child_remove_fork_catchpoint;
   t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
+  t->to_remove_vfork_catchpoint = linux_child_remove_vfork_catchpoint;
   t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
+  t->to_remove_exec_catchpoint = linux_child_remove_exec_catchpoint;
   t->to_set_syscall_catchpoint = linux_child_set_syscall_catchpoint;
   t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
   t->to_post_startup_inferior = linux_child_post_startup_inferior;
@@ -5675,6 +5706,7 @@ linux_nat_add_target (struct target_ops *t)
   t->to_detach = linux_nat_detach;
   t->to_resume = linux_nat_resume;
   t->to_wait = linux_nat_wait;
+  t->to_pass_signals = linux_nat_pass_signals;
   t->to_xfer_partial = linux_nat_xfer_partial;
   t->to_kill = linux_nat_kill;
   t->to_mourn_inferior = linux_nat_mourn_inferior;