Make a more convenient way to allow Darwin users to ignore certain Mach Exceptions

[jingham]

Summary

For relatively uninteresting reasons, it is not possible when running under the debugger to invoke the mechanism that converts a Mach Exception into its BSD signal equivalent. The Mach Exceptions contain more information than the signal does, so we prefer to stop at the mach exception raise for most purposes. But if your application relies on a SIGBUS, SIGSEGV, etc. handler, then your application won't run properly in the debugger, it will just get stuck on the exception.

A workaround for this was added a while back - by passing -U to debugserver, EXC_BAD_ACCESS, EXC_BAD_INSTRUCTION and EXC_ARITHMETIC are masked out. But this isn't terribly convenient, because you have to invoke debugserver specially so you have to do this every time you debug, you can't use the feature when you don't control how debugserver is launched, and you can't control which exception you want to mask out.

I made this more convenient by adding a QSetIgnoredExceptions packet to debugserver which will set the exceptions not to include, so we can direct this from lldb.

Then I added a way for Platform to provide "extra startup commands" to the remote startup sequence - there was already a way for the user to supply extra startup commands, and I could have had users set the QSetIgnoredExceptions in the "target.extra-startup-commands", but that would be pretty undiscoverable. Instead, I added a "platform.plugin.darwin.ignored-exceptions" property that users can set with just the exception mask. Then PlatformDarwin gathers the results of this setting, and conses up the appropriate packet and returns that from PlatformDarwin::ExtraStartupCommands.

I also wanted to add a validator for the property. Since I don't control the property creation (that all happens through processing the .td file) I couldn't put my validator in the OptionValueString made for the setting on construction, so I added an API to set it after the fact.

[hawkinsw]

I hope that those minor edits help at least a little!

lldb/source/Plugins/Platform/MacOSX/PlatformMacOSXProperties.td

14

15

[jasonmolenda]

This is a nice piece of work, and a good cleanup, LGTM.

[JDevlieghere]

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

80–111

What's the point of having this? Isn't PlatformDarwin an abstract class anyway?

166

PlatformDarwin is the name of the class, but I don't think we ever present it that way to the user.

176–177

Unless you expect this string to contain a null byte you could turn this into a StringRef and check ::empty() instead.

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

959–964

You can use a range-based for loop here.

967–970

nit: LLVM likes to do this but I personally don't care.

lldb/tools/debugserver/source/MacOSX/MachException.cpp

527–558

Why not make it a string and use it's equals method? All these strcmps make the whole this unnecessary verbose imho.

if (name == "BAD_ACCESS")

[jingham]

Addressed review comments.

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

80–111

As it currently stands, you can't create a plugin setting if the plugin doesn't have a CreateInstance. I wanted settings set platform.plugin.darwin.ignored-exceptions, rather than repeating the setting on all the concrete instances of PlatformDarwin, since this is a Darwin feature, so I had to add that.

176–177

This won't contain nulls, so that part's okay. Using a StringRef simplifies the check here, but in order to make up the packet I have to call ignored_exceptions_as_StringRef.str() in order to have something to pass to packet.append. This isn't performance critical, so I don't mind the copy, but since we're going to end up making a std string anyway, I used std::string rather than StringRef.

[jingham]

Address review comments

lldb/include/lldb/Interpreter/OptionValueString.h

if (value && value[0])
       m_default_value.assign(value);
     else
       m_default_value.clear();
   }
 
   bool IsCurrentValueEmpty() const { return m_current_value.empty(); }
 
   bool IsDefaultValueEmpty() const { return m_default_value.empty(); }
   
+  void SetValidator(ValidatorCallback validator, void *baton = nullptr) {
+    m_validator = validator;
+    m_validator_baton = baton;
+  }
+
 protected:
   std::string m_current_value;
   std::string m_default_value;
   Flags m_options;
   ValidatorCallback m_validator = nullptr;
   void *m_validator_baton = nullptr;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONVALUESTRING_H

lldb/include/lldb/Target/Platform.h

public:
   ///     entry value. \b nullptr if not implemented or  if the process has no
   ///     crash information entry. \b error if an error occured.
   virtual llvm::Expected<StructuredData::DictionarySP>
   FetchExtendedCrashInformation(lldb_private::Process &process) {
     return nullptr;
   }
 
   virtual CompilerType GetSiginfoType(const llvm::Triple &triple);
   
+  virtual Args GetExtraStartupCommands();
+
 protected:
   /// Create a list of ArchSpecs with the given OS and a architectures. The
   /// vendor field is left as an "unspecified unknown".
   static std::vector<ArchSpec>
   CreateArchList(llvm::ArrayRef<llvm::Triple::ArchType> archs,
                  llvm::Triple::OSType os);
 
   /// Private implementation of connecting to a process. If the stream is set

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

enum ServerPacketType {
     eServerPacketType_jLLDBTraceStop,
     eServerPacketType_jLLDBTraceGetState,
     eServerPacketType_jLLDBTraceGetBinaryData,
 
     eServerPacketType_qMemTags, // read memory tags
     eServerPacketType_QMemTags, // write memory tags
 
     eServerPacketType_qLLDBSaveCore,
+    eServerPacketType_QSetIgnoredExceptions
   };
 
   ServerPacketType GetServerPacketType() const;
 
   enum ResponseType { eUnsupported = 0, eAck, eNack, eError, eOK, eResponse };
 
   ResponseType GetResponseType() const;
 

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

 class Target;
 
 class PlatformDarwin : public PlatformPOSIX {
 public:
   using PlatformPOSIX::PlatformPOSIX;
 
   ~PlatformDarwin() override;
 
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+
+  static void DebuggerInitialize(lldb_private::Debugger &debugger);
+  
+  static void Initialize();
+
+  static void Terminate();
+
+  static llvm::StringRef GetPluginNameStatic() { return "darwin"; }
+
+  static llvm::StringRef GetDescriptionStatic();
+
   Status PutFile(const FileSpec &source, const FileSpec &destination,
                  uint32_t uid = UINT32_MAX, uint32_t gid = UINT32_MAX) override;
 
   // Platform functions
   Status ResolveSymbolFile(Target &target, const ModuleSpec &sym_spec,
                            FileSpec &sym_file) override;
 
   FileSpecList
public:
 
   bool SupportsModules() override { return true; }
 
   ConstString GetFullNameForDylib(ConstString basename) override;
 
   FileSpec LocateExecutable(const char *basename) override;
 
   Status LaunchProcess(ProcessLaunchInfo &launch_info) override;
   
+  Args GetExtraStartupCommands() override;
+
   static std::tuple<llvm::VersionTuple, llvm::StringRef>
   ParseVersionBuildDir(llvm::StringRef str);
 
   llvm::Expected<StructuredData::DictionarySP>
   FetchExtendedCrashInformation(Process &process) override;
 
   /// Return the toolchain directory the current LLDB instance is located in.
   static FileSpec GetCurrentToolchainDirectory();

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 #include <memory>
 #include <mutex>
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/OptionValueProperties.h"
+#include "lldb/Interpreter/OptionValueString.h"
+#include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Timer.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/VersionTuple.h"
 
 #if defined(__APPLE__)
 #include <TargetConditionals.h>
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 
+static Status ExceptionMaskValidator(const char *string, void *unused) {
+  Status error;
+  llvm::StringRef str_ref(string);
+  llvm::SmallVector<llvm::StringRef> candidates;
+  str_ref.split(candidates, '|');
+  for (auto candidate : candidates) {
+    if (!(candidate == "EXC_BAD_ACCESS"
+          || candidate == "EXC_BAD_INSTRUCTION"
+          || candidate == "EXC_ARITHMETIC"
+          || candidate == "EXC_RESOURCE"
+          || candidate == "EXC_GUARD")) {
+      error.SetErrorStringWithFormat("invalid exception type: '%s'", 
+          candidate.str().c_str());
+      return error;
+    }
+  }
+  return {};
+}
+
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.
 PlatformDarwin::~PlatformDarwin() = default;
 
+// Static Variables
+static uint32_t g_initialize_count = 0;
+
+void PlatformDarwin::Initialize() {
+  Platform::Initialize();
+
+  if (g_initialize_count++ == 0) {
+    PluginManager::RegisterPlugin(PlatformDarwin::GetPluginNameStatic(),
+                                  PlatformDarwin::GetDescriptionStatic(),
+                                  PlatformDarwin::CreateInstance,
+                                  PlatformDarwin::DebuggerInitialize);
+  }
+}
+
+void PlatformDarwin::Terminate() {
+  if (g_initialize_count > 0) {
+    if (--g_initialize_count == 0) {
+      PluginManager::UnregisterPlugin(PlatformDarwin::CreateInstance);
+    }
+  }
+
+  Platform::Terminate();
+}
+
+llvm::StringRef PlatformDarwin::GetDescriptionStatic() {
+  return "Darwin platform plug-in.";
+}
+
+PlatformSP PlatformDarwin::CreateInstance(bool force, const ArchSpec *arch) {
+   // We only create subclasses of the PlatformDarwin plugin.
+   return PlatformSP();
+}
+
+#define LLDB_PROPERTIES_platformdarwin
+#include "PlatformMacOSXProperties.inc"
+
+#define LLDB_PROPERTIES_platformdarwin
+enum {
+#include "PlatformMacOSXPropertiesEnum.inc"
+};
+
+class PlatformDarwinProperties : public Properties {
+public:
+  static ConstString &GetSettingName() {
+    static ConstString g_setting_name("darwin");
+    return g_setting_name;
+  }
+
+  PlatformDarwinProperties() : Properties() {
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
+    m_collection_sp->Initialize(g_platformdarwin_properties);
+  }
+
+  ~PlatformDarwinProperties() override = default;
+
+  const char *GetIgnoredExceptions() const {
+    const uint32_t idx = ePropertyIgnoredExceptions;
+    const OptionValueString *option_value =
+        m_collection_sp->GetPropertyAtIndexAsOptionValueString(
+            NULL, false, idx);
+    assert(option_value);
+    return option_value->GetCurrentValue();
+  }
+    
+  OptionValueString *GetIgnoredExceptionValue() {
+    const uint32_t idx = ePropertyIgnoredExceptions;
+    OptionValueString *option_value =
+        m_collection_sp->GetPropertyAtIndexAsOptionValueString(
+            NULL, false, idx);
+    assert(option_value);
+    return option_value;
+  }
+};
+
+static PlatformDarwinProperties &GetGlobalProperties() {
+  static PlatformDarwinProperties g_settings;
+  return g_settings;
+}
+
+void PlatformDarwin::DebuggerInitialize(
+    lldb_private::Debugger &debugger) {
+  if (!PluginManager::GetSettingForPlatformPlugin(
+          debugger, PlatformDarwinProperties::GetSettingName())) {
+    const bool is_global_setting = false;
+    PluginManager::CreateSettingForPlatformPlugin(
+        debugger, GetGlobalProperties().GetValueProperties(),
+        ConstString("Properties for the Darwin platform plug-in."),
+        is_global_setting);
+    OptionValueString *value = GetGlobalProperties().GetIgnoredExceptionValue();
+    value->SetValidator(ExceptionMaskValidator);
+  }
+}
+
+Args
+PlatformDarwin::GetExtraStartupCommands() {
+  std::string ignored_exceptions 
+      = GetGlobalProperties().GetIgnoredExceptions();
+  if (ignored_exceptions.empty())
+    return {};
+  Args ret_args;
+  std::string packet = "QSetIgnoredExceptions:";
+  packet.append(ignored_exceptions);
+  ret_args.AppendArgument(packet);
+  return ret_args;
+}
+
 lldb_private::Status
 PlatformDarwin::PutFile(const lldb_private::FileSpec &source,
                         const lldb_private::FileSpec &destination, uint32_t uid,
                         uint32_t gid) {
   // Unconditionally unlink the destination. If it is an executable,
   // simply opening it and truncating its contents would invalidate
   // its cached code signature.
   Unlink(destination);

lldb/source/Plugins/Platform/MacOSX/PlatformMacOSXProperties.td

 include "../../../../include/lldb/Core/PropertiesBase.td"
 
 let Definition = "platformdarwinkernel" in {
   def KextDirectories: Property<"kext-directories", "FileSpecList">,
     DefaultStringValue<"">,
     Desc<"Directories/KDKs to search for kexts in when starting a kernel debug session.">;
 }
+
+let Definition = "platformdarwin" in {
+  def IgnoredExceptions: Property<"ignored-exceptions", "String">,
+    DefaultStringValue<"">,
+    Desc<"List the mach exceptions to ignore, separated by '|' "
+         "(e.g. 'EXC_BAD_ACCESS|EXC_BAD_INSTRUCTION'). "
+         "lldb will instead stop on the BSD signal the exception was converted "
+         "into, if there is one.">;
+}

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

Status ProcessGDBRemote::ConnectToDebugserver(llvm::StringRef connect_url) {
   m_gdb_comm.GetEchoSupported();
   m_gdb_comm.GetThreadSuffixSupported();
   m_gdb_comm.GetListThreadsInStopReplySupported();
   m_gdb_comm.GetHostInfo();
   m_gdb_comm.GetVContSupported('c');
   m_gdb_comm.GetVAttachOrWaitSupported();
   m_gdb_comm.EnableErrorStringInPacket();
 
-  size_t num_cmds = GetExtraStartupCommands().GetArgumentCount();
-  for (size_t idx = 0; idx < num_cmds; idx++) {
+  // First dispatch any commands from the platform:
+  auto handle_cmds = [&] (const Args &args) ->  void {
+    for (const Args::ArgEntry &entry : args) {
       StringExtractorGDBRemote response;
       m_gdb_comm.SendPacketAndWaitForResponse(
-        GetExtraStartupCommands().GetArgumentAtIndex(idx), response);
+          entry.c_str(), response);
     }
+  };
+  
+  PlatformSP platform_sp = GetTarget().GetPlatform();
+  if (platform_sp) {
+    handle_cmds(platform_sp->GetExtraStartupCommands());
+  }
+  
+  // Then dispatch any process commands:
+  handle_cmds(GetExtraStartupCommands());
+
   return error;
 }
 
 void ProcessGDBRemote::DidLaunchOrAttach(ArchSpec &process_arch) {
   Log *log = GetLog(GDBRLog::Process);
   BuildDynamicRegisterInfo(false);
 
   // See if the GDB server supports qHostInfo or qProcessInfo packets. Prefer

lldb/source/Target/Platform.cpp

size_t Platform::GetSoftwareBreakpointTrapOpcode(Target &target,
 
   return 0;
 }
 
 CompilerType Platform::GetSiginfoType(const llvm::Triple& triple) {
   return CompilerType();
 }
 
+Args Platform::GetExtraStartupCommands() {
+  return {};
+}
+
 PlatformSP PlatformList::GetOrCreate(llvm::StringRef name) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   for (const PlatformSP &platform_sp : m_platforms) {
     if (platform_sp->GetName() == name)
       return platform_sp;
   }
   return Create(name);
 }

lldb/source/Utility/StringExtractorGDBRemote.cpp

case 'S':
       if (PACKET_STARTS_WITH("QSetSTDOUT:"))
         return eServerPacketType_QSetSTDOUT;
       if (PACKET_STARTS_WITH("QSetSTDERR:"))
         return eServerPacketType_QSetSTDERR;
       if (PACKET_STARTS_WITH("QSetWorkingDir:"))
         return eServerPacketType_QSetWorkingDir;
       if (PACKET_STARTS_WITH("QSetLogging:"))
         return eServerPacketType_QSetLogging;
+      if (PACKET_STARTS_WITH("QSetIgnoredExceptions"))
+        return eServerPacketType_QSetIgnoredExceptions;
       if (PACKET_STARTS_WITH("QSetMaxPacketSize:"))
         return eServerPacketType_QSetMaxPacketSize;
       if (PACKET_STARTS_WITH("QSetMaxPayloadSize:"))
         return eServerPacketType_QSetMaxPayloadSize;
       if (PACKET_STARTS_WITH("QSetEnableAsyncProfiling;"))
         return eServerPacketType_QSetEnableAsyncProfiling;
       if (PACKET_STARTS_WITH("QSyncThreadState:"))
         return eServerPacketType_QSyncThreadState;

lldb/test/API/macosx/ignore_exceptions/Makefile

+C_SOURCES := main.c
+CFLAGS_EXTRAS := -std=c99
+
+include Makefile.rules

lldb/test/API/macosx/ignore_exceptions/TestIgnoredExceptions.py

+"""
+Test that by turning off EXC_BAD_ACCESS catching, we can
+debug into and out of a signal handler.
+"""
+
+import lldb
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+class TestDarwinSignalHandlers(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    @skipUnlessDarwin
+    def test_ignored_thread(self):
+        """It isn't possible to convert an EXC_BAD_ACCESS to a signal when
+        running under the debugger, which makes debugging SIGBUS handlers
+        and so forth difficult.  This test sends QIgnoreExceptions and that
+        should get us into the signal handler and out again. """
+        self.build()
+        self.main_source_file = lldb.SBFileSpec("main.c")
+        self.suspended_thread_test()
+
+    def suspended_thread_test(self):
+        # Make sure that we don't accept bad values:
+        self.match("settings set platform.plugin.darwin.ignored-exceptions EXC_BAD_AXESS", "EXC_BAD_AXESS", error=True)
+        # Now set ourselves to ignore some exceptions.  The test depends on ignoring EXC_BAD_ACCESS, but I passed a couple
+        # to make sure they parse:
+        self.runCmd("settings set platform.plugin.darwin.ignored-exceptions EXC_BAD_ACCESS|EXC_ARITHMETIC")
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                   "Stop here to get things going", self.main_source_file)
+
+        sig_bkpt = target.BreakpointCreateBySourceRegex("stop here in the signal handler",
+                                                        self.main_source_file)
+        self.assertEqual(sig_bkpt.GetNumLocations(), 1, "Found sig handler breakpoint")
+        return_bkpt = target.BreakpointCreateBySourceRegex("Break here to make sure we got past the signal handler",
+                                                        self.main_source_file)
+        self.assertEqual(return_bkpt.GetNumLocations(), 1, "Found return breakpoint")
+        # Now continue, and we should stop with a stop reason of SIGBUS:
+        process.Continue()
+        self.assertEqual(process.state, lldb.eStateStopped, "Stopped after continue to SIGBUS")
+        self.assertEqual(thread.stop_reason, lldb.eStopReasonSignal)
+        self.assertEqual(thread.GetStopReasonDataAtIndex(0), 10, "Got a SIGBUS")
+
+        # Now when we continue, we'll find our way into the signal handler:
+        threads = lldbutil.continue_to_breakpoint(process, sig_bkpt)
+        self.assertEqual(len(threads), 1, "Stopped at sig breakpoint")
+
+        threads = lldbutil.continue_to_breakpoint(process, return_bkpt)
+        self.assertEqual(len(threads), 1, "Stopped at return breakpoint")
+
+        # Make sure we really changed the value:
+        
+        process.Continue()
+        self.assertEqual(process.state, lldb.eStateExited, "Process exited")
+        self.assertEqual(process.exit_state, 20, "Got the right exit status")
+                         

lldb/test/API/macosx/ignore_exceptions/main.c

+#include <signal.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <stdio.h>
+
+int g_ints[] = {10, 20, 30, 40, 50, 60};
+
+void
+saction_handler(int signo, siginfo_t info, void *baton) {
+  printf("Got into handler.\n");
+  mprotect(g_ints, sizeof(g_ints), PROT_READ|PROT_WRITE); // stop here in the signal handler
+  g_ints[0] = 20;
+}
+int
+main()
+{
+  mprotect(g_ints, 10*sizeof(int) , PROT_NONE);
+  struct sigaction my_action;
+  sigemptyset(&my_action.sa_mask);
+  my_action.sa_handler = (void (*)(int)) saction_handler;
+  my_action.sa_flags = SA_SIGINFO;
+
+  sigaction(SIGBUS, &my_action, NULL); // Stop here to get things going.
+  int local_value = g_ints[1];
+  return local_value; // Break here to make sure we got past the signal handler
+}

lldb/tools/debugserver/source/DNB.h

nub_process_t DNBProcessLaunch(
     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, int disable_aslr, const char *event_data, char *err_str,
     size_t err_len);
 
 nub_process_t DNBProcessGetPIDByName(const char *name);
 nub_process_t DNBProcessAttach(nub_process_t pid, struct timespec *timeout,
-                               bool unmask_signals, char *err_str,
+                               const RNBContext::IgnoredExceptions 
+                                   &ignored_exceptions, 
+                               char *err_str,
                                size_t err_len);
 nub_process_t DNBProcessAttachByName(const char *name, struct timespec *timeout,
-                                     bool unmask_signals, char *err_str,
+                                     const RNBContext::IgnoredExceptions 
+                                         &ignored_exceptions, 
+                                     char *err_str,
                                      size_t err_len);
 nub_process_t DNBProcessAttachWait(RNBContext *ctx, const char *wait_name,
                                    bool ignore_existing,
                                    struct timespec *timeout,
                                    useconds_t interval, char *err_str,
                                    size_t err_len,
                                    DNBShouldCancelCallback should_cancel = NULL,
                                    void *callback_data = NULL);

lldb/tools/debugserver/source/DNB.cpp

nub_process_t DNBProcessLaunch(
   }
 
   MachProcessSP processSP(new MachProcess);
   if (processSP.get()) {
     DNBError launch_err;
     pid_t pid = processSP->LaunchForDebug(
         path, argv, envp, working_directory, stdin_path, stdout_path,
         stderr_path, no_stdio, ctx->LaunchFlavor(), disable_aslr, event_data,
-        ctx->GetUnmaskSignals(), launch_err);
+        ctx->GetIgnoredExceptions(), launch_err);
     if (err_str) {
       *err_str = '\0';
       if (launch_err.Fail()) {
         const char *launch_err_str = launch_err.AsString();
         if (launch_err_str) {
           strlcpy(err_str, launch_err_str, err_len - 1);
           err_str[err_len - 1] =
               '\0'; // Make sure the error string is terminated
size_t num_matching_proc_infos =
       GetAllInfosMatchingName(name, matching_proc_infos);
   if (num_matching_proc_infos == 1) {
     return matching_proc_infos[0].kp_proc.p_pid;
   }
   return INVALID_NUB_PROCESS;
 }
 
 nub_process_t DNBProcessAttachByName(const char *name, struct timespec *timeout,
-                                     bool unmask_signals, char *err_str,
+                                     const RNBContext::IgnoredExceptions 
+                                             &ignored_exceptions, char *err_str,
                                      size_t err_len) {
   if (err_str && err_len > 0)
     err_str[0] = '\0';
   std::vector<struct kinfo_proc> matching_proc_infos;
   size_t num_matching_proc_infos =
       GetAllInfosMatchingName(name, matching_proc_infos);
   if (num_matching_proc_infos == 0) {
     DNBLogError("error: no processes match '%s'\n", name);
     return INVALID_NUB_PROCESS;
   }
   if (num_matching_proc_infos > 1) {
     DNBLogError("error: %llu processes match '%s':\n",
                 (uint64_t)num_matching_proc_infos, name);
     size_t i;
     for (i = 0; i < num_matching_proc_infos; ++i)
       DNBLogError("%6u - %s\n", matching_proc_infos[i].kp_proc.p_pid,
                   matching_proc_infos[i].kp_proc.p_comm);
     return INVALID_NUB_PROCESS;
   }
 
   return DNBProcessAttach(matching_proc_infos[0].kp_proc.p_pid, timeout,
-                          unmask_signals, err_str, err_len);
+                          ignored_exceptions, err_str, err_len);
 }
 
 nub_process_t DNBProcessAttach(nub_process_t attach_pid,
-                               struct timespec *timeout, bool unmask_signals,
+                               struct timespec *timeout, 
+                               const RNBContext::IgnoredExceptions 
+                                       &ignored_exceptions,
                                char *err_str, size_t err_len) {
   if (err_str && err_len > 0)
     err_str[0] = '\0';
 
   if (getenv("LLDB_DEBUGSERVER_PATH") == NULL) {
     int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID,
                  static_cast<int>(attach_pid)};
     struct kinfo_proc processInfo;
nub_process_t DNBProcessAttach(nub_process_t attach_pid,
   }
 
   pid_t pid = INVALID_NUB_PROCESS;
   MachProcessSP processSP(new MachProcess);
   if (processSP.get()) {
     DNBLogThreadedIf(LOG_PROCESS, "(DebugNub) attaching to pid %d...",
                      attach_pid);
     pid =
-        processSP->AttachForDebug(attach_pid, unmask_signals, err_str, err_len);
+        processSP->AttachForDebug(attach_pid, ignored_exceptions, err_str, 
+                                  err_len);
 
     if (pid != INVALID_NUB_PROCESS) {
       bool res = AddProcessToMap(pid, processSP);
       UNUSED_IF_ASSERT_DISABLED(res);
       assert(res && "Couldn't add process to map!");
       spawn_waitpid_thread(pid);
     }
   }
if (waitfor_pid == INVALID_NUB_PROCESS) {
       ::usleep(waitfor_interval); // Sleep for WAITFOR_INTERVAL, then poll again
     }
   }
 
   if (waitfor_pid != INVALID_NUB_PROCESS) {
     DNBLogThreadedIf(LOG_PROCESS, "Attaching to %s with pid %i...\n",
                      waitfor_process_name, waitfor_pid);
     waitfor_pid = DNBProcessAttach(waitfor_pid, timeout_abstime,
-                                   ctx->GetUnmaskSignals(), err_str, err_len);
+                                   ctx->GetIgnoredExceptions(), err_str, 
+                                   err_len);
   }
 
   bool success = waitfor_pid != INVALID_NUB_PROCESS;
   MachProcess::CleanupAfterAttach(attach_token, launch_flavor, success,
                                   prepare_error);
 
   return waitfor_pid;
 }

lldb/tools/debugserver/source/MacOSX/MachException.h

std::vector<mach_exception_data_type_t> exc_data_value; // Value to compare
                                                             // to exception data
                                                             // after masking, or
                                                             // empty to ignore
                                                             // exc_data value
                                                             // for exception
     uint8_t flags; // Action flags describing what to do with the exception
   };
   static const char *Name(exception_type_t exc_type);
+  static exception_mask_t ExceptionMask(const char *name);
 };
 
 #endif

lldb/tools/debugserver/source/MacOSX/MachException.cpp

#ifdef EXC_CORPSE_VARIANT_BIT
   case EXC_CORPSE_VARIANT_BIT:
     return "EXC_CORPSE_VARIANT_BIT";
 #endif
   default:
     break;
   }
   return NULL;
 }
+
+// Returns the exception mask for a given exception name.  
+// 0 is not a legit mask, so we return that in the case of an error.
+exception_mask_t MachException::ExceptionMask(const char *name) {
+  static const char *exception_prefix = "EXC_";
+  static const int prefix_len = strlen(exception_prefix);
+
+  // All mach exceptions start with this prefix:
+  if (strstr(name, exception_prefix) != name)
+    return 0;
+
+  name += prefix_len;
+  std::string name_str = name;
+  if (name_str == "BAD_ACCESS")
+    return EXC_MASK_BAD_ACCESS;
+  if (name_str == "BAD_INSTRUCTION")
+    return EXC_MASK_BAD_INSTRUCTION;
+  if (name_str == "ARITHMETIC")
+    return EXC_MASK_ARITHMETIC;
+  if (name_str == "EMULATION")
+    return EXC_MASK_EMULATION;
+  if (name_str == "SOFTWARE")
+    return EXC_MASK_SOFTWARE;
+  if (name_str == "BREAKPOINT")
+    return EXC_MASK_BREAKPOINT;
+  if (name_str == "SYSCALL")
+    return EXC_MASK_SYSCALL;
+  if (name_str == "MACH_SYSCALL")
+    return EXC_MASK_MACH_SYSCALL;
+  if (name_str == "RPC_ALERT")
+    return EXC_MASK_RPC_ALERT;
+#ifdef EXC_CRASH
+  if (name_str == "CRASH")
+    return EXC_MASK_CRASH;
+#endif
+  if (name_str == "RESOURCE")
+    return EXC_MASK_RESOURCE;
+#ifdef EXC_GUARD
+  if (name_str == "GUARD")
+    return EXC_MASK_GUARD;
+#endif
+#ifdef EXC_CORPSE_NOTIFY
+  if (name_str == "CORPSE_NOTIFY")
+    return EXC_MASK_CORPSE_NOTIFY;
+#endif
+  return 0;
+}

lldb/tools/debugserver/source/MacOSX/MachProcess.h

 #include "JSONGenerator.h"
 #include "MachException.h"
 #include "MachTask.h"
 #include "MachThreadList.h"
 #include "MachVMMemory.h"
 #include "PThreadCondition.h"
 #include "PThreadEvent.h"
 #include "PThreadMutex.h"
+#include "RNBContext.h"
 #include "ThreadInfo.h"
 
 class DNBThreadResumeActions;
 
 class MachProcess {
 public:
   // Constructors and Destructors
   MachProcess();
struct binary_image_information {
     uint64_t mod_date; // may not be available - 0 if so
     struct mach_o_information macho_info;
 
     binary_image_information()
         : filename(), load_address(INVALID_NUB_ADDRESS), mod_date(0) {}
   };
 
   // Child process control
-  pid_t AttachForDebug(pid_t pid, bool unmask_signals, char *err_str,
+  pid_t AttachForDebug(pid_t pid,
+                       const RNBContext::IgnoredExceptions &ignored_exceptions,
+                       char *err_str,
                        size_t err_len);
   pid_t LaunchForDebug(const char *path, 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, nub_launch_flavor_t launch_flavor,
                        int disable_aslr, const char *event_data,
-                       bool unmask_signals, DNBError &err);
+                       const RNBContext::IgnoredExceptions &ignored_exceptions,
+                       DNBError &err);
 
   static uint32_t GetCPUTypeForLocalProcess(pid_t pid);
   static pid_t ForkChildForPTraceDebugging(const char *path, char const *argv[],
                                            char const *envp[],
                                            MachProcess *process, DNBError &err);
   static pid_t PosixSpawnChildForPTraceDebugging(
       const char *path, cpu_type_t cpu_type, cpu_subtype_t cpu_subtype,
       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);
   nub_addr_t GetDYLDAllImageInfosAddress();
   static const void *PrepareForAttach(const char *path,
                                       nub_launch_flavor_t launch_flavor,
                                       bool waitfor, DNBError &err_str);
   static void CleanupAfterAttach(const void *attach_token,
                                  nub_launch_flavor_t launch_flavor,
                                  bool success, DNBError &err_str);
   static nub_process_t CheckForProcess(const void *attach_token,
                                        nub_launch_flavor_t launch_flavor);
 #if defined(WITH_BKS) || defined(WITH_FBS)
   pid_t BoardServiceLaunchForDebug(const char *app_bundle_path,
                                    char const *argv[], char const *envp[],
                                    bool no_stdio, bool disable_aslr,
-                                   const char *event_data, bool unmask_signals,
+                                   const char *event_data,
+                                   const RNBContext::IgnoredExceptions &ignored_exceptions,
                                    DNBError &launch_err);
   pid_t BoardServiceForkChildForPTraceDebugging(
       const char *path, char const *argv[], char const *envp[], bool no_stdio,
       bool disable_aslr, const char *event_data, DNBError &launch_err);
   bool BoardServiceSendEvent(const char *event, DNBError &error);
 #endif
   static bool GetOSVersionNumbers(uint64_t *major, uint64_t *minor,
                                   uint64_t *patch);

lldb/tools/debugserver/source/MacOSX/MachProcess.mm

uint32_t bits_set =
         proc->m_profile_events.WaitForSetEvents(eMachProcessProfileCancel, &ts);
     // If we got bits back, we were told to exit.  Do so.
     if (bits_set & eMachProcessProfileCancel)
       break;
   }
   return NULL;
 }
 
-pid_t MachProcess::AttachForDebug(pid_t pid, bool unmask_signals, char *err_str,
-                                  size_t err_len) {
+pid_t MachProcess::AttachForDebug(
+    pid_t pid, 
+    const RNBContext::IgnoredExceptions &ignored_exceptions, 
+    char *err_str,
   // 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");
       DNBLogError ("MachProcess::AttachForDebug pid %d does not exist", pid);
       return INVALID_NUB_PROCESS;
     }
 
     SetState(eStateAttaching);
     m_pid = pid;
-    if (!m_task.StartExceptionThread(unmask_signals, err)) {
+    if (!m_task.StartExceptionThread(ignored_exceptions, 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);
       DNBLogError(
           "[LaunchAttach] END (%d) MachProcess::AttachForDebug failed to start "
           "exception thread attaching to pid %i: %s",
           getpid(), pid, err_str);

 }
 
 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, bool unmask_signals, DNBError &launch_err) {
+    const char *event_data, 
+    const RNBContext::IgnoredExceptions &ignored_exceptions, 
+    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, static_cast<const void *>(argv),
                    static_cast<const void *>(envp), launch_flavor,
case eLaunchFlavorForkExec:
     break;
 #ifdef WITH_FBS
   case eLaunchFlavorFBS: {
     std::string app_bundle_path = GetAppBundle(path);
     if (!app_bundle_path.empty()) {
       m_flags |= (eMachProcessFlagsUsingFBS | eMachProcessFlagsBoardCalculated);
       if (BoardServiceLaunchForDebug(app_bundle_path.c_str(), argv, envp,
                                      no_stdio, disable_aslr, event_data,
-                                     unmask_signals, launch_err) != 0)
+                                     ignored_exceptions, launch_err) != 0)
         return m_pid; // A successful SBLaunchForDebug() returns and assigns a
                       // non-zero m_pid.
     }
     DNBLog("Failed to launch '%s' with FBS", app_bundle_path);
   } break;
 #endif
 #ifdef WITH_BKS
   case eLaunchFlavorBKS: {
     std::string app_bundle_path = GetAppBundle(path);
     if (!app_bundle_path.empty()) {
       m_flags |= (eMachProcessFlagsUsingBKS | eMachProcessFlagsBoardCalculated);
       if (BoardServiceLaunchForDebug(app_bundle_path.c_str(), argv, envp,
                                      no_stdio, disable_aslr, event_data,
-                                     unmask_signals, launch_err) != 0)
+                                     ignored_exceptions, launch_err) != 0)
         return m_pid; // A successful SBLaunchForDebug() returns and assigns a
                       // non-zero m_pid.
     }
     DNBLog("Failed to launch '%s' with BKS", app_bundle_path);
   } break;
 #endif
 #ifdef WITH_SPRINGBOARD
   case eLaunchFlavorSpringBoard: {
     std::string app_bundle_path = GetAppBundle(path);
     if (!app_bundle_path.empty()) {
       if (SBLaunchForDebug(app_bundle_path.c_str(), argv, envp, no_stdio,
-                           disable_aslr, unmask_signals, launch_err) != 0)
+                           disable_aslr, ignored_exceptions, launch_err) != 0)
         return m_pid; // A successful SBLaunchForDebug() returns and assigns a
                       // non-zero m_pid.
     }
     DNBLog("Failed to launch '%s' with SpringBoard", app_bundle_path);
   } break;
 
 #endif
 
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(unmask_signals, launch_err);
+    m_task.StartExceptionThread(ignored_exceptions, 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;
static CFStringRef CopyBundleIDForPath(const char *app_bundle_path,
   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, bool unmask_signals,
+                                    bool disable_aslr, 
+                                    const RNBContext::IgnoredExceptions 
+                                        &ignored_exceptions,
                                     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_path = path;
     size_t i;
     char const *arg;
     for (i = 0; (arg = argv[i]) != NULL; i++)
       m_args.push_back(arg);
-    m_task.StartExceptionThread(unmask_signals, launch_err);
+    m_task.StartExceptionThread(ignored_exceptions, 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;
pid_t MachProcess::SBForkChildForPTraceDebugging(
   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, bool unmask_signals,
+    bool disable_aslr, const char *event_data, 
+    const RNBContext::IgnoredExceptions &ignored_exceptions,
     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(unmask_signals, launch_err);
+    m_task.StartExceptionThread(ignored_exceptions, launch_err);
 
     if (launch_err.Fail()) {
       if (launch_err.AsString() == NULL)
         launch_err.SetErrorString("unable to start the exception thread");
       DNBLog("[LaunchAttach] END (%d) Could not get inferior's Mach exception "
              "port, "
              "sending ptrace "
              "PT_KILL to pid %i and exiting.",

lldb/tools/debugserver/source/MacOSX/MachTask.h

 #ifndef LLDB_TOOLS_DEBUGSERVER_SOURCE_MACOSX_MACHTASK_H
 #define LLDB_TOOLS_DEBUGSERVER_SOURCE_MACOSX_MACHTASK_H
 
 #include <mach/mach.h>
 #include <sys/socket.h>
 #include <map>
 #include <string>
 #include "DNBDefs.h"
+#include "RNBContext.h"
 #include "MachException.h"
 #include "MachVMMemory.h"
 #include "PThreadMutex.h"
 
 class MachProcess;
 
 typedef uint64_t MachMallocEventId;
 
public:
   nub_bool_t DeallocateMemory(nub_addr_t addr);
 
   mach_port_t ExceptionPort() const;
   bool ExceptionPortIsValid() const;
   kern_return_t SaveExceptionPortInfo();
   kern_return_t RestoreExceptionPortInfo();
   kern_return_t ShutDownExcecptionThread();
 
-  bool StartExceptionThread(bool unmask_signals, DNBError &err);
+  bool StartExceptionThread(
+      const RNBContext::IgnoredExceptions &ignored_exceptions, DNBError &err);
   nub_addr_t GetDYLDAllImageInfosAddress(DNBError &err);
   kern_return_t BasicInfo(struct task_basic_info *info);
   static kern_return_t BasicInfo(task_t task, struct task_basic_info *info);
   bool IsValid() const;
   static bool IsValid(task_t task);
   static void *ExceptionThread(void *arg);
   void TaskPortChanged(task_t task);
   task_t TaskPort() const { return m_task; }

lldb/tools/debugserver/source/MacOSX/MachTask.mm

 bool MachTask::IsValid(task_t task) {
   if (task != TASK_NULL) {
     struct task_basic_info task_info;
     return BasicInfo(task, &task_info) == KERN_SUCCESS;
   }
   return false;
 }
 
-bool MachTask::StartExceptionThread(bool unmask_signals, DNBError &err) {
+bool MachTask::StartExceptionThread(
+        const RNBContext::IgnoredExceptions &ignored_exceptions, 
+        DNBError &err) {
   DNBLogThreadedIf(LOG_EXCEPTIONS, "MachTask::%s ( )", __FUNCTION__);
 
   task_t task = TaskPortForProcessID(err);
   if (MachTask::IsValid(task)) {
     // Got the mach port for the current process
     mach_port_t task_self = mach_task_self();
 
     // Allocate an exception port that we will use to track our child process
if (MachTask::IsValid(task)) {
     SaveExceptionPortInfo();
 
     // We weren't able to save the info for our exception ports, we must stop...
     if (m_exc_port_info.mask == 0) {
       err.SetErrorString("failed to get exception port info");
       return false;
     }
 
-    if (unmask_signals) {
-      m_exc_port_info.mask = m_exc_port_info.mask &
-                             ~(EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION |
-                               EXC_MASK_ARITHMETIC);
+    if (!ignored_exceptions.empty()) {
+      for (exception_mask_t mask : ignored_exceptions)
+        m_exc_port_info.mask = m_exc_port_info.mask & ~mask;
     }
 
     // Set the ability to get all exceptions on this port
     err = ::task_set_exception_ports(
         task, m_exc_port_info.mask, m_exception_port,
         EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES, THREAD_STATE_NONE);
     if (DNBLogCheckLogBit(LOG_EXCEPTIONS) || err.Fail()) {
       err.LogThreaded("::task_set_exception_ports ( task = 0x%4.4x, "

lldb/tools/debugserver/source/RNBContext.h

 #include "DNBError.h"
 #include "PThreadEvent.h"
 #include "RNBDefs.h"
 #include <string>
 #include <vector>
 
 class RNBContext {
 public:
+  using IgnoredExceptions = std::vector<exception_mask_t>;
   enum {
     event_proc_state_changed = 0x001,
     event_proc_thread_running = 0x002, // Sticky
     event_proc_thread_exiting = 0x004,
     event_proc_stdio_available = 0x008,
     event_proc_profile_data = 0x010,
     event_read_packet_available = 0x020,
     event_read_thread_running = 0x040, // Sticky
public:
   }
 
   void PushProcessEvent(const char *p) { m_process_event.assign(p); }
   const char *GetProcessEvent() { return m_process_event.c_str(); }
 
   void SetDetachOnError(bool detach) { m_detach_on_error = detach; }
   bool GetDetachOnError() { return m_detach_on_error; }
 
-  void SetUnmaskSignals(bool unmask_signals) {
-    m_unmask_signals = unmask_signals;
+  bool AddIgnoredException(const char *exception_name);
+  
+  void AddDefaultIgnoredExceptions();
+
+  const IgnoredExceptions &GetIgnoredExceptions() {
+    return m_ignored_exceptions;
   }
-  bool GetUnmaskSignals() { return m_unmask_signals; }
 
 protected:
   // Classes that inherit from RNBContext can see and modify these
   nub_process_t m_pid = INVALID_NUB_PROCESS;
   std::string m_stdin;
   std::string m_stdout;
   std::string m_stderr;
   std::string m_working_dir;
   nub_size_t m_pid_stop_count = 0;
   /// Threaded events that we can wait for.
   PThreadEvent m_events{0, all_event_bits};
   pthread_t m_pid_pthread;
   /// How to launch our inferior process.
   nub_launch_flavor_t m_launch_flavor = eLaunchFlavorDefault;
   /// This holds the status from the last launch attempt.
   DNBError m_launch_status;
   std::vector<std::string> m_arg_vec;
   /// This will be unparsed entries FOO=value
   std::vector<std::string> m_env_vec;
   std::string m_working_directory;
   std::string m_process_event;
   bool m_detach_on_error = false;
-  bool m_unmask_signals = false;
+  IgnoredExceptions m_ignored_exceptions;
 
   void StartProcessStatusThread();
   void StopProcessStatusThread();
   static void *ThreadFunctionProcessStatus(void *arg);
 
 private:
   RNBContext(const RNBContext &rhs) = delete;
   RNBContext &operator=(const RNBContext &rhs) = delete;
 };
 
 #endif // LLDB_TOOLS_DEBUGSERVER_SOURCE_RNBCONTEXT_H

lldb/tools/debugserver/source/RNBContext.cpp

 #include <pthread.h>
 #include <sched.h>
 #endif
 
 #include "CFString.h"
 #include "DNB.h"
 #include "DNBLog.h"
 #include "RNBRemote.h"
+#include "MacOSX/MachException.h"
 
 // Destructor
 RNBContext::~RNBContext() { SetProcessID(INVALID_NUB_PROCESS); }
 
 // RNBContext constructor
 
 const char *RNBContext::EnvironmentAtIndex(size_t index) {
   if (index < m_env_vec.size())
const char *RNBContext::LaunchStatusAsString(std::string &s) {
   }
   return s.c_str();
 }
 
 bool RNBContext::ProcessStateRunning() const {
   nub_state_t pid_state = DNBProcessGetState(m_pid);
   return pid_state == eStateRunning || pid_state == eStateStepping;
 }
+
+bool RNBContext::AddIgnoredException(const char *exception_name) {
+  exception_mask_t exc_mask = MachException::ExceptionMask(exception_name);
+  if (exc_mask == 0)
+    return false;
+  m_ignored_exceptions.push_back(exc_mask);
+  return true;
+}
+
+void RNBContext::AddDefaultIgnoredExceptions() {
+  m_ignored_exceptions.push_back(EXC_MASK_BAD_ACCESS);
+  m_ignored_exceptions.push_back(EXC_MASK_BAD_INSTRUCTION);
+  m_ignored_exceptions.push_back(EXC_MASK_ARITHMETIC);
+}

lldb/tools/debugserver/source/RNBRemote.h

enum PacketEnum {
     json_query_thread_extended_info,               // 'jThreadExtendedInfo'
     json_query_get_loaded_dynamic_libraries_infos, // 'jGetLoadedDynamicLibrariesInfos'
     json_query_threads_info,                       // 'jThreadsInfo'
     json_query_get_shared_cache_info,              // 'jGetSharedCacheInfo'
     pass_signals_to_inferior,                      // 'QPassSignals'
     start_noack_mode,                              // 'QStartNoAckMode'
     prefix_reg_packets_with_tid,        // 'QPrefixRegisterPacketsWithThreadID
     set_logging_mode,                   // 'QSetLogging:'
+    set_ignored_exceptions,             // 'QSetIgnoredExceptions'           
     set_max_packet_size,                // 'QSetMaxPacketSize:'
     set_max_payload_size,               // 'QSetMaxPayloadSize:'
     set_environment_variable,           // 'QEnvironment:'
     set_environment_variable_hex,       // 'QEnvironmentHexEncoded:'
     set_launch_arch,                    // 'QLaunchArch:'
     set_disable_aslr,                   // 'QSetDisableASLR:'
     set_stdin,                          // 'QSetSTDIN:'
     set_stdout,                         // 'QSetSTDOUT:'
public:
   rnb_err_t HandlePacket_qThreadStopInfo(const char *p);
   rnb_err_t HandlePacket_qHostInfo(const char *p);
   rnb_err_t HandlePacket_qGDBServerVersion(const char *p);
   rnb_err_t HandlePacket_qProcessInfo(const char *p);
   rnb_err_t HandlePacket_qSymbol(const char *p);
   rnb_err_t HandlePacket_QStartNoAckMode(const char *p);
   rnb_err_t HandlePacket_QThreadSuffixSupported(const char *p);
   rnb_err_t HandlePacket_QSetLogging(const char *p);
+  rnb_err_t HandlePacket_QSetIgnoredExceptions(const char *p);
   rnb_err_t HandlePacket_QSetDisableASLR(const char *p);
   rnb_err_t HandlePacket_QSetSTDIO(const char *p);
   rnb_err_t HandlePacket_QSetWorkingDir(const char *p);
   rnb_err_t HandlePacket_QSetMaxPayloadSize(const char *p);
   rnb_err_t HandlePacket_QSetMaxPacketSize(const char *p);
   rnb_err_t HandlePacket_QEnvironment(const char *p);
   rnb_err_t HandlePacket_QEnvironmentHexEncoded(const char *p);
   rnb_err_t HandlePacket_QLaunchArch(const char *p);

lldb/tools/debugserver/source/RNBRemote.cpp

t.push_back(Packet(start_noack_mode, &RNBRemote::HandlePacket_QStartNoAckMode,
                      " stop acking remote protocol packets"));
   t.push_back(Packet(prefix_reg_packets_with_tid,
                      &RNBRemote::HandlePacket_QThreadSuffixSupported, NULL,
                      "QThreadSuffixSupported",
                      "Check if thread specific packets (register packets 'g', "
                      "'G', 'p', and 'P') support having the thread ID appended "
                      "to the end of the command"));
   t.push_back(Packet(set_logging_mode, &RNBRemote::HandlePacket_QSetLogging,
-                     NULL, "QSetLogging:", "Check if register packets ('g', "
-                                           "'G', 'p', and 'P' support having "
-                                           "the thread ID prefix"));
+                     NULL, "QSetLogging:", "Turn on log channels in debugserver"));
+  t.push_back(Packet(set_ignored_exceptions, &RNBRemote::HandlePacket_QSetIgnoredExceptions,
+                     NULL, "QSetIgnoredExceptions:", "Set the exception types "
+                                           "debugserver won't wait for, allowing "
+                                           "them to be turned into the equivalent "
+                                           "BSD signals by the normal means."));
   t.push_back(Packet(
       set_max_packet_size, &RNBRemote::HandlePacket_QSetMaxPacketSize, NULL,
       "QSetMaxPacketSize:",
       "Tell " DEBUGSERVER_PROGRAM_NAME " the max sized packet gdb can handle"));
   t.push_back(Packet(
       set_max_payload_size, &RNBRemote::HandlePacket_QSetMaxPayloadSize, NULL,
       "QSetMaxPayloadSize:", "Tell " DEBUGSERVER_PROGRAM_NAME
                              " the max sized payload gdb can handle"));
else {
       else
         p = strchr(p, '\0');
     }
   }
 
   return rnb_success;
 }
 
+rnb_err_t RNBRemote::HandlePacket_QSetIgnoredExceptions(const char *p) {
+  // We can't set the ignored exceptions if we have a running process:
+  if (m_ctx.HasValidProcessID())
+    return SendPacket("E35");
+
+  p += sizeof("QSetIgnoredExceptions:") - 1;
+  bool success = true;
+  while(1) {
+    const char *bar  = strchr(p, '|');
+    if (bar == nullptr) {
+      success = m_ctx.AddIgnoredException(p);
+      break;
+    } else {
+      std::string exc_str(p, bar - p);
+      if (exc_str.empty()) {
+        success = false;
+        break;
+      }
+
+      success = m_ctx.AddIgnoredException(exc_str.c_str());
+      if (!success)
+        break;
+      p = bar + 1;
+    }
+  }
+  if (success)
+    return SendPacket("OK");
+  else
+    return SendPacket("E36");
+}
+
 rnb_err_t RNBRemote::HandlePacket_QThreadSuffixSupported(const char *p) {
   m_thread_suffix_supported = true;
   return SendPacket("OK");
 }
 
 rnb_err_t RNBRemote::HandlePacket_QStartNoAckMode(const char *p) {
   // Send the OK packet first so the correct checksum is appended...
   rnb_err_t result = SendPacket("OK");
if (strstr(p, "vAttachWait;") == p) {
         return HandlePacket_ILLFORMED(
             __FILE__, __LINE__, p, "non-hex char in arg on 'vAttachName' pkt");
       }
 
       DNBLog("[LaunchAttach] START %d vAttachName attach to process name "
              "'%s'",
              getpid(), attach_name.c_str());
       attach_pid = DNBProcessAttachByName(attach_name.c_str(), NULL,
-                                          Context().GetUnmaskSignals(), err_str,
-                                          sizeof(err_str));
+                                          Context().GetIgnoredExceptions(), 
+                                          err_str, sizeof(err_str));
 
     } else if (strstr(p, "vAttach;") == p) {
       p += strlen("vAttach;");
       char *end = NULL;
       pid_attaching_to = static_cast<int>(
           strtoul(p, &end, 16)); // PID will be in hex, so use base 16 to decode
       if (p != end && *end == '\0') {
         // Wait at most 30 second for attach
         struct timespec attach_timeout_abstime;
         DNBTimer::OffsetTimeOfDay(&attach_timeout_abstime, 30, 0);
         DNBLog("[LaunchAttach] START %d vAttach to pid %d", getpid(),
                pid_attaching_to);
         attach_pid = DNBProcessAttach(pid_attaching_to, &attach_timeout_abstime,
-                                      false, err_str, sizeof(err_str));
+                                      m_ctx.GetIgnoredExceptions(), 
+                                      err_str, sizeof(err_str));
       }
     } else {
       return HandlePacket_UNIMPLEMENTED(p);
     }
 
     if (attach_pid == INVALID_NUB_PROCESS_ARCH) {
       DNBLogError("debugserver is x86_64 binary running in translation, attach "
                   "failed.");

lldb/tools/debugserver/source/debugserver.cpp

 RNBRunLoopMode RNBRunLoopLaunchAttaching(RNBRemote *remote,
                                          nub_process_t attach_pid,
                                          nub_process_t &pid) {
   RNBContext &ctx = remote->Context();
 
   DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s Attaching to pid %i...", __FUNCTION__,
                    attach_pid);
   char err_str[1024];
-  pid = DNBProcessAttach(attach_pid, NULL, ctx.GetUnmaskSignals(), err_str,
+  pid = DNBProcessAttach(attach_pid, NULL, ctx.GetIgnoredExceptions(), err_str,
                          sizeof(err_str));
   g_pid = pid;
 
   if (pid == INVALID_NUB_PROCESS) {
     ctx.LaunchStatus().SetError(-1, DNBError::Generic);
     if (err_str[0])
       ctx.LaunchStatus().SetErrorString(err_str);
     return eRNBRunLoopModeExit;
case 'e':
       remote->Context().PushEnvironment(optarg);
       break;
 
     case 'F':
       forward_env = true;
       break;
 
     case 'U':
-      ctx.SetUnmaskSignals(true);
+      ctx.AddDefaultIgnoredExceptions();
       break;
 
     case '2':
       // File descriptor passed to this process during fork/exec and is already
       // open and ready for communication.
       communication_fd = atoi(optarg);
       break;
     }
case eRNBRunLoopModeInferiorAttaching:
         if (waitfor_duration != 0) {
           DNBTimer::OffsetTimeOfDay(&attach_timeout_abstime, waitfor_duration,
                                     0);
           timeout_ptr = &attach_timeout_abstime;
         }
 
         RNBLogSTDOUT("Attaching to process %s...\n", attach_pid_name.c_str());
         nub_process_t pid = DNBProcessAttachByName(
-            attach_pid_name.c_str(), timeout_ptr, ctx.GetUnmaskSignals(),
+            attach_pid_name.c_str(), timeout_ptr, ctx.GetIgnoredExceptions(),
             err_str, sizeof(err_str));
         g_pid = pid;
         if (pid == INVALID_NUB_PROCESS) {
           ctx.LaunchStatus().SetError(-1, DNBError::Generic);
           if (err_str[0])
             ctx.LaunchStatus().SetErrorString(err_str);
           RNBLogSTDERR("error: failed to attach to process named: \"%s\" %s\n",
                        waitfor_pid_name.c_str(), err_str);