[NFC] Darwin llgs support from Week of Code

This code represents the Week of Code work I did on bringing up
lldb-server LLGS support for Darwin.  It does not include the
Xcode project changes needed, as we don't want to throw that switch
until more support is implemented (i.e. this change is inert, no
build systems use it yet.  I've verified on Ubuntu 16.04, macOS
Xcode and macOS cmake builds).

This change does some minimal refactoring of code that is shared
with the Linux LLGS portion, moving it from NativeProcessLinux into
NativeProcessProtocol.  That code is also used by NativeProcessDarwin.

Current state on Darwin:
* Process launching is implemented.  (Attach is not).
  Launching on devices has not yet been tested (FBS/BKS might
  need a bit of work).
* Inferior waitpid monitoring and communication of exit status
  via MainLoop callback is implemented.
* Memory read/write, breakpoints, thread register context, etc.
  are not yet implemented.  This impacts process stop/resume, as
  the initial launch suspended immediately starts the process
  up and running because it doesn't know it is supposed to remain
  stopped.
* I implemented the equivalent of MachThreadList as
  NativeThreadListDarwin, in anticipation that we might want to
  factor out common parts into NativeThreadList{Protocol} and share
  some code here.  After writing it, though, the fallout from merging
  Mach Task/Process into a single concept plus some other minor
  changes makes the whole NativeThreadListDarwin concept nothing more
  than dead weight.  I am likely going to get rid of this class and
  just manage it directly in NativeProcessDarwin, much like I did
  for NativeProcessLinux.
* There is a stub-out call for starting a STDIO thread.  That will
  go away and adopt the MainLoop pselect-based IOObject reading.

I am developing the fully-integrated changes in the following repo,
which contains the necessary Xcode bits and the glue that enables
lldb-debugserver on a macOS system:

  https://github.com/tfiala/lldb/tree/llgs-darwin

This change also breaks out a few of the lldb-server tests into
their own directory, and adds some $qHostInfo tests (not sure why
I didn't write those tests back when I initially implemented that
on the Linux side).

llvm-svn: 280604

1 files changed, 1825 insertions, 0 deletions

diff --git a/lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.cpp b/lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.cpp
new file mode 100644
index 00000000000..d0eaac3c793
--- /dev/null
+++ b/lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.cpp
@@ -0,0 +1,1825 @@
+//===-- NativeProcessDarwin.cpp ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "NativeProcessDarwin.h"
+
+// C includes
+#include <mach/mach_init.h>
+#include <mach/mach_traps.h>
+#include <sys/ptrace.h>
+#include <sys/stat.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
+
+// C++ includes
+// LLDB includes
+#include "lldb/Core/Log.h"
+#include "lldb/Core/State.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Target/ProcessLaunchInfo.h"
+#include "lldb/Utility/PseudoTerminal.h"
+
+#include "CFBundle.h"
+#include "CFString.h"
+#include "DarwinProcessLauncher.h"
+
+#include "MachException.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::process_darwin;
+using namespace lldb_private::darwin_process_launcher;
+
+// -----------------------------------------------------------------------------
+// Hidden Impl
+// -----------------------------------------------------------------------------
+
+namespace
+{
+    struct hack_task_dyld_info {
+        mach_vm_address_t   all_image_info_addr;
+        mach_vm_size_t      all_image_info_size;
+    };
+}
+
+// -----------------------------------------------------------------------------
+// Public Static Methods
+// -----------------------------------------------------------------------------
+
+Error
+NativeProcessProtocol::Launch(ProcessLaunchInfo &launch_info,
+                              NativeProcessProtocol::NativeDelegate
+                              &native_delegate,
+                              MainLoop &mainloop,
+                              NativeProcessProtocolSP &native_process_sp)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    Error error;
+
+    // Verify the working directory is valid if one was specified.
+    FileSpec working_dir(launch_info.GetWorkingDirectory());
+    if (working_dir &&
+        (!working_dir.ResolvePath() ||
+         working_dir.GetFileType() != FileSpec::eFileTypeDirectory))
+    {
+        error.SetErrorStringWithFormat("No such file or directory: %s",
+                                       working_dir.GetCString());
+        return error;
+    }
+
+    // Launch the inferior.
+    int pty_master_fd = -1;
+    LaunchFlavor launch_flavor = LaunchFlavor::Default;
+
+    error = LaunchInferior(launch_info, &pty_master_fd, &launch_flavor);
+
+    // Handle launch failure.
+    if (!error.Success())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s() failed to launch process: "
+                        "%s",
+                        __FUNCTION__, error.AsCString());
+        return error;
+    }
+
+    // Handle failure to return a pid.
+    if (launch_info.GetProcessID() == LLDB_INVALID_PROCESS_ID)
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s() launch succeeded but no "
+                        "pid was returned!  Aborting.", __FUNCTION__);
+        return error;
+    }
+
+    // Create the Darwin native process impl.
+    std::shared_ptr<NativeProcessDarwin>
+        np_darwin_sp(new NativeProcessDarwin(launch_info.GetProcessID(),
+                                             pty_master_fd));
+    if (!np_darwin_sp->RegisterNativeDelegate(native_delegate))
+    {
+        native_process_sp.reset ();
+        error.SetErrorStringWithFormat ("failed to register the native delegate");
+        return error;
+    }
+
+    // Finalize the processing needed to debug the launched process with
+    // a NativeProcessDarwin instance.
+    error = np_darwin_sp->FinalizeLaunch(launch_flavor, mainloop);
+    if (!error.Success())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s() aborting, failed to finalize"
+                        " the launching of the process: %s",
+                        __FUNCTION__, error.AsCString());
+        return error;
+    }
+
+    // Return the process and process id to the caller through the launch args.
+    native_process_sp = np_darwin_sp;
+    return error;
+}
+
+Error
+NativeProcessProtocol::Attach(lldb::pid_t pid,
+                              NativeProcessProtocol::NativeDelegate
+                              &native_delegate,
+                              MainLoop &mainloop,
+                              NativeProcessProtocolSP &native_process_sp)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+    if (log)
+        log->Printf ("NativeProcessDarwin::%s(pid = %" PRIi64 ")", __FUNCTION__,
+                     pid);
+
+    // Retrieve the architecture for the running process.
+    ArchSpec process_arch;
+    Error error = ResolveProcessArchitecture(pid, process_arch);
+    if (!error.Success())
+        return error;
+
+    // TODO get attach to return this value.
+    const int pty_master_fd = -1;
+    std::shared_ptr<NativeProcessDarwin> native_process_darwin_sp(
+                                   new NativeProcessDarwin(pid, pty_master_fd));
+
+    if (!native_process_darwin_sp->RegisterNativeDelegate(native_delegate))
+    {
+        error.SetErrorStringWithFormat("failed to register the native "
+                                       "delegate");
+        return error;
+    }
+
+    native_process_darwin_sp->AttachToInferior(mainloop, pid, error);
+    if (!error.Success())
+        return error;
+
+    native_process_sp = native_process_darwin_sp;
+    return error;
+}
+
+// -----------------------------------------------------------------------------
+// ctor/dtor
+// -----------------------------------------------------------------------------
+
+NativeProcessDarwin::NativeProcessDarwin(lldb::pid_t pid, int pty_master_fd) :
+    NativeProcessProtocol(pid),
+    m_task(TASK_NULL),
+    m_did_exec(false),
+    m_cpu_type(0),
+    m_exception_port(MACH_PORT_NULL),
+    m_exc_port_info(),
+    m_exception_thread(nullptr),
+    m_exception_messages_mutex(),
+    m_sent_interrupt_signo(0),
+    m_auto_resume_signo(0),
+    m_thread_list(),
+    m_thread_actions(),
+    m_waitpid_pipe(),
+    m_waitpid_thread(nullptr),
+    m_waitpid_reader_handle()
+{
+    // TODO add this to the NativeProcessProtocol constructor.
+    m_terminal_fd = pty_master_fd;
+}
+
+NativeProcessDarwin::~NativeProcessDarwin()
+{
+}
+
+// -----------------------------------------------------------------------------
+// Instance methods
+// -----------------------------------------------------------------------------
+
+Error
+NativeProcessDarwin::FinalizeLaunch(LaunchFlavor launch_flavor,
+                                    MainLoop &main_loop)
+{
+    Error error;
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+#if 0
+    m_path = path;
+    size_t i;
+    char const *arg;
+    for (i=0; (arg = argv[i]) != NULL; i++)
+        m_args.push_back(arg);
+#endif
+
+    error = StartExceptionThread();
+    if (!error.Success())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): failure starting the "
+                        "mach exception port monitor thread: %s",
+                        __FUNCTION__, error.AsCString());
+
+        // Terminate the inferior process.  There's nothing meaningful we can
+        // do if we can't receive signals and exceptions.  Since we launched
+        // the process, it's fair game for us to kill it.
+        ::ptrace(PT_KILL, m_pid, 0, 0);
+        SetState(eStateExited);
+
+        return error;
+    }
+
+    StartSTDIOThread();
+
+    if (launch_flavor == LaunchFlavor::PosixSpawn)
+    {
+        SetState(eStateAttaching);
+        errno = 0;
+        int err = ::ptrace(PT_ATTACHEXC, m_pid, 0, 0);
+        if (err == 0)
+        {
+            // m_flags |= eMachProcessFlagsAttached;
+            if (log)
+                log->Printf("NativeProcessDarwin::%s(): successfully spawned "
+                            "process with pid %" PRIu64, __FUNCTION__, m_pid);
+        }
+        else
+        {
+            error.SetErrorToErrno();
+            SetState(eStateExited);
+            if (log)
+                log->Printf("NativeProcessDarwin::%s(): error: failed to "
+                            "attach to spawned pid %" PRIu64 " (error=%d (%s))",
+                            __FUNCTION__, m_pid, (int)error.GetError(),
+                            error.AsCString());
+            return error;
+        }
+    }
+
+    if (log)
+        log->Printf("NativeProcessDarwin::%s(): new pid is %" PRIu64 "...",
+                    __FUNCTION__, m_pid);
+
+    // Spawn a thread to reap our child inferior process...
+    error = StartWaitpidThread(main_loop);
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): failed to start waitpid() "
+                        "thread: %s", __FUNCTION__, error.AsCString());
+        kill(SIGKILL, static_cast<::pid_t>(m_pid));
+        return error;
+    }
+
+    if (TaskPortForProcessID(error) == TASK_NULL)
+    {
+        // We failed to get the task for our process ID which is bad.
+        // Kill our process; otherwise, it will be stopped at the entry
+        // point and get reparented to someone else and never go away.
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): could not get task port "
+                        "for process, sending SIGKILL and exiting: %s",
+                        __FUNCTION__, error.AsCString());
+        kill(SIGKILL, static_cast<::pid_t>(m_pid));
+        return error;
+    }
+
+    // Indicate that we're stopped, as we always launch suspended.
+    SetState(eStateStopped);
+
+    // Success.
+    return error;
+}
+
+Error
+NativeProcessDarwin::SaveExceptionPortInfo()
+{
+    return m_exc_port_info.Save(m_task);
+}
+
+bool
+NativeProcessDarwin::ProcessUsingSpringBoard() const
+{
+    // TODO implement flags
+    // return (m_flags & eMachProcessFlagsUsingSBS) != 0;
+    return false;
+}
+
+bool
+NativeProcessDarwin::ProcessUsingBackBoard() const
+{
+    // TODO implement flags
+    // return (m_flags & eMachProcessFlagsUsingBKS) != 0;
+    return false;
+}
+
+// Called by the exception thread when an exception has been received from
+// our process. The exception message is completely filled and the exception
+// data has already been copied.
+void
+NativeProcessDarwin::ExceptionMessageReceived(const MachException::Message&
+                                              message)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS |
+                                      LIBLLDB_LOG_VERBOSE));
+
+    std::lock_guard<std::recursive_mutex> locker(m_exception_messages_mutex);
+    if (m_exception_messages.empty())
+    {
+        // Suspend the task the moment we receive our first exception message.
+        SuspendTask();
+    }
+
+    // Use a locker to automatically unlock our mutex in case of exceptions
+    // Add the exception to our internal exception stack
+    m_exception_messages.push_back(message);
+
+    if (log)
+        log->Printf("NativeProcessDarwin::%s(): new queued message count: %lu",
+                    __FUNCTION__, m_exception_messages.size());
+}
+
+void*
+NativeProcessDarwin::ExceptionThread(void *arg)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS |
+                                      LIBLLDB_LOG_VERBOSE));
+    if (!arg)
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): cannot run mach exception "
+                        "thread, mandatory process arg was null", __FUNCTION__);
+        return nullptr;
+    }
+
+    return reinterpret_cast<NativeProcessDarwin*>(arg)->DoExceptionThread();
+}
+
+void*
+NativeProcessDarwin::DoExceptionThread()
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS |
+                                      LIBLLDB_LOG_VERBOSE));
+
+    if (log)
+        log->Printf("NativeProcessDarwin::%s(arg=%p) starting thread...",
+                    __FUNCTION__, this);
+
+    pthread_setname_np("exception monitoring thread");
+
+    // Ensure we don't get CPU starved.
+    MaybeRaiseThreadPriority();
+
+    // We keep a count of the number of consecutive exceptions received so
+    // we know to grab all exceptions without a timeout. We do this to get a
+    // bunch of related exceptions on our exception port so we can process
+    // then together. When we have multiple threads, we can get an exception
+    // per thread and they will come in consecutively. The main loop in this
+    // thread can stop periodically if needed to service things related to this
+    // process.
+    //
+    // [did we lose some words here?]
+    //
+    // flag set in the options, so we will wait forever for an exception on
+    //0 our exception port. After we get one exception, we then will use the
+    // MACH_RCV_TIMEOUT option with a zero timeout to grab all other current
+    // exceptions for our process. After we have received the last pending
+    // exception, we will get a timeout which enables us to then notify
+    // our main thread that we have an exception bundle available. We then wait
+    // for the main thread to tell this exception thread to start trying to get
+    // exceptions messages again and we start again with a mach_msg read with
+    // infinite timeout.
+    //
+    // We choose to park a thread on this, rather than polling, because the
+    // polling is expensive.  On devices, we need to minimize overhead caused
+    // by the process monitor.
+    uint32_t num_exceptions_received = 0;
+    Error error;
+    task_t task = m_task;
+    mach_msg_timeout_t periodic_timeout = 0;
+
+#if defined (WITH_SPRINGBOARD) && !defined (WITH_BKS)
+    mach_msg_timeout_t watchdog_elapsed = 0;
+    mach_msg_timeout_t watchdog_timeout = 60 * 1000;
+    ::pid_t pid = (::pid_t)process->GetID();
+    CFReleaser<SBSWatchdogAssertionRef> watchdog;
+
+    if (process->ProcessUsingSpringBoard())
+    {
+        // Request a renewal for every 60 seconds if we attached using
+        // SpringBoard.
+        watchdog.reset(::SBSWatchdogAssertionCreateForPID(nullptr, pid, 60));
+        if (log)
+            log->Printf("::SBSWatchdogAssertionCreateForPID(NULL, %4.4x, 60) "
+                        "=> %p", pid, watchdog.get());
+
+        if (watchdog.get())
+        {
+            ::SBSWatchdogAssertionRenew (watchdog.get());
+
+            CFTimeInterval watchdogRenewalInterval =
+                ::SBSWatchdogAssertionGetRenewalInterval (watchdog.get());
+            if (log)
+                log->Printf("::SBSWatchdogAssertionGetRenewalInterval(%p) => "
+                            "%g seconds", watchdog.get(),
+                            watchdogRenewalInterval);
+            if (watchdogRenewalInterval > 0.0)
+            {
+                watchdog_timeout =
+                    (mach_msg_timeout_t)watchdogRenewalInterval * 1000;
+                if (watchdog_timeout > 3000)
+                {
+                    // Give us a second to renew our timeout.
+                    watchdog_timeout -= 1000;
+                }
+                else if (watchdog_timeout > 1000)
+                {
+                    // Give us a quarter of a second to renew our timeout.
+                    watchdog_timeout -= 250;
+                }
+            }
+        }
+        if (periodic_timeout == 0 || periodic_timeout > watchdog_timeout)
+            periodic_timeout = watchdog_timeout;
+    }
+#endif  // #if defined (WITH_SPRINGBOARD) && !defined (WITH_BKS)
+
+#ifdef WITH_BKS
+    CFReleaser<BKSWatchdogAssertionRef> watchdog;
+    if (process->ProcessUsingBackBoard())
+    {
+        ::pid_t pid = process->GetID();
+        CFAllocatorRef alloc = kCFAllocatorDefault;
+        watchdog.reset(::BKSWatchdogAssertionCreateForPID(alloc, pid));
+    }
+#endif // #ifdef WITH_BKS
+
+    // Do we want to use a weak pointer to the NativeProcessDarwin here, in
+    // which case we can guarantee we don't whack the process monitor if we
+    // race between this thread and the main one on shutdown?
+    while (IsExceptionPortValid())
+    {
+        ::pthread_testcancel();
+
+        MachException::Message exception_message;
+
+        if (num_exceptions_received > 0)
+        {
+            // We don't want a timeout here, just receive as many exceptions as
+            // we can since we already have one.  We want to get all currently
+            // available exceptions for this task at once.
+            error = exception_message.Receive(GetExceptionPort(),
+                                              MACH_RCV_MSG | MACH_RCV_INTERRUPT
+                                              | MACH_RCV_TIMEOUT, 0);
+        }
+        else if (periodic_timeout > 0)
+        {
+            // We need to stop periodically in this loop, so try and get a mach
+            // message with a valid timeout (ms).
+            error = exception_message.Receive(GetExceptionPort(),
+                                              MACH_RCV_MSG | MACH_RCV_INTERRUPT
+                                              | MACH_RCV_TIMEOUT,
+                                              periodic_timeout);
+        }
+        else
+        {
+            // We don't need to parse all current exceptions or stop
+            // periodically, just wait for an exception forever.
+            error = exception_message.Receive(GetExceptionPort(),
+                                              MACH_RCV_MSG | MACH_RCV_INTERRUPT,
+                                              0);
+        }
+
+        if (error.Success())
+        {
+            // We successfully received an exception.
+            if (exception_message.CatchExceptionRaise(task))
+            {
+                ++num_exceptions_received;
+                ExceptionMessageReceived(exception_message);
+            }
+        }
+        else
+        {
+            if (error.GetError() == MACH_RCV_INTERRUPTED)
+            {
+                // We were interrupted.
+
+                // If we have no task port we should exit this thread, as it implies
+                // the inferior went down.
+                if (!IsExceptionPortValid())
+                {
+                    if (log)
+                        log->Printf("NativeProcessDarwin::%s(): the inferior "
+                                    "exception port is no longer valid, "
+                                    "canceling exception thread...", __FUNCTION__);
+                    // Should we be setting a process state here?
+                    break;
+                }
+
+                // Make sure the inferior task is still valid.
+                if (IsTaskValid())
+                {
+                    // Task is still ok.
+                    if (log)
+                        log->Printf("NativeProcessDarwin::%s(): interrupted, but "
+                                    "the inferior task iss till valid, "
+                                    "continuing...", __FUNCTION__);
+                    continue;
+                }
+                else
+                {
+                    // The inferior task is no longer valid.  Time to exit as
+                    // the process has gone away.
+                    if (log)
+                        log->Printf("NativeProcessDarwin::%s(): the inferior task "
+                                    "has exited, and so will we...", __FUNCTION__);
+                    // Does this race at all with our waitpid()?
+                    SetState(eStateExited);
+                    break;
+                }
+            }
+            else if (error.GetError() == MACH_RCV_TIMED_OUT)
+            {
+                // We timed out when waiting for exceptions.
+
+                if (num_exceptions_received > 0)
+                {
+                    // We were receiving all current exceptions with a timeout of
+                    // zero.  It is time to go back to our normal looping mode.
+                    num_exceptions_received = 0;
+
+                    // Notify our main thread we have a complete exception message
+                    // bundle available.  Get the possibly updated task port back
+                    // from the process in case we exec'ed and our task port
+                    // changed.
+                    task = ExceptionMessageBundleComplete();
+
+                    // In case we use a timeout value when getting exceptions,
+                    // make sure our task is still valid.
+                    if (IsTaskValid(task))
+                    {
+                        // Task is still ok.
+                        if (log)
+                            log->Printf("NativeProcessDarwin::%s(): got a timeout, "
+                                        "continuing...", __FUNCTION__);
+                        continue;
+                    }
+                    else
+                    {
+                        // The inferior task is no longer valid.  Time to exit as
+                        // the process has gone away.
+                        if (log)
+                            log->Printf("NativeProcessDarwin::%s(): the inferior "
+                                        "task has exited, and so will we...",
+                                        __FUNCTION__);
+                        // Does this race at all with our waitpid()?
+                        SetState(eStateExited);
+                        break;
+                    }
+                }
+
+#if defined (WITH_SPRINGBOARD) && !defined (WITH_BKS)
+                if (watchdog.get())
+                {
+                    watchdog_elapsed += periodic_timeout;
+                    if (watchdog_elapsed >= watchdog_timeout)
+                    {
+                        if (log)
+                            log->Printf("SBSWatchdogAssertionRenew(%p)",
+                                        watchdog.get());
+                        ::SBSWatchdogAssertionRenew (watchdog.get());
+                        watchdog_elapsed = 0;
+                    }
+                }
+#endif
+            }
+            else
+            {
+                if (log)
+                    log->Printf("NativeProcessDarwin::%s(): continuing after "
+                                "receiving an unexpected error: %u (%s)",
+                                __FUNCTION__, error.GetError(), error.AsCString());
+                // TODO: notify of error?
+            }
+        }
+    }
+
+#if defined (WITH_SPRINGBOARD) && !defined (WITH_BKS)
+    if (watchdog.get())
+    {
+        // TODO: change SBSWatchdogAssertionRelease to SBSWatchdogAssertionCancel when we
+        // all are up and running on systems that support it. The SBS framework has a #define
+        // that will forward SBSWatchdogAssertionRelease to SBSWatchdogAssertionCancel for now
+        // so it should still build either way.
+        DNBLogThreadedIf(LOG_TASK, "::SBSWatchdogAssertionRelease(%p)", watchdog.get());
+        ::SBSWatchdogAssertionRelease (watchdog.get());
+    }
+#endif  // #if defined (WITH_SPRINGBOARD) && !defined (WITH_BKS)
+    
+    if (log)
+        log->Printf("NativeProcessDarwin::%s(%p): thread exiting...",
+                    __FUNCTION__, this);
+    return nullptr;
+}
+
+Error
+NativeProcessDarwin::StartExceptionThread()
+{
+    Error error;
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+    if (log)
+        log->Printf("NativeProcessDarwin::%s() called", __FUNCTION__);
+
+    // Make sure we've looked up the inferior port.
+    TaskPortForProcessID(error);
+
+    // Ensure the inferior task is valid.
+    if (!IsTaskValid())
+    {
+        error.SetErrorStringWithFormat("cannot start exception thread: "
+                                       "task 0x%4.4x is not valid", m_task);
+        return error;
+    }
+
+    // Get the mach port for the process monitor.
+    mach_port_t task_self = mach_task_self();
+
+    // Allocate an exception port that we will use to track our child process
+    auto mach_err = ::mach_port_allocate(task_self, MACH_PORT_RIGHT_RECEIVE,
+                                         &m_exception_port);
+    error.SetError(mach_err, eErrorTypeMachKernel);
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): mach_port_allocate("
+                        "task_self=0x%4.4x, MACH_PORT_RIGHT_RECEIVE, "
+                        "&m_exception_port) failed: %u (%s)", __FUNCTION__,
+                        task_self, error.GetError(), error.AsCString());
+        return error;
+    }
+
+    // Add the ability to send messages on the new exception port
+    mach_err = ::mach_port_insert_right(task_self, m_exception_port,
+                                   m_exception_port, MACH_MSG_TYPE_MAKE_SEND);
+    error.SetError(mach_err, eErrorTypeMachKernel);
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): mach_port_insert_right("
+                        "task_self=0x%4.4x, m_exception_port=0x%4.4x, "
+                        "m_exception_port=0x%4.4x, MACH_MSG_TYPE_MAKE_SEND) "
+                        "failed: %u (%s)", __FUNCTION__,
+                        task_self, m_exception_port, m_exception_port,
+                        error.GetError(), error.AsCString());
+        return error;
+    }
+
+    // Save the original state of the exception ports for our child process.
+    error = SaveExceptionPortInfo();
+    if (error.Fail() || (m_exc_port_info.mask == 0))
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): SaveExceptionPortInfo() "
+                        "failed, cannot install exception handler: %s",
+                        __FUNCTION__, error.AsCString());
+        return error;
+    }
+
+    // Set the ability to get all exceptions on this port.
+    mach_err = ::task_set_exception_ports(m_task, m_exc_port_info.mask,
+                                          m_exception_port,
+                                          EXCEPTION_DEFAULT |
+                                          MACH_EXCEPTION_CODES,
+                                          THREAD_STATE_NONE);
+    error.SetError(mach_err, eErrorTypeMachKernel);
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf("::task_set_exception_ports (task = 0x%4.4x, "
+                        "exception_mask = 0x%8.8x, new_port = 0x%4.4x, "
+                        "behavior = 0x%8.8x, new_flavor = 0x%8.8x) failed: "
+                        "%u (%s)", m_task, m_exc_port_info.mask,
+                        m_exception_port, (EXCEPTION_DEFAULT |
+                                           MACH_EXCEPTION_CODES),
+                        THREAD_STATE_NONE, error.GetError(),
+                        error.AsCString());
+        return error;
+    }
+
+    // Create the exception thread.
+    auto pthread_err = ::pthread_create(&m_exception_thread, nullptr,
+                                        ExceptionThread, this);
+    error.SetError(pthread_err, eErrorTypePOSIX);
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): failed to create Mach "
+                        "exception-handling thread: %u (%s)", __FUNCTION__,
+                        error.GetError(), error.AsCString());
+    }
+
+    return error;
+}
+
+lldb::addr_t
+NativeProcessDarwin::GetDYLDAllImageInfosAddress(Error &error) const
+{
+    error.Clear();
+
+    struct hack_task_dyld_info dyld_info;
+    mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
+    // Make sure that COUNT isn't bigger than our hacked up struct
+    // hack_task_dyld_info.  If it is, then make COUNT smaller to match.
+    if (count > (sizeof(struct hack_task_dyld_info) / sizeof(natural_t)))
+    {
+        count = (sizeof(struct hack_task_dyld_info) / sizeof(natural_t));
+    }
+
+    TaskPortForProcessID(error);
+    if (error.Fail())
+        return LLDB_INVALID_ADDRESS;
+
+    auto mach_err = ::task_info(m_task, TASK_DYLD_INFO, (task_info_t)&dyld_info,
+                                &count);
+    error.SetError(mach_err, eErrorTypeMachKernel);
+    if (error.Success())
+    {
+        // We now have the address of the all image infos structure.
+        return dyld_info.all_image_info_addr;
+    }
+
+    // We don't have it.
+    return LLDB_INVALID_ADDRESS;
+}
+
+uint32_t
+NativeProcessDarwin::GetCPUTypeForLocalProcess(::pid_t pid)
+{
+    int mib[CTL_MAXNAME] = {0, };
+    size_t len = CTL_MAXNAME;
+
+    if (::sysctlnametomib("sysctl.proc_cputype", mib, &len))
+        return 0;
+
+    mib[len] = pid;
+    len++;
+
+    cpu_type_t cpu;
+    size_t cpu_len = sizeof(cpu);
+    if (::sysctl (mib, static_cast<u_int>(len), &cpu, &cpu_len, 0, 0))
+        cpu = 0;
+    return cpu;
+}
+
+uint32_t
+NativeProcessDarwin::GetCPUType() const
+{
+    if (m_cpu_type == 0 && m_pid != 0)
+        m_cpu_type = GetCPUTypeForLocalProcess(m_pid);
+    return m_cpu_type;
+}
+
+task_t
+NativeProcessDarwin::ExceptionMessageBundleComplete()
+{
+    // We have a complete bundle of exceptions for our child process.
+    Error error;
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS |
+                                      LIBLLDB_LOG_VERBOSE));
+
+    std::lock_guard<std::recursive_mutex> locker(m_exception_messages_mutex);
+    if (log)
+        log->Printf("NativeProcessDarwin::%s(): processing %lu exception "
+                    "messages.", __FUNCTION__, m_exception_messages.size());
+
+    if (m_exception_messages.empty())
+    {
+        // Not particularly useful...
+        return m_task;
+    }
+
+    bool auto_resume = false;
+    m_did_exec = false;
+
+    // First check for any SIGTRAP and make sure we didn't exec
+    const task_t task = m_task;
+    size_t i;
+    if (m_pid != 0)
+    {
+        bool received_interrupt = false;
+        uint32_t num_task_exceptions = 0;
+        for (i = 0; i < m_exception_messages.size(); ++i)
+        {
+            if (m_exception_messages[i].state.task_port != task)
+            {
+                // This is an exception that is not for our inferior, ignore.
+                continue;
+            }
+
+            // This is an exception for the inferior.
+            ++num_task_exceptions;
+            const int signo = m_exception_messages[i].state.SoftSignal();
+            if (signo == SIGTRAP)
+            {
+                // SIGTRAP could mean that we exec'ed. We need to check the
+                // dyld all_image_infos.infoArray to see if it is NULL and if
+                // so, say that we exec'ed.
+                const addr_t aii_addr =
+                    GetDYLDAllImageInfosAddress(error);
+                if (aii_addr == LLDB_INVALID_ADDRESS)
+                    break;
+
+                const addr_t info_array_count_addr = aii_addr + 4;
+                uint32_t info_array_count = 0;
+                size_t bytes_read = 0;
+                Error read_error;
+                read_error = ReadMemory(info_array_count_addr,   // source addr
+                                        &info_array_count,       // dest addr
+                                        4,                       // byte count
+                                        bytes_read);             // #bytes read
+                if (read_error.Success() && (bytes_read == 4))
+                {
+                    if (info_array_count == 0)
+                    {
+                        // We got the all infos address, and there are zero
+                        // entries.  We think we exec'd.
+                        m_did_exec = true;
+
+                        // Force the task port to update itself in case the
+                        // task port changed after exec
+                        const task_t old_task = m_task;
+                        const bool force_update = true;
+                        const task_t new_task =
+                            TaskPortForProcessID(error, force_update);
+                        if (old_task != new_task)
+                        {
+                            if (log)
+                                log->Printf("exec: inferior task port changed "
+                                            "from 0x%4.4x to 0x%4.4x", old_task,
+                                            new_task);
+                        }
+                    }
+                }
+                else
+                {
+                    if (log)
+                        log->Printf("NativeProcessDarwin::%s() warning: "
+                                    "failed to read all_image_infos."
+                                    "infoArrayCount from 0x%8.8llx",
+                                    __FUNCTION__, info_array_count_addr);
+                }
+            }
+            else if ((m_sent_interrupt_signo != 0) &&
+                     (signo == m_sent_interrupt_signo))
+            {
+                // We just received the interrupt that we sent to ourselves.
+                received_interrupt = true;
+            }
+        }
+
+        if (m_did_exec)
+        {
+            cpu_type_t process_cpu_type = GetCPUTypeForLocalProcess(m_pid);
+            if (m_cpu_type != process_cpu_type)
+            {
+                if (log)
+                    log->Printf("NativeProcessDarwin::%s(): arch changed from "
+                                "0x%8.8x to 0x%8.8x", __FUNCTION__, m_cpu_type,
+                                process_cpu_type);
+                m_cpu_type = process_cpu_type;
+                // TODO figure out if we need to do something here.
+                // DNBArchProtocol::SetArchitecture (process_cpu_type);
+            }
+            m_thread_list.Clear();
+
+            // TODO hook up breakpoints.
+            // m_breakpoints.DisableAll();
+        }
+
+        if (m_sent_interrupt_signo != 0)
+        {
+            if (received_interrupt)
+            {
+                if (log)
+                    log->Printf("NativeProcessDarwin::%s(): process "
+                                "successfully interrupted with signal %i",
+                                __FUNCTION__, m_sent_interrupt_signo);
+
+                // Mark that we received the interrupt signal
+                m_sent_interrupt_signo = 0;
+                // Now check if we had a case where:
+                // 1 - We called NativeProcessDarwin::Interrupt() but we stopped
+                //     for another reason.
+                // 2 - We called NativeProcessDarwin::Resume() (but still
+                //     haven't gotten the interrupt signal).
+                // 3 - We are now incorrectly stopped because we are handling
+                //     the interrupt signal we missed.
+                // 4 - We might need to resume if we stopped only with the
+                //     interrupt signal that we never handled.
+                if (m_auto_resume_signo != 0)
+                {
+                    // Only auto_resume if we stopped with _only_ the interrupt
+                    // signal.
+                    if (num_task_exceptions == 1)
+                    {
+                        auto_resume = true;
+                        if (log)
+                            log->Printf("NativeProcessDarwin::%s(): auto "
+                                        "resuming due to unhandled interrupt "
+                                        "signal %i", __FUNCTION__,
+                                        m_auto_resume_signo);
+                    }
+                    m_auto_resume_signo = 0;
+                }
+            }
+            else
+            {
+                if (log)
+                    log->Printf("NativeProcessDarwin::%s(): didn't get signal "
+                                "%i after MachProcess::Interrupt()",
+                                __FUNCTION__, m_sent_interrupt_signo);
+            }
+        }
+    }
+
+    // Let all threads recover from stopping and do any clean up based
+    // on the previous thread state (if any).
+    m_thread_list.ProcessDidStop(*this);
+
+    // Let each thread know of any exceptions
+    for (i = 0; i < m_exception_messages.size(); ++i)
+    {
+        // Let the thread list forward all exceptions on down to each thread.
+        if (m_exception_messages[i].state.task_port == task)
+        {
+            // This exception is for our inferior.
+            m_thread_list.NotifyException(m_exception_messages[i].state);
+        }
+
+        if (log)
+        {
+            StreamString stream;
+            m_exception_messages[i].Dump(stream);
+            stream.Flush();
+            log->PutCString(stream.GetString().c_str());
+        }
+    }
+
+    if (log)
+    {
+        StreamString stream;
+        m_thread_list.Dump(stream);
+        stream.Flush();
+        log->PutCString(stream.GetString().c_str());
+    }
+
+    bool step_more = false;
+    if (m_thread_list.ShouldStop(step_more) && (auto_resume == false))
+    {
+        // TODO - need to hook up event system here. !!!!
+#if 0
+        // Wait for the eEventProcessRunningStateChanged event to be reset
+        // before changing state to stopped to avoid race condition with
+        // very fast start/stops.
+        struct timespec timeout;
+
+        //DNBTimer::OffsetTimeOfDay(&timeout, 0, 250 * 1000);   // Wait for 250 ms
+        DNBTimer::OffsetTimeOfDay(&timeout, 1, 0);  // Wait for 250 ms
+        m_events.WaitForEventsToReset(eEventProcessRunningStateChanged,
+                                      &timeout);
+#endif
+        SetState(eStateStopped);
+    }
+    else
+    {
+        // Resume without checking our current state.
+        PrivateResume();
+    }
+
+    return m_task;
+}
+
+void
+NativeProcessDarwin::StartSTDIOThread()
+{
+    // TODO implement
+}
+
+Error
+NativeProcessDarwin::StartWaitpidThread(MainLoop &main_loop)
+{
+    Error error;
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    // Strategy: create a thread that sits on waitpid(), waiting for the
+    // inferior process to die, reaping it in the process.  Arrange for
+    // the thread to have a pipe file descriptor that it can send a byte
+    // over when the waitpid completes.  Have the main loop have a read
+    // object for the other side of the pipe, and have the callback for
+    // the read do the process termination message sending.
+
+    // Create a single-direction communication channel.
+    const bool child_inherits = false;
+    error = m_waitpid_pipe.CreateNew(child_inherits);
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): failed to create waitpid "
+                        "communication pipe: %s", __FUNCTION__,
+                        error.AsCString());
+        return error;
+    }
+
+    // Hook up the waitpid reader callback.
+
+    // TODO make PipePOSIX derive from IOObject.  This is goofy here.
+    const bool transfer_ownership = false;
+    auto io_sp = IOObjectSP(new File(m_waitpid_pipe.GetReadFileDescriptor(),
+                                     transfer_ownership));
+    m_waitpid_reader_handle =
+        main_loop.RegisterReadObject(
+                          io_sp,
+                          [this](MainLoopBase &){ HandleWaitpidResult(); },
+                          error);
+
+    // Create the thread.
+    auto pthread_err = ::pthread_create(&m_waitpid_thread, nullptr,
+                                        WaitpidThread, this);
+    error.SetError(pthread_err, eErrorTypePOSIX);
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): failed to create waitpid "
+                        "handling thread: %u (%s)", __FUNCTION__,
+                        error.GetError(), error.AsCString());
+        return error;
+    }
+
+    return error;
+}
+
+void*
+NativeProcessDarwin::WaitpidThread(void *arg)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+    if (!arg)
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): cannot run waitpid "
+                        "thread, mandatory process arg was null", __FUNCTION__);
+        return nullptr;
+    }
+
+    return reinterpret_cast<NativeProcessDarwin*>(arg)->DoWaitpidThread();
+}
+
+void
+NativeProcessDarwin::MaybeRaiseThreadPriority()
+{
+#if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
+    struct sched_param thread_param;
+    int thread_sched_policy;
+    if (pthread_getschedparam(pthread_self(), &thread_sched_policy,
+                              &thread_param) == 0)
+    {
+        thread_param.sched_priority = 47;
+        pthread_setschedparam(pthread_self(), thread_sched_policy,
+                              &thread_param);
+    }
+#endif
+}
+
+void*
+NativeProcessDarwin::DoWaitpidThread()
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    if (m_pid == LLDB_INVALID_PROCESS_ID)
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): inferior process ID is "
+                        "not set, cannot waitpid on it", __FUNCTION__);
+        return nullptr;
+    }
+
+    // Name the thread.
+    pthread_setname_np("waitpid thread");
+
+    // Ensure we don't get CPU starved.
+    MaybeRaiseThreadPriority();
+
+    Error error;
+    int status = -1;
+
+    while (1)
+    {
+        // Do a waitpid.
+        ::pid_t child_pid = ::waitpid(m_pid, &status, 0);
+        if (child_pid < 0)
+            error.SetErrorToErrno();
+        if (error.Fail())
+        {
+            if (error.GetError() == EINTR)
+            {
+                // This is okay, we can keep going.
+                if (log)
+                    log->Printf("NativeProcessDarwin::%s(): waitpid(pid = %"
+                                PRIu64 ", &status, 0) interrupted, continuing",
+                                __FUNCTION__, m_pid);
+                continue;
+            }
+
+            // This error is not okay, abort.
+            if (log)
+                log->Printf("NativeProcessDarwin::%s(): waitpid(pid = %" PRIu64
+                            ", &status, 0) aborting due to error: %u (%s)",
+                            __FUNCTION__, m_pid, error.GetError(),
+                            error.AsCString());
+            break;
+        }
+
+        // Log the successful result.
+        if (log)
+                log->Printf("NativeProcessDarwin::%s(): waitpid(pid = %" PRIu64
+                            ", &status, 0) => %i, status = %i", __FUNCTION__,
+                            m_pid, child_pid, status);
+
+        // Handle the result.
+        if (WIFSTOPPED(status))
+        {
+            if (log)
+                log->Printf("NativeProcessDarwin::%s(): waitpid(pid = %" PRIu64
+                            ") received a stop, continuing waitpid() loop",
+                            __FUNCTION__, m_pid);
+            continue;
+        }
+        else // if (WIFEXITED(status) || WIFSIGNALED(status))
+        {
+            if (log)
+                log->Printf("NativeProcessDarwin::%s(pid = %" PRIu64 "): "
+                            "waitpid thread is setting exit status for pid = "
+                            "%i to %i", __FUNCTION__, m_pid,
+                            child_pid, status);
+
+            error = SendInferiorExitStatusToMainLoop(child_pid, status);
+            return nullptr;
+        }
+    }
+
+    // We should never exit as long as our child process is alive.  If we
+    // get here, something completely unexpected went wrong and we should exit.
+    if (log)
+        log->Printf("NativeProcessDarwin::%s(): internal error: waitpid thread "
+                    "exited out of its main loop in an unexpected way. pid = %"
+                    PRIu64 ". Sending exit status of -1.", __FUNCTION__, m_pid);
+
+    error = SendInferiorExitStatusToMainLoop((::pid_t)m_pid, -1);
+    return nullptr;
+}
+
+Error
+NativeProcessDarwin::SendInferiorExitStatusToMainLoop(::pid_t pid, int status)
+{
+    Error error;
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    size_t bytes_written = 0;
+
+    // Send the pid.
+    error = m_waitpid_pipe.Write(&pid, sizeof(pid), bytes_written);
+    if (error.Fail() || (bytes_written < sizeof(pid)))
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s() - failed to write "
+                        "waitpid exiting pid to the pipe.  Client will not "
+                        "hear about inferior exit status!",
+                        __FUNCTION__);
+        return error;
+    }
+
+    // Send the status.
+    bytes_written = 0;
+    error = m_waitpid_pipe.Write(&status, sizeof(status), bytes_written);
+    if (error.Fail() || (bytes_written < sizeof(status)))
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s() - failed to write "
+                        "waitpid exit result to the pipe.  Client will not "
+                        "hear about inferior exit status!",
+                        __FUNCTION__);
+    }
+    return error;
+}
+
+Error
+NativeProcessDarwin::HandleWaitpidResult()
+{
+    Error error;
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    // Read the pid.
+    const bool notify_status = true;
+
+    ::pid_t pid = -1;
+    size_t bytes_read = 0;
+    error = m_waitpid_pipe.Read(&pid, sizeof(pid), bytes_read);
+    if (error.Fail() || (bytes_read < sizeof(pid)))
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s() - failed to read "
+                        "waitpid exiting pid from the pipe.  Will notify "
+                        "as if parent process died with exit status -1.",
+                        __FUNCTION__);
+        SetExitStatus(eExitTypeInvalid, -1, "failed to receive waitpid result",
+                      notify_status);
+        return error;
+    }
+
+    // Read the status.
+    int status = -1;
+    error = m_waitpid_pipe.Read(&status, sizeof(status), bytes_read);
+    if (error.Fail() || (bytes_read < sizeof(status)))
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s() - failed to read "
+                        "waitpid exit status from the pipe.  Will notify "
+                        "as if parent process died with exit status -1.",
+                        __FUNCTION__);
+        SetExitStatus(eExitTypeInvalid, -1, "failed to receive waitpid result",
+                      notify_status);
+        return error;
+    }
+
+    // Notify the monitor that our state has changed.
+    if (log)
+        log->Printf("NativeProcessDarwin::%s(): main loop received waitpid "
+                    "exit status info: pid=%i (%s), status=%i",
+                    __FUNCTION__, pid,
+                    (pid == m_pid) ? "the inferior" : "not the inferior",
+                    status);
+
+    ExitType exit_type = eExitTypeInvalid;
+    int exit_status = -1;
+
+    if (WIFEXITED(status))
+    {
+        exit_type = eExitTypeExit;
+        exit_status = WEXITSTATUS(status);
+    }
+    else if (WIFSIGNALED(status))
+    {
+        exit_type = eExitTypeSignal;
+        exit_status = WTERMSIG(status);
+    }
+
+    SetExitStatus(exit_type, exit_status, nullptr, notify_status);
+    return error;
+}
+
+task_t
+NativeProcessDarwin::TaskPortForProcessID(Error &error, bool force) const
+{
+    if ((m_task == TASK_NULL) || force)
+    {
+        Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+        if (m_pid == LLDB_INVALID_PROCESS_ID)
+        {
+            if (log)
+                log->Printf("NativeProcessDarwin::%s(): cannot get task due "
+                            "to invalid pid", __FUNCTION__);
+            return TASK_NULL;
+        }
+
+        const uint32_t num_retries = 10;
+        const uint32_t usec_interval = 10000;
+
+        mach_port_t task_self = mach_task_self();
+        task_t task = TASK_NULL;
+
+        for (uint32_t i = 0; i < num_retries; i++)
+        {
+            kern_return_t err = ::task_for_pid(task_self, m_pid, &task);
+            if (err == 0)
+            {
+                // Succeeded.  Save and return it.
+                error.Clear();
+                m_task = task;
+                log->Printf("NativeProcessDarwin::%s(): ::task_for_pid("
+                            "stub_port = 0x%4.4x, pid = %llu, &task) "
+                            "succeeded: inferior task port = 0x%4.4x",
+                            __FUNCTION__, task_self, m_pid, m_task);
+                return m_task;
+            }
+            else
+            {
+                // Failed to get the task for the inferior process.
+                error.SetError(err, eErrorTypeMachKernel);
+                if (log)
+                {
+                    log->Printf("NativeProcessDarwin::%s(): ::task_for_pid("
+                                "stub_port = 0x%4.4x, pid = %llu, &task) "
+                                "failed, err = 0x%8.8x (%s)",
+                                __FUNCTION__, task_self,
+                                m_pid,
+                                err,
+                                error.AsCString());
+                }
+            }
+
+            // Sleep a bit and try again
+            ::usleep (usec_interval);
+        }
+
+        // We failed to get the task for the inferior process.
+        // Ensure that it is cleared out.
+        m_task = TASK_NULL;
+    }
+    return m_task;
+}
+
+void
+NativeProcessDarwin::AttachToInferior(MainLoop &mainloop, lldb::pid_t pid,
+                                      Error &error)
+{
+    error.SetErrorString("TODO: implement");
+}
+
+Error
+NativeProcessDarwin::PrivateResume()
+{
+    Error error;
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    std::lock_guard<std::recursive_mutex> locker(m_exception_messages_mutex);
+    m_auto_resume_signo = m_sent_interrupt_signo;
+
+    if (log)
+    {
+        if (m_auto_resume_signo)
+            log->Printf("NativeProcessDarwin::%s(): task 0x%x resuming (with "
+                        "unhandled interrupt signal %i)...", __FUNCTION__,
+                        m_task, m_auto_resume_signo);
+        else
+            log->Printf("NativeProcessDarwin::%s(): task 0x%x resuming...",
+                        __FUNCTION__, m_task);
+    }
+
+    error = ReplyToAllExceptions();
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): aborting, failed to "
+                        "reply to exceptions: %s", __FUNCTION__,
+                        error.AsCString());
+        return error;
+    }
+    //    bool stepOverBreakInstruction = step;
+
+    // Let the thread prepare to resume and see if any threads want us to
+    // step over a breakpoint instruction (ProcessWillResume will modify
+    // the value of stepOverBreakInstruction).
+    m_thread_list.ProcessWillResume(*this, m_thread_actions);
+
+    // Set our state accordingly
+    if (m_thread_actions.NumActionsWithState(eStateStepping))
+        SetState(eStateStepping);
+    else
+        SetState(eStateRunning);
+
+    // Now resume our task.
+    error = ResumeTask();
+    return error;
+}
+
+Error
+NativeProcessDarwin::ReplyToAllExceptions()
+{
+    Error error;
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS |
+                                      LIBLLDB_LOG_VERBOSE));
+
+    TaskPortForProcessID(error);
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): no task port, aborting",
+                        __FUNCTION__);
+        return error;
+    }
+
+    std::lock_guard<std::recursive_mutex> locker(m_exception_messages_mutex);
+    if (m_exception_messages.empty())
+    {
+        // We're done.
+        return error;
+    }
+
+    size_t index = 0;
+    for (auto &message : m_exception_messages)
+    {
+        if (log)
+        {
+            log->Printf("NativeProcessDarwin::%s(): replying to exception "
+                        "%zu...", __FUNCTION__, index++);
+        }
+
+        int thread_reply_signal = 0;
+
+        const tid_t tid =
+            m_thread_list.GetThreadIDByMachPortNumber(message.state
+                                                      .thread_port);
+        const ResumeAction *action = nullptr;
+        if (tid != LLDB_INVALID_THREAD_ID)
+            action = m_thread_actions.GetActionForThread (tid, false);
+
+        if (action)
+        {
+            thread_reply_signal = action->signal;
+            if (thread_reply_signal)
+                m_thread_actions.SetSignalHandledForThread(tid);
+        }
+
+        error = message.Reply(m_pid, m_task, thread_reply_signal);
+        if (error.Fail() && log)
+        {
+            // We log any error here, but we don't stop the exception
+            // response handling.
+            log->Printf("NativeProcessDarwin::%s(): failed to reply to "
+                        "exception: %s", __FUNCTION__, error.AsCString());
+            error.Clear();
+        }
+    }
+
+    // Erase all exception message as we should have used and replied
+    // to them all already.
+    m_exception_messages.clear();
+    return error;
+}
+
+Error
+NativeProcessDarwin::ResumeTask()
+{
+    Error error;
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    TaskPortForProcessID(error);
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): failed to get task port "
+                        "for process when attempting to resume: %s",
+                        __FUNCTION__, error.AsCString());
+        return error;
+    }
+    if (m_task == TASK_NULL)
+    {
+        error.SetErrorString("task port retrieval succeeded but task port is "
+                             "null when attempting to resume the task");
+        return error;
+    }
+
+    if (log)
+        log->Printf("NativeProcessDarwin::%s(): requesting resume of task "
+                    "0x%4.4x", __FUNCTION__, m_task);
+
+    // Get the BasicInfo struct to verify that we're suspended before we try
+    // to resume the task.
+    struct task_basic_info task_info;
+    error = GetTaskBasicInfo(m_task, &task_info);
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): failed to get task "
+                        "BasicInfo when attempting to resume: %s",
+                        __FUNCTION__, error.AsCString());
+        return error;
+    }
+
+    // task_resume isn't counted like task_suspend calls are, so if the
+    // task is not suspended, don't try and resume it since it is already
+    // running
+    if (task_info.suspend_count > 0)
+    {
+        auto mach_err = ::task_resume(m_task);
+        error.SetError(mach_err, eErrorTypeMachKernel);
+        if (log)
+        {
+            if (error.Success())
+                log->Printf("::task_resume(target_task = 0x%4.4x): success",
+                            m_task);
+            else
+                log->Printf("::task_resume(target_task = 0x%4.4x) error: %s",
+                            m_task, error.AsCString());
+        }
+    }
+    else
+    {
+        if (log)
+            log->Printf("::task_resume(target_task = 0x%4.4x): ignored, "
+                        "already running", m_task);
+    }
+
+    return error;
+}
+
+bool
+NativeProcessDarwin::IsTaskValid() const
+{
+    if (m_task == TASK_NULL)
+        return false;
+
+    struct task_basic_info task_info;
+    return GetTaskBasicInfo(m_task, &task_info).Success();
+}
+
+bool
+NativeProcessDarwin::IsTaskValid(task_t task) const
+{
+    if (task == TASK_NULL)
+        return false;
+
+    struct task_basic_info task_info;
+    return GetTaskBasicInfo(task, &task_info).Success();
+}
+
+mach_port_t
+NativeProcessDarwin::GetExceptionPort() const
+{
+    return m_exception_port;
+}
+
+bool
+NativeProcessDarwin::IsExceptionPortValid () const
+{
+    return MACH_PORT_VALID(m_exception_port);
+}
+
+Error
+NativeProcessDarwin::GetTaskBasicInfo(task_t task,
+                                      struct task_basic_info *info) const
+{
+    Error error;
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    // Validate args.
+    if (info == NULL)
+    {
+        error.SetErrorStringWithFormat("NativeProcessDarwin::%s(): mandatory "
+                                       "info arg is null", __FUNCTION__);
+        return error;
+    }
+
+    // Grab the task if we don't already have it.
+    if (task == TASK_NULL)
+    {
+        error.SetErrorStringWithFormat("NativeProcessDarwin::%s(): given task "
+                                       "is invalid", __FUNCTION__);
+    }
+
+    mach_msg_type_number_t count = TASK_BASIC_INFO_COUNT;
+    auto err = ::task_info(m_task, TASK_BASIC_INFO, (task_info_t)info, &count);
+    error.SetError(err, eErrorTypeMachKernel);
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf("::task_info(target_task = 0x%4.4x, "
+                        "flavor = TASK_BASIC_INFO, task_info_out => %p, "
+                        "task_info_outCnt => %u) failed: %u (%s)", m_task, info,
+                        count, error.GetError(), error.AsCString());
+        return error;
+    }
+
+    Log *verbose_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS |
+                                              LIBLLDB_LOG_VERBOSE));
+    if (verbose_log)
+    {
+        float user = (float)info->user_time.seconds +
+            (float)info->user_time.microseconds / 1000000.0f;
+        float system = (float)info->user_time.seconds +
+            (float)info->user_time.microseconds / 1000000.0f;
+        verbose_log->Printf("task_basic_info = { suspend_count = %i, "
+                            "virtual_size = 0x%8.8llx, resident_size = "
+                            "0x%8.8llx, user_time = %f, system_time = %f }",
+                            info->suspend_count,
+                            (uint64_t)info->virtual_size,
+                            (uint64_t)info->resident_size,
+                            user, system);
+    }
+    return error;
+}
+
+Error
+NativeProcessDarwin::SuspendTask()
+{
+    Error error;
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    if (m_task == TASK_NULL)
+    {
+        error.SetErrorString("task port is null, cannot suspend task");
+        if (log)
+            log->Printf("NativeProcessDarwin::%s() failed: %s",
+                        __FUNCTION__, error.AsCString());
+        return error;
+    }
+
+    auto mach_err = ::task_suspend(m_task);
+    error.SetError(mach_err, eErrorTypeMachKernel);
+    if (error.Fail() && log)
+        log->Printf("::task_suspend(target_task = 0x%4.4x)", m_task);
+
+    return error;
+}
+
+Error
+NativeProcessDarwin::Resume(const ResumeActionList &resume_actions)
+{
+    Error error;
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    if (log)
+        log->Printf("NativeProcessDarwin::%s() called", __FUNCTION__);
+
+    if (CanResume())
+    {
+        m_thread_actions = resume_actions;
+        error = PrivateResume();
+        return error;
+    }
+
+    auto state = GetState();
+    if (state == eStateRunning)
+    {
+        if (log)
+            log->Printf("NativeProcessDarwin::%s(): task 0x%x is already "
+                        "running, ignoring...", __FUNCTION__,
+                        TaskPortForProcessID(error));
+        return error;
+    }
+
+    // We can't resume from this state.
+    error.SetErrorStringWithFormat("task 0x%x has state %s, can't resume",
+                                   TaskPortForProcessID(error),
+                                   StateAsCString(state));
+    return error;
+}
+
+Error
+NativeProcessDarwin::Halt()
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+Error
+NativeProcessDarwin::Detach()
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+Error
+NativeProcessDarwin::Signal(int signo)
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+Error
+NativeProcessDarwin::Interrupt()
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+Error
+NativeProcessDarwin::Kill()
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+Error
+NativeProcessDarwin::GetMemoryRegionInfo(lldb::addr_t load_addr,
+                                         MemoryRegionInfo &range_info)
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+Error
+NativeProcessDarwin::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                                size_t &bytes_read)
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+Error
+NativeProcessDarwin::ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf,
+                                           size_t size, size_t &bytes_read)
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+Error
+NativeProcessDarwin::WriteMemory(lldb::addr_t addr, const void *buf,
+                                 size_t size, size_t &bytes_written)
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+Error
+NativeProcessDarwin::AllocateMemory(size_t size, uint32_t permissions,
+                                    lldb::addr_t &addr)
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+Error
+NativeProcessDarwin::DeallocateMemory(lldb::addr_t addr)
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+lldb::addr_t
+NativeProcessDarwin::GetSharedLibraryInfoAddress()
+{
+    return LLDB_INVALID_ADDRESS;
+}
+
+size_t
+NativeProcessDarwin::UpdateThreads()
+{
+    return 0;
+}
+
+bool
+NativeProcessDarwin::GetArchitecture(ArchSpec &arch) const
+{
+    return false;
+}
+
+Error
+NativeProcessDarwin::SetBreakpoint(lldb::addr_t addr, uint32_t size,
+                                   bool hardware)
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+void
+NativeProcessDarwin::DoStopIDBumped(uint32_t newBumpId)
+{
+}
+
+Error
+NativeProcessDarwin::GetLoadedModuleFileSpec(const char* module_path,
+                                             FileSpec& file_spec)
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+Error
+NativeProcessDarwin::GetFileLoadAddress(const llvm::StringRef& file_name,
+                                        lldb::addr_t& load_addr)
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}
+
+// -----------------------------------------------------------------
+// NativeProcessProtocol protected interface
+// -----------------------------------------------------------------
+Error
+NativeProcessDarwin::GetSoftwareBreakpointTrapOpcode(size_t
+                                                     trap_opcode_size_hint,
+                                                     size_t &actual_opcode_size,
+                                                     const uint8_t
+                                                     *&trap_opcode_bytes)
+{
+    Error error;
+    error.SetErrorString("TODO: implement");
+    return error;
+}