Merge GDB 7.5.1

gdb/darwin-nat.c

 /* Darwin support for GDB, the GNU debugger.
    Copyright (C) 2008-2012 Free Software Foundation, Inc.
 
    Contributed by AdaCore.
 
    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 3 of the License, or
@@ skipping 21 matching lines @@
 #include "gdbthread.h"
 #include "regcache.h"
 #include "event-top.h"
 #include "inf-loop.h"
 #include "gdb_stat.h"
 #include "exceptions.h"
 #include "inf-child.h"
 #include "value.h"
 #include "arch-utils.h"
 #include "bfd.h"
+#include "bfd/mach-o.h"
 
 #include <sys/ptrace.h>
 #include <sys/signal.h>
 #include <machine/setjmp.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <signal.h>
 #include <string.h>
 #include <ctype.h>
 #include <sys/param.h>
@@ skipping 31 matching lines @@
 
 
 #define PTRACE(CMD, PID, ADDR, SIG) \
  darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
 
 extern boolean_t exc_server (mach_msg_header_t *in, mach_msg_header_t *out);
 
 static void darwin_stop (ptid_t);
 
 static void darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
-                              enum target_signal signal);
+                              enum gdb_signal signal);
 static void darwin_resume (ptid_t ptid, int step,
-                           enum target_signal signal);
+                           enum gdb_signal signal);
 
 static ptid_t darwin_wait_to (struct target_ops *ops, ptid_t ptid,
                               struct target_waitstatus *status, int options);
 static ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);
 
 static void darwin_mourn_inferior (struct target_ops *ops);
 
 static void darwin_kill_inferior (struct target_ops *ops);
 
 static void darwin_ptrace_me (void);
@@ skipping 591 matching lines @@
       else if (nsignal)
         {
           /* Note: ptrace is allowed only if the process is stopped.
              Directly send the signal to the thread.  */
           res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
           inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
                           thread->gdb_port, nsignal, res);
           thread->signaled = 1;
         }
 
-      /* Set single step.  */
-      inferior_debug (4, _("darwin_set_sstep (thread=%x, enable=%d)\n"),
-                      thread->gdb_port, step);
-      darwin_set_sstep (thread->gdb_port, step);
-      thread->single_step = step;
+      /* Set or reset single step.  */
+      if (step != thread->single_step)
+        {
+          inferior_debug (4, _("darwin_set_sstep (thread=%x, enable=%d)\n"),
+                          thread->gdb_port, step);
+          darwin_set_sstep (thread->gdb_port, step);
+          thread->single_step = step;
+        }
 
       darwin_send_reply (inf, thread);
       thread->msg_state = DARWIN_RUNNING;
       break;
 
     case DARWIN_RUNNING:
       break;
 
     case DARWIN_STOPPED:
       kret = thread_resume (thread->gdb_port);
@@ skipping 54 matching lines @@
         break;
       case DARWIN_RUNNING:
         kret = thread_suspend (thread->gdb_port);
         MACH_CHECK_ERROR (kret);
         thread->msg_state = DARWIN_STOPPED;
         break;
       }
 }
 
 static void
-darwin_resume (ptid_t ptid, int step, enum target_signal signal)
+darwin_resume (ptid_t ptid, int step, enum gdb_signal signal)
 {
   struct target_waitstatus status;
   int pid;
 
   kern_return_t kret;
   int res;
   int nsignal;
   struct inferior *inf;
 
   inferior_debug
     (2, _("darwin_resume: pid=%d, tid=0x%x, step=%d, signal=%d\n"),
      ptid_get_pid (ptid), ptid_get_tid (ptid), step, signal);
 
-  if (signal == TARGET_SIGNAL_0)
+  if (signal == GDB_SIGNAL_0)
     nsignal = 0;
   else
-    nsignal = target_signal_to_host (signal);
+    nsignal = gdb_signal_to_host (signal);
 
   /* Don't try to single step all threads.  */
   if (step)
     ptid = inferior_ptid;
 
   /* minus_one_ptid is RESUME_ALL.  */
   if (ptid_equal (ptid, minus_one_ptid))
     {
       struct resume_inferior_threads_param param;
 
@@ skipping 28 matching lines @@
           darwin_resume_thread (inf, thread, step, nsignal);
         }
 
       /* Resume the task.  */
       darwin_resume_inferior (inf);
     }
 }
 
 static void
 darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
-                  enum target_signal signal)
+                  enum gdb_signal signal)
 {
   return darwin_resume (ptid, step, signal);
 }
 
 static ptid_t
 darwin_decode_message (mach_msg_header_t *hdr,
                        darwin_thread_t **pthread,
                        struct inferior **pinf,
                        struct target_waitstatus *status)
 {
@@ skipping 39 matching lines @@
         case EXC_ARITHMETIC:
           status->value.sig = TARGET_EXC_ARITHMETIC;
           break;
         case EXC_EMULATION:
           status->value.sig = TARGET_EXC_EMULATION;
           break;
         case EXC_SOFTWARE:
           if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
             {
               status->value.sig =
-                target_signal_from_host (thread->event.ex_data[1]);
+                gdb_signal_from_host (thread->event.ex_data[1]);
               inferior_debug (5, _("  (signal %d: %s)\n"),
                               thread->event.ex_data[1],
-                              target_signal_to_name (status->value.sig));
+                              gdb_signal_to_name (status->value.sig));
 
               /* If the thread is stopped because it has received a signal
                  that gdb has just sent, continue.  */
               if (thread->signaled)
                 {
                   thread->signaled = 0;
                   darwin_send_reply (inf, thread);
                   thread->msg_state = DARWIN_RUNNING;
                   status->kind = TARGET_WAITKIND_IGNORE;
                 }
             }
           else
             status->value.sig = TARGET_EXC_SOFTWARE;
           break;
         case EXC_BREAKPOINT:
           /* Many internal GDB routines expect breakpoints to be reported
-             as TARGET_SIGNAL_TRAP, and will report TARGET_EXC_BREAKPOINT
+             as GDB_SIGNAL_TRAP, and will report TARGET_EXC_BREAKPOINT
              as a spurious signal.  */
-          status->value.sig = TARGET_SIGNAL_TRAP;
+          status->value.sig = GDB_SIGNAL_TRAP;
           break;
         default:
-          status->value.sig = TARGET_SIGNAL_UNKNOWN;
+          status->value.sig = GDB_SIGNAL_UNKNOWN;
           break;
         }
 
       return ptid_build (inf->pid, 0, thread->gdb_port);
     }
 
   *pinf = NULL;
   *pthread = NULL;
 
   inf = darwin_find_inferior_by_notify (hdr->msgh_local_port);
@@ skipping 93 matching lines @@
     (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
      ptid_get_pid (ptid), ptid_get_tid (ptid));
 
   /* Handle fake stop events at first.  */
   if (darwin_inf_fake_stop != NULL)
     {
       inf = darwin_inf_fake_stop;
       darwin_inf_fake_stop = NULL;
 
       status->kind = TARGET_WAITKIND_STOPPED;
-      status->value.sig = TARGET_SIGNAL_TRAP;
+      status->value.sig = GDB_SIGNAL_TRAP;
       thread = VEC_index (darwin_thread_t, inf->private->threads, 0);
       thread->msg_state = DARWIN_STOPPED;
       return ptid_build (inf->pid, 0, thread->gdb_port);
     }
 
   do
     {
       /* set_sigint_trap (); */
 
       /* Wait for a message.  */
@@ skipping 190 matching lines @@
 
   res = kill (inf->pid, SIGSTOP);
   if (res != 0)
     warning (_("cannot kill: %s"), safe_strerror (errno));
 
   /* Wait until the process is really stopped.  */
   while (1)
     {
       ptid = darwin_wait (inferior_ptid, &wstatus);
       if (wstatus.kind == TARGET_WAITKIND_STOPPED
-          && wstatus.value.sig == TARGET_SIGNAL_STOP)
+          && wstatus.value.sig == GDB_SIGNAL_STOP)
         break;
     }
 }
 
 static kern_return_t
 darwin_save_exception_ports (darwin_inferior *inf)
 {
   kern_return_t kret;
 
   inf->exception_info.count =
@@ skipping 32 matching lines @@
   ptid_t ptid;
   kern_return_t kret;
   int status;
   int res;
 
   if (ptid_equal (inferior_ptid, null_ptid))
     return;
 
   gdb_assert (inf != NULL);
 
-  if (!inf->private->no_ptrace)
+  kret = darwin_restore_exception_ports (inf->private);
+  MACH_CHECK_ERROR (kret);
+
+  darwin_reply_to_all_pending_messages (inf);
+
+  res = kill (inf->pid, 9);
+
+  if (res == 0)
     {
-      darwin_stop_inferior (inf);
-
-      res = PTRACE (PT_KILL, inf->pid, 0, 0);
-      if (res != 0)
-        warning (_("Failed to kill inferior: ptrace returned %d "
-                   "[%s] (pid=%d)"),
-                 res, safe_strerror (errno), inf->pid);
-
-      darwin_reply_to_all_pending_messages (inf);
-
       darwin_resume_inferior (inf);
-
+          
       ptid = darwin_wait (inferior_ptid, &wstatus);
     }
-  else
-    {
-      kret = darwin_restore_exception_ports (inf->private);
-      MACH_CHECK_ERROR (kret);
-
-      darwin_reply_to_all_pending_messages (inf);
-
-      darwin_resume_inferior (inf);
-
-      res = kill (inf->pid, 9);
-
-      ptid = darwin_wait (inferior_ptid, &wstatus);
-    }
+  else if (errno != ESRCH)
+    warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
+             inf->pid, safe_strerror (errno));
 
   target_mourn_inferior ();
 }
 
 static void
 darwin_attach_pid (struct inferior *inf)
 {
   kern_return_t kret;
   mach_port_t prev_port;
   int traps_expected;
@@ skipping 651 matching lines @@
   vm_deallocate (gdb_task, (vm_address_t) names,
                  names_count * sizeof (mach_port_t));
 
   if (res)
     return ptid_build (ptid_get_pid (inferior_ptid), 0, res);
   else
     return null_ptid;
 }
 
 static int