1 files changed, 0 insertions, 3919 deletions

diff --git a/tools/debugserver/source/MacOSX/MachProcess.mm b/tools/debugserver/source/MacOSX/MachProcess.mm
deleted file mode 100644
index a3b905d05150..000000000000
--- a/tools/debugserver/source/MacOSX/MachProcess.mm
+++ /dev/null
@@ -1,3919 +0,0 @@
-//===-- MachProcess.cpp -----------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-//  Created by Greg Clayton on 6/15/07.
-//
-//===----------------------------------------------------------------------===//
-
-#include "DNB.h"
-#include "MacOSX/CFUtils.h"
-#include "SysSignal.h"
-#include <dlfcn.h>
-#include <inttypes.h>
-#include <mach-o/loader.h>
-#include <mach/mach.h>
-#include <mach/task.h>
-#include <pthread.h>
-#include <signal.h>
-#include <spawn.h>
-#include <sys/fcntl.h>
-#include <sys/ptrace.h>
-#include <sys/stat.h>
-#include <sys/sysctl.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <uuid/uuid.h>
-
-#include <algorithm>
-#include <map>
-
-#import <Foundation/Foundation.h>
-
-#include "DNBDataRef.h"
-#include "DNBLog.h"
-#include "DNBThreadResumeActions.h"
-#include "DNBTimer.h"
-#include "MachProcess.h"
-#include "PseudoTerminal.h"
-
-#include "CFBundle.h"
-#include "CFString.h"
-
-#ifdef WITH_SPRINGBOARD
-
-#include <CoreFoundation/CoreFoundation.h>
-#include <SpringBoardServices/SBSWatchdogAssertion.h>
-#include <SpringBoardServices/SpringBoardServer.h>
-
-static bool IsSBProcess(nub_process_t pid) {
-  CFReleaser<CFArrayRef> appIdsForPID(
-      ::SBSCopyDisplayIdentifiersForProcessID(pid));
-  return appIdsForPID.get() != NULL;
-}
-
-#endif // WITH_SPRINGBOARD
-
-#if defined(WITH_SPRINGBOARD) || defined(WITH_BKS) || defined(WITH_FBS)
-// This returns a CFRetained pointer to the Bundle ID for app_bundle_path,
-// or NULL if there was some problem getting the bundle id.
-static CFStringRef CopyBundleIDForPath(const char *app_bundle_path,
-                                       DNBError &err_str);
-#endif
-
-#if defined(WITH_BKS) || defined(WITH_FBS)
-#import <Foundation/Foundation.h>
-static const int OPEN_APPLICATION_TIMEOUT_ERROR = 111;
-typedef void (*SetErrorFunction)(NSInteger, DNBError &);
-typedef bool (*CallOpenApplicationFunction)(NSString *bundleIDNSStr,
-                                            NSDictionary *options,
-                                            DNBError &error, pid_t *return_pid);
-// This function runs the BKSSystemService (or FBSSystemService) method
-// openApplication:options:clientPort:withResult,
-// messaging the app passed in bundleIDNSStr.
-// The function should be run inside of an NSAutoReleasePool.
-//
-// It will use the "options" dictionary passed in, and fill the error passed in
-// if there is an error.
-// If return_pid is not NULL, we'll fetch the pid that was made for the
-// bundleID.
-// If bundleIDNSStr is NULL, then the system application will be messaged.
-
-template <typename OpenFlavor, typename ErrorFlavor,
-          ErrorFlavor no_error_enum_value, SetErrorFunction error_function>
-static bool CallBoardSystemServiceOpenApplication(NSString *bundleIDNSStr,
-                                                  NSDictionary *options,
-                                                  DNBError &error,
-                                                  pid_t *return_pid) {
-  // Now make our systemService:
-  OpenFlavor *system_service = [[OpenFlavor alloc] init];
-
-  if (bundleIDNSStr == nil) {
-    bundleIDNSStr = [system_service systemApplicationBundleIdentifier];
-    if (bundleIDNSStr == nil) {
-      // Okay, no system app...
-      error.SetErrorString("No system application to message.");
-      return false;
-    }
-  }
-
-  mach_port_t client_port = [system_service createClientPort];
-  __block dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
-  __block ErrorFlavor open_app_error = no_error_enum_value;
-  bool wants_pid = (return_pid != NULL);
-  __block pid_t pid_in_block;
-
-  const char *cstr = [bundleIDNSStr UTF8String];
-  if (!cstr)
-    cstr = "<Unknown Bundle ID>";
-
-  NSString *description = [options description];
-  DNBLog("About to launch process for bundle ID: %s - options:\n%s", cstr,
-    [description UTF8String]);
-  [system_service
-      openApplication:bundleIDNSStr
-              options:options
-           clientPort:client_port
-           withResult:^(NSError *bks_error) {
-             // The system service will cleanup the client port we created for
-             // us.
-             if (bks_error)
-               open_app_error = (ErrorFlavor)[bks_error code];
-
-             if (open_app_error == no_error_enum_value) {
-               if (wants_pid) {
-                 pid_in_block =
-                     [system_service pidForApplication:bundleIDNSStr];
-                 DNBLog(
-                     "In completion handler, got pid for bundle id, pid: %d.",
-                     pid_in_block);
-                 DNBLogThreadedIf(
-                     LOG_PROCESS,
-                     "In completion handler, got pid for bundle id, pid: %d.",
-                     pid_in_block);
-               } else
-                 DNBLogThreadedIf(LOG_PROCESS,
-                                  "In completion handler: success.");
-             } else {
-               const char *error_str =
-                   [(NSString *)[bks_error localizedDescription] UTF8String];
-               DNBLogThreadedIf(LOG_PROCESS, "In completion handler for send "
-                                             "event, got error \"%s\"(%ld).",
-                                error_str ? error_str : "<unknown error>",
-                                open_app_error);
-               // REMOVE ME
-               DNBLogError("In completion handler for send event, got error "
-                           "\"%s\"(%ld).",
-                           error_str ? error_str : "<unknown error>",
-                           open_app_error);
-             }
-
-             [system_service release];
-             dispatch_semaphore_signal(semaphore);
-           }
-
-  ];
-
-  const uint32_t timeout_secs = 30;
-
-  dispatch_time_t timeout =
-      dispatch_time(DISPATCH_TIME_NOW, timeout_secs * NSEC_PER_SEC);
-
-  long success = dispatch_semaphore_wait(semaphore, timeout) == 0;
-
-  dispatch_release(semaphore);
-
-  if (!success) {
-    DNBLogError("timed out trying to send openApplication to %s.", cstr);
-    error.SetError(OPEN_APPLICATION_TIMEOUT_ERROR, DNBError::Generic);
-    error.SetErrorString("timed out trying to launch app");
-  } else if (open_app_error != no_error_enum_value) {
-    error_function(open_app_error, error);
-    DNBLogError("unable to launch the application with CFBundleIdentifier '%s' "
-                "bks_error = %u",
-                cstr, open_app_error);
-    success = false;
-  } else if (wants_pid) {
-    *return_pid = pid_in_block;
-    DNBLogThreadedIf(
-        LOG_PROCESS,
-        "Out of completion handler, pid from block %d and passing out: %d",
-        pid_in_block, *return_pid);
-  }
-
-  return success;
-}
-#endif
-
-#if defined(WITH_BKS) || defined(WITH_FBS)
-static void SplitEventData(const char *data, std::vector<std::string> &elements)
-{
-  elements.clear();
-  if (!data)
-    return;
-
-  const char *start = data;
-
-  while (*start != '\0') {
-    const char *token = strchr(start, ':');
-    if (!token) {
-      elements.push_back(std::string(start));
-      return;
-    }
-    if (token != start)
-      elements.push_back(std::string(start, token - start));
-    start = ++token;
-  }
-}
-#endif
-
-#ifdef WITH_BKS
-#import <Foundation/Foundation.h>
-extern "C" {
-#import <BackBoardServices/BKSOpenApplicationConstants_Private.h>
-#import <BackBoardServices/BKSSystemService_LaunchServices.h>
-#import <BackBoardServices/BackBoardServices.h>
-}
-
-static bool IsBKSProcess(nub_process_t pid) {
-  BKSApplicationStateMonitor *state_monitor =
-      [[BKSApplicationStateMonitor alloc] init];
-  BKSApplicationState app_state =
-      [state_monitor mostElevatedApplicationStateForPID:pid];
-  return app_state != BKSApplicationStateUnknown;
-}
-
-static void SetBKSError(NSInteger error_code, DNBError &error) {
-  error.SetError(error_code, DNBError::BackBoard);
-  NSString *err_nsstr = ::BKSOpenApplicationErrorCodeToString(
-      (BKSOpenApplicationErrorCode)error_code);
-  const char *err_str = NULL;
-  if (err_nsstr == NULL)
-    err_str = "unknown BKS error";
-  else {
-    err_str = [err_nsstr UTF8String];
-    if (err_str == NULL)
-      err_str = "unknown BKS error";
-  }
-  error.SetErrorString(err_str);
-}
-
-static bool BKSAddEventDataToOptions(NSMutableDictionary *options,
-                                     const char *event_data,
-                                     DNBError &option_error) {
-  std::vector<std::string> values;
-  SplitEventData(event_data, values);
-  bool found_one = false;
-  for (std::string value : values)
-  {
-      if (value.compare("BackgroundContentFetching") == 0) {
-        DNBLog("Setting ActivateForEvent key in options dictionary.");
-        NSDictionary *event_details = [NSDictionary dictionary];
-        NSDictionary *event_dictionary = [NSDictionary
-            dictionaryWithObject:event_details
-                          forKey:
-                              BKSActivateForEventOptionTypeBackgroundContentFetching];
-        [options setObject:event_dictionary
-                    forKey:BKSOpenApplicationOptionKeyActivateForEvent];
-        found_one = true;
-      } else if (value.compare("ActivateSuspended") == 0) {
-        DNBLog("Setting ActivateSuspended key in options dictionary.");
-        [options setObject:@YES forKey: BKSOpenApplicationOptionKeyActivateSuspended];
-        found_one = true;
-      } else {
-        DNBLogError("Unrecognized event type: %s.  Ignoring.", value.c_str());
-        option_error.SetErrorString("Unrecognized event data");
-      }
-  }
-  return found_one;
-}
-
-static NSMutableDictionary *BKSCreateOptionsDictionary(
-    const char *app_bundle_path, NSMutableArray *launch_argv,
-    NSMutableDictionary *launch_envp, NSString *stdio_path, bool disable_aslr,
-    const char *event_data) {
-  NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
-  if (launch_argv != nil)
-    [debug_options setObject:launch_argv forKey:BKSDebugOptionKeyArguments];
-  if (launch_envp != nil)
-    [debug_options setObject:launch_envp forKey:BKSDebugOptionKeyEnvironment];
-
-  [debug_options setObject:stdio_path forKey:BKSDebugOptionKeyStandardOutPath];
-  [debug_options setObject:stdio_path
-                    forKey:BKSDebugOptionKeyStandardErrorPath];
-  [debug_options setObject:[NSNumber numberWithBool:YES]
-                    forKey:BKSDebugOptionKeyWaitForDebugger];
-  if (disable_aslr)
-    [debug_options setObject:[NSNumber numberWithBool:YES]
-                      forKey:BKSDebugOptionKeyDisableASLR];
-
-  // That will go in the overall dictionary:
-
-  NSMutableDictionary *options = [NSMutableDictionary dictionary];
-  [options setObject:debug_options
-              forKey:BKSOpenApplicationOptionKeyDebuggingOptions];
-  // And there are some other options at the top level in this dictionary:
-  [options setObject:[NSNumber numberWithBool:YES]
-              forKey:BKSOpenApplicationOptionKeyUnlockDevice];
-
-  DNBError error;
-  BKSAddEventDataToOptions(options, event_data, error);
-
-  return options;
-}
-
-static CallOpenApplicationFunction BKSCallOpenApplicationFunction =
-    CallBoardSystemServiceOpenApplication<
-        BKSSystemService, BKSOpenApplicationErrorCode,
-        BKSOpenApplicationErrorCodeNone, SetBKSError>;
-#endif // WITH_BKS
-
-#ifdef WITH_FBS
-#import <Foundation/Foundation.h>
-extern "C" {
-#import <FrontBoardServices/FBSOpenApplicationConstants_Private.h>
-#import <FrontBoardServices/FBSSystemService_LaunchServices.h>
-#import <FrontBoardServices/FrontBoardServices.h>
-#import <MobileCoreServices/LSResourceProxy.h>
-#import <MobileCoreServices/MobileCoreServices.h>
-}
-
-#ifdef WITH_BKS
-static bool IsFBSProcess(nub_process_t pid) {
-  BKSApplicationStateMonitor *state_monitor =
-      [[BKSApplicationStateMonitor alloc] init];
-  BKSApplicationState app_state =
-      [state_monitor mostElevatedApplicationStateForPID:pid];
-  return app_state != BKSApplicationStateUnknown;
-}
-#else
-static bool IsFBSProcess(nub_process_t pid) {
-  // FIXME: What is the FBS equivalent of BKSApplicationStateMonitor
-  return true;
-}
-#endif
-
-static void SetFBSError(NSInteger error_code, DNBError &error) {
-  error.SetError((DNBError::ValueType)error_code, DNBError::FrontBoard);
-  NSString *err_nsstr = ::FBSOpenApplicationErrorCodeToString(
-      (FBSOpenApplicationErrorCode)error_code);
-  const char *err_str = NULL;
-  if (err_nsstr == NULL)
-    err_str = "unknown FBS error";
-  else {
-    err_str = [err_nsstr UTF8String];
-    if (err_str == NULL)
-      err_str = "unknown FBS error";
-  }
-  error.SetErrorString(err_str);
-}
-
-static bool FBSAddEventDataToOptions(NSMutableDictionary *options,
-                                     const char *event_data,
-                                     DNBError &option_error) {
-  std::vector<std::string> values;
-  SplitEventData(event_data, values);
-  bool found_one = false;
-  for (std::string value : values)
-  {
-      if (value.compare("BackgroundContentFetching") == 0) {
-        DNBLog("Setting ActivateForEvent key in options dictionary.");
-        NSDictionary *event_details = [NSDictionary dictionary];
-        NSDictionary *event_dictionary = [NSDictionary
-            dictionaryWithObject:event_details
-                          forKey:
-                              FBSActivateForEventOptionTypeBackgroundContentFetching];
-        [options setObject:event_dictionary
-                    forKey:FBSOpenApplicationOptionKeyActivateForEvent];
-        found_one = true;
-      } else if (value.compare("ActivateSuspended") == 0) {
-        DNBLog("Setting ActivateSuspended key in options dictionary.");
-        [options setObject:@YES forKey: FBSOpenApplicationOptionKeyActivateSuspended];
-        found_one = true;
-      } else {
-        DNBLogError("Unrecognized event type: %s.  Ignoring.", value.c_str());
-        option_error.SetErrorString("Unrecognized event data.");
-      }
-  }
-  return found_one;
-}
-
-static NSMutableDictionary *
-FBSCreateOptionsDictionary(const char *app_bundle_path,
-                           NSMutableArray *launch_argv,
-                           NSDictionary *launch_envp, NSString *stdio_path,
-                           bool disable_aslr, const char *event_data) {
-  NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
-
-  if (launch_argv != nil)
-    [debug_options setObject:launch_argv forKey:FBSDebugOptionKeyArguments];
-  if (launch_envp != nil)
-    [debug_options setObject:launch_envp forKey:FBSDebugOptionKeyEnvironment];
-
-  [debug_options setObject:stdio_path forKey:FBSDebugOptionKeyStandardOutPath];
-  [debug_options setObject:stdio_path
-                    forKey:FBSDebugOptionKeyStandardErrorPath];
-  [debug_options setObject:[NSNumber numberWithBool:YES]
-                    forKey:FBSDebugOptionKeyWaitForDebugger];
-  if (disable_aslr)
-    [debug_options setObject:[NSNumber numberWithBool:YES]
-                      forKey:FBSDebugOptionKeyDisableASLR];
-
-  // That will go in the overall dictionary:
-
-  NSMutableDictionary *options = [NSMutableDictionary dictionary];
-  [options setObject:debug_options
-              forKey:FBSOpenApplicationOptionKeyDebuggingOptions];
-  // And there are some other options at the top level in this dictionary:
-  [options setObject:[NSNumber numberWithBool:YES]
-              forKey:FBSOpenApplicationOptionKeyUnlockDevice];
-
-  // We have to get the "sequence ID & UUID" for this app bundle path and send
-  // them to FBS:
-
-  NSURL *app_bundle_url =
-      [NSURL fileURLWithPath:[NSString stringWithUTF8String:app_bundle_path]
-                 isDirectory:YES];
-  LSApplicationProxy *app_proxy =
-      [LSApplicationProxy applicationProxyForBundleURL:app_bundle_url];
-  if (app_proxy) {
-    DNBLog("Sending AppProxy info: sequence no: %lu, GUID: %s.",
-           app_proxy.sequenceNumber,
-           [app_proxy.cacheGUID.UUIDString UTF8String]);
-    [options
-        setObject:[NSNumber numberWithUnsignedInteger:app_proxy.sequenceNumber]
-           forKey:FBSOpenApplicationOptionKeyLSSequenceNumber];
-    [options setObject:app_proxy.cacheGUID.UUIDString
-                forKey:FBSOpenApplicationOptionKeyLSCacheGUID];
-  }
-
-  DNBError error;
-  FBSAddEventDataToOptions(options, event_data, error);
-
-  return options;
-}
-static CallOpenApplicationFunction FBSCallOpenApplicationFunction =
-    CallBoardSystemServiceOpenApplication<
-        FBSSystemService, FBSOpenApplicationErrorCode,
-        FBSOpenApplicationErrorCodeNone, SetFBSError>;
-#endif // WITH_FBS
-
-#if 0
-#define DEBUG_LOG(fmt, ...) printf(fmt, ##__VA_ARGS__)
-#else
-#define DEBUG_LOG(fmt, ...)
-#endif
-
-#ifndef MACH_PROCESS_USE_POSIX_SPAWN
-#define MACH_PROCESS_USE_POSIX_SPAWN 1
-#endif
-
-#ifndef _POSIX_SPAWN_DISABLE_ASLR
-#define _POSIX_SPAWN_DISABLE_ASLR 0x0100
-#endif
-
-MachProcess::MachProcess()
-    : m_pid(0), m_cpu_type(0), m_child_stdin(-1), m_child_stdout(-1),
-      m_child_stderr(-1), m_path(), m_args(), m_task(this),
-      m_flags(eMachProcessFlagsNone), m_stdio_thread(0),
-      m_stdio_mutex(PTHREAD_MUTEX_RECURSIVE), m_stdout_data(),
-      m_profile_enabled(false), m_profile_interval_usec(0), m_profile_thread(0),
-      m_profile_data_mutex(PTHREAD_MUTEX_RECURSIVE), m_profile_data(),
-      m_thread_actions(), m_exception_messages(),
-      m_exception_messages_mutex(PTHREAD_MUTEX_RECURSIVE), m_thread_list(),
-      m_activities(), m_state(eStateUnloaded),
-      m_state_mutex(PTHREAD_MUTEX_RECURSIVE), m_events(0, kAllEventsMask),
-      m_private_events(0, kAllEventsMask), m_breakpoints(), m_watchpoints(),
-      m_name_to_addr_callback(NULL), m_name_to_addr_baton(NULL),
-      m_image_infos_callback(NULL), m_image_infos_baton(NULL),
-      m_sent_interrupt_signo(0), m_auto_resume_signo(0), m_did_exec(false),
-      m_dyld_process_info_create(nullptr),
-      m_dyld_process_info_for_each_image(nullptr),
-      m_dyld_process_info_release(nullptr),
-      m_dyld_process_info_get_cache(nullptr) {
-  m_dyld_process_info_create =
-      (void *(*)(task_t task, uint64_t timestamp, kern_return_t * kernelError))
-          dlsym(RTLD_DEFAULT, "_dyld_process_info_create");
-  m_dyld_process_info_for_each_image =
-      (void (*)(void *info, void (^)(uint64_t machHeaderAddress,
-                                     const uuid_t uuid, const char *path)))
-          dlsym(RTLD_DEFAULT, "_dyld_process_info_for_each_image");
-  m_dyld_process_info_release =
-      (void (*)(void *info))dlsym(RTLD_DEFAULT, "_dyld_process_info_release");
-  m_dyld_process_info_get_cache = (void (*)(void *info, void *cacheInfo))dlsym(
-      RTLD_DEFAULT, "_dyld_process_info_get_cache");
-
-  DNBLogThreadedIf(LOG_PROCESS | LOG_VERBOSE, "%s", __PRETTY_FUNCTION__);
-}
-
-MachProcess::~MachProcess() {
-  DNBLogThreadedIf(LOG_PROCESS | LOG_VERBOSE, "%s", __PRETTY_FUNCTION__);
-  Clear();
-}
-
-pid_t MachProcess::SetProcessID(pid_t pid) {
-  // Free any previous process specific data or resources
-  Clear();
-  // Set the current PID appropriately
-  if (pid == 0)
-    m_pid = ::getpid();
-  else
-    m_pid = pid;
-  return m_pid; // Return actually PID in case a zero pid was passed in
-}
-
-nub_state_t MachProcess::GetState() {
-  // If any other threads access this we will need a mutex for it
-  PTHREAD_MUTEX_LOCKER(locker, m_state_mutex);
-  return m_state;
-}
-
-const char *MachProcess::ThreadGetName(nub_thread_t tid) {
-  return m_thread_list.GetName(tid);
-}
-
-nub_state_t MachProcess::ThreadGetState(nub_thread_t tid) {
-  return m_thread_list.GetState(tid);
-}
-
-nub_size_t MachProcess::GetNumThreads() const {
-  return m_thread_list.NumThreads();
-}
-
-nub_thread_t MachProcess::GetThreadAtIndex(nub_size_t thread_idx) const {
-  return m_thread_list.ThreadIDAtIndex(thread_idx);
-}
-
-nub_thread_t
-MachProcess::GetThreadIDForMachPortNumber(thread_t mach_port_number) const {
-  return m_thread_list.GetThreadIDByMachPortNumber(mach_port_number);
-}
-
-nub_bool_t MachProcess::SyncThreadState(nub_thread_t tid) {
-  MachThreadSP thread_sp(m_thread_list.GetThreadByID(tid));
-  if (!thread_sp)
-    return false;
-  kern_return_t kret = ::thread_abort_safely(thread_sp->MachPortNumber());
-  DNBLogThreadedIf(LOG_THREAD, "thread = 0x%8.8" PRIx32
-                               " calling thread_abort_safely (tid) => %u "
-                               "(GetGPRState() for stop_count = %u)",
-                   thread_sp->MachPortNumber(), kret,
-                   thread_sp->Process()->StopCount());
-
-  if (kret == KERN_SUCCESS)
-    return true;
-  else
-    return false;
-}
-
-ThreadInfo::QoS MachProcess::GetRequestedQoS(nub_thread_t tid, nub_addr_t tsd,
-                                             uint64_t dti_qos_class_index) {
-  return m_thread_list.GetRequestedQoS(tid, tsd, dti_qos_class_index);
-}
-
-nub_addr_t MachProcess::GetPThreadT(nub_thread_t tid) {
-  return m_thread_list.GetPThreadT(tid);
-}
-
-nub_addr_t MachProcess::GetDispatchQueueT(nub_thread_t tid) {
-  return m_thread_list.GetDispatchQueueT(tid);
-}
-
-nub_addr_t MachProcess::GetTSDAddressForThread(
-    nub_thread_t tid, uint64_t plo_pthread_tsd_base_address_offset,
-    uint64_t plo_pthread_tsd_base_offset, uint64_t plo_pthread_tsd_entry_size) {
-  return m_thread_list.GetTSDAddressForThread(
-      tid, plo_pthread_tsd_base_address_offset, plo_pthread_tsd_base_offset,
-      plo_pthread_tsd_entry_size);
-}
-
-
-const char *MachProcess::GetDeploymentInfo(const struct load_command& lc,
-                                           uint64_t load_command_address,
-                                           uint32_t& major_version,
-                                           uint32_t& minor_version,
-                                           uint32_t& patch_version) {
-  uint32_t cmd = lc.cmd & ~LC_REQ_DYLD;
-  bool lc_cmd_known =
-    cmd == LC_VERSION_MIN_IPHONEOS || cmd == LC_VERSION_MIN_MACOSX ||
-    cmd == LC_VERSION_MIN_TVOS || cmd == LC_VERSION_MIN_WATCHOS;
-
-  if (lc_cmd_known) {
-    struct version_min_command vers_cmd;
-    if (ReadMemory(load_command_address, sizeof(struct version_min_command),
-                   &vers_cmd) != sizeof(struct version_min_command)) {
-      return nullptr;
-    }
-    major_version = vers_cmd.sdk >> 16;
-    minor_version = (vers_cmd.sdk >> 8) & 0xffu;
-    patch_version = vers_cmd.sdk & 0xffu;
-
-    switch (cmd) {
-    case LC_VERSION_MIN_IPHONEOS:
-      return "ios";
-    case LC_VERSION_MIN_MACOSX:
-      return "macosx";
-    case LC_VERSION_MIN_TVOS:
-      return "tvos";
-    case LC_VERSION_MIN_WATCHOS:
-      return "watchos";
-    default:
-      return nullptr;
-    }
-  }
-#if defined (LC_BUILD_VERSION)
-#ifndef PLATFORM_IOSSIMULATOR
-#define PLATFORM_IOSSIMULATOR 7
-#define PLATFORM_TVOSSIMULATOR 8
-#define PLATFORM_WATCHOSSIMULATOR 9
-#endif
-  if (cmd == LC_BUILD_VERSION) {
-    struct build_version_command build_vers;
-    if (ReadMemory(load_command_address, sizeof(struct build_version_command),
-                   &build_vers) != sizeof(struct build_version_command)) {
-      return nullptr;
-    }
-    major_version = build_vers.sdk >> 16;;
-    minor_version = (build_vers.sdk >> 8) & 0xffu;
-    patch_version = build_vers.sdk & 0xffu;
-
-    switch (build_vers.platform) {
-    case PLATFORM_MACOS:
-      return "macosx";
-    case PLATFORM_IOS:
-    case PLATFORM_IOSSIMULATOR:
-      return "ios";
-    case PLATFORM_TVOS:
-    case PLATFORM_TVOSSIMULATOR:
-      return "tvos";
-    case PLATFORM_WATCHOS:
-    case PLATFORM_WATCHOSSIMULATOR:
-      return "watchos";
-    case PLATFORM_BRIDGEOS:
-      return "bridgeos";
-    }
-  }
-#endif
-  return nullptr;
-}
-
-// Given an address, read the mach-o header and load commands out of memory to
-// fill in
-// the mach_o_information "inf" object.
-//
-// Returns false if there was an error in reading this mach-o file header/load
-// commands.
-
-bool MachProcess::GetMachOInformationFromMemory(
-    nub_addr_t mach_o_header_addr, int wordsize,
-    struct mach_o_information &inf) {
-  uint64_t load_cmds_p;
-  if (wordsize == 4) {
-    struct mach_header header;
-    if (ReadMemory(mach_o_header_addr, sizeof(struct mach_header), &header) !=
-        sizeof(struct mach_header)) {
-      return false;
-    }
-    load_cmds_p = mach_o_header_addr + sizeof(struct mach_header);
-    inf.mach_header.magic = header.magic;
-    inf.mach_header.cputype = header.cputype;
-    // high byte of cpusubtype is used for "capability bits", v.
-    // CPU_SUBTYPE_MASK, CPU_SUBTYPE_LIB64 in machine.h
-    inf.mach_header.cpusubtype = header.cpusubtype & 0x00ffffff;
-    inf.mach_header.filetype = header.filetype;
-    inf.mach_header.ncmds = header.ncmds;
-    inf.mach_header.sizeofcmds = header.sizeofcmds;
-    inf.mach_header.flags = header.flags;
-  } else {
-    struct mach_header_64 header;
-    if (ReadMemory(mach_o_header_addr, sizeof(struct mach_header_64),
-                   &header) != sizeof(struct mach_header_64)) {
-      return false;
-    }
-    load_cmds_p = mach_o_header_addr + sizeof(struct mach_header_64);
-    inf.mach_header.magic = header.magic;
-    inf.mach_header.cputype = header.cputype;
-    // high byte of cpusubtype is used for "capability bits", v.
-    // CPU_SUBTYPE_MASK, CPU_SUBTYPE_LIB64 in machine.h
-    inf.mach_header.cpusubtype = header.cpusubtype & 0x00ffffff;
-    inf.mach_header.filetype = header.filetype;
-    inf.mach_header.ncmds = header.ncmds;
-    inf.mach_header.sizeofcmds = header.sizeofcmds;
-    inf.mach_header.flags = header.flags;
-  }
-  for (uint32_t j = 0; j < inf.mach_header.ncmds; j++) {
-    struct load_command lc;
-    if (ReadMemory(load_cmds_p, sizeof(struct load_command), &lc) !=
-        sizeof(struct load_command)) {
-      return false;
-    }
-    if (lc.cmd == LC_SEGMENT) {
-      struct segment_command seg;
-      if (ReadMemory(load_cmds_p, sizeof(struct segment_command), &seg) !=
-          sizeof(struct segment_command)) {
-        return false;
-      }
-      struct mach_o_segment this_seg;
-      char name[17];
-      ::memset(name, 0, sizeof(name));
-      memcpy(name, seg.segname, sizeof(seg.segname));
-      this_seg.name = name;
-      this_seg.vmaddr = seg.vmaddr;
-      this_seg.vmsize = seg.vmsize;
-      this_seg.fileoff = seg.fileoff;
-      this_seg.filesize = seg.filesize;
-      this_seg.maxprot = seg.maxprot;
-      this_seg.initprot = seg.initprot;
-      this_seg.nsects = seg.nsects;
-      this_seg.flags = seg.flags;
-      inf.segments.push_back(this_seg);
-    }
-    if (lc.cmd == LC_SEGMENT_64) {
-      struct segment_command_64 seg;
-      if (ReadMemory(load_cmds_p, sizeof(struct segment_command_64), &seg) !=
-          sizeof(struct segment_command_64)) {
-        return false;
-      }
-      struct mach_o_segment this_seg;
-      char name[17];
-      ::memset(name, 0, sizeof(name));
-      memcpy(name, seg.segname, sizeof(seg.segname));
-      this_seg.name = name;
-      this_seg.vmaddr = seg.vmaddr;
-      this_seg.vmsize = seg.vmsize;
-      this_seg.fileoff = seg.fileoff;
-      this_seg.filesize = seg.filesize;
-      this_seg.maxprot = seg.maxprot;
-      this_seg.initprot = seg.initprot;
-      this_seg.nsects = seg.nsects;
-      this_seg.flags = seg.flags;
-      inf.segments.push_back(this_seg);
-    }
-    if (lc.cmd == LC_UUID) {
-      struct uuid_command uuidcmd;
-      if (ReadMemory(load_cmds_p, sizeof(struct uuid_command), &uuidcmd) ==
-          sizeof(struct uuid_command))
-        uuid_copy(inf.uuid, uuidcmd.uuid);
-    }
-
-    uint32_t major_version, minor_version, patch_version;
-    if (const char *platform = GetDeploymentInfo(lc, load_cmds_p,
-                                                 major_version, minor_version,
-                                                 patch_version)) {
-      inf.min_version_os_name = platform;
-      inf.min_version_os_version = "";
-      inf.min_version_os_version += std::to_string(major_version);
-      inf.min_version_os_version += ".";
-      inf.min_version_os_version += std::to_string(minor_version);
-      if (patch_version != 0) {
-        inf.min_version_os_version += ".";
-        inf.min_version_os_version += std::to_string(patch_version);
-      }
-    }
-
-    load_cmds_p += lc.cmdsize;
-  }
-  return true;
-}
-
-// Given completely filled in array of binary_image_information structures,
-// create a JSONGenerator object
-// with all the details we want to send to lldb.
-JSONGenerator::ObjectSP MachProcess::FormatDynamicLibrariesIntoJSON(
-    const std::vector<struct binary_image_information> &image_infos) {
-
-  JSONGenerator::ArraySP image_infos_array_sp(new JSONGenerator::Array());
-
-  const size_t image_count = image_infos.size();
-
-  for (size_t i = 0; i < image_count; i++) {
-    JSONGenerator::DictionarySP image_info_dict_sp(
-        new JSONGenerator::Dictionary());
-    image_info_dict_sp->AddIntegerItem("load_address",
-                                       image_infos[i].load_address);
-    image_info_dict_sp->AddIntegerItem("mod_date", image_infos[i].mod_date);
-    image_info_dict_sp->AddStringItem("pathname", image_infos[i].filename);
-
-    uuid_string_t uuidstr;
-    uuid_unparse_upper(image_infos[i].macho_info.uuid, uuidstr);
-    image_info_dict_sp->AddStringItem("uuid", uuidstr);
-
-    if (!image_infos[i].macho_info.min_version_os_name.empty() &&
-        !image_infos[i].macho_info.min_version_os_version.empty()) {
-      image_info_dict_sp->AddStringItem(
-          "min_version_os_name", image_infos[i].macho_info.min_version_os_name);
-      image_info_dict_sp->AddStringItem(
-          "min_version_os_sdk",
-          image_infos[i].macho_info.min_version_os_version);
-    }
-
-    JSONGenerator::DictionarySP mach_header_dict_sp(
-        new JSONGenerator::Dictionary());
-    mach_header_dict_sp->AddIntegerItem(
-        "magic", image_infos[i].macho_info.mach_header.magic);
-    mach_header_dict_sp->AddIntegerItem(
-        "cputype", (uint32_t)image_infos[i].macho_info.mach_header.cputype);
-    mach_header_dict_sp->AddIntegerItem(
-        "cpusubtype",
-        (uint32_t)image_infos[i].macho_info.mach_header.cpusubtype);
-    mach_header_dict_sp->AddIntegerItem(
-        "filetype", image_infos[i].macho_info.mach_header.filetype);
-    mach_header_dict_sp->AddIntegerItem ("flags", 
-                         image_infos[i].macho_info.mach_header.flags);
-
-    //          DynamicLoaderMacOSX doesn't currently need these fields, so
-    //          don't send them.
-    //            mach_header_dict_sp->AddIntegerItem ("ncmds",
-    //            image_infos[i].macho_info.mach_header.ncmds);
-    //            mach_header_dict_sp->AddIntegerItem ("sizeofcmds",
-    //            image_infos[i].macho_info.mach_header.sizeofcmds);
-    image_info_dict_sp->AddItem("mach_header", mach_header_dict_sp);
-
-    JSONGenerator::ArraySP segments_sp(new JSONGenerator::Array());
-    for (size_t j = 0; j < image_infos[i].macho_info.segments.size(); j++) {
-      JSONGenerator::DictionarySP segment_sp(new JSONGenerator::Dictionary());
-      segment_sp->AddStringItem("name",
-                                image_infos[i].macho_info.segments[j].name);
-      segment_sp->AddIntegerItem("vmaddr",
-                                 image_infos[i].macho_info.segments[j].vmaddr);
-      segment_sp->AddIntegerItem("vmsize",
-                                 image_infos[i].macho_info.segments[j].vmsize);
-      segment_sp->AddIntegerItem("fileoff",
-                                 image_infos[i].macho_info.segments[j].fileoff);
-      segment_sp->AddIntegerItem(
-          "filesize", image_infos[i].macho_info.segments[j].filesize);
-      segment_sp->AddIntegerItem("maxprot",
-                                 image_infos[i].macho_info.segments[j].maxprot);
-
-      //              DynamicLoaderMacOSX doesn't currently need these fields,
-      //              so don't send them.
-      //                segment_sp->AddIntegerItem ("initprot",
-      //                image_infos[i].macho_info.segments[j].initprot);
-      //                segment_sp->AddIntegerItem ("nsects",
-      //                image_infos[i].macho_info.segments[j].nsects);
-      //                segment_sp->AddIntegerItem ("flags",
-      //                image_infos[i].macho_info.segments[j].flags);
-      segments_sp->AddItem(segment_sp);
-    }
-    image_info_dict_sp->AddItem("segments", segments_sp);
-
-    image_infos_array_sp->AddItem(image_info_dict_sp);
-  }
-
-  JSONGenerator::DictionarySP reply_sp(new JSONGenerator::Dictionary());
-  ;
-  reply_sp->AddItem("images", image_infos_array_sp);
-
-  return reply_sp;
-}
-
-// Get the shared library information using the old (pre-macOS 10.12, pre-iOS
-// 10, pre-tvOS 10, pre-watchOS 3)
-// code path.  We'll be given the address of an array of structures in the form
-// {void* load_addr, void* mod_date, void* pathname}
-//
-// In macOS 10.12 etc and newer, we'll use SPI calls into dyld to gather this
-// information.
-JSONGenerator::ObjectSP MachProcess::GetLoadedDynamicLibrariesInfos(
-    nub_process_t pid, nub_addr_t image_list_address, nub_addr_t image_count) {
-  JSONGenerator::DictionarySP reply_sp;
-
-  int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
-  struct kinfo_proc processInfo;
-  size_t bufsize = sizeof(processInfo);
-  if (sysctl(mib, (unsigned)(sizeof(mib) / sizeof(int)), &processInfo, &bufsize,
-             NULL, 0) == 0 &&
-      bufsize > 0) {
-    uint32_t pointer_size = 4;
-    if (processInfo.kp_proc.p_flag & P_LP64)
-      pointer_size = 8;
-
-    std::vector<struct binary_image_information> image_infos;
-    size_t image_infos_size = image_count * 3 * pointer_size;
-
-    uint8_t *image_info_buf = (uint8_t *)malloc(image_infos_size);
-    if (image_info_buf == NULL) {
-      return reply_sp;
-    }
-    if (ReadMemory(image_list_address, image_infos_size, image_info_buf) !=
-        image_infos_size) {
-      return reply_sp;
-    }
-
-    ////  First the image_infos array with (load addr, pathname, mod date)
-    ///tuples
-
-    for (size_t i = 0; i < image_count; i++) {
-      struct binary_image_information info;
-      nub_addr_t pathname_address;
-      if (pointer_size == 4) {
-        uint32_t load_address_32;
-        uint32_t pathname_address_32;
-        uint32_t mod_date_32;
-        ::memcpy(&load_address_32, image_info_buf + (i * 3 * pointer_size), 4);
-        ::memcpy(&pathname_address_32,
-                 image_info_buf + (i * 3 * pointer_size) + pointer_size, 4);
-        ::memcpy(&mod_date_32, image_info_buf + (i * 3 * pointer_size) +
-                                   pointer_size + pointer_size,
-                 4);
-        info.load_address = load_address_32;
-        info.mod_date = mod_date_32;
-        pathname_address = pathname_address_32;
-      } else {
-        uint64_t load_address_64;
-        uint64_t pathname_address_64;
-        uint64_t mod_date_64;
-        ::memcpy(&load_address_64, image_info_buf + (i * 3 * pointer_size), 8);
-        ::memcpy(&pathname_address_64,
-                 image_info_buf + (i * 3 * pointer_size) + pointer_size, 8);
-        ::memcpy(&mod_date_64, image_info_buf + (i * 3 * pointer_size) +
-                                   pointer_size + pointer_size,
-                 8);
-        info.load_address = load_address_64;
-        info.mod_date = mod_date_64;
-        pathname_address = pathname_address_64;
-      }
-      char strbuf[17];
-      info.filename = "";
-      uint64_t pathname_ptr = pathname_address;
-      bool still_reading = true;
-      while (still_reading &&
-             ReadMemory(pathname_ptr, sizeof(strbuf) - 1, strbuf) ==
-                 sizeof(strbuf) - 1) {
-        strbuf[sizeof(strbuf) - 1] = '\0';
-        info.filename += strbuf;
-        pathname_ptr += sizeof(strbuf) - 1;
-        // Stop if we found nul byte indicating the end of the string
-        for (size_t i = 0; i < sizeof(strbuf) - 1; i++) {
-          if (strbuf[i] == '\0') {
-            still_reading = false;
-            break;
-          }
-        }
-      }
-      uuid_clear(info.macho_info.uuid);
-      image_infos.push_back(info);
-    }
-    if (image_infos.size() == 0) {
-      return reply_sp;
-    }
-
-    free(image_info_buf);
-
-    ////  Second, read the mach header / load commands for all the dylibs
-
-    for (size_t i = 0; i < image_count; i++) {
-      if (!GetMachOInformationFromMemory(image_infos[i].load_address,
-                                         pointer_size,
-                                         image_infos[i].macho_info)) {
-        return reply_sp;
-      }
-    }
-
-    ////  Third, format all of the above in the JSONGenerator object.
-
-    return FormatDynamicLibrariesIntoJSON(image_infos);
-  }
-
-  return reply_sp;
-}
-
-// From dyld SPI header dyld_process_info.h
-typedef void *dyld_process_info;
-struct dyld_process_cache_info {
-  uuid_t cacheUUID;          // UUID of cache used by process
-  uint64_t cacheBaseAddress; // load address of dyld shared cache
-  bool noCache;              // process is running without a dyld cache
-  bool privateCache; // process is using a private copy of its dyld cache
-};
-
-// Use the dyld SPI present in macOS 10.12, iOS 10, tvOS 10, watchOS 3 and newer
-// to get
-// the load address, uuid, and filenames of all the libraries.
-// This only fills in those three fields in the 'struct
-// binary_image_information' - call
-// GetMachOInformationFromMemory to fill in the mach-o header/load command
-// details.
-void MachProcess::GetAllLoadedBinariesViaDYLDSPI(
-    std::vector<struct binary_image_information> &image_infos) {
-  kern_return_t kern_ret;
-  if (m_dyld_process_info_create) {
-    dyld_process_info info =
-        m_dyld_process_info_create(m_task.TaskPort(), 0, &kern_ret);
-    if (info) {
-      m_dyld_process_info_for_each_image(
-          info,
-          ^(uint64_t mach_header_addr, const uuid_t uuid, const char *path) {
-            struct binary_image_information image;
-            image.filename = path;
-            uuid_copy(image.macho_info.uuid, uuid);
-            image.load_address = mach_header_addr;
-            image_infos.push_back(image);
-          });
-      m_dyld_process_info_release(info);
-    }
-  }
-}
-
-// Fetch information about all shared libraries using the dyld SPIs that exist
-// in
-// macOS 10.12, iOS 10, tvOS 10, watchOS 3 and newer.
-JSONGenerator::ObjectSP
-MachProcess::GetAllLoadedLibrariesInfos(nub_process_t pid) {
-  JSONGenerator::DictionarySP reply_sp;
-
-  int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
-  struct kinfo_proc processInfo;
-  size_t bufsize = sizeof(processInfo);
-  if (sysctl(mib, (unsigned)(sizeof(mib) / sizeof(int)), &processInfo, &bufsize,
-             NULL, 0) == 0 &&
-      bufsize > 0) {
-    uint32_t pointer_size = 4;
-    if (processInfo.kp_proc.p_flag & P_LP64)
-      pointer_size = 8;
-
-    std::vector<struct binary_image_information> image_infos;
-    GetAllLoadedBinariesViaDYLDSPI(image_infos);
-    const size_t image_count = image_infos.size();
-    for (size_t i = 0; i < image_count; i++) {
-      GetMachOInformationFromMemory(image_infos[i].load_address, pointer_size,
-                                    image_infos[i].macho_info);
-    }
-    return FormatDynamicLibrariesIntoJSON(image_infos);
-  }
-  return reply_sp;
-}
-
-// Fetch information about the shared libraries at the given load addresses
-// using the
-// dyld SPIs that exist in macOS 10.12, iOS 10, tvOS 10, watchOS 3 and newer.
-JSONGenerator::ObjectSP MachProcess::GetLibrariesInfoForAddresses(
-    nub_process_t pid, std::vector<uint64_t> &macho_addresses) {
-  JSONGenerator::DictionarySP reply_sp;
-
-  int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
-  struct kinfo_proc processInfo;
-  size_t bufsize = sizeof(processInfo);
-  if (sysctl(mib, (unsigned)(sizeof(mib) / sizeof(int)), &processInfo, &bufsize,
-             NULL, 0) == 0 &&
-      bufsize > 0) {
-    uint32_t pointer_size = 4;
-    if (processInfo.kp_proc.p_flag & P_LP64)
-      pointer_size = 8;
-
-    std::vector<struct binary_image_information> all_image_infos;
-    GetAllLoadedBinariesViaDYLDSPI(all_image_infos);
-
-    std::vector<struct binary_image_information> image_infos;
-    const size_t macho_addresses_count = macho_addresses.size();
-    const size_t all_image_infos_count = all_image_infos.size();
-    for (size_t i = 0; i < macho_addresses_count; i++) {
-      for (size_t j = 0; j < all_image_infos_count; j++) {
-        if (all_image_infos[j].load_address == macho_addresses[i]) {
-          image_infos.push_back(all_image_infos[j]);
-        }
-      }
-    }
-
-    const size_t image_infos_count = image_infos.size();
-    for (size_t i = 0; i < image_infos_count; i++) {
-      GetMachOInformationFromMemory(image_infos[i].load_address, pointer_size,
-                                    image_infos[i].macho_info);
-    }
-    return FormatDynamicLibrariesIntoJSON(image_infos);
-  }
-  return reply_sp;
-}
-
-// From dyld's internal podyld_process_info.h:
-
-JSONGenerator::ObjectSP MachProcess::GetSharedCacheInfo(nub_process_t pid) {
-  JSONGenerator::DictionarySP reply_sp(new JSONGenerator::Dictionary());
-  ;
-  kern_return_t kern_ret;
-  if (m_dyld_process_info_create && m_dyld_process_info_get_cache) {
-    dyld_process_info info =
-        m_dyld_process_info_create(m_task.TaskPort(), 0, &kern_ret);
-    if (info) {
-      struct dyld_process_cache_info shared_cache_info;
-      m_dyld_process_info_get_cache(info, &shared_cache_info);
-
-      reply_sp->AddIntegerItem("shared_cache_base_address",
-                               shared_cache_info.cacheBaseAddress);
-
-      uuid_string_t uuidstr;
-      uuid_unparse_upper(shared_cache_info.cacheUUID, uuidstr);
-      reply_sp->AddStringItem("shared_cache_uuid", uuidstr);
-
-      reply_sp->AddBooleanItem("no_shared_cache", shared_cache_info.noCache);
-      reply_sp->AddBooleanItem("shared_cache_private_cache",
-                               shared_cache_info.privateCache);
-
-      m_dyld_process_info_release(info);
-    }
-  }
-  return reply_sp;
-}
-
-nub_thread_t MachProcess::GetCurrentThread() {
-  return m_thread_list.CurrentThreadID();
-}
-
-nub_thread_t MachProcess::GetCurrentThreadMachPort() {
-  return m_thread_list.GetMachPortNumberByThreadID(
-      m_thread_list.CurrentThreadID());
-}
-
-nub_thread_t MachProcess::SetCurrentThread(nub_thread_t tid) {
-  return m_thread_list.SetCurrentThread(tid);
-}
-
-bool MachProcess::GetThreadStoppedReason(nub_thread_t tid,
-                                         struct DNBThreadStopInfo *stop_info) {
-  if (m_thread_list.GetThreadStoppedReason(tid, stop_info)) {
-    if (m_did_exec)
-      stop_info->reason = eStopTypeExec;
-    return true;
-  }
-  return false;
-}
-
-void MachProcess::DumpThreadStoppedReason(nub_thread_t tid) const {
-  return m_thread_list.DumpThreadStoppedReason(tid);
-}
-
-const char *MachProcess::GetThreadInfo(nub_thread_t tid) const {
-  return m_thread_list.GetThreadInfo(tid);
-}
-
-uint32_t MachProcess::GetCPUType() {
-  if (m_cpu_type == 0 && m_pid != 0)
-    m_cpu_type = MachProcess::GetCPUTypeForLocalProcess(m_pid);
-  return m_cpu_type;
-}
-
-const DNBRegisterSetInfo *
-MachProcess::GetRegisterSetInfo(nub_thread_t tid,
-                                nub_size_t *num_reg_sets) const {
-  MachThreadSP thread_sp(m_thread_list.GetThreadByID(tid));
-  if (thread_sp) {
-    DNBArchProtocol *arch = thread_sp->GetArchProtocol();
-    if (arch)
-      return arch->GetRegisterSetInfo(num_reg_sets);
-  }
-  *num_reg_sets = 0;
-  return NULL;
-}
-
-bool MachProcess::GetRegisterValue(nub_thread_t tid, uint32_t set, uint32_t reg,
-                                   DNBRegisterValue *value) const {
-  return m_thread_list.GetRegisterValue(tid, set, reg, value);
-}
-
-bool MachProcess::SetRegisterValue(nub_thread_t tid, uint32_t set, uint32_t reg,
-                                   const DNBRegisterValue *value) const {
-  return m_thread_list.SetRegisterValue(tid, set, reg, value);
-}
-
-void MachProcess::SetState(nub_state_t new_state) {
-  // If any other threads access this we will need a mutex for it
-  uint32_t event_mask = 0;
-
-  // Scope for mutex locker
-  {
-    PTHREAD_MUTEX_LOCKER(locker, m_state_mutex);
-    const nub_state_t old_state = m_state;
-
-    if (old_state == eStateExited) {
-      DNBLogThreadedIf(LOG_PROCESS, "MachProcess::SetState(%s) ignoring new "
-                                    "state since current state is exited",
-                       DNBStateAsString(new_state));
-    } else if (old_state == new_state) {
-      DNBLogThreadedIf(
-          LOG_PROCESS,
-          "MachProcess::SetState(%s) ignoring redundant state change...",
-          DNBStateAsString(new_state));
-    } else {
-      if (NUB_STATE_IS_STOPPED(new_state))
-        event_mask = eEventProcessStoppedStateChanged;
-      else
-        event_mask = eEventProcessRunningStateChanged;
-
-      DNBLogThreadedIf(
-          LOG_PROCESS, "MachProcess::SetState(%s) upating state (previous "
-                       "state was %s), event_mask = 0x%8.8x",
-          DNBStateAsString(new_state), DNBStateAsString(old_state), event_mask);
-
-      m_state = new_state;
-      if (new_state == eStateStopped)
-        m_stop_count++;
-    }
-  }
-
-  if (event_mask != 0) {
-    m_events.SetEvents(event_mask);
-    m_private_events.SetEvents(event_mask);
-    if (event_mask == eEventProcessStoppedStateChanged)
-      m_private_events.ResetEvents(eEventProcessRunningStateChanged);
-    else
-      m_private_events.ResetEvents(eEventProcessStoppedStateChanged);
-
-    // Wait for the event bit to reset if a reset ACK is requested
-    m_events.WaitForResetAck(event_mask);
-  }
-}
-
-void MachProcess::Clear(bool detaching) {
-  // Clear any cached thread list while the pid and task are still valid
-
-  m_task.Clear();
-  // Now clear out all member variables
-  m_pid = INVALID_NUB_PROCESS;
-  if (!detaching)
-    CloseChildFileDescriptors();
-
-  m_path.clear();
-  m_args.clear();
-  SetState(eStateUnloaded);
-  m_flags = eMachProcessFlagsNone;
-  m_stop_count = 0;
-  m_thread_list.Clear();
-  {
-    PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
-    m_exception_messages.clear();
-  }
-  m_activities.Clear();
-  if (m_profile_thread) {
-    pthread_join(m_profile_thread, NULL);
-    m_profile_thread = NULL;
-  }
-}
-
-bool MachProcess::StartSTDIOThread() {
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( )", __FUNCTION__);
-  // Create the thread that watches for the child STDIO
-  return ::pthread_create(&m_stdio_thread, NULL, MachProcess::STDIOThread,
-                          this) == 0;
-}
-
-void MachProcess::SetEnableAsyncProfiling(bool enable, uint64_t interval_usec,
-                                          DNBProfileDataScanType scan_type) {
-  m_profile_enabled = enable;
-  m_profile_interval_usec = static_cast<useconds_t>(interval_usec);
-  m_profile_scan_type = scan_type;
-
-  if (m_profile_enabled && (m_profile_thread == NULL)) {
-    StartProfileThread();
-  } else if (!m_profile_enabled && m_profile_thread) {
-    pthread_join(m_profile_thread, NULL);
-    m_profile_thread = NULL;
-  }
-}
-
-bool MachProcess::StartProfileThread() {
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( )", __FUNCTION__);
-  // Create the thread that profiles the inferior and reports back if enabled
-  return ::pthread_create(&m_profile_thread, NULL, MachProcess::ProfileThread,
-                          this) == 0;
-}
-
-nub_addr_t MachProcess::LookupSymbol(const char *name, const char *shlib) {
-  if (m_name_to_addr_callback != NULL && name && name[0])
-    return m_name_to_addr_callback(ProcessID(), name, shlib,
-                                   m_name_to_addr_baton);
-  return INVALID_NUB_ADDRESS;
-}
-
-bool MachProcess::Resume(const DNBThreadResumeActions &thread_actions) {
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Resume ()");
-  nub_state_t state = GetState();
-
-  if (CanResume(state)) {
-    m_thread_actions = thread_actions;
-    PrivateResume();
-    return true;
-  } else if (state == eStateRunning) {
-    DNBLog("Resume() - task 0x%x is already running, ignoring...",
-           m_task.TaskPort());
-    return true;
-  }
-  DNBLog("Resume() - task 0x%x has state %s, can't continue...",
-         m_task.TaskPort(), DNBStateAsString(state));
-  return false;
-}
-
-bool MachProcess::Kill(const struct timespec *timeout_abstime) {
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill ()");
-  nub_state_t state = DoSIGSTOP(true, false, NULL);
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill() DoSIGSTOP() state = %s",
-                   DNBStateAsString(state));
-  errno = 0;
-  DNBLog("Sending ptrace PT_KILL to terminate inferior process.");
-  ::ptrace(PT_KILL, m_pid, 0, 0);
-  DNBError err;
-  err.SetErrorToErrno();
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill() DoSIGSTOP() ::ptrace "
-                                "(PT_KILL, pid=%u, 0, 0) => 0x%8.8x (%s)",
-                   m_pid, err.Status(), err.AsString());
-  m_thread_actions = DNBThreadResumeActions(eStateRunning, 0);
-  PrivateResume();
-
-  // Try and reap the process without touching our m_events since
-  // we want the code above this to still get the eStateExited event
-  const uint32_t reap_timeout_usec =
-      1000000; // Wait 1 second and try to reap the process
-  const uint32_t reap_interval_usec = 10000; //
-  uint32_t reap_time_elapsed;
-  for (reap_time_elapsed = 0; reap_time_elapsed < reap_timeout_usec;
-       reap_time_elapsed += reap_interval_usec) {
-    if (GetState() == eStateExited)
-      break;
-    usleep(reap_interval_usec);
-  }
-  DNBLog("Waited %u ms for process to be reaped (state = %s)",
-         reap_time_elapsed / 1000, DNBStateAsString(GetState()));
-  return true;
-}
-
-bool MachProcess::Interrupt() {
-  nub_state_t state = GetState();
-  if (IsRunning(state)) {
-    if (m_sent_interrupt_signo == 0) {
-      m_sent_interrupt_signo = SIGSTOP;
-      if (Signal(m_sent_interrupt_signo)) {
-        DNBLogThreadedIf(
-            LOG_PROCESS,
-            "MachProcess::Interrupt() - sent %i signal to interrupt process",
-            m_sent_interrupt_signo);
-        return true;
-      } else {
-        m_sent_interrupt_signo = 0;
-        DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - failed to "
-                                      "send %i signal to interrupt process",
-                         m_sent_interrupt_signo);
-      }
-    } else {
-      DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - previously "
-                                    "sent an interrupt signal %i that hasn't "
-                                    "been received yet, interrupt aborted",
-                       m_sent_interrupt_signo);
-    }
-  } else {
-    DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - process already "
-                                  "stopped, no interrupt sent");
-  }
-  return false;
-}
-
-bool MachProcess::Signal(int signal, const struct timespec *timeout_abstime) {
-  DNBLogThreadedIf(LOG_PROCESS,
-                   "MachProcess::Signal (signal = %d, timeout = %p)", signal,
-                   reinterpret_cast<const void *>(timeout_abstime));
-  nub_state_t state = GetState();
-  if (::kill(ProcessID(), signal) == 0) {
-    // If we were running and we have a timeout, wait for the signal to stop
-    if (IsRunning(state) && timeout_abstime) {
-      DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Signal (signal = %d, timeout "
-                                    "= %p) waiting for signal to stop "
-                                    "process...",
-                       signal, reinterpret_cast<const void *>(timeout_abstime));
-      m_private_events.WaitForSetEvents(eEventProcessStoppedStateChanged,
-                                        timeout_abstime);
-      state = GetState();
-      DNBLogThreadedIf(
-          LOG_PROCESS,
-          "MachProcess::Signal (signal = %d, timeout = %p) state = %s", signal,
-          reinterpret_cast<const void *>(timeout_abstime),
-          DNBStateAsString(state));
-      return !IsRunning(state);
-    }
-    DNBLogThreadedIf(
-        LOG_PROCESS,
-        "MachProcess::Signal (signal = %d, timeout = %p) not waiting...",
-        signal, reinterpret_cast<const void *>(timeout_abstime));
-    return true;
-  }
-  DNBError err(errno, DNBError::POSIX);
-  err.LogThreadedIfError("kill (pid = %d, signo = %i)", ProcessID(), signal);
-  return false;
-}
-
-bool MachProcess::SendEvent(const char *event, DNBError &send_err) {
-  DNBLogThreadedIf(LOG_PROCESS,
-                   "MachProcess::SendEvent (event = %s) to pid: %d", event,
-                   m_pid);
-  if (m_pid == INVALID_NUB_PROCESS)
-    return false;
-// FIXME: Shouldn't we use the launch flavor we were started with?
-#if defined(WITH_FBS) || defined(WITH_BKS)
-  return BoardServiceSendEvent(event, send_err);
-#endif
-  return true;
-}
-
-nub_state_t MachProcess::DoSIGSTOP(bool clear_bps_and_wps, bool allow_running,
-                                   uint32_t *thread_idx_ptr) {
-  nub_state_t state = GetState();
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::DoSIGSTOP() state = %s",
-                   DNBStateAsString(state));
-
-  if (!IsRunning(state)) {
-    if (clear_bps_and_wps) {
-      DisableAllBreakpoints(true);
-      DisableAllWatchpoints(true);
-      clear_bps_and_wps = false;
-    }
-
-    // If we already have a thread stopped due to a SIGSTOP, we don't have
-    // to do anything...
-    uint32_t thread_idx =
-        m_thread_list.GetThreadIndexForThreadStoppedWithSignal(SIGSTOP);
-    if (thread_idx_ptr)
-      *thread_idx_ptr = thread_idx;
-    if (thread_idx != UINT32_MAX)
-      return GetState();
-
-    // No threads were stopped with a SIGSTOP, we need to run and halt the
-    // process with a signal
-    DNBLogThreadedIf(LOG_PROCESS,
-                     "MachProcess::DoSIGSTOP() state = %s -- resuming process",
-                     DNBStateAsString(state));
-    if (allow_running)
-      m_thread_actions = DNBThreadResumeActions(eStateRunning, 0);
-    else
-      m_thread_actions = DNBThreadResumeActions(eStateSuspended, 0);
-
-    PrivateResume();
-
-    // Reset the event that says we were indeed running
-    m_events.ResetEvents(eEventProcessRunningStateChanged);
-    state = GetState();
-  }
-
-  // We need to be stopped in order to be able to detach, so we need
-  // to send ourselves a SIGSTOP
-
-  DNBLogThreadedIf(LOG_PROCESS,
-                   "MachProcess::DoSIGSTOP() state = %s -- sending SIGSTOP",
-                   DNBStateAsString(state));
-  struct timespec sigstop_timeout;
-  DNBTimer::OffsetTimeOfDay(&sigstop_timeout, 2, 0);
-  Signal(SIGSTOP, &sigstop_timeout);
-  if (clear_bps_and_wps) {
-    DisableAllBreakpoints(true);
-    DisableAllWatchpoints(true);
-    // clear_bps_and_wps = false;
-  }
-  uint32_t thread_idx =
-      m_thread_list.GetThreadIndexForThreadStoppedWithSignal(SIGSTOP);
-  if (thread_idx_ptr)
-    *thread_idx_ptr = thread_idx;
-  return GetState();
-}
-
-bool MachProcess::Detach() {
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Detach()");
-
-  uint32_t thread_idx = UINT32_MAX;
-  nub_state_t state = DoSIGSTOP(true, true, &thread_idx);
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Detach() DoSIGSTOP() returned %s",
-                   DNBStateAsString(state));
-
-  {
-    m_thread_actions.Clear();
-    m_activities.Clear();
-    DNBThreadResumeAction thread_action;
-    thread_action.tid = m_thread_list.ThreadIDAtIndex(thread_idx);
-    thread_action.state = eStateRunning;
-    thread_action.signal = -1;
-    thread_action.addr = INVALID_NUB_ADDRESS;
-
-    m_thread_actions.Append(thread_action);
-    m_thread_actions.SetDefaultThreadActionIfNeeded(eStateRunning, 0);
-
-    PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
-
-    ReplyToAllExceptions();
-  }
-
-  m_task.ShutDownExcecptionThread();
-
-  // Detach from our process
-  errno = 0;
-  nub_process_t pid = m_pid;
-  int ret = ::ptrace(PT_DETACH, pid, (caddr_t)1, 0);
-  DNBError err(errno, DNBError::POSIX);
-  if (DNBLogCheckLogBit(LOG_PROCESS) || err.Fail() || (ret != 0))
-    err.LogThreaded("::ptrace (PT_DETACH, %u, (caddr_t)1, 0)", pid);
-
-  // Resume our task
-  m_task.Resume();
-
-  // NULL our task out as we have already restored all exception ports
-  m_task.Clear();
-
-  // Clear out any notion of the process we once were
-  const bool detaching = true;
-  Clear(detaching);
-
-  SetState(eStateDetached);
-
-  return true;
-}
-
-//----------------------------------------------------------------------
-// ReadMemory from the MachProcess level will always remove any software
-// breakpoints from the memory buffer before returning. If you wish to
-// read memory and see those traps, read from the MachTask
-// (m_task.ReadMemory()) as that version will give you what is actually
-// in inferior memory.
-//----------------------------------------------------------------------
-nub_size_t MachProcess::ReadMemory(nub_addr_t addr, nub_size_t size,
-                                   void *buf) {
-  // We need to remove any current software traps (enabled software
-  // breakpoints) that we may have placed in our tasks memory.
-
-  // First just read the memory as is
-  nub_size_t bytes_read = m_task.ReadMemory(addr, size, buf);
-
-  // Then place any opcodes that fall into this range back into the buffer
-  // before we return this to callers.
-  if (bytes_read > 0)
-    m_breakpoints.RemoveTrapsFromBuffer(addr, bytes_read, buf);
-  return bytes_read;
-}
-
-//----------------------------------------------------------------------
-// WriteMemory from the MachProcess level will always write memory around
-// any software breakpoints. Any software breakpoints will have their
-// opcodes modified if they are enabled. Any memory that doesn't overlap
-// with software breakpoints will be written to. If you wish to write to
-// inferior memory without this interference, then write to the MachTask
-// (m_task.WriteMemory()) as that version will always modify inferior
-// memory.
-//----------------------------------------------------------------------
-nub_size_t MachProcess::WriteMemory(nub_addr_t addr, nub_size_t size,
-                                    const void *buf) {
-  // We need to write any data that would go where any current software traps
-  // (enabled software breakpoints) any software traps (breakpoints) that we
-  // may have placed in our tasks memory.
-
-  std::vector<DNBBreakpoint *> bps;
-
-  const size_t num_bps =
-      m_breakpoints.FindBreakpointsThatOverlapRange(addr, size, bps);
-  if (num_bps == 0)
-    return m_task.WriteMemory(addr, size, buf);
-
-  nub_size_t bytes_written = 0;
-  nub_addr_t intersect_addr;
-  nub_size_t intersect_size;
-  nub_size_t opcode_offset;
-  const uint8_t *ubuf = (const uint8_t *)buf;
-
-  for (size_t i = 0; i < num_bps; ++i) {
-    DNBBreakpoint *bp = bps[i];
-
-    const bool intersects = bp->IntersectsRange(
-        addr, size, &intersect_addr, &intersect_size, &opcode_offset);
-    UNUSED_IF_ASSERT_DISABLED(intersects);
-    assert(intersects);
-    assert(addr <= intersect_addr && intersect_addr < addr + size);
-    assert(addr < intersect_addr + intersect_size &&
-           intersect_addr + intersect_size <= addr + size);
-    assert(opcode_offset + intersect_size <= bp->ByteSize());
-
-    // Check for bytes before this breakpoint
-    const nub_addr_t curr_addr = addr + bytes_written;
-    if (intersect_addr > curr_addr) {
-      // There are some bytes before this breakpoint that we need to
-      // just write to memory
-      nub_size_t curr_size = intersect_addr - curr_addr;
-      nub_size_t curr_bytes_written =
-          m_task.WriteMemory(curr_addr, curr_size, ubuf + bytes_written);
-      bytes_written += curr_bytes_written;
-      if (curr_bytes_written != curr_size) {
-        // We weren't able to write all of the requested bytes, we
-        // are done looping and will return the number of bytes that
-        // we have written so far.
-        break;
-      }
-    }
-
-    // Now write any bytes that would cover up any software breakpoints
-    // directly into the breakpoint opcode buffer
-    ::memcpy(bp->SavedOpcodeBytes() + opcode_offset, ubuf + bytes_written,
-             intersect_size);
-    bytes_written += intersect_size;
-  }
-
-  // Write any remaining bytes after the last breakpoint if we have any left
-  if (bytes_written < size)
-    bytes_written += m_task.WriteMemory(
-        addr + bytes_written, size - bytes_written, ubuf + bytes_written);
-
-  return bytes_written;
-}
-
-void MachProcess::ReplyToAllExceptions() {
-  PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
-  if (!m_exception_messages.empty()) {
-    MachException::Message::iterator pos;
-    MachException::Message::iterator begin = m_exception_messages.begin();
-    MachException::Message::iterator end = m_exception_messages.end();
-    for (pos = begin; pos != end; ++pos) {
-      DNBLogThreadedIf(LOG_EXCEPTIONS, "Replying to exception %u...",
-                       (uint32_t)std::distance(begin, pos));
-      int thread_reply_signal = 0;
-
-      nub_thread_t tid =
-          m_thread_list.GetThreadIDByMachPortNumber(pos->state.thread_port);
-      const DNBThreadResumeAction *action = NULL;
-      if (tid != INVALID_NUB_THREAD) {
-        action = m_thread_actions.GetActionForThread(tid, false);
-      }
-
-      if (action) {
-        thread_reply_signal = action->signal;
-        if (thread_reply_signal)
-          m_thread_actions.SetSignalHandledForThread(tid);
-      }
-
-      DNBError err(pos->Reply(this, thread_reply_signal));
-      if (DNBLogCheckLogBit(LOG_EXCEPTIONS))
-        err.LogThreadedIfError("Error replying to exception");
-    }
-
-    // Erase all exception message as we should have used and replied
-    // to them all already.
-    m_exception_messages.clear();
-  }
-}
-void MachProcess::PrivateResume() {
-  PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
-
-  m_auto_resume_signo = m_sent_interrupt_signo;
-  if (m_auto_resume_signo)
-    DNBLogThreadedIf(LOG_PROCESS, "MachProcess::PrivateResume() - task 0x%x "
-                                  "resuming (with unhandled interrupt signal "
-                                  "%i)...",
-                     m_task.TaskPort(), m_auto_resume_signo);
-  else
-    DNBLogThreadedIf(LOG_PROCESS,
-                     "MachProcess::PrivateResume() - task 0x%x resuming...",
-                     m_task.TaskPort());
-
-  ReplyToAllExceptions();
-  //    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.
-  m_task.Resume();
-}
-
-DNBBreakpoint *MachProcess::CreateBreakpoint(nub_addr_t addr, nub_size_t length,
-                                             bool hardware) {
-  DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::CreateBreakpoint ( addr = "
-                                    "0x%8.8llx, length = %llu, hardware = %i)",
-                   (uint64_t)addr, (uint64_t)length, hardware);
-
-  DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr);
-  if (bp)
-    bp->Retain();
-  else
-    bp = m_breakpoints.Add(addr, length, hardware);
-
-  if (EnableBreakpoint(addr)) {
-    DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::CreateBreakpoint ( addr = "
-                                      "0x%8.8llx, length = %llu) => %p",
-                     (uint64_t)addr, (uint64_t)length,
-                     reinterpret_cast<void *>(bp));
-    return bp;
-  } else if (bp->Release() == 0) {
-    m_breakpoints.Remove(addr);
-  }
-  // We failed to enable the breakpoint
-  return NULL;
-}
-
-DNBBreakpoint *MachProcess::CreateWatchpoint(nub_addr_t addr, nub_size_t length,
-                                             uint32_t watch_flags,
-                                             bool hardware) {
-  DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = "
-                                    "0x%8.8llx, length = %llu, flags = "
-                                    "0x%8.8x, hardware = %i)",
-                   (uint64_t)addr, (uint64_t)length, watch_flags, hardware);
-
-  DNBBreakpoint *wp = m_watchpoints.FindByAddress(addr);
-  // since the Z packets only send an address, we can only have one watchpoint
-  // at
-  // an address. If there is already one, we must refuse to create another
-  // watchpoint
-  if (wp)
-    return NULL;
-
-  wp = m_watchpoints.Add(addr, length, hardware);
-  wp->SetIsWatchpoint(watch_flags);
-
-  if (EnableWatchpoint(addr)) {
-    DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = "
-                                      "0x%8.8llx, length = %llu) => %p",
-                     (uint64_t)addr, (uint64_t)length,
-                     reinterpret_cast<void *>(wp));
-    return wp;
-  } else {
-    DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = "
-                                      "0x%8.8llx, length = %llu) => FAILED",
-                     (uint64_t)addr, (uint64_t)length);
-    m_watchpoints.Remove(addr);
-  }
-  // We failed to enable the watchpoint
-  return NULL;
-}
-
-void MachProcess::DisableAllBreakpoints(bool remove) {
-  DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::%s (remove = %d )",
-                   __FUNCTION__, remove);
-
-  m_breakpoints.DisableAllBreakpoints(this);
-
-  if (remove)
-    m_breakpoints.RemoveDisabled();
-}
-
-void MachProcess::DisableAllWatchpoints(bool remove) {
-  DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::%s (remove = %d )",
-                   __FUNCTION__, remove);
-
-  m_watchpoints.DisableAllWatchpoints(this);
-
-  if (remove)
-    m_watchpoints.RemoveDisabled();
-}
-
-bool MachProcess::DisableBreakpoint(nub_addr_t addr, bool remove) {
-  DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr);
-  if (bp) {
-    // After "exec" we might end up with a bunch of breakpoints that were
-    // disabled
-    // manually, just ignore them
-    if (!bp->IsEnabled()) {
-      // Breakpoint might have been disabled by an exec
-      if (remove && bp->Release() == 0) {
-        m_thread_list.NotifyBreakpointChanged(bp);
-        m_breakpoints.Remove(addr);
-      }
-      return true;
-    }
-
-    // We have multiple references to this breakpoint, decrement the ref count
-    // and if it isn't zero, then return true;
-    if (remove && bp->Release() > 0)
-      return true;
-
-    DNBLogThreadedIf(
-        LOG_BREAKPOINTS | LOG_VERBOSE,
-        "MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = %d )",
-        (uint64_t)addr, remove);
-
-    if (bp->IsHardware()) {
-      bool hw_disable_result = m_thread_list.DisableHardwareBreakpoint(bp);
-
-      if (hw_disable_result) {
-        bp->SetEnabled(false);
-        // Let the thread list know that a breakpoint has been modified
-        if (remove) {
-          m_thread_list.NotifyBreakpointChanged(bp);
-          m_breakpoints.Remove(addr);
-        }
-        DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::DisableBreakpoint ( "
-                                          "addr = 0x%8.8llx, remove = %d ) "
-                                          "(hardware) => success",
-                         (uint64_t)addr, remove);
-        return true;
-      }
-
-      return false;
-    }
-
-    const nub_size_t break_op_size = bp->ByteSize();
-    assert(break_op_size > 0);
-    const uint8_t *const break_op =
-        DNBArchProtocol::GetBreakpointOpcode(bp->ByteSize());
-    if (break_op_size > 0) {
-      // Clear a software breakpoint instruction
-      uint8_t curr_break_op[break_op_size];
-      bool break_op_found = false;
-
-      // Read the breakpoint opcode
-      if (m_task.ReadMemory(addr, break_op_size, curr_break_op) ==
-          break_op_size) {
-        bool verify = false;
-        if (bp->IsEnabled()) {
-          // Make sure a breakpoint opcode exists at this address
-          if (memcmp(curr_break_op, break_op, break_op_size) == 0) {
-            break_op_found = true;
-            // We found a valid breakpoint opcode at this address, now restore
-            // the saved opcode.
-            if (m_task.WriteMemory(addr, break_op_size,
-                                   bp->SavedOpcodeBytes()) == break_op_size) {
-              verify = true;
-            } else {
-              DNBLogError("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, "
-                          "remove = %d ) memory write failed when restoring "
-                          "original opcode",
-                          (uint64_t)addr, remove);
-            }
-          } else {
-            DNBLogWarning("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, "
-                          "remove = %d ) expected a breakpoint opcode but "
-                          "didn't find one.",
-                          (uint64_t)addr, remove);
-            // Set verify to true and so we can check if the original opcode has
-            // already been restored
-            verify = true;
-          }
-        } else {
-          DNBLogThreadedIf(LOG_BREAKPOINTS | LOG_VERBOSE,
-                           "MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, "
-                           "remove = %d ) is not enabled",
-                           (uint64_t)addr, remove);
-          // Set verify to true and so we can check if the original opcode is
-          // there
-          verify = true;
-        }
-
-        if (verify) {
-          uint8_t verify_opcode[break_op_size];
-          // Verify that our original opcode made it back to the inferior
-          if (m_task.ReadMemory(addr, break_op_size, verify_opcode) ==
-              break_op_size) {
-            // compare the memory we just read with the original opcode
-            if (memcmp(bp->SavedOpcodeBytes(), verify_opcode, break_op_size) ==
-                0) {
-              // SUCCESS
-              bp->SetEnabled(false);
-              // Let the thread list know that a breakpoint has been modified
-              if (remove && bp->Release() == 0) {
-                m_thread_list.NotifyBreakpointChanged(bp);
-                m_breakpoints.Remove(addr);
-              }
-              DNBLogThreadedIf(LOG_BREAKPOINTS,
-                               "MachProcess::DisableBreakpoint ( addr = "
-                               "0x%8.8llx, remove = %d ) => success",
-                               (uint64_t)addr, remove);
-              return true;
-            } else {
-              if (break_op_found)
-                DNBLogError("MachProcess::DisableBreakpoint ( addr = "
-                            "0x%8.8llx, remove = %d ) : failed to restore "
-                            "original opcode",
-                            (uint64_t)addr, remove);
-              else
-                DNBLogError("MachProcess::DisableBreakpoint ( addr = "
-                            "0x%8.8llx, remove = %d ) : opcode changed",
-                            (uint64_t)addr, remove);
-            }
-          } else {
-            DNBLogWarning("MachProcess::DisableBreakpoint: unable to disable "
-                          "breakpoint 0x%8.8llx",
-                          (uint64_t)addr);
-          }
-        }
-      } else {
-        DNBLogWarning("MachProcess::DisableBreakpoint: unable to read memory "
-                      "at 0x%8.8llx",
-                      (uint64_t)addr);
-      }
-    }
-  } else {
-    DNBLogError("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = "
-                "%d ) invalid breakpoint address",
-                (uint64_t)addr, remove);
-  }
-  return false;
-}
-
-bool MachProcess::DisableWatchpoint(nub_addr_t addr, bool remove) {
-  DNBLogThreadedIf(LOG_WATCHPOINTS,
-                   "MachProcess::%s(addr = 0x%8.8llx, remove = %d)",
-                   __FUNCTION__, (uint64_t)addr, remove);
-  DNBBreakpoint *wp = m_watchpoints.FindByAddress(addr);
-  if (wp) {
-    // If we have multiple references to a watchpoint, removing the watchpoint
-    // shouldn't clear it
-    if (remove && wp->Release() > 0)
-      return true;
-
-    nub_addr_t addr = wp->Address();
-    DNBLogThreadedIf(
-        LOG_WATCHPOINTS,
-        "MachProcess::DisableWatchpoint ( addr = 0x%8.8llx, remove = %d )",
-        (uint64_t)addr, remove);
-
-    if (wp->IsHardware()) {
-      bool hw_disable_result = m_thread_list.DisableHardwareWatchpoint(wp);
-
-      if (hw_disable_result) {
-        wp->SetEnabled(false);
-        if (remove)
-          m_watchpoints.Remove(addr);
-        DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::Disablewatchpoint ( "
-                                          "addr = 0x%8.8llx, remove = %d ) "
-                                          "(hardware) => success",
-                         (uint64_t)addr, remove);
-        return true;
-      }
-    }
-
-    // TODO: clear software watchpoints if we implement them
-  } else {
-    DNBLogError("MachProcess::DisableWatchpoint ( addr = 0x%8.8llx, remove = "
-                "%d ) invalid watchpoint ID",
-                (uint64_t)addr, remove);
-  }
-  return false;
-}
-
-uint32_t MachProcess::GetNumSupportedHardwareWatchpoints() const {
-  return m_thread_list.NumSupportedHardwareWatchpoints();
-}
-
-bool MachProcess::EnableBreakpoint(nub_addr_t addr) {
-  DNBLogThreadedIf(LOG_BREAKPOINTS,
-                   "MachProcess::EnableBreakpoint ( addr = 0x%8.8llx )",
-                   (uint64_t)addr);
-  DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr);
-  if (bp) {
-    if (bp->IsEnabled()) {
-      DNBLogWarning("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
-                    "breakpoint already enabled.",
-                    (uint64_t)addr);
-      return true;
-    } else {
-      if (bp->HardwarePreferred()) {
-        bp->SetHardwareIndex(m_thread_list.EnableHardwareBreakpoint(bp));
-        if (bp->IsHardware()) {
-          bp->SetEnabled(true);
-          return true;
-        }
-      }
-
-      const nub_size_t break_op_size = bp->ByteSize();
-      assert(break_op_size != 0);
-      const uint8_t *const break_op =
-          DNBArchProtocol::GetBreakpointOpcode(break_op_size);
-      if (break_op_size > 0) {
-        // Save the original opcode by reading it
-        if (m_task.ReadMemory(addr, break_op_size, bp->SavedOpcodeBytes()) ==
-            break_op_size) {
-          // Write a software breakpoint in place of the original opcode
-          if (m_task.WriteMemory(addr, break_op_size, break_op) ==
-              break_op_size) {
-            uint8_t verify_break_op[4];
-            if (m_task.ReadMemory(addr, break_op_size, verify_break_op) ==
-                break_op_size) {
-              if (memcmp(break_op, verify_break_op, break_op_size) == 0) {
-                bp->SetEnabled(true);
-                // Let the thread list know that a breakpoint has been modified
-                m_thread_list.NotifyBreakpointChanged(bp);
-                DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::"
-                                                  "EnableBreakpoint ( addr = "
-                                                  "0x%8.8llx ) : SUCCESS.",
-                                 (uint64_t)addr);
-                return true;
-              } else {
-                DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx "
-                            "): breakpoint opcode verification failed.",
-                            (uint64_t)addr);
-              }
-            } else {
-              DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
-                          "unable to read memory to verify breakpoint opcode.",
-                          (uint64_t)addr);
-            }
-          } else {
-            DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
-                        "unable to write breakpoint opcode to memory.",
-                        (uint64_t)addr);
-          }
-        } else {
-          DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
-                      "unable to read memory at breakpoint address.",
-                      (uint64_t)addr);
-        }
-      } else {
-        DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ) no "
-                    "software breakpoint opcode for current architecture.",
-                    (uint64_t)addr);
-      }
-    }
-  }
-  return false;
-}
-
-bool MachProcess::EnableWatchpoint(nub_addr_t addr) {
-  DNBLogThreadedIf(LOG_WATCHPOINTS,
-                   "MachProcess::EnableWatchpoint(addr = 0x%8.8llx)",
-                   (uint64_t)addr);
-  DNBBreakpoint *wp = m_watchpoints.FindByAddress(addr);
-  if (wp) {
-    nub_addr_t addr = wp->Address();
-    if (wp->IsEnabled()) {
-      DNBLogWarning("MachProcess::EnableWatchpoint(addr = 0x%8.8llx): "
-                    "watchpoint already enabled.",
-                    (uint64_t)addr);
-      return true;
-    } else {
-      // Currently only try and set hardware watchpoints.
-      wp->SetHardwareIndex(m_thread_list.EnableHardwareWatchpoint(wp));
-      if (wp->IsHardware()) {
-        wp->SetEnabled(true);
-        return true;
-      }
-      // TODO: Add software watchpoints by doing page protection tricks.
-    }
-  }
-  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 MachProcess::ExceptionMessageReceived(
-    const MachException::Message &exceptionMessage) {
-  PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
-
-  if (m_exception_messages.empty())
-    m_task.Suspend();
-
-  DNBLogThreadedIf(LOG_EXCEPTIONS, "MachProcess::ExceptionMessageReceived ( )");
-
-  // 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(exceptionMessage);
-}
-
-task_t MachProcess::ExceptionMessageBundleComplete() {
-  // We have a complete bundle of exceptions for our child process.
-  PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
-  DNBLogThreadedIf(LOG_EXCEPTIONS, "%s: %llu exception messages.",
-                   __PRETTY_FUNCTION__, (uint64_t)m_exception_messages.size());
-  bool auto_resume = false;
-  if (!m_exception_messages.empty()) {
-    m_did_exec = false;
-    // First check for any SIGTRAP and make sure we didn't exec
-    const task_t task = m_task.TaskPort();
-    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) {
-          ++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 nub_addr_t aii_addr = GetDYLDAllImageInfosAddress();
-            if (aii_addr != INVALID_NUB_ADDRESS) {
-              const nub_addr_t info_array_count_addr = aii_addr + 4;
-              uint32_t info_array_count = 0;
-              if (m_task.ReadMemory(info_array_count_addr, 4,
-                                    &info_array_count) == 4) {
-                if (info_array_count == 0) {
-                  m_did_exec = true;
-                  // Force the task port to update itself in case the task port
-                  // changed after exec
-                  DNBError err;
-                  const task_t old_task = m_task.TaskPort();
-                  const task_t new_task =
-                      m_task.TaskPortForProcessID(err, true);
-                  if (old_task != new_task)
-                    DNBLogThreadedIf(
-                        LOG_PROCESS,
-                        "exec: task changed from 0x%4.4x to 0x%4.4x", old_task,
-                        new_task);
-                }
-              } else {
-                DNBLog("error: failed to read all_image_infos.infoArrayCount "
-                       "from 0x%8.8llx",
-                       (uint64_t)info_array_count_addr);
-              }
-            }
-            break;
-          } else if (m_sent_interrupt_signo != 0 &&
-                     signo == m_sent_interrupt_signo) {
-            received_interrupt = true;
-          }
-        }
-      }
-
-      if (m_did_exec) {
-        cpu_type_t process_cpu_type =
-            MachProcess::GetCPUTypeForLocalProcess(m_pid);
-        if (m_cpu_type != process_cpu_type) {
-          DNBLog("arch changed from 0x%8.8x to 0x%8.8x", m_cpu_type,
-                 process_cpu_type);
-          m_cpu_type = process_cpu_type;
-          DNBArchProtocol::SetArchitecture(process_cpu_type);
-        }
-        m_thread_list.Clear();
-        m_activities.Clear();
-        m_breakpoints.DisableAll();
-      }
-
-      if (m_sent_interrupt_signo != 0) {
-        if (received_interrupt) {
-          DNBLogThreadedIf(LOG_PROCESS,
-                           "MachProcess::ExceptionMessageBundleComplete(): "
-                           "process successfully interrupted with signal %i",
-                           m_sent_interrupt_signo);
-
-          // Mark that we received the interrupt signal
-          m_sent_interrupt_signo = 0;
-          // Not check if we had a case where:
-          // 1 - We called MachProcess::Interrupt() but we stopped for another
-          // reason
-          // 2 - We called MachProcess::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;
-              DNBLogThreadedIf(LOG_PROCESS, "MachProcess::"
-                                            "ExceptionMessageBundleComplete(): "
-                                            "auto resuming due to unhandled "
-                                            "interrupt signal %i",
-                               m_auto_resume_signo);
-            }
-            m_auto_resume_signo = 0;
-          }
-        } else {
-          DNBLogThreadedIf(LOG_PROCESS, "MachProcess::"
-                                        "ExceptionMessageBundleComplete(): "
-                                        "didn't get signal %i after "
-                                        "MachProcess::Interrupt()",
-                           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);
-    m_activities.Clear();
-
-    // Let each thread know of any exceptions
-    for (i = 0; i < m_exception_messages.size(); ++i) {
-      // Let the thread list figure use the MachProcess to forward all
-      // exceptions
-      // on down to each thread.
-      if (m_exception_messages[i].state.task_port == task)
-        m_thread_list.NotifyException(m_exception_messages[i].state);
-      if (DNBLogCheckLogBit(LOG_EXCEPTIONS))
-        m_exception_messages[i].Dump();
-    }
-
-    if (DNBLogCheckLogBit(LOG_THREAD))
-      m_thread_list.Dump();
-
-    bool step_more = false;
-    if (m_thread_list.ShouldStop(step_more) && !auto_resume) {
-      // 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);
-      SetState(eStateStopped);
-    } else {
-      // Resume without checking our current state.
-      PrivateResume();
-    }
-  } else {
-    DNBLogThreadedIf(
-        LOG_EXCEPTIONS, "%s empty exception messages bundle (%llu exceptions).",
-        __PRETTY_FUNCTION__, (uint64_t)m_exception_messages.size());
-  }
-  return m_task.TaskPort();
-}
-
-nub_size_t
-MachProcess::CopyImageInfos(struct DNBExecutableImageInfo **image_infos,
-                            bool only_changed) {
-  if (m_image_infos_callback != NULL)
-    return m_image_infos_callback(ProcessID(), image_infos, only_changed,
-                                  m_image_infos_baton);
-  return 0;
-}
-
-void MachProcess::SharedLibrariesUpdated() {
-  uint32_t event_bits = eEventSharedLibsStateChange;
-  // Set the shared library event bit to let clients know of shared library
-  // changes
-  m_events.SetEvents(event_bits);
-  // Wait for the event bit to reset if a reset ACK is requested
-  m_events.WaitForResetAck(event_bits);
-}
-
-void MachProcess::SetExitInfo(const char *info) {
-  if (info && info[0]) {
-    DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s(\"%s\")", __FUNCTION__,
-                     info);
-    m_exit_info.assign(info);
-  } else {
-    DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s(NULL)", __FUNCTION__);
-    m_exit_info.clear();
-  }
-}
-
-void MachProcess::AppendSTDOUT(char *s, size_t len) {
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (<%llu> %s) ...", __FUNCTION__,
-                   (uint64_t)len, s);
-  PTHREAD_MUTEX_LOCKER(locker, m_stdio_mutex);
-  m_stdout_data.append(s, len);
-  m_events.SetEvents(eEventStdioAvailable);
-
-  // Wait for the event bit to reset if a reset ACK is requested
-  m_events.WaitForResetAck(eEventStdioAvailable);
-}
-
-size_t MachProcess::GetAvailableSTDOUT(char *buf, size_t buf_size) {
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (&%p[%llu]) ...", __FUNCTION__,
-                   reinterpret_cast<void *>(buf), (uint64_t)buf_size);
-  PTHREAD_MUTEX_LOCKER(locker, m_stdio_mutex);
-  size_t bytes_available = m_stdout_data.size();
-  if (bytes_available > 0) {
-    if (bytes_available > buf_size) {
-      memcpy(buf, m_stdout_data.data(), buf_size);
-      m_stdout_data.erase(0, buf_size);
-      bytes_available = buf_size;
-    } else {
-      memcpy(buf, m_stdout_data.data(), bytes_available);
-      m_stdout_data.clear();
-    }
-  }
-  return bytes_available;
-}
-
-nub_addr_t MachProcess::GetDYLDAllImageInfosAddress() {
-  DNBError err;
-  return m_task.GetDYLDAllImageInfosAddress(err);
-}
-
-size_t MachProcess::GetAvailableSTDERR(char *buf, size_t buf_size) { return 0; }
-
-void *MachProcess::STDIOThread(void *arg) {
-  MachProcess *proc = (MachProcess *)arg;
-  DNBLogThreadedIf(LOG_PROCESS,
-                   "MachProcess::%s ( arg = %p ) thread starting...",
-                   __FUNCTION__, arg);
-
-#if defined(__APPLE__)
-  pthread_setname_np("stdio monitoring thread");
-#endif
-
-  // We start use a base and more options so we can control if we
-  // are currently using a timeout on the mach_msg. 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 thread loop
-  // will start by calling mach_msg to without having the MACH_RCV_TIMEOUT
-  // flag set in the options, so we will wait forever for an exception on
-  // 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.
-  DNBError err;
-  int stdout_fd = proc->GetStdoutFileDescriptor();
-  int stderr_fd = proc->GetStderrFileDescriptor();
-  if (stdout_fd == stderr_fd)
-    stderr_fd = -1;
-
-  while (stdout_fd >= 0 || stderr_fd >= 0) {
-    ::pthread_testcancel();
-
-    fd_set read_fds;
-    FD_ZERO(&read_fds);
-    if (stdout_fd >= 0)
-      FD_SET(stdout_fd, &read_fds);
-    if (stderr_fd >= 0)
-      FD_SET(stderr_fd, &read_fds);
-    int nfds = std::max<int>(stdout_fd, stderr_fd) + 1;
-
-    int num_set_fds = select(nfds, &read_fds, NULL, NULL, NULL);
-    DNBLogThreadedIf(LOG_PROCESS,
-                     "select (nfds, &read_fds, NULL, NULL, NULL) => %d",
-                     num_set_fds);
-
-    if (num_set_fds < 0) {
-      int select_errno = errno;
-      if (DNBLogCheckLogBit(LOG_PROCESS)) {
-        err.SetError(select_errno, DNBError::POSIX);
-        err.LogThreadedIfError(
-            "select (nfds, &read_fds, NULL, NULL, NULL) => %d", num_set_fds);
-      }
-
-      switch (select_errno) {
-      case EAGAIN: // The kernel was (perhaps temporarily) unable to allocate
-                   // the requested number of file descriptors, or we have
-                   // non-blocking IO
-        break;
-      case EBADF: // One of the descriptor sets specified an invalid descriptor.
-        return NULL;
-        break;
-      case EINTR:  // A signal was delivered before the time limit expired and
-                   // before any of the selected events occurred.
-      case EINVAL: // The specified time limit is invalid. One of its components
-                   // is negative or too large.
-      default:     // Other unknown error
-        break;
-      }
-    } else if (num_set_fds == 0) {
-    } else {
-      char s[1024];
-      s[sizeof(s) - 1] = '\0'; // Ensure we have NULL termination
-      ssize_t bytes_read = 0;
-      if (stdout_fd >= 0 && FD_ISSET(stdout_fd, &read_fds)) {
-        do {
-          bytes_read = ::read(stdout_fd, s, sizeof(s) - 1);
-          if (bytes_read < 0) {
-            int read_errno = errno;
-            DNBLogThreadedIf(LOG_PROCESS,
-                             "read (stdout_fd, ) => %zd   errno: %d (%s)",
-                             bytes_read, read_errno, strerror(read_errno));
-          } else if (bytes_read == 0) {
-            // EOF...
-            DNBLogThreadedIf(
-                LOG_PROCESS,
-                "read (stdout_fd, ) => %zd  (reached EOF for child STDOUT)",
-                bytes_read);
-            stdout_fd = -1;
-          } else if (bytes_read > 0) {
-            proc->AppendSTDOUT(s, bytes_read);
-          }
-
-        } while (bytes_read > 0);
-      }
-
-      if (stderr_fd >= 0 && FD_ISSET(stderr_fd, &read_fds)) {
-        do {
-          bytes_read = ::read(stderr_fd, s, sizeof(s) - 1);
-          if (bytes_read < 0) {
-            int read_errno = errno;
-            DNBLogThreadedIf(LOG_PROCESS,
-                             "read (stderr_fd, ) => %zd   errno: %d (%s)",
-                             bytes_read, read_errno, strerror(read_errno));
-          } else if (bytes_read == 0) {
-            // EOF...
-            DNBLogThreadedIf(
-                LOG_PROCESS,
-                "read (stderr_fd, ) => %zd  (reached EOF for child STDERR)",
-                bytes_read);
-            stderr_fd = -1;
-          } else if (bytes_read > 0) {
-            proc->AppendSTDOUT(s, bytes_read);
-          }
-
-        } while (bytes_read > 0);
-      }
-    }
-  }
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (%p): thread exiting...",
-                   __FUNCTION__, arg);
-  return NULL;
-}
-
-void MachProcess::SignalAsyncProfileData(const char *info) {
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (%s) ...", __FUNCTION__, info);
-  PTHREAD_MUTEX_LOCKER(locker, m_profile_data_mutex);
-  m_profile_data.push_back(info);
-  m_events.SetEvents(eEventProfileDataAvailable);
-
-  // Wait for the event bit to reset if a reset ACK is requested
-  m_events.WaitForResetAck(eEventProfileDataAvailable);
-}
-
-size_t MachProcess::GetAsyncProfileData(char *buf, size_t buf_size) {
-  DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (&%p[%llu]) ...", __FUNCTION__,
-                   reinterpret_cast<void *>(buf), (uint64_t)buf_size);
-  PTHREAD_MUTEX_LOCKER(locker, m_profile_data_mutex);
-  if (m_profile_data.empty())
-    return 0;
-
-  size_t bytes_available = m_profile_data.front().size();
-  if (bytes_available > 0) {
-    if (bytes_available > buf_size) {
-      memcpy(buf, m_profile_data.front().data(), buf_size);
-      m_profile_data.front().erase(0, buf_size);
-      bytes_available = buf_size;
-    } else {
-      memcpy(buf, m_profile_data.front().data(), bytes_available);
-      m_profile_data.erase(m_profile_data.begin());
-    }
-  }
-  return bytes_available;
-}
-
-void *MachProcess::ProfileThread(void *arg) {
-  MachProcess *proc = (MachProcess *)arg;
-  DNBLogThreadedIf(LOG_PROCESS,
-                   "MachProcess::%s ( arg = %p ) thread starting...",
-                   __FUNCTION__, arg);
-
-#if defined(__APPLE__)
-  pthread_setname_np("performance profiling thread");
-#endif
-
-  while (proc->IsProfilingEnabled()) {
-    nub_state_t state = proc->GetState();
-    if (state == eStateRunning) {
-      std::string data =
-          proc->Task().GetProfileData(proc->GetProfileScanType());
-      if (!data.empty()) {
-        proc->SignalAsyncProfileData(data.c_str());
-      }
-    } else if ((state == eStateUnloaded) || (state == eStateDetached) ||
-               (state == eStateUnloaded)) {
-      // Done. Get out of this thread.
-      break;
-    }
-
-    // A simple way to set up the profile interval. We can also use select() or
-    // dispatch timer source if necessary.
-    usleep(proc->ProfileInterval());
-  }
-  return NULL;
-}
-
-pid_t MachProcess::AttachForDebug(pid_t pid, char *err_str, size_t err_len) {
-  // Clear out and clean up from any current state
-  Clear();
-  if (pid != 0) {
-    DNBError err;
-    // Make sure the process exists...
-    if (::getpgid(pid) < 0) {
-      err.SetErrorToErrno();
-      const char *err_cstr = err.AsString();
-      ::snprintf(err_str, err_len, "%s",
-                 err_cstr ? err_cstr : "No such process");
-      return INVALID_NUB_PROCESS;
-    }
-
-    SetState(eStateAttaching);
-    m_pid = pid;
-// Let ourselves know we are going to be using SBS or BKS if the correct flag
-// bit is set...
-#if defined(WITH_FBS) || defined(WITH_BKS)
-    bool found_app_flavor = false;
-#endif
-
-#if defined(WITH_FBS)
-    if (!found_app_flavor && IsFBSProcess(pid)) {
-      found_app_flavor = true;
-      m_flags |= eMachProcessFlagsUsingFBS;
-    }
-#elif defined(WITH_BKS)
-    if (!found_app_flavor && IsBKSProcess(pid)) {
-      found_app_flavor = true;
-      m_flags |= eMachProcessFlagsUsingBKS;
-    }
-#elif defined(WITH_SPRINGBOARD)
-    if (IsSBProcess(pid))
-      m_flags |= eMachProcessFlagsUsingSBS;
-#endif
-    if (!m_task.StartExceptionThread(err)) {
-      const char *err_cstr = err.AsString();
-      ::snprintf(err_str, err_len, "%s",
-                 err_cstr ? err_cstr : "unable to start the exception thread");
-      DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", pid);
-      m_pid = INVALID_NUB_PROCESS;
-      return INVALID_NUB_PROCESS;
-    }
-
-    errno = 0;
-    if (::ptrace(PT_ATTACHEXC, pid, 0, 0))
-      err.SetError(errno);
-    else
-      err.Clear();
-
-    if (err.Success()) {
-      m_flags |= eMachProcessFlagsAttached;
-      // Sleep a bit to let the exception get received and set our process
-      // status
-      // to stopped.
-      ::usleep(250000);
-      DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", pid);
-      return m_pid;
-    } else {
-      ::snprintf(err_str, err_len, "%s", err.AsString());
-      DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", pid);
-    }
-  }
-  return INVALID_NUB_PROCESS;
-}
-
-Genealogy::ThreadActivitySP
-MachProcess::GetGenealogyInfoForThread(nub_thread_t tid, bool &timed_out) {
-  return m_activities.GetGenealogyInfoForThread(m_pid, tid, m_thread_list,
-                                                m_task.TaskPort(), timed_out);
-}
-
-Genealogy::ProcessExecutableInfoSP
-MachProcess::GetGenealogyImageInfo(size_t idx) {
-  return m_activities.GetProcessExecutableInfosAtIndex(idx);
-}
-
-bool MachProcess::GetOSVersionNumbers(uint64_t *major, uint64_t *minor,
-                                      uint64_t *patch) {
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) &&                  \
-    (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101000)
-  return false;
-#else
-  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-
-  NSOperatingSystemVersion vers =
-      [[NSProcessInfo processInfo] operatingSystemVersion];
-  if (major)
-    *major = vers.majorVersion;
-  if (minor)
-    *minor = vers.minorVersion;
-  if (patch)
-    *patch = vers.patchVersion;
-
-  [pool drain];
-
-  return true;
-#endif
-}
-
-// Do the process specific setup for attach.  If this returns NULL, then there's
-// no
-// platform specific stuff to be done to wait for the attach.  If you get
-// non-null,
-// pass that token to the CheckForProcess method, and then to
-// CleanupAfterAttach.
-
-//  Call PrepareForAttach before attaching to a process that has not yet
-//  launched
-// This returns a token that can be passed to CheckForProcess, and to
-// CleanupAfterAttach.
-// You should call CleanupAfterAttach to free the token, and do whatever other
-// cleanup seems good.
-
-const void *MachProcess::PrepareForAttach(const char *path,
-                                          nub_launch_flavor_t launch_flavor,
-                                          bool waitfor, DNBError &attach_err) {
-#if defined(WITH_SPRINGBOARD) || defined(WITH_BKS) || defined(WITH_FBS)
-  // Tell SpringBoard to halt the next launch of this application on startup.
-
-  if (!waitfor)
-    return NULL;
-
-  const char *app_ext = strstr(path, ".app");
-  const bool is_app =
-      app_ext != NULL && (app_ext[4] == '\0' || app_ext[4] == '/');
-  if (!is_app) {
-    DNBLogThreadedIf(
-        LOG_PROCESS,
-        "MachProcess::PrepareForAttach(): path '%s' doesn't contain .app, "
-        "we can't tell springboard to wait for launch...",
-        path);
-    return NULL;
-  }
-
-#if defined(WITH_FBS)
-  if (launch_flavor == eLaunchFlavorDefault)
-    launch_flavor = eLaunchFlavorFBS;
-  if (launch_flavor != eLaunchFlavorFBS)
-    return NULL;
-#elif defined(WITH_BKS)
-  if (launch_flavor == eLaunchFlavorDefault)
-    launch_flavor = eLaunchFlavorBKS;
-  if (launch_flavor != eLaunchFlavorBKS)
-    return NULL;
-#elif defined(WITH_SPRINGBOARD)
-  if (launch_flavor == eLaunchFlavorDefault)
-    launch_flavor = eLaunchFlavorSpringBoard;
-  if (launch_flavor != eLaunchFlavorSpringBoard)
-    return NULL;
-#endif
-
-  std::string app_bundle_path(path, app_ext + strlen(".app"));
-
-  CFStringRef bundleIDCFStr =
-      CopyBundleIDForPath(app_bundle_path.c_str(), attach_err);
-  std::string bundleIDStr;
-  CFString::UTF8(bundleIDCFStr, bundleIDStr);
-  DNBLogThreadedIf(LOG_PROCESS,
-                   "CopyBundleIDForPath (%s, err_str) returned @\"%s\"",
-                   app_bundle_path.c_str(), bundleIDStr.c_str());
-
-  if (bundleIDCFStr == NULL) {
-    return NULL;
-  }
-
-#if defined(WITH_FBS)
-  if (launch_flavor == eLaunchFlavorFBS) {
-    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-
-    NSString *stdio_path = nil;
-    NSFileManager *file_manager = [NSFileManager defaultManager];
-    const char *null_path = "/dev/null";
-    stdio_path =
-        [file_manager stringWithFileSystemRepresentation:null_path
-                                                  length:strlen(null_path)];
-
-    NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
-    NSMutableDictionary *options = [NSMutableDictionary dictionary];
-
-    DNBLogThreadedIf(LOG_PROCESS, "Calling BKSSystemService openApplication: "
-                                  "@\"%s\",options include stdio path: \"%s\", "
-                                  "BKSDebugOptionKeyDebugOnNextLaunch & "
-                                  "BKSDebugOptionKeyWaitForDebugger )",
-                     bundleIDStr.c_str(), null_path);
-
-    [debug_options setObject:stdio_path
-                      forKey:FBSDebugOptionKeyStandardOutPath];
-    [debug_options setObject:stdio_path
-                      forKey:FBSDebugOptionKeyStandardErrorPath];
-    [debug_options setObject:[NSNumber numberWithBool:YES]
-                      forKey:FBSDebugOptionKeyWaitForDebugger];
-    [debug_options setObject:[NSNumber numberWithBool:YES]
-                      forKey:FBSDebugOptionKeyDebugOnNextLaunch];
-
-    [options setObject:debug_options
-                forKey:FBSOpenApplicationOptionKeyDebuggingOptions];
-
-    FBSSystemService *system_service = [[FBSSystemService alloc] init];
-
-    mach_port_t client_port = [system_service createClientPort];
-    __block dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
-    __block FBSOpenApplicationErrorCode attach_error_code =
-        FBSOpenApplicationErrorCodeNone;
-
-    NSString *bundleIDNSStr = (NSString *)bundleIDCFStr;
-
-    [system_service openApplication:bundleIDNSStr
-                            options:options
-                         clientPort:client_port
-                         withResult:^(NSError *error) {
-                           // The system service will cleanup the client port we
-                           // created for us.
-                           if (error)
-                             attach_error_code =
-                                 (FBSOpenApplicationErrorCode)[error code];
-
-                           [system_service release];
-                           dispatch_semaphore_signal(semaphore);
-                         }];
-
-    const uint32_t timeout_secs = 9;
-
-    dispatch_time_t timeout =
-        dispatch_time(DISPATCH_TIME_NOW, timeout_secs * NSEC_PER_SEC);
-
-    long success = dispatch_semaphore_wait(semaphore, timeout) == 0;
-
-    if (!success) {
-      DNBLogError("timed out trying to launch %s.", bundleIDStr.c_str());
-      attach_err.SetErrorString(
-          "debugserver timed out waiting for openApplication to complete.");
-      attach_err.SetError(OPEN_APPLICATION_TIMEOUT_ERROR, DNBError::Generic);
-    } else if (attach_error_code != FBSOpenApplicationErrorCodeNone) {
-      SetFBSError(attach_error_code, attach_err);
-      DNBLogError("unable to launch the application with CFBundleIdentifier "
-                  "'%s' bks_error = %ld",
-                  bundleIDStr.c_str(), (NSInteger)attach_error_code);
-    }
-    dispatch_release(semaphore);
-    [pool drain];
-  }
-#endif
-#if defined(WITH_BKS)
-  if (launch_flavor == eLaunchFlavorBKS) {
-    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-
-    NSString *stdio_path = nil;
-    NSFileManager *file_manager = [NSFileManager defaultManager];
-    const char *null_path = "/dev/null";
-    stdio_path =
-        [file_manager stringWithFileSystemRepresentation:null_path
-                                                  length:strlen(null_path)];
-
-    NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
-    NSMutableDictionary *options = [NSMutableDictionary dictionary];
-
-    DNBLogThreadedIf(LOG_PROCESS, "Calling BKSSystemService openApplication: "
-                                  "@\"%s\",options include stdio path: \"%s\", "
-                                  "BKSDebugOptionKeyDebugOnNextLaunch & "
-                                  "BKSDebugOptionKeyWaitForDebugger )",
-                     bundleIDStr.c_str(), null_path);
-
-    [debug_options setObject:stdio_path
-                      forKey:BKSDebugOptionKeyStandardOutPath];
-    [debug_options setObject:stdio_path
-                      forKey:BKSDebugOptionKeyStandardErrorPath];
-    [debug_options setObject:[NSNumber numberWithBool:YES]
-                      forKey:BKSDebugOptionKeyWaitForDebugger];
-    [debug_options setObject:[NSNumber numberWithBool:YES]
-                      forKey:BKSDebugOptionKeyDebugOnNextLaunch];
-
-    [options setObject:debug_options
-                forKey:BKSOpenApplicationOptionKeyDebuggingOptions];
-
-    BKSSystemService *system_service = [[BKSSystemService alloc] init];
-
-    mach_port_t client_port = [system_service createClientPort];
-    __block dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
-    __block BKSOpenApplicationErrorCode attach_error_code =
-        BKSOpenApplicationErrorCodeNone;
-
-    NSString *bundleIDNSStr = (NSString *)bundleIDCFStr;
-
-    [system_service openApplication:bundleIDNSStr
-                            options:options
-                         clientPort:client_port
-                         withResult:^(NSError *error) {
-                           // The system service will cleanup the client port we
-                           // created for us.
-                           if (error)
-                             attach_error_code =
-                                 (BKSOpenApplicationErrorCode)[error code];
-
-                           [system_service release];
-                           dispatch_semaphore_signal(semaphore);
-                         }];
-
-    const uint32_t timeout_secs = 9;
-
-    dispatch_time_t timeout =
-        dispatch_time(DISPATCH_TIME_NOW, timeout_secs * NSEC_PER_SEC);
-
-    long success = dispatch_semaphore_wait(semaphore, timeout) == 0;
-
-    if (!success) {
-      DNBLogError("timed out trying to launch %s.", bundleIDStr.c_str());
-      attach_err.SetErrorString(
-          "debugserver timed out waiting for openApplication to complete.");
-      attach_err.SetError(OPEN_APPLICATION_TIMEOUT_ERROR, DNBError::Generic);
-    } else if (attach_error_code != BKSOpenApplicationErrorCodeNone) {
-      SetBKSError(attach_error_code, attach_err);
-      DNBLogError("unable to launch the application with CFBundleIdentifier "
-                  "'%s' bks_error = %ld",
-                  bundleIDStr.c_str(), attach_error_code);
-    }
-    dispatch_release(semaphore);
-    [pool drain];
-  }
-#endif
-
-#if defined(WITH_SPRINGBOARD)
-  if (launch_flavor == eLaunchFlavorSpringBoard) {
-    SBSApplicationLaunchError sbs_error = 0;
-
-    const char *stdout_err = "/dev/null";
-    CFString stdio_path;
-    stdio_path.SetFileSystemRepresentation(stdout_err);
-
-    DNBLogThreadedIf(LOG_PROCESS, "SBSLaunchApplicationForDebugging ( @\"%s\" "
-                                  ", NULL, NULL, NULL, @\"%s\", @\"%s\", "
-                                  "SBSApplicationDebugOnNextLaunch | "
-                                  "SBSApplicationLaunchWaitForDebugger )",
-                     bundleIDStr.c_str(), stdout_err, stdout_err);
-
-    sbs_error = SBSLaunchApplicationForDebugging(
-        bundleIDCFStr,
-        (CFURLRef)NULL, // openURL
-        NULL,           // launch_argv.get(),
-        NULL,           // launch_envp.get(),  // CFDictionaryRef environment
-        stdio_path.get(), stdio_path.get(),
-        SBSApplicationDebugOnNextLaunch | SBSApplicationLaunchWaitForDebugger);
-
-    if (sbs_error != SBSApplicationLaunchErrorSuccess) {
-      attach_err.SetError(sbs_error, DNBError::SpringBoard);
-      return NULL;
-    }
-  }
-#endif // WITH_SPRINGBOARD
-
-  DNBLogThreadedIf(LOG_PROCESS, "Successfully set DebugOnNextLaunch.");
-  return bundleIDCFStr;
-#else // !(defined (WITH_SPRINGBOARD) || defined (WITH_BKS) || defined
-      // (WITH_FBS))
-  return NULL;
-#endif
-}
-
-// Pass in the token you got from PrepareForAttach.  If there is a process
-// for that token, then the pid will be returned, otherwise INVALID_NUB_PROCESS
-// will be returned.
-
-nub_process_t MachProcess::CheckForProcess(const void *attach_token,
-                                           nub_launch_flavor_t launch_flavor) {
-  if (attach_token == NULL)
-    return INVALID_NUB_PROCESS;
-
-#if defined(WITH_FBS)
-  if (launch_flavor == eLaunchFlavorFBS) {
-    NSString *bundleIDNSStr = (NSString *)attach_token;
-    FBSSystemService *systemService = [[FBSSystemService alloc] init];
-    pid_t pid = [systemService pidForApplication:bundleIDNSStr];
-    [systemService release];
-    if (pid == 0)
-      return INVALID_NUB_PROCESS;
-    else
-      return pid;
-  }
-#endif
-
-#if defined(WITH_BKS)
-  if (launch_flavor == eLaunchFlavorBKS) {
-    NSString *bundleIDNSStr = (NSString *)attach_token;
-    BKSSystemService *systemService = [[BKSSystemService alloc] init];
-    pid_t pid = [systemService pidForApplication:bundleIDNSStr];
-    [systemService release];
-    if (pid == 0)
-      return INVALID_NUB_PROCESS;
-    else
-      return pid;
-  }
-#endif
-
-#if defined(WITH_SPRINGBOARD)
-  if (launch_flavor == eLaunchFlavorSpringBoard) {
-    CFStringRef bundleIDCFStr = (CFStringRef)attach_token;
-    Boolean got_it;
-    nub_process_t attach_pid;
-    got_it = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &attach_pid);
-    if (got_it)
-      return attach_pid;
-    else
-      return INVALID_NUB_PROCESS;
-  }
-#endif
-  return INVALID_NUB_PROCESS;
-}
-
-// Call this to clean up after you have either attached or given up on the
-// attach.
-// Pass true for success if you have attached, false if you have not.
-// The token will also be freed at this point, so you can't use it after calling
-// this method.
-
-void MachProcess::CleanupAfterAttach(const void *attach_token,
-                                     nub_launch_flavor_t launch_flavor,
-                                     bool success, DNBError &err_str) {
-  if (attach_token == NULL)
-    return;
-
-#if defined(WITH_FBS)
-  if (launch_flavor == eLaunchFlavorFBS) {
-    if (!success) {
-      FBSCleanupAfterAttach(attach_token, err_str);
-    }
-    CFRelease((CFStringRef)attach_token);
-  }
-#endif
-
-#if defined(WITH_BKS)
-
-  if (launch_flavor == eLaunchFlavorBKS) {
-    if (!success) {
-      BKSCleanupAfterAttach(attach_token, err_str);
-    }
-    CFRelease((CFStringRef)attach_token);
-  }
-#endif
-
-#if defined(WITH_SPRINGBOARD)
-  // Tell SpringBoard to cancel the debug on next launch of this application
-  // if we failed to attach
-  if (launch_flavor == eMachProcessFlagsUsingSpringBoard) {
-    if (!success) {
-      SBSApplicationLaunchError sbs_error = 0;
-      CFStringRef bundleIDCFStr = (CFStringRef)attach_token;
-
-      sbs_error = SBSLaunchApplicationForDebugging(
-          bundleIDCFStr, (CFURLRef)NULL, NULL, NULL, NULL, NULL,
-          SBSApplicationCancelDebugOnNextLaunch);
-
-      if (sbs_error != SBSApplicationLaunchErrorSuccess) {
-        err_str.SetError(sbs_error, DNBError::SpringBoard);
-        return;
-      }
-    }
-
-    CFRelease((CFStringRef)attach_token);
-  }
-#endif
-}
-
-pid_t MachProcess::LaunchForDebug(
-    const char *path, char const *argv[], char const *envp[],
-    const char *working_directory, // NULL => don't change, non-NULL => set
-                                   // working directory for inferior to this
-    const char *stdin_path, const char *stdout_path, const char *stderr_path,
-    bool no_stdio, nub_launch_flavor_t launch_flavor, int disable_aslr,
-    const char *event_data, DNBError &launch_err) {
-  // Clear out and clean up from any current state
-  Clear();
-
-  DNBLogThreadedIf(LOG_PROCESS,
-                   "%s( path = '%s', argv = %p, envp = %p, "
-                   "launch_flavor = %u, disable_aslr = %d )",
-                   __FUNCTION__, path, reinterpret_cast<const void *>(argv),
-                   reinterpret_cast<const void *>(envp), launch_flavor,
-                   disable_aslr);
-
-  // Fork a child process for debugging
-  SetState(eStateLaunching);
-
-  switch (launch_flavor) {
-  case eLaunchFlavorForkExec:
-    m_pid = MachProcess::ForkChildForPTraceDebugging(path, argv, envp, this,
-                                                     launch_err);
-    break;
-#ifdef WITH_FBS
-  case eLaunchFlavorFBS: {
-    const char *app_ext = strstr(path, ".app");
-    if (app_ext && (app_ext[4] == '\0' || app_ext[4] == '/')) {
-      std::string app_bundle_path(path, app_ext + strlen(".app"));
-      m_flags |= eMachProcessFlagsUsingFBS;
-      if (BoardServiceLaunchForDebug(app_bundle_path.c_str(), argv, envp,
-                                     no_stdio, disable_aslr, event_data,
-                                     launch_err) != 0)
-        return m_pid; // A successful SBLaunchForDebug() returns and assigns a
-                      // non-zero m_pid.
-      else
-        break; // We tried a FBS launch, but didn't succeed lets get out
-    }
-  } break;
-#endif
-#ifdef WITH_BKS
-  case eLaunchFlavorBKS: {
-    const char *app_ext = strstr(path, ".app");
-    if (app_ext && (app_ext[4] == '\0' || app_ext[4] == '/')) {
-      std::string app_bundle_path(path, app_ext + strlen(".app"));
-      m_flags |= eMachProcessFlagsUsingBKS;
-      if (BoardServiceLaunchForDebug(app_bundle_path.c_str(), argv, envp,
-                                     no_stdio, disable_aslr, event_data,
-                                     launch_err) != 0)
-        return m_pid; // A successful SBLaunchForDebug() returns and assigns a
-                      // non-zero m_pid.
-      else
-        break; // We tried a BKS launch, but didn't succeed lets get out
-    }
-  } break;
-#endif
-#ifdef WITH_SPRINGBOARD
-
-  case eLaunchFlavorSpringBoard: {
-    //  .../whatever.app/whatever ?
-    //  Or .../com.apple.whatever.app/whatever -- be careful of ".app" in
-    //  "com.apple.whatever" here
-    const char *app_ext = strstr(path, ".app/");
-    if (app_ext == NULL) {
-      // .../whatever.app ?
-      int len = strlen(path);
-      if (len > 5) {
-        if (strcmp(path + len - 4, ".app") == 0) {
-          app_ext = path + len - 4;
-        }
-      }
-    }
-    if (app_ext) {
-      std::string app_bundle_path(path, app_ext + strlen(".app"));
-      if (SBLaunchForDebug(app_bundle_path.c_str(), argv, envp, no_stdio,
-                           disable_aslr, launch_err) != 0)
-        return m_pid; // A successful SBLaunchForDebug() returns and assigns a
-                      // non-zero m_pid.
-      else
-        break; // We tried a springboard launch, but didn't succeed lets get out
-    }
-  } break;
-
-#endif
-
-  case eLaunchFlavorPosixSpawn:
-    m_pid = MachProcess::PosixSpawnChildForPTraceDebugging(
-        path, DNBArchProtocol::GetArchitecture(), argv, envp, working_directory,
-        stdin_path, stdout_path, stderr_path, no_stdio, this, disable_aslr,
-        launch_err);
-    break;
-
-  default:
-    // Invalid  launch
-    launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic);
-    return INVALID_NUB_PROCESS;
-  }
-
-  if (m_pid == INVALID_NUB_PROCESS) {
-    // If we don't have a valid process ID and no one has set the error,
-    // then return a generic error
-    if (launch_err.Success())
-      launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic);
-  } else {
-    m_path = path;
-    size_t i;
-    char const *arg;
-    for (i = 0; (arg = argv[i]) != NULL; i++)
-      m_args.push_back(arg);
-
-    m_task.StartExceptionThread(launch_err);
-    if (launch_err.Fail()) {
-      if (launch_err.AsString() == NULL)
-        launch_err.SetErrorString("unable to start the exception thread");
-      DNBLog("Could not get inferior's Mach exception port, sending ptrace "
-             "PT_KILL and exiting.");
-      ::ptrace(PT_KILL, m_pid, 0, 0);
-      m_pid = INVALID_NUB_PROCESS;
-      return INVALID_NUB_PROCESS;
-    }
-
-    StartSTDIOThread();
-
-    if (launch_flavor == eLaunchFlavorPosixSpawn) {
-
-      SetState(eStateAttaching);
-      errno = 0;
-      int err = ::ptrace(PT_ATTACHEXC, m_pid, 0, 0);
-      if (err == 0) {
-        m_flags |= eMachProcessFlagsAttached;
-        DNBLogThreadedIf(LOG_PROCESS, "successfully spawned pid %d", m_pid);
-        launch_err.Clear();
-      } else {
-        SetState(eStateExited);
-        DNBError ptrace_err(errno, DNBError::POSIX);
-        DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to spawned pid "
-                                      "%d (err = %i, errno = %i (%s))",
-                         m_pid, err, ptrace_err.Status(),
-                         ptrace_err.AsString());
-        launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic);
-      }
-    } else {
-      launch_err.Clear();
-    }
-  }
-  return m_pid;
-}
-
-pid_t MachProcess::PosixSpawnChildForPTraceDebugging(
-    const char *path, cpu_type_t cpu_type, char const *argv[],
-    char const *envp[], const char *working_directory, const char *stdin_path,
-    const char *stdout_path, const char *stderr_path, bool no_stdio,
-    MachProcess *process, int disable_aslr, DNBError &err) {
-  posix_spawnattr_t attr;
-  short flags;
-  DNBLogThreadedIf(LOG_PROCESS, "%s ( path='%s', argv=%p, envp=%p, "
-                                "working_dir=%s, stdin=%s, stdout=%s "
-                                "stderr=%s, no-stdio=%i)",
-                   __FUNCTION__, path, reinterpret_cast<const void *>(argv),
-                   reinterpret_cast<const void *>(envp), working_directory,
-                   stdin_path, stdout_path, stderr_path, no_stdio);
-
-  err.SetError(::posix_spawnattr_init(&attr), DNBError::POSIX);
-  if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
-    err.LogThreaded("::posix_spawnattr_init ( &attr )");
-  if (err.Fail())
-    return INVALID_NUB_PROCESS;
-
-  flags = POSIX_SPAWN_START_SUSPENDED | POSIX_SPAWN_SETSIGDEF |
-          POSIX_SPAWN_SETSIGMASK;
-  if (disable_aslr)
-    flags |= _POSIX_SPAWN_DISABLE_ASLR;
-
-  sigset_t no_signals;
-  sigset_t all_signals;
-  sigemptyset(&no_signals);
-  sigfillset(&all_signals);
-  ::posix_spawnattr_setsigmask(&attr, &no_signals);
-  ::posix_spawnattr_setsigdefault(&attr, &all_signals);
-
-  err.SetError(::posix_spawnattr_setflags(&attr, flags), DNBError::POSIX);
-  if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
-    err.LogThreaded(
-        "::posix_spawnattr_setflags ( &attr, POSIX_SPAWN_START_SUSPENDED%s )",
-        flags & _POSIX_SPAWN_DISABLE_ASLR ? " | _POSIX_SPAWN_DISABLE_ASLR"
-                                          : "");
-  if (err.Fail())
-    return INVALID_NUB_PROCESS;
-
-// Don't do this on SnowLeopard, _sometimes_ the TASK_BASIC_INFO will fail
-// and we will fail to continue with our process...
-
-// On SnowLeopard we should set "DYLD_NO_PIE" in the inferior environment....
-
-#if !defined(__arm__)
-
-  // We don't need to do this for ARM, and we really shouldn't now that we
-  // have multiple CPU subtypes and no posix_spawnattr call that allows us
-  // to set which CPU subtype to launch...
-  if (cpu_type != 0) {
-    size_t ocount = 0;
-    err.SetError(::posix_spawnattr_setbinpref_np(&attr, 1, &cpu_type, &ocount),
-                 DNBError::POSIX);
-    if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
-      err.LogThreaded("::posix_spawnattr_setbinpref_np ( &attr, 1, cpu_type = "
-                      "0x%8.8x, count => %llu )",
-                      cpu_type, (uint64_t)ocount);
-
-    if (err.Fail() != 0 || ocount != 1)
-      return INVALID_NUB_PROCESS;
-  }
-#endif
-
-  PseudoTerminal pty;
-
-  posix_spawn_file_actions_t file_actions;
-  err.SetError(::posix_spawn_file_actions_init(&file_actions), DNBError::POSIX);
-  int file_actions_valid = err.Success();
-  if (!file_actions_valid || DNBLogCheckLogBit(LOG_PROCESS))
-    err.LogThreaded("::posix_spawn_file_actions_init ( &file_actions )");
-  int pty_error = -1;
-  pid_t pid = INVALID_NUB_PROCESS;
-  if (file_actions_valid) {
-    if (stdin_path == NULL && stdout_path == NULL && stderr_path == NULL &&
-        !no_stdio) {
-      pty_error = pty.OpenFirstAvailableMaster(O_RDWR | O_NOCTTY);
-      if (pty_error == PseudoTerminal::success) {
-        stdin_path = stdout_path = stderr_path = pty.SlaveName();
-      }
-    }
-
-    // if no_stdio or std paths not supplied, then route to "/dev/null".
-    if (no_stdio || stdin_path == NULL || stdin_path[0] == '\0')
-      stdin_path = "/dev/null";
-    if (no_stdio || stdout_path == NULL || stdout_path[0] == '\0')
-      stdout_path = "/dev/null";
-    if (no_stdio || stderr_path == NULL || stderr_path[0] == '\0')
-      stderr_path = "/dev/null";
-
-    err.SetError(::posix_spawn_file_actions_addopen(&file_actions, STDIN_FILENO,
-                                                    stdin_path,
-                                                    O_RDONLY | O_NOCTTY, 0),
-                 DNBError::POSIX);
-    if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
-      err.LogThreaded("::posix_spawn_file_actions_addopen (&file_actions, "
-                      "filedes=STDIN_FILENO, path='%s')",
-                      stdin_path);
-
-    err.SetError(::posix_spawn_file_actions_addopen(
-                     &file_actions, STDOUT_FILENO, stdout_path,
-                     O_WRONLY | O_NOCTTY | O_CREAT, 0640),
-                 DNBError::POSIX);
-    if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
-      err.LogThreaded("::posix_spawn_file_actions_addopen (&file_actions, "
-                      "filedes=STDOUT_FILENO, path='%s')",
-                      stdout_path);
-
-    err.SetError(::posix_spawn_file_actions_addopen(
-                     &file_actions, STDERR_FILENO, stderr_path,
-                     O_WRONLY | O_NOCTTY | O_CREAT, 0640),
-                 DNBError::POSIX);
-    if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
-      err.LogThreaded("::posix_spawn_file_actions_addopen (&file_actions, "
-                      "filedes=STDERR_FILENO, path='%s')",
-                      stderr_path);
-
-    // TODO: Verify if we can set the working directory back immediately
-    // after the posix_spawnp call without creating a race condition???
-    if (working_directory)
-      ::chdir(working_directory);
-
-    err.SetError(::posix_spawnp(&pid, path, &file_actions, &attr,
-                                const_cast<char *const *>(argv),
-                                const_cast<char *const *>(envp)),
-                 DNBError::POSIX);
-    if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
-      err.LogThreaded("::posix_spawnp ( pid => %i, path = '%s', file_actions = "
-                      "%p, attr = %p, argv = %p, envp = %p )",
-                      pid, path, &file_actions, &attr, argv, envp);
-  } else {
-    // TODO: Verify if we can set the working directory back immediately
-    // after the posix_spawnp call without creating a race condition???
-    if (working_directory)
-      ::chdir(working_directory);
-
-    err.SetError(::posix_spawnp(&pid, path, NULL, &attr,
-                                const_cast<char *const *>(argv),
-                                const_cast<char *const *>(envp)),
-                 DNBError::POSIX);
-    if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
-      err.LogThreaded("::posix_spawnp ( pid => %i, path = '%s', file_actions = "
-                      "%p, attr = %p, argv = %p, envp = %p )",
-                      pid, path, NULL, &attr, argv, envp);
-  }
-
-  // We have seen some cases where posix_spawnp was returning a valid
-  // looking pid even when an error was returned, so clear it out
-  if (err.Fail())
-    pid = INVALID_NUB_PROCESS;
-
-  if (pty_error == 0) {
-    if (process != NULL) {
-      int master_fd = pty.ReleaseMasterFD();
-      process->SetChildFileDescriptors(master_fd, master_fd, master_fd);
-    }
-  }
-  ::posix_spawnattr_destroy(&attr);
-
-  if (pid != INVALID_NUB_PROCESS) {
-    cpu_type_t pid_cpu_type = MachProcess::GetCPUTypeForLocalProcess(pid);
-    DNBLogThreadedIf(LOG_PROCESS,
-                     "MachProcess::%s ( ) pid=%i, cpu_type=0x%8.8x",
-                     __FUNCTION__, pid, pid_cpu_type);
-    if (pid_cpu_type)
-      DNBArchProtocol::SetArchitecture(pid_cpu_type);
-  }
-
-  if (file_actions_valid) {
-    DNBError err2;
-    err2.SetError(::posix_spawn_file_actions_destroy(&file_actions),
-                  DNBError::POSIX);
-    if (err2.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
-      err2.LogThreaded("::posix_spawn_file_actions_destroy ( &file_actions )");
-  }
-
-  return pid;
-}
-
-uint32_t MachProcess::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;
-}
-
-pid_t MachProcess::ForkChildForPTraceDebugging(const char *path,
-                                               char const *argv[],
-                                               char const *envp[],
-                                               MachProcess *process,
-                                               DNBError &launch_err) {
-  PseudoTerminal::Status pty_error = PseudoTerminal::success;
-
-  // Use a fork that ties the child process's stdin/out/err to a pseudo
-  // terminal so we can read it in our MachProcess::STDIOThread
-  // as unbuffered io.
-  PseudoTerminal pty;
-  pid_t pid = pty.Fork(pty_error);
-
-  if (pid < 0) {
-    //--------------------------------------------------------------
-    // Status during fork.
-    //--------------------------------------------------------------
-    return pid;
-  } else if (pid == 0) {
-    //--------------------------------------------------------------
-    // Child process
-    //--------------------------------------------------------------
-    ::ptrace(PT_TRACE_ME, 0, 0, 0); // Debug this process
-    ::ptrace(PT_SIGEXC, 0, 0, 0);   // Get BSD signals as mach exceptions
-
-    // If our parent is setgid, lets make sure we don't inherit those
-    // extra powers due to nepotism.
-    if (::setgid(getgid()) == 0) {
-
-      // Let the child have its own process group. We need to execute
-      // this call in both the child and parent to avoid a race condition
-      // between the two processes.
-      ::setpgid(0, 0); // Set the child process group to match its pid
-
-      // Sleep a bit to before the exec call
-      ::sleep(1);
-
-      // Turn this process into
-      ::execv(path, const_cast<char *const *>(argv));
-    }
-    // Exit with error code. Child process should have taken
-    // over in above exec call and if the exec fails it will
-    // exit the child process below.
-    ::exit(127);
-  } else {
-    //--------------------------------------------------------------
-    // Parent process
-    //--------------------------------------------------------------
-    // Let the child have its own process group. We need to execute
-    // this call in both the child and parent to avoid a race condition
-    // between the two processes.
-    ::setpgid(pid, pid); // Set the child process group to match its pid
-
-    if (process != NULL) {
-      // Release our master pty file descriptor so the pty class doesn't
-      // close it and so we can continue to use it in our STDIO thread
-      int master_fd = pty.ReleaseMasterFD();
-      process->SetChildFileDescriptors(master_fd, master_fd, master_fd);
-    }
-  }
-  return pid;
-}
-
-#if defined(WITH_SPRINGBOARD) || defined(WITH_BKS) || defined(WITH_FBS)
-// This returns a CFRetained pointer to the Bundle ID for app_bundle_path,
-// or NULL if there was some problem getting the bundle id.
-static CFStringRef CopyBundleIDForPath(const char *app_bundle_path,
-                                       DNBError &err_str) {
-  CFBundle bundle(app_bundle_path);
-  CFStringRef bundleIDCFStr = bundle.GetIdentifier();
-  std::string bundleID;
-  if (CFString::UTF8(bundleIDCFStr, bundleID) == NULL) {
-    struct stat app_bundle_stat;
-    char err_msg[PATH_MAX];
-
-    if (::stat(app_bundle_path, &app_bundle_stat) < 0) {
-      err_str.SetError(errno, DNBError::POSIX);
-      snprintf(err_msg, sizeof(err_msg), "%s: \"%s\"", err_str.AsString(),
-               app_bundle_path);
-      err_str.SetErrorString(err_msg);
-      DNBLogThreadedIf(LOG_PROCESS, "%s() error: %s", __FUNCTION__, err_msg);
-    } else {
-      err_str.SetError(-1, DNBError::Generic);
-      snprintf(err_msg, sizeof(err_msg),
-               "failed to extract CFBundleIdentifier from %s", app_bundle_path);
-      err_str.SetErrorString(err_msg);
-      DNBLogThreadedIf(
-          LOG_PROCESS,
-          "%s() error: failed to extract CFBundleIdentifier from '%s'",
-          __FUNCTION__, app_bundle_path);
-    }
-    return NULL;
-  }
-
-  DNBLogThreadedIf(LOG_PROCESS, "%s() extracted CFBundleIdentifier: %s",
-                   __FUNCTION__, bundleID.c_str());
-  CFRetain(bundleIDCFStr);
-
-  return bundleIDCFStr;
-}
-#endif // #if defined (WITH_SPRINGBOARD) || defined (WITH_BKS) || defined
-       // (WITH_FBS)
-#ifdef WITH_SPRINGBOARD
-
-pid_t MachProcess::SBLaunchForDebug(const char *path, char const *argv[],
-                                    char const *envp[], bool no_stdio,
-                                    bool disable_aslr, DNBError &launch_err) {
-  // Clear out and clean up from any current state
-  Clear();
-
-  DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv)", __FUNCTION__, path);
-
-  // Fork a child process for debugging
-  SetState(eStateLaunching);
-  m_pid = MachProcess::SBForkChildForPTraceDebugging(path, argv, envp, no_stdio,
-                                                     this, launch_err);
-  if (m_pid != 0) {
-    m_flags |= eMachProcessFlagsUsingSBS;
-    m_path = path;
-    size_t i;
-    char const *arg;
-    for (i = 0; (arg = argv[i]) != NULL; i++)
-      m_args.push_back(arg);
-    m_task.StartExceptionThread(launch_err);
-
-    if (launch_err.Fail()) {
-      if (launch_err.AsString() == NULL)
-        launch_err.SetErrorString("unable to start the exception thread");
-      DNBLog("Could not get inferior's Mach exception port, sending ptrace "
-             "PT_KILL and exiting.");
-      ::ptrace(PT_KILL, m_pid, 0, 0);
-      m_pid = INVALID_NUB_PROCESS;
-      return INVALID_NUB_PROCESS;
-    }
-
-    StartSTDIOThread();
-    SetState(eStateAttaching);
-    int err = ::ptrace(PT_ATTACHEXC, m_pid, 0, 0);
-    if (err == 0) {
-      m_flags |= eMachProcessFlagsAttached;
-      DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", m_pid);
-    } else {
-      SetState(eStateExited);
-      DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", m_pid);
-    }
-  }
-  return m_pid;
-}
-
-#include <servers/bootstrap.h>
-
-pid_t MachProcess::SBForkChildForPTraceDebugging(
-    const char *app_bundle_path, char const *argv[], char const *envp[],
-    bool no_stdio, MachProcess *process, DNBError &launch_err) {
-  DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv, %p)", __FUNCTION__,
-                   app_bundle_path, process);
-  CFAllocatorRef alloc = kCFAllocatorDefault;
-
-  if (argv[0] == NULL)
-    return INVALID_NUB_PROCESS;
-
-  size_t argc = 0;
-  // Count the number of arguments
-  while (argv[argc] != NULL)
-    argc++;
-
-  // Enumerate the arguments
-  size_t first_launch_arg_idx = 1;
-  CFReleaser<CFMutableArrayRef> launch_argv;
-
-  if (argv[first_launch_arg_idx]) {
-    size_t launch_argc = argc > 0 ? argc - 1 : 0;
-    launch_argv.reset(
-        ::CFArrayCreateMutable(alloc, launch_argc, &kCFTypeArrayCallBacks));
-    size_t i;
-    char const *arg;
-    CFString launch_arg;
-    for (i = first_launch_arg_idx; (i < argc) && ((arg = argv[i]) != NULL);
-         i++) {
-      launch_arg.reset(
-          ::CFStringCreateWithCString(alloc, arg, kCFStringEncodingUTF8));
-      if (launch_arg.get() != NULL)
-        CFArrayAppendValue(launch_argv.get(), launch_arg.get());
-      else
-        break;
-    }
-  }
-
-  // Next fill in the arguments dictionary.  Note, the envp array is of the form
-  // Variable=value but SpringBoard wants a CF dictionary.  So we have to
-  // convert
-  // this here.
-
-  CFReleaser<CFMutableDictionaryRef> launch_envp;
-
-  if (envp[0]) {
-    launch_envp.reset(
-        ::CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks,
-                                    &kCFTypeDictionaryValueCallBacks));
-    const char *value;
-    int name_len;
-    CFString name_string, value_string;
-
-    for (int i = 0; envp[i] != NULL; i++) {
-      value = strstr(envp[i], "=");
-
-      // If the name field is empty or there's no =, skip it.  Somebody's
-      // messing with us.
-      if (value == NULL || value == envp[i])
-        continue;
-
-      name_len = value - envp[i];
-
-      // Now move value over the "="
-      value++;
-
-      name_string.reset(
-          ::CFStringCreateWithBytes(alloc, (const UInt8 *)envp[i], name_len,
-                                    kCFStringEncodingUTF8, false));
-      value_string.reset(
-          ::CFStringCreateWithCString(alloc, value, kCFStringEncodingUTF8));
-      CFDictionarySetValue(launch_envp.get(), name_string.get(),
-                           value_string.get());
-    }
-  }
-
-  CFString stdio_path;
-
-  PseudoTerminal pty;
-  if (!no_stdio) {
-    PseudoTerminal::Status pty_err =
-        pty.OpenFirstAvailableMaster(O_RDWR | O_NOCTTY);
-    if (pty_err == PseudoTerminal::success) {
-      const char *slave_name = pty.SlaveName();
-      DNBLogThreadedIf(LOG_PROCESS,
-                       "%s() successfully opened master pty, slave is %s",
-                       __FUNCTION__, slave_name);
-      if (slave_name && slave_name[0]) {
-        ::chmod(slave_name, S_IRWXU | S_IRWXG | S_IRWXO);
-        stdio_path.SetFileSystemRepresentation(slave_name);
-      }
-    }
-  }
-
-  if (stdio_path.get() == NULL) {
-    stdio_path.SetFileSystemRepresentation("/dev/null");
-  }
-
-  CFStringRef bundleIDCFStr = CopyBundleIDForPath(app_bundle_path, launch_err);
-  if (bundleIDCFStr == NULL)
-    return INVALID_NUB_PROCESS;
-
-  // This is just for logging:
-  std::string bundleID;
-  CFString::UTF8(bundleIDCFStr, bundleID);
-
-  DNBLogThreadedIf(LOG_PROCESS, "%s() serialized launch arg array",
-                   __FUNCTION__);
-
-  // Find SpringBoard
-  SBSApplicationLaunchError sbs_error = 0;
-  sbs_error = SBSLaunchApplicationForDebugging(
-      bundleIDCFStr,
-      (CFURLRef)NULL, // openURL
-      launch_argv.get(),
-      launch_envp.get(), // CFDictionaryRef environment
-      stdio_path.get(), stdio_path.get(),
-      SBSApplicationLaunchWaitForDebugger | SBSApplicationLaunchUnlockDevice);
-
-  launch_err.SetError(sbs_error, DNBError::SpringBoard);
-
-  if (sbs_error == SBSApplicationLaunchErrorSuccess) {
-    static const useconds_t pid_poll_interval = 200000;
-    static const useconds_t pid_poll_timeout = 30000000;
-
-    useconds_t pid_poll_total = 0;
-
-    nub_process_t pid = INVALID_NUB_PROCESS;
-    Boolean pid_found = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &pid);
-    // Poll until the process is running, as long as we are getting valid
-    // responses and the timeout hasn't expired
-    // A return PID of 0 means the process is not running, which may be because
-    // it hasn't been (asynchronously) started
-    // yet, or that it died very quickly (if you weren't using waitForDebugger).
-    while (!pid_found && pid_poll_total < pid_poll_timeout) {
-      usleep(pid_poll_interval);
-      pid_poll_total += pid_poll_interval;
-      DNBLogThreadedIf(LOG_PROCESS,
-                       "%s() polling Springboard for pid for %s...",
-                       __FUNCTION__, bundleID.c_str());
-      pid_found = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &pid);
-    }
-
-    CFRelease(bundleIDCFStr);
-    if (pid_found) {
-      if (process != NULL) {
-        // Release our master pty file descriptor so the pty class doesn't
-        // close it and so we can continue to use it in our STDIO thread
-        int master_fd = pty.ReleaseMasterFD();
-        process->SetChildFileDescriptors(master_fd, master_fd, master_fd);
-      }
-      DNBLogThreadedIf(LOG_PROCESS, "%s() => pid = %4.4x", __FUNCTION__, pid);
-    } else {
-      DNBLogError("failed to lookup the process ID for CFBundleIdentifier %s.",
-                  bundleID.c_str());
-    }
-    return pid;
-  }
-
-  DNBLogError("unable to launch the application with CFBundleIdentifier '%s' "
-              "sbs_error = %u",
-              bundleID.c_str(), sbs_error);
-  return INVALID_NUB_PROCESS;
-}
-
-#endif // #ifdef WITH_SPRINGBOARD
-
-#if defined(WITH_BKS) || defined(WITH_FBS)
-pid_t MachProcess::BoardServiceLaunchForDebug(
-    const char *path, char const *argv[], char const *envp[], bool no_stdio,
-    bool disable_aslr, const char *event_data, DNBError &launch_err) {
-  DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv)", __FUNCTION__, path);
-
-  // Fork a child process for debugging
-  SetState(eStateLaunching);
-  m_pid = BoardServiceForkChildForPTraceDebugging(
-      path, argv, envp, no_stdio, disable_aslr, event_data, launch_err);
-  if (m_pid != 0) {
-    m_path = path;
-    size_t i;
-    char const *arg;
-    for (i = 0; (arg = argv[i]) != NULL; i++)
-      m_args.push_back(arg);
-    m_task.StartExceptionThread(launch_err);
-
-    if (launch_err.Fail()) {
-      if (launch_err.AsString() == NULL)
-        launch_err.SetErrorString("unable to start the exception thread");
-      DNBLog("Could not get inferior's Mach exception port, sending ptrace "
-             "PT_KILL and exiting.");
-      ::ptrace(PT_KILL, m_pid, 0, 0);
-      m_pid = INVALID_NUB_PROCESS;
-      return INVALID_NUB_PROCESS;
-    }
-
-    StartSTDIOThread();
-    SetState(eStateAttaching);
-    int err = ::ptrace(PT_ATTACHEXC, m_pid, 0, 0);
-    if (err == 0) {
-      m_flags |= eMachProcessFlagsAttached;
-      DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", m_pid);
-    } else {
-      SetState(eStateExited);
-      DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", m_pid);
-    }
-  }
-  return m_pid;
-}
-
-pid_t MachProcess::BoardServiceForkChildForPTraceDebugging(
-    const char *app_bundle_path, char const *argv[], char const *envp[],
-    bool no_stdio, bool disable_aslr, const char *event_data,
-    DNBError &launch_err) {
-  if (argv[0] == NULL)
-    return INVALID_NUB_PROCESS;
-
-  DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv, %p)", __FUNCTION__,
-                   app_bundle_path, this);
-
-  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-
-  size_t argc = 0;
-  // Count the number of arguments
-  while (argv[argc] != NULL)
-    argc++;
-
-  // Enumerate the arguments
-  size_t first_launch_arg_idx = 1;
-
-  NSMutableArray *launch_argv = nil;
-
-  if (argv[first_launch_arg_idx]) {
-    size_t launch_argc = argc > 0 ? argc - 1 : 0;
-    launch_argv = [NSMutableArray arrayWithCapacity:launch_argc];
-    size_t i;
-    char const *arg;
-    NSString *launch_arg;
-    for (i = first_launch_arg_idx; (i < argc) && ((arg = argv[i]) != NULL);
-         i++) {
-      launch_arg = [NSString stringWithUTF8String:arg];
-      // FIXME: Should we silently eat an argument that we can't convert into a
-      // UTF8 string?
-      if (launch_arg != nil)
-        [launch_argv addObject:launch_arg];
-      else
-        break;
-    }
-  }
-
-  NSMutableDictionary *launch_envp = nil;
-  if (envp[0]) {
-    launch_envp = [[NSMutableDictionary alloc] init];
-    const char *value;
-    int name_len;
-    NSString *name_string, *value_string;
-
-    for (int i = 0; envp[i] != NULL; i++) {
-      value = strstr(envp[i], "=");
-
-      // If the name field is empty or there's no =, skip it.  Somebody's
-      // messing with us.
-      if (value == NULL || value == envp[i])
-        continue;
-
-      name_len = value - envp[i];
-
-      // Now move value over the "="
-      value++;
-      name_string = [[NSString alloc] initWithBytes:envp[i]
-                                             length:name_len
-                                           encoding:NSUTF8StringEncoding];
-      value_string = [NSString stringWithUTF8String:value];
-      [launch_envp setObject:value_string forKey:name_string];
-    }
-  }
-
-  NSString *stdio_path = nil;
-  NSFileManager *file_manager = [NSFileManager defaultManager];
-
-  PseudoTerminal pty;
-  if (!no_stdio) {
-    PseudoTerminal::Status pty_err =
-        pty.OpenFirstAvailableMaster(O_RDWR | O_NOCTTY);
-    if (pty_err == PseudoTerminal::success) {
-      const char *slave_name = pty.SlaveName();
-      DNBLogThreadedIf(LOG_PROCESS,
-                       "%s() successfully opened master pty, slave is %s",
-                       __FUNCTION__, slave_name);
-      if (slave_name && slave_name[0]) {
-        ::chmod(slave_name, S_IRWXU | S_IRWXG | S_IRWXO);
-        stdio_path = [file_manager
-            stringWithFileSystemRepresentation:slave_name
-                                        length:strlen(slave_name)];
-      }
-    }
-  }
-
-  if (stdio_path == nil) {
-    const char *null_path = "/dev/null";
-    stdio_path =
-        [file_manager stringWithFileSystemRepresentation:null_path
-                                                  length:strlen(null_path)];
-  }
-
-  CFStringRef bundleIDCFStr = CopyBundleIDForPath(app_bundle_path, launch_err);
-  if (bundleIDCFStr == NULL) {
-    [pool drain];
-    return INVALID_NUB_PROCESS;
-  }
-
-  // Instead of rewriting CopyBundleIDForPath for NSStrings, we'll just use
-  // toll-free bridging here:
-  NSString *bundleIDNSStr = (NSString *)bundleIDCFStr;
-
-  // Okay, now let's assemble all these goodies into the BackBoardServices
-  // options mega-dictionary:
-
-  NSMutableDictionary *options = nullptr;
-  pid_t return_pid = INVALID_NUB_PROCESS;
-  bool success = false;
-
-#ifdef WITH_BKS
-  if (m_flags & eMachProcessFlagsUsingBKS) {
-    options =
-        BKSCreateOptionsDictionary(app_bundle_path, launch_argv, launch_envp,
-                                   stdio_path, disable_aslr, event_data);
-    success = BKSCallOpenApplicationFunction(bundleIDNSStr, options, launch_err,
-                                             &return_pid);
-  }
-#endif
-#ifdef WITH_FBS
-  if (m_flags & eMachProcessFlagsUsingFBS) {
-    options =
-        FBSCreateOptionsDictionary(app_bundle_path, launch_argv, launch_envp,
-                                   stdio_path, disable_aslr, event_data);
-    success = FBSCallOpenApplicationFunction(bundleIDNSStr, options, launch_err,
-                                             &return_pid);
-  }
-#endif
-
-  if (success) {
-    int master_fd = pty.ReleaseMasterFD();
-    SetChildFileDescriptors(master_fd, master_fd, master_fd);
-    CFString::UTF8(bundleIDCFStr, m_bundle_id);
-  }
-
-  [pool drain];
-
-  return return_pid;
-}
-
-bool MachProcess::BoardServiceSendEvent(const char *event_data,
-                                        DNBError &send_err) {
-  bool return_value = true;
-
-  if (event_data == NULL || *event_data == '\0') {
-    DNBLogError("SendEvent called with NULL event data.");
-    send_err.SetErrorString("SendEvent called with empty event data");
-    return false;
-  }
-
-  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-
-  if (strcmp(event_data, "BackgroundApplication") == 0) {
-// This is an event I cooked up.  What you actually do is foreground the system
-// app, so:
-#ifdef WITH_BKS
-    if (m_flags & eMachProcessFlagsUsingBKS) {
-      return_value = BKSCallOpenApplicationFunction(nil, nil, send_err, NULL);
-    }
-#endif
-#ifdef WITH_FBS
-    if (m_flags & eMachProcessFlagsUsingFBS) {
-      return_value = FBSCallOpenApplicationFunction(nil, nil, send_err, NULL);
-    }
-#endif
-    if (!return_value) {
-      DNBLogError("Failed to background application, error: %s.",
-                  send_err.AsString());
-    }
-  } else {
-    if (m_bundle_id.empty()) {
-      // See if we can figure out the bundle ID for this PID:
-
-      DNBLogError(
-          "Tried to send event \"%s\" to a process that has no bundle ID.",
-          event_data);
-      return false;
-    }
-
-    NSString *bundleIDNSStr =
-        [NSString stringWithUTF8String:m_bundle_id.c_str()];
-
-    NSMutableDictionary *options = [NSMutableDictionary dictionary];
-
-#ifdef WITH_BKS
-    if (m_flags & eMachProcessFlagsUsingBKS) {
-      if (!BKSAddEventDataToOptions(options, event_data, send_err)) {
-        [pool drain];
-        return false;
-      }
-      return_value = BKSCallOpenApplicationFunction(bundleIDNSStr, options,
-                                                    send_err, NULL);
-      DNBLogThreadedIf(LOG_PROCESS,
-                       "Called BKSCallOpenApplicationFunction to send event.");
-    }
-#endif
-#ifdef WITH_FBS
-    if (m_flags & eMachProcessFlagsUsingFBS) {
-      if (!FBSAddEventDataToOptions(options, event_data, send_err)) {
-        [pool drain];
-        return false;
-      }
-      return_value = FBSCallOpenApplicationFunction(bundleIDNSStr, options,
-                                                    send_err, NULL);
-      DNBLogThreadedIf(LOG_PROCESS,
-                       "Called FBSCallOpenApplicationFunction to send event.");
-    }
-#endif
-
-    if (!return_value) {
-      DNBLogError("Failed to send event: %s, error: %s.", event_data,
-                  send_err.AsString());
-    }
-  }
-
-  [pool drain];
-  return return_value;
-}
-#endif // defined(WITH_BKS) || defined (WITH_FBS)
-
-#ifdef WITH_BKS
-void MachProcess::BKSCleanupAfterAttach(const void *attach_token,
-                                        DNBError &err_str) {
-  bool success;
-
-  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-
-  // Instead of rewriting CopyBundleIDForPath for NSStrings, we'll just use
-  // toll-free bridging here:
-  NSString *bundleIDNSStr = (NSString *)attach_token;
-
-  // Okay, now let's assemble all these goodies into the BackBoardServices
-  // options mega-dictionary:
-
-  // First we have the debug sub-dictionary:
-  NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
-  [debug_options setObject:[NSNumber numberWithBool:YES]
-                    forKey:BKSDebugOptionKeyCancelDebugOnNextLaunch];
-
-  // That will go in the overall dictionary:
-
-  NSMutableDictionary *options = [NSMutableDictionary dictionary];
-  [options setObject:debug_options
-              forKey:BKSOpenApplicationOptionKeyDebuggingOptions];
-
-  success =
-      BKSCallOpenApplicationFunction(bundleIDNSStr, options, err_str, NULL);
-
-  if (!success) {
-    DNBLogError("error trying to cancel debug on next launch for %s: %s",
-                [bundleIDNSStr UTF8String], err_str.AsString());
-  }
-
-  [pool drain];
-}
-#endif // WITH_BKS
-
-#ifdef WITH_FBS
-void MachProcess::FBSCleanupAfterAttach(const void *attach_token,
-                                        DNBError &err_str) {
-  bool success;
-
-  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-
-  // Instead of rewriting CopyBundleIDForPath for NSStrings, we'll just use
-  // toll-free bridging here:
-  NSString *bundleIDNSStr = (NSString *)attach_token;
-
-  // Okay, now let's assemble all these goodies into the BackBoardServices
-  // options mega-dictionary:
-
-  // First we have the debug sub-dictionary:
-  NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
-  [debug_options setObject:[NSNumber numberWithBool:YES]
-                    forKey:FBSDebugOptionKeyCancelDebugOnNextLaunch];
-
-  // That will go in the overall dictionary:
-
-  NSMutableDictionary *options = [NSMutableDictionary dictionary];
-  [options setObject:debug_options
-              forKey:FBSOpenApplicationOptionKeyDebuggingOptions];
-
-  success =
-      FBSCallOpenApplicationFunction(bundleIDNSStr, options, err_str, NULL);
-
-  if (!success) {
-    DNBLogError("error trying to cancel debug on next launch for %s: %s",
-                [bundleIDNSStr UTF8String], err_str.AsString());
-  }
-
-  [pool drain];
-}
-#endif // WITH_FBS