gdb: fix python/lib/gdb/__init__.py formatting

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

diff --git a/gdb/darwin-nat.c b/gdb/darwin-nat.c
index f985c0ca8455828340dba6cd54c60626bacf3c18..a6790792fb651eb74a1a6e1ef15f5e5aaabddd6f 100644 (file)
--- a/gdb/darwin-nat.c
+++ b/gdb/darwin-nat.c
@@ -1,5 +1,5 @@
 /* Darwin support for GDB, the GNU debugger.
 /* Darwin support for GDB, the GNU debugger.

-   Copyright (C) 2008-2018 Free Software Foundation, Inc.
+   Copyright (C) 2008-2021 Free Software Foundation, Inc.

 
    Contributed by AdaCore.
 
 
    Contributed by AdaCore.
 


@@ -37,6 +37,7 @@
 #include "arch-utils.h"
 #include "bfd.h"
 #include "bfd/mach-o.h"
 #include "arch-utils.h"
 #include "bfd.h"
 #include "bfd/mach-o.h"

+#include "gdbarch.h"

 
 #include <copyfile.h>
 #include <sys/ptrace.h>
 
 #include <copyfile.h>
 #include <sys/ptrace.h>


@@ -63,10 +64,10 @@
 
 #include "darwin-nat.h"
 #include "filenames.h"
 
 #include "darwin-nat.h"
 #include "filenames.h"

-#include "common/filestuff.h"
-#include "common/gdb_unlinker.h"
-#include "common/pathstuff.h"
-#include "common/scoped_fd.h"
+#include "gdbsupport/filestuff.h"
+#include "gdbsupport/gdb_unlinker.h"
+#include "gdbsupport/pathstuff.h"
+#include "gdbsupport/scoped_fd.h"

 #include "nat/fork-inferior.h"
 
 /* Quick overview.
 #include "nat/fork-inferior.h"
 
 /* Quick overview.


@@ -88,12 +89,8 @@
 #define PTRACE(CMD, PID, ADDR, SIG) \
  darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
 
 #define PTRACE(CMD, PID, ADDR, SIG) \
  darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
 

-static ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);
-

 static void darwin_ptrace_me (void);
 
 static void darwin_ptrace_me (void);
 

-static void darwin_ptrace_him (int pid);
-

 static void darwin_encode_reply (mig_reply_error_t *reply,
                                 mach_msg_header_t *hdr, integer_t code);
 
 static void darwin_encode_reply (mig_reply_error_t *reply,
                                 mach_msg_header_t *hdr, integer_t code);
 


@@ -119,7 +116,7 @@ static vm_size_t mach_page_size;
 
 /* If Set, catch all mach exceptions (before they are converted to signals
    by the kernel).  */
 
 /* If Set, catch all mach exceptions (before they are converted to signals
    by the kernel).  */

-static int enable_mach_exceptions;
+static bool enable_mach_exceptions;

 
 /* Inferior that should report a fake stop event.  */
 static struct inferior *darwin_inf_fake_stop;
 
 /* Inferior that should report a fake stop event.  */
 static struct inferior *darwin_inf_fake_stop;


@@ -179,7 +176,7 @@ inferior_debug (int level, const char *fmt, ...)
 
 void
 mach_check_error (kern_return_t ret, const char *file,
 
 void
 mach_check_error (kern_return_t ret, const char *file,

-                  unsigned int line, const char *func)
+                 unsigned int line, const char *func)

 {
   if (ret == KERN_SUCCESS)
     return;
 {
   if (ret == KERN_SUCCESS)
     return;


@@ -244,8 +241,8 @@ darwin_ptrace (const char *name,
     ret = 0;
 
   inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
     ret = 0;
 
   inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),

-                  name, pid, (unsigned long) arg3, arg4, ret,
-                  (ret != 0) ? safe_strerror (errno) : _("no error"));
+                 name, pid, (unsigned long) arg3, arg4, ret,
+                 (ret != 0) ? safe_strerror (errno) : _("no error"));

   return ret;
 }
 
   return ret;
 }
 


@@ -257,8 +254,8 @@ cmp_thread_t (const void *l, const void *r)
   return (int)(tl - tr);
 }
 
   return (int)(tl - tr);
 }
 

-static void
-darwin_check_new_threads (struct inferior *inf)
+void
+darwin_nat_target::check_new_threads (inferior *inf)

 {
   kern_return_t kret;
   thread_array_t thread_list;
 {
   kern_return_t kret;
   thread_array_t thread_list;


@@ -354,7 +351,7 @@ darwin_check_new_threads (struct inferior *inf)
          pti->msg_state = DARWIN_RUNNING;
 
          /* Add the new thread.  */
          pti->msg_state = DARWIN_RUNNING;
 
          /* Add the new thread.  */

-         add_thread_with_info (ptid_t (inf->pid, 0, new_id), pti);
+         add_thread_with_info (this, ptid_t (inf->pid, 0, new_id), pti);

          new_thread_vec.push_back (pti);
          new_ix++;
          continue;
          new_thread_vec.push_back (pti);
          new_ix++;
          continue;


@@ -363,7 +360,7 @@ darwin_check_new_threads (struct inferior *inf)
        {
          /* A thread was removed.  */
          struct thread_info *thr
        {
          /* A thread was removed.  */
          struct thread_info *thr

-           = find_thread_ptid (ptid_t (inf->pid, 0, old_id));
+           = find_thread_ptid (this, ptid_t (inf->pid, 0, old_id));

          delete_thread (thr);
          kret = mach_port_deallocate (gdb_task, old_id);
          MACH_CHECK_ERROR (kret);
          delete_thread (thr);
          kret = mach_port_deallocate (gdb_task, old_id);
          MACH_CHECK_ERROR (kret);


@@ -381,32 +378,30 @@ darwin_check_new_threads (struct inferior *inf)
   MACH_CHECK_ERROR (kret);
 }
 
   MACH_CHECK_ERROR (kret);
 }
 

-static int
-find_inferior_task_it (struct inferior *inf, void *port_ptr)
-{
-  darwin_inferior *priv = get_darwin_inferior (inf);
-
-  return priv != nullptr && priv->task == *(task_t *)port_ptr;
-}
-
-static int
-find_inferior_pid_it (struct inferior *inf, void *pid_ptr)
-{
-  return inf->pid == *(int *)pid_ptr;
-}
-

 /* Return an inferior by task port.  */
 static struct inferior *
 darwin_find_inferior_by_task (task_t port)
 {
 /* Return an inferior by task port.  */
 static struct inferior *
 darwin_find_inferior_by_task (task_t port)
 {

-  return iterate_over_inferiors (&find_inferior_task_it, &port);
+  for (inferior *inf : all_inferiors ())
+    {
+      darwin_inferior *priv = get_darwin_inferior (inf);
+
+      if (priv != nullptr && priv->task == port)
+       return inf;
+    }
+  return nullptr;

 }
 
 /* Return an inferior by pid port.  */
 static struct inferior *
 darwin_find_inferior_by_pid (int pid)
 {
 }
 
 /* Return an inferior by pid port.  */
 static struct inferior *
 darwin_find_inferior_by_pid (int pid)
 {

-  return iterate_over_inferiors (&find_inferior_pid_it, &pid);
+  for (inferior *inf : all_inferiors ())
+    {
+      if (inf->pid == pid)
+       return inf;
+    }
+  return nullptr;

 }
 
 /* Return a thread by port.  */
 }
 
 /* Return a thread by port.  */


@@ -461,23 +456,6 @@ darwin_resume_inferior (struct inferior *inf)
     }
 }
 
     }
 }
 

-/* Iterator functions.  */
-
-static int
-darwin_suspend_inferior_it (struct inferior *inf, void *arg)
-{
-  darwin_suspend_inferior (inf);
-  darwin_check_new_threads (inf);
-  return 0;
-}
-
-static int
-darwin_resume_inferior_it (struct inferior *inf, void *arg)
-{
-  darwin_resume_inferior (inf);
-  return 0;
-}
-

 static void
 darwin_dump_message (mach_msg_header_t *hdr, int disp_body)
 {
 static void
 darwin_dump_message (mach_msg_header_t *hdr, int disp_body)
 {


@@ -610,10 +588,10 @@ darwin_check_message_ndr (NDR_record_t *ndr)
 
 /* Decode an exception message.  */
 
 
 /* Decode an exception message.  */
 

-static int
-darwin_decode_exception_message (mach_msg_header_t *hdr,
-                                struct inferior **pinf,
-                                darwin_thread_t **pthread)
+int
+darwin_nat_target::decode_exception_message (mach_msg_header_t *hdr,
+                                            inferior **pinf,
+                                            darwin_thread_t **pthread)

 {
   mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);
   mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);
 {
   mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);
   mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);


@@ -687,7 +665,6 @@ darwin_decode_exception_message (mach_msg_header_t *hdr,
       /* Not a known inferior.  This could happen if the child fork, as
         the created process will inherit its exception port.
         FIXME: should the exception port be restored ?  */
       /* Not a known inferior.  This could happen if the child fork, as
         the created process will inherit its exception port.
         FIXME: should the exception port be restored ?  */

-      kern_return_t kret;

       mig_reply_error_t reply;
 
       inferior_debug
       mig_reply_error_t reply;
 
       inferior_debug


@@ -712,7 +689,7 @@ darwin_decode_exception_message (mach_msg_header_t *hdr,
   /* Find thread by port.  */
   /* Check for new threads.  Do it early so that the port in the exception
      message can be deallocated.  */
   /* Find thread by port.  */
   /* Check for new threads.  Do it early so that the port in the exception
      message can be deallocated.  */

-  darwin_check_new_threads (inf);
+  check_new_threads (inf);

 
   /* Free the thread port (as gdb knows the thread, it has already has a right
      for it, so this just decrement a reference counter).  */
 
   /* Free the thread port (as gdb knows the thread, it has already has a right
      for it, so this just decrement a reference counter).  */


@@ -898,23 +875,6 @@ darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
       darwin_resume_thread (inf, thread, step, nsignal);
 }
 
       darwin_resume_thread (inf, thread, step, nsignal);
 }
 

-struct resume_inferior_threads_param
-{
-  int step;
-  int nsignal;
-};
-
-static int
-darwin_resume_inferior_threads_it (struct inferior *inf, void *param)
-{
-  int step = ((struct resume_inferior_threads_param *)param)->step;
-  int nsignal = ((struct resume_inferior_threads_param *)param)->nsignal;
-
-  darwin_resume_inferior_threads (inf, step, nsignal);
-
-  return 0;
-}
-

 /* Suspend all threads of INF.  */
 
 static void
 /* Suspend all threads of INF.  */
 
 static void


@@ -943,8 +903,6 @@ darwin_suspend_inferior_threads (struct inferior *inf)
 void
 darwin_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
 {
 void
 darwin_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
 {

-  struct target_waitstatus status;
-

   int nsignal;
 
   inferior_debug
   int nsignal;
 
   inferior_debug


@@ -963,49 +921,47 @@ darwin_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
   /* minus_one_ptid is RESUME_ALL.  */
   if (ptid == minus_one_ptid)
     {
   /* minus_one_ptid is RESUME_ALL.  */
   if (ptid == minus_one_ptid)
     {

-      struct resume_inferior_threads_param param;
-
-      param.nsignal = nsignal;
-      param.step = step;
-

       /* Resume threads.  */
       /* Resume threads.  */

-      iterate_over_inferiors (darwin_resume_inferior_threads_it, &param);
+      for (inferior *inf : all_inferiors ())
+       darwin_resume_inferior_threads (inf, step, nsignal);
+

       /* Resume tasks.  */
       /* Resume tasks.  */

-      iterate_over_inferiors (darwin_resume_inferior_it, NULL);
+      for (inferior *inf : all_inferiors ())
+       darwin_resume_inferior (inf);

     }
   else
     {
     }
   else
     {

-      struct inferior *inf = find_inferior_ptid (ptid);
+      inferior *inf = find_inferior_ptid (this, ptid);

       long tid = ptid.tid ();
 
       /* Stop the inferior (should be useless).  */
       darwin_suspend_inferior (inf);
 
       if (tid == 0)
       long tid = ptid.tid ();
 
       /* Stop the inferior (should be useless).  */
       darwin_suspend_inferior (inf);
 
       if (tid == 0)

-        darwin_resume_inferior_threads (inf, step, nsignal);
+       darwin_resume_inferior_threads (inf, step, nsignal);

       else
       else

-        {
-          darwin_thread_t *thread;
+       {
+         darwin_thread_t *thread;

 
 

-          /* Suspend threads of the task.  */
-          darwin_suspend_inferior_threads (inf);
+         /* Suspend threads of the task.  */
+         darwin_suspend_inferior_threads (inf);

 
 

-          /* Resume the selected thread.  */
-          thread = darwin_find_thread (inf, tid);
-          gdb_assert (thread);
-          darwin_resume_thread (inf, thread, step, nsignal);
-        }
+         /* Resume the selected thread.  */
+         thread = darwin_find_thread (inf, tid);
+         gdb_assert (thread);
+         darwin_resume_thread (inf, thread, step, nsignal);
+       }

 
       /* Resume the task.  */
       darwin_resume_inferior (inf);
     }
 }
 
 
       /* Resume the task.  */
       darwin_resume_inferior (inf);
     }
 }
 

-static ptid_t
-darwin_decode_message (mach_msg_header_t *hdr,
-                      darwin_thread_t **pthread,
-                      struct inferior **pinf,
-                      struct target_waitstatus *status)
+ptid_t
+darwin_nat_target::decode_message (mach_msg_header_t *hdr,
+                                  darwin_thread_t **pthread,
+                                  inferior **pinf,
+                                  target_waitstatus *status)

 {
   darwin_thread_t *thread;
   struct inferior *inf;
 {
   darwin_thread_t *thread;
   struct inferior *inf;


@@ -1016,7 +972,7 @@ darwin_decode_message (mach_msg_header_t *hdr,
       int res;
 
       /* Decode message.  */
       int res;
 
       /* Decode message.  */

-      res = darwin_decode_exception_message (hdr, &inf, &thread);
+      res = decode_exception_message (hdr, &inf, &thread);

 
       if (res < 0)
        {
 
       if (res < 0)
        {


@@ -1125,14 +1081,14 @@ darwin_decode_message (mach_msg_header_t *hdr,
 
          if (!priv->no_ptrace)
            {
 
          if (!priv->no_ptrace)
            {

-             pid_t res;
+             pid_t res_pid;

              int wstatus;
 
              int wstatus;
 

-             res = wait4 (inf->pid, &wstatus, 0, NULL);
-             if (res < 0 || res != inf->pid)
+             res_pid = wait4 (inf->pid, &wstatus, 0, NULL);
+             if (res_pid < 0 || res_pid != inf->pid)

                {
                  printf_unfiltered (_("wait4: res=%d: %s\n"),
                {
                  printf_unfiltered (_("wait4: res=%d: %s\n"),

-                                    res, safe_strerror (errno));
+                                    res_pid, safe_strerror (errno));

                  status->kind = TARGET_WAITKIND_IGNORE;
                  return minus_one_ptid;
                }
                  status->kind = TARGET_WAITKIND_IGNORE;
                  return minus_one_ptid;
                }


@@ -1148,13 +1104,12 @@ darwin_decode_message (mach_msg_header_t *hdr,
                }
 
              inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
                }
 
              inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),

-                             res, wstatus);
+                             res_pid, wstatus);

 
              /* Looks necessary on Leopard and harmless...  */
              wait4 (inf->pid, &wstatus, 0, NULL);
 
 
              /* Looks necessary on Leopard and harmless...  */
              wait4 (inf->pid, &wstatus, 0, NULL);
 

-             inferior_ptid = ptid_t (inf->pid, 0, 0);
-             return inferior_ptid;
+             return ptid_t (inf->pid);

            }
          else
            {
            }
          else
            {


@@ -1172,8 +1127,8 @@ darwin_decode_message (mach_msg_header_t *hdr,
   return minus_one_ptid;
 }
 
   return minus_one_ptid;
 }
 

-static int
-cancel_breakpoint (ptid_t ptid)
+int
+darwin_nat_target::cancel_breakpoint (ptid_t ptid)

 {
   /* Arrange for a breakpoint to be hit again later.  We will handle
      the current event, eventually we will resume this thread, and this
 {
   /* Arrange for a breakpoint to be hit again later.  We will handle
      the current event, eventually we will resume this thread, and this


@@ -1183,7 +1138,7 @@ cancel_breakpoint (ptid_t ptid)
      delete or disable the breakpoint, but the thread will have already
      tripped on it.  */
 
      delete or disable the breakpoint, but the thread will have already
      tripped on it.  */
 

-  struct regcache *regcache = get_thread_regcache (ptid);
+  struct regcache *regcache = get_thread_regcache (this, ptid);

   struct gdbarch *gdbarch = regcache->arch ();
   CORE_ADDR pc;
 
   struct gdbarch *gdbarch = regcache->arch ();
   CORE_ADDR pc;
 


@@ -1202,8 +1157,8 @@ cancel_breakpoint (ptid_t ptid)
   return 0;
 }
 
   return 0;
 }
 

-static ptid_t
-darwin_wait (ptid_t ptid, struct target_waitstatus *status)
+ptid_t
+darwin_nat_target::wait_1 (ptid_t ptid, struct target_waitstatus *status)

 {
   kern_return_t kret;
   union
 {
   kern_return_t kret;
   union


@@ -1214,7 +1169,6 @@ darwin_wait (ptid_t ptid, struct target_waitstatus *status)
   mach_msg_header_t *hdr = &msgin.hdr;
   ptid_t res;
   darwin_thread_t *thread;
   mach_msg_header_t *hdr = &msgin.hdr;
   ptid_t res;
   darwin_thread_t *thread;

-  struct inferior *inf;

 
   inferior_debug
     (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
 
   inferior_debug
     (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),


@@ -1223,7 +1177,7 @@ darwin_wait (ptid_t ptid, struct target_waitstatus *status)
   /* Handle fake stop events at first.  */
   if (darwin_inf_fake_stop != NULL)
     {
   /* Handle fake stop events at first.  */
   if (darwin_inf_fake_stop != NULL)
     {

-      inf = darwin_inf_fake_stop;
+      inferior *inf = darwin_inf_fake_stop;

       darwin_inf_fake_stop = NULL;
 
       darwin_inferior *priv = get_darwin_inferior (inf);
       darwin_inf_fake_stop = NULL;
 
       darwin_inferior *priv = get_darwin_inferior (inf);


@@ -1262,7 +1216,8 @@ darwin_wait (ptid_t ptid, struct target_waitstatus *status)
       if (darwin_debug_flag > 10)
        darwin_dump_message (hdr, darwin_debug_flag > 11);
 
       if (darwin_debug_flag > 10)
        darwin_dump_message (hdr, darwin_debug_flag > 11);
 

-      res = darwin_decode_message (hdr, &thread, &inf, status);
+      inferior *inf;
+      res = decode_message (hdr, &thread, &inf, status);

       if (res == minus_one_ptid)
        continue;
 
       if (res == minus_one_ptid)
        continue;
 


@@ -1273,7 +1228,11 @@ darwin_wait (ptid_t ptid, struct target_waitstatus *status)
   while (status->kind == TARGET_WAITKIND_IGNORE);
 
   /* Stop all tasks.  */
   while (status->kind == TARGET_WAITKIND_IGNORE);
 
   /* Stop all tasks.  */

-  iterate_over_inferiors (darwin_suspend_inferior_it, NULL);
+  for (inferior *inf : all_inferiors (this))
+    {
+      darwin_suspend_inferior (inf);
+      check_new_threads (inf);
+    }

 
   /* Read pending messages.  */
   while (1)
 
   /* Read pending messages.  */
   while (1)


@@ -1298,7 +1257,8 @@ darwin_wait (ptid_t ptid, struct target_waitstatus *status)
       if (darwin_debug_flag > 10)
        darwin_dump_message (hdr, darwin_debug_flag > 11);
 
       if (darwin_debug_flag > 10)
        darwin_dump_message (hdr, darwin_debug_flag > 11);
 

-      ptid2 = darwin_decode_message (hdr, &thread, &inf, &status2);
+      inferior *inf;
+      ptid2 = decode_message (hdr, &thread, &inf, &status2);

 
       if (inf != NULL && thread != NULL
          && thread->event.ex_type == EXC_BREAKPOINT)
 
       if (inf != NULL && thread != NULL
          && thread->event.ex_type == EXC_BREAKPOINT)


@@ -1323,9 +1283,9 @@ darwin_wait (ptid_t ptid, struct target_waitstatus *status)
 
 ptid_t
 darwin_nat_target::wait (ptid_t ptid, struct target_waitstatus *status,
 
 ptid_t
 darwin_nat_target::wait (ptid_t ptid, struct target_waitstatus *status,

-                        int options)
+                        target_wait_flags options)

 {
 {

-  return darwin_wait (ptid, status);
+  return wait_1 (ptid, status);

 }
 
 void
 }
 
 void


@@ -1415,8 +1375,8 @@ darwin_reply_to_all_pending_messages (struct inferior *inf)
     }
 }
 
     }
 }
 

-static void
-darwin_stop_inferior (struct inferior *inf)
+void
+darwin_nat_target::stop_inferior (inferior *inf)

 {
   struct target_waitstatus wstatus;
   ptid_t ptid;
 {
   struct target_waitstatus wstatus;
   ptid_t ptid;


@@ -1432,14 +1392,14 @@ darwin_stop_inferior (struct inferior *inf)
   if (priv->no_ptrace)
     return;
 
   if (priv->no_ptrace)
     return;
 

-  res = kill (inf->pid, SIGSTOP);
+  res = ::kill (inf->pid, SIGSTOP);

   if (res != 0)
     warning (_("cannot kill: %s"), safe_strerror (errno));
 
   /* Wait until the process is really stopped.  */
   while (1)
     {
   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);
+      ptid = wait_1 (ptid_t (inf->pid), &wstatus);

       if (wstatus.kind == TARGET_WAITKIND_STOPPED
          && wstatus.value.sig == GDB_SIGNAL_STOP)
        break;
       if (wstatus.kind == TARGET_WAITKIND_STOPPED
          && wstatus.value.sig == GDB_SIGNAL_STOP)
        break;


@@ -1470,10 +1430,10 @@ darwin_restore_exception_ports (darwin_inferior *inf)
   for (i = 0; i < inf->exception_info.count; i++)
     {
       kret = task_set_exception_ports
   for (i = 0; i < inf->exception_info.count; i++)
     {
       kret = task_set_exception_ports

-        (inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
+       (inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],

         inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
       if (kret != KERN_SUCCESS)
         inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
       if (kret != KERN_SUCCESS)

-        return kret;
+       return kret;

     }
 
   return KERN_SUCCESS;
     }
 
   return KERN_SUCCESS;


@@ -1546,32 +1506,31 @@ darwin_nat_target::kill ()
   if (res == 0)
     {
       /* On MacOS version Sierra, the darwin_restore_exception_ports call
   if (res == 0)
     {
       /* On MacOS version Sierra, the darwin_restore_exception_ports call

-         does not work as expected.
-         When the kill function is called, the SIGKILL signal is received
-         by gdb whereas it should have been received by the kernel since
-         the exception ports have been restored.
-         This behavior is not the expected one thus gdb does not reply to
-         the received SIGKILL message. This situation leads to a "busy"
-         resource from the kernel point of view and the inferior is never
-         released, causing it to remain as a zombie process, even after
+        does not work as expected.
+        When the kill function is called, the SIGKILL signal is received
+        by gdb whereas it should have been received by the kernel since
+        the exception ports have been restored.
+        This behavior is not the expected one thus gdb does not reply to
+        the received SIGKILL message. This situation leads to a "busy"
+        resource from the kernel point of view and the inferior is never
+        released, causing it to remain as a zombie process, even after

         GDB exits.
         GDB exits.

-         To work around this, we mark all the threads of the inferior as
-         signaled thus darwin_decode_message function knows that the kill
-         signal was sent by gdb and will take the appropriate action
-         (cancel signal and reply to the signal message).  */
-      darwin_inferior *priv = get_darwin_inferior (inf);
+        To work around this, we mark all the threads of the inferior as
+        signaled thus darwin_decode_message function knows that the kill
+        signal was sent by gdb and will take the appropriate action
+        (cancel signal and reply to the signal message).  */

       for (darwin_thread_t *thread : priv->threads)
       for (darwin_thread_t *thread : priv->threads)

-        thread->signaled = 1;
+       thread->signaled = 1;

 
       darwin_resume_inferior (inf);
 
 
       darwin_resume_inferior (inf);
 

-      ptid = darwin_wait (inferior_ptid, &wstatus);
+      ptid = wait_1 (ptid_t (inf->pid), &wstatus);

     }
   else if (errno != ESRCH)
     warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
             inf->pid, safe_strerror (errno));
 
     }
   else if (errno != ESRCH)
     warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
             inf->pid, safe_strerror (errno));
 

-  target_mourn_inferior (inferior_ptid);
+  target_mourn_inferior (ptid_t (inf->pid));

 }
 
 static void
 }
 
 static void


@@ -1611,7 +1570,7 @@ darwin_attach_pid (struct inferior *inf)
   darwin_inferior *priv = new darwin_inferior;
   inf->priv.reset (priv);
 
   darwin_inferior *priv = new darwin_inferior;
   inf->priv.reset (priv);
 

-  TRY
+  try

     {
       kret = task_for_pid (gdb_task, inf->pid, &priv->task);
       if (kret != KERN_SUCCESS)
     {
       kret = task_for_pid (gdb_task, inf->pid, &priv->task);
       if (kret != KERN_SUCCESS)


@@ -1688,18 +1647,17 @@ darwin_attach_pid (struct inferior *inf)
 
       darwin_setup_exceptions (inf);
     }
 
       darwin_setup_exceptions (inf);
     }

-  CATCH (ex, RETURN_MASK_ALL)
+  catch (const gdb_exception &ex)

     {
       exit_inferior (inf);
     {
       exit_inferior (inf);

-      inferior_ptid = null_ptid;
+      switch_to_no_thread ();

 
 

-      throw_exception (ex);
+      throw;

     }
     }

-  END_CATCH

 
   target_ops *darwin_ops = get_native_target ();
 
   target_ops *darwin_ops = get_native_target ();

-  if (!target_is_pushed (darwin_ops))
-    push_target (darwin_ops);
+  if (!inf->target_is_pushed (darwin_ops))
+    inf->push_target (darwin_ops);

 }
 
 /* Get the thread_info object corresponding to this darwin_thread_info.  */
 }
 
 /* Get the thread_info object corresponding to this darwin_thread_info.  */


@@ -1707,25 +1665,21 @@ darwin_attach_pid (struct inferior *inf)
 static struct thread_info *
 thread_info_from_private_thread_info (darwin_thread_info *pti)
 {
 static struct thread_info *
 thread_info_from_private_thread_info (darwin_thread_info *pti)
 {

-  struct thread_info *it;
-
-  ALL_THREADS (it)
+  for (struct thread_info *it : all_threads ())

     {
       darwin_thread_info *iter_pti = get_darwin_thread_info (it);
 
       if (iter_pti->gdb_port == pti->gdb_port)
     {
       darwin_thread_info *iter_pti = get_darwin_thread_info (it);
 
       if (iter_pti->gdb_port == pti->gdb_port)

-       break;
+       return it;

     }
 
     }
 

-  gdb_assert (it != NULL);
-
-  return it;
+  gdb_assert_not_reached ("did not find gdb thread for darwin thread");

 }
 
 }
 

-static void
-darwin_init_thread_list (struct inferior *inf)
+void
+darwin_nat_target::init_thread_list (inferior *inf)

 {
 {

-  darwin_check_new_threads (inf);
+  check_new_threads (inf);

 
   darwin_inferior *priv = get_darwin_inferior (inf);
 
 
   darwin_inferior *priv = get_darwin_inferior (inf);
 


@@ -1735,7 +1689,7 @@ darwin_init_thread_list (struct inferior *inf)
   struct thread_info *first_thread
     = thread_info_from_private_thread_info (first_pti);
 
   struct thread_info *first_thread
     = thread_info_from_private_thread_info (first_pti);
 

-  inferior_ptid = first_thread->ptid;
+  switch_to_thread (first_thread);

 }
 
 /* The child must synchronize with gdb: gdb must set the exception port
 }
 
 /* The child must synchronize with gdb: gdb must set the exception port


@@ -1789,21 +1743,21 @@ darwin_pre_ptrace (void)
   mark_fd_no_cloexec (ptrace_fds[1]);
 }
 
   mark_fd_no_cloexec (ptrace_fds[1]);
 }
 

-static void
-darwin_ptrace_him (int pid)
+void
+darwin_nat_target::ptrace_him (int pid)

 {
   struct inferior *inf = current_inferior ();
 
   darwin_attach_pid (inf);
 
   /* Let's the child run.  */
 {
   struct inferior *inf = current_inferior ();
 
   darwin_attach_pid (inf);
 
   /* Let's the child run.  */

-  close (ptrace_fds[0]);
-  close (ptrace_fds[1]);
+  ::close (ptrace_fds[0]);
+  ::close (ptrace_fds[1]);

 
   unmark_fd_no_cloexec (ptrace_fds[0]);
   unmark_fd_no_cloexec (ptrace_fds[1]);
 
 
   unmark_fd_no_cloexec (ptrace_fds[0]);
   unmark_fd_no_cloexec (ptrace_fds[1]);
 

-  darwin_init_thread_list (inf);
+  init_thread_list (inf);

 
   gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
 }
 
   gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
 }


@@ -1819,7 +1773,7 @@ darwin_execvp (const char *file, char * const argv[], char * const env[])
   if (res != 0)
     {
       fprintf_unfiltered
   if (res != 0)
     {
       fprintf_unfiltered

-        (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
+       (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");

       return;
     }
 
       return;
     }
 


@@ -1857,7 +1811,7 @@ may_have_sip ()
     {
       unsigned long ver = strtoul (str, NULL, 10);
       if (ver >= 16)
     {
       unsigned long ver = strtoul (str, NULL, 10);
       if (ver >= 16)

-        return true;
+       return true;

     }
   return false;
 }
     }
   return false;
 }


@@ -1953,11 +1907,11 @@ The error was: %s"),
   /* Maybe it was cached by some earlier gdb.  */
   if (stat (new_name.c_str (), &sb) != 0 || !S_ISREG (sb.st_mode))
     {
   /* Maybe it was cached by some earlier gdb.  */
   if (stat (new_name.c_str (), &sb) != 0 || !S_ISREG (sb.st_mode))
     {

-      TRY
+      try

        {
          copy_shell_to_cache (shell, new_name);
        }
        {
          copy_shell_to_cache (shell, new_name);
        }

-      CATCH (ex, RETURN_MASK_ERROR)
+      catch (const gdb_exception_error &ex)

        {
          warning (_("This version of macOS has System Integrity Protection.\n\
 Because `startup-with-shell' is enabled, gdb tried to work around SIP by\n\
        {
          warning (_("This version of macOS has System Integrity Protection.\n\
 Because `startup-with-shell' is enabled, gdb tried to work around SIP by\n\


@@ -1966,10 +1920,9 @@ caching a copy of your shell.  However, this failed:\n\
 If you correct the problem, gdb will automatically try again the next time\n\
 you \"run\".  To prevent these attempts, you can use:\n\
     set startup-with-shell off"),
 If you correct the problem, gdb will automatically try again the next time\n\
 you \"run\".  To prevent these attempts, you can use:\n\
     set startup-with-shell off"),

-                  ex.message);
+                  ex.what ());

          return false;
        }
          return false;
        }

-      END_CATCH

 
       printf_filtered (_("Note: this version of macOS has System Integrity Protection.\n\
 Because `startup-with-shell' is enabled, gdb has worked around this by\n\
 
       printf_filtered (_("Note: this version of macOS has System Integrity Protection.\n\
 Because `startup-with-shell' is enabled, gdb has worked around this by\n\


@@ -1992,7 +1945,8 @@ darwin_nat_target::create_inferior (const char *exec_file,
                                    const std::string &allargs,
                                    char **env, int from_tty)
 {
                                    const std::string &allargs,
                                    char **env, int from_tty)
 {

-  gdb::optional<scoped_restore_tmpl<int>> restore_startup_with_shell;
+  gdb::optional<scoped_restore_tmpl<bool>> restore_startup_with_shell;
+  darwin_nat_target *the_target = this;

 
   if (startup_with_shell && may_have_sip ())
     {
 
   if (startup_with_shell && may_have_sip ())
     {


@@ -2005,7 +1959,11 @@ darwin_nat_target::create_inferior (const char *exec_file,
 
   /* Do the hard work.  */
   fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
 
   /* Do the hard work.  */
   fork_inferior (exec_file, allargs, env, darwin_ptrace_me,

-                darwin_ptrace_him, darwin_pre_ptrace, copied_shell,
+                [the_target] (int pid)
+                  {
+                    the_target->ptrace_him (pid);
+                  },
+                darwin_pre_ptrace, copied_shell,

                 darwin_execvp);
 }
 \f
                 darwin_execvp);
 }
 \f


@@ -2052,23 +2010,20 @@ darwin_nat_target::attach (const char *args, int from_tty)
 
   if (from_tty)
     {
 
   if (from_tty)
     {

-      char *exec_file = get_exec_file (0);
+      const char *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,

-                          target_pid_to_str (ptid_t (pid)));
+                          target_pid_to_str (ptid_t (pid)).c_str ());

       else
        printf_unfiltered (_("Attaching to %s\n"),
       else
        printf_unfiltered (_("Attaching to %s\n"),

-                          target_pid_to_str (ptid_t (pid)));
-
-      gdb_flush (gdb_stdout);
+                          target_pid_to_str (ptid_t (pid)).c_str ());

     }
 
   if (pid == 0 || ::kill (pid, 0) < 0)
     error (_("Can't attach to process %d: %s (%d)"),
     }
 
   if (pid == 0 || ::kill (pid, 0) < 0)
     error (_("Can't attach to process %d: %s (%d)"),

-           pid, safe_strerror (errno), errno);
+          pid, safe_strerror (errno), errno);

 
 

-  inferior_ptid = ptid_t (pid);

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


@@ -2077,7 +2032,7 @@ darwin_nat_target::attach (const char *args, int from_tty)
 
   darwin_suspend_inferior (inf);
 
 
   darwin_suspend_inferior (inf);
 

-  darwin_init_thread_list (inf);
+  init_thread_list (inf);

 
   darwin_inferior *priv = get_darwin_inferior (inf);
 
 
   darwin_inferior *priv = get_darwin_inferior (inf);
 


@@ -2108,7 +2063,7 @@ darwin_nat_target::detach (inferior *inf, int from_tty)
 
   /* If ptrace() is in use, stop the process.  */
   if (!priv->no_ptrace)
 
   /* If ptrace() is in use, stop the process.  */
   if (!priv->no_ptrace)

-    darwin_stop_inferior (inf);
+    stop_inferior (inf);

 
   kret = darwin_restore_exception_ports (priv);
   MACH_CHECK_ERROR (kret);
 
   kret = darwin_restore_exception_ports (priv);
   MACH_CHECK_ERROR (kret);


@@ -2132,18 +2087,14 @@ darwin_nat_target::detach (inferior *inf, int from_tty)
   mourn_inferior ();
 }
 
   mourn_inferior ();
 }
 

-const char *
+std::string

 darwin_nat_target::pid_to_str (ptid_t ptid)
 {
 darwin_nat_target::pid_to_str (ptid_t ptid)
 {

-  static char buf[80];

   long tid = ptid.tid ();
 
   if (tid != 0)
   long tid = ptid.tid ();
 
   if (tid != 0)

-    {
-      snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
-               tid, ptid.pid ());
-      return buf;
-    }
+    return string_printf (_("Thread 0x%lx of process %u"),
+                         tid, ptid.pid ());

 
   return normal_pid_to_str (ptid);
 }
 
   return normal_pid_to_str (ptid);
 }


@@ -2158,7 +2109,7 @@ darwin_nat_target::thread_alive (ptid_t ptid)
    copy it to RDADDR in gdb's address space.
    If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
    to ADDR in inferior task's address space.
    copy it to RDADDR in gdb's address space.
    If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
    to ADDR in inferior task's address space.

-   Return 0 on failure; number of bytes read / writen otherwise.  */
+   Return 0 on failure; number of bytes read / written otherwise.  */

 
 static int
 darwin_read_write_inferior (task_t task, CORE_ADDR addr,
 
 static int
 darwin_read_write_inferior (task_t task, CORE_ADDR addr,


@@ -2374,10 +2325,10 @@ darwin_nat_target::xfer_partial (enum target_object object, const char *annex,
 #ifdef TASK_DYLD_INFO_COUNT
     case TARGET_OBJECT_DARWIN_DYLD_INFO:
       if (writebuf != NULL || readbuf == NULL)
 #ifdef TASK_DYLD_INFO_COUNT
     case TARGET_OBJECT_DARWIN_DYLD_INFO:
       if (writebuf != NULL || readbuf == NULL)

-        {
-          /* Support only read.  */
-          return TARGET_XFER_E_IO;
-        }
+       {
+         /* Support only read.  */
+         return TARGET_XFER_E_IO;
+       }

       return darwin_read_dyld_info (priv->task, offset, readbuf, len,
                                    xfered_len);
 #endif
       return darwin_read_dyld_info (priv->task, offset, readbuf, len,
                                    xfered_len);
 #endif


@@ -2481,10 +2432,10 @@ darwin_nat_target::get_ada_task_ptid (long lwp, long thread)
     }
 
   vm_deallocate (gdb_task, (vm_address_t) names,
     }
 
   vm_deallocate (gdb_task, (vm_address_t) names,

-                 names_count * sizeof (mach_port_t));
+                names_count * sizeof (mach_port_t));

 
   if (res)
 
   if (res)

-    return ptid_t (inferior_ptid.pid (), 0, res);
+    return ptid_t (current_inferior ()->pid, 0, res);

   else
     return null_ptid;
 }
   else
     return null_ptid;
 }


@@ -2495,6 +2446,7 @@ darwin_nat_target::supports_multi_process ()
   return true;
 }
 
   return true;
 }
 

+void _initialize_darwin_nat ();

 void
 _initialize_darwin_nat ()
 {
 void
 _initialize_darwin_nat ()
 {