[debugserver] Add option to propagate SIGSEGV to target process

[aarzilli]

Summary

Adds a command line option that makes debugserver propagate the SIGSEGV signal to the target process.

Motivation: I'm one of the maintainers of Delve [1] a debugger for Go. We
use debugserver as our backend on macOS and one of the most often reported
bugs is that, on macOS, we don't propagate SIGSEGV back to the target
process [2]. Sometimes some programs will actually cause a SIGSEGV, by
design, and then handle it. Those programs can not be debugged at all.

Since catching signals isn't very important for a Go debugger I'd much
rather have a command line option in debugserver that causes it to let
SIGSEGV go directly to the target process.

[1] https://github.com/go-delve/delve/
[2] https://github.com/go-delve/delve/issues/852

[jingham]

The return from a SIGSEGV or SIGILL has less information than the equivalent exception, so reporting the exceptions should be the default, but having a switch for people who need the exception to propagate is okay.

I wonder if the implementation would be less intrusive (and keep some of these functions from adding to their already too many arguments) if you added this flag to the RNBContext that RNBRemote holds onto. You'll still have to pass it down to the Mach layers by hand, but maybe you could do less work handing it from call to call. RNBContext has other related flags, so this seems a natural extension.

You might even get away with treating this as a launch flavor (which it sort of is), though to do that you'd have to make the launch flavor OR-able which might be more work than its worth.

[aarzilli]

I wonder if the implementation would be less intrusive (and keep some of these functions from adding to their already too many arguments) if you added this flag to the RNBContext that RNBRemote holds onto.

Done.

You might even get away with treating this as a launch flavor (which it sort of is), though to do that you'd have to make the launch flavor OR-able which might be more work than its worth.

I'm not familiar enough with the codebase to do this.

[jingham]

Thanks, that's a little better.

It would be even nicer if the DNB API's you are adding "unmask_signals" to would take the Context instead. At this point they are pulling the launch flavor and the unmask signals from the context, so just getting the RNBContext would be cleaner. If you feel motivated to make that change as well, that would be great. But this is also okay as it stands.

[aarzilli]

Like this?

[jingham]

That's nicer, thanks!

[aarzilli]

I don't want to be overbearing but should I be doing something else? Is this going to be merged and, if it is, what timeline should I expect?

[JDevlieghere]

In D89315#2399805, @aarzilli wrote:

I don't want to be overbearing but should I be doing something else? Is this going to be merged and, if it is, what timeline should I expect?

I think nobody realized you didn't have commit access, feel free to ask someone to merge something for you in the future. I'll take care of this patch for you.

[aarzilli]

In D89315#2400244, @JDevlieghere wrote:

In D89315#2399805, @aarzilli wrote:

I don't want to be overbearing but should I be doing something else? Is this going to be merged and, if it is, what timeline should I expect?

I think nobody realized you didn't have commit access, feel free to ask someone to merge something for you in the future. I'll take care of this patch for you.

Thank you.

lldb/tools/debugserver/source/DNB.h

 
 // Process control
 nub_process_t DNBProcessLaunch(
     const char *path, char const *argv[], const char *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, char *err_str, size_t err_len);
+    const char *event_data, bool unmask_signals, 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,
-                               char *err_str, size_t err_len);
+                               bool unmask_signals, char *err_str,
+                               size_t err_len);
 nub_process_t DNBProcessAttachByName(const char *name, struct timespec *timeout,
-                                     char *err_str, size_t err_len);
-nub_process_t
-DNBProcessAttachWait(const char *wait_name, nub_launch_flavor_t launch_flavor,
-                     bool ignore_existing, struct timespec *timeout,
-                     useconds_t interval, char *err_str, size_t err_len,
-                     DNBShouldCancelCallback should_cancel = NULL,
-                     void *callback_data = NULL);
+                                     bool unmask_signals, char *err_str,
+                                     size_t err_len);
+nub_process_t DNBProcessAttachWait(
+    const char *wait_name, nub_launch_flavor_t launch_flavor,
+    bool ignore_existing, struct timespec *timeout, useconds_t interval,
+    bool unmask_signals, char *err_str, size_t err_len,
+    DNBShouldCancelCallback should_cancel = NULL, void *callback_data = NULL);
 // Resume a process with exact instructions on what to do with each thread:
 // - If no thread actions are supplied (actions is NULL or num_actions is zero),
 //   then all threads are continued.
 // - If any thread actions are supplied, then each thread will do as it is told
 //   by the action. A default actions for any threads that don't have an
 //   explicit thread action can be made by making a thread action with a tid of
 //   INVALID_NUB_THREAD. If there is no default action, those threads will
 //   remain stopped.

lldb/tools/debugserver/source/DNB.cpp

 }
 
 nub_process_t DNBProcessLaunch(
     const char *path, char const *argv[], const char *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, char *err_str, size_t err_len) {
+    const char *event_data, bool unmask_signals, char *err_str,
+    size_t err_len) {
   DNBLogThreadedIf(LOG_PROCESS, "%s ( path='%s', argv = %p, envp = %p, "
                                 "working_dir=%s, stdin=%s, stdout=%s, "
                                 "stderr=%s, no-stdio=%i, launch_flavor = %u, "
                                 "disable_aslr = %d, err = %p, err_len = "
                                 "%llu) called...",
                    __FUNCTION__, path, static_cast<void *>(argv),
                    static_cast<void *>(envp), working_directory, stdin_path,
                    stdout_path, stderr_path, no_stdio, launch_flavor,
                    disable_aslr, static_cast<void *>(err_str),
                    static_cast<uint64_t>(err_len));
 
   if (err_str && err_len > 0)
     err_str[0] = '\0';
   struct stat path_stat;
   if (::stat(path, &path_stat) == -1) {
     char stat_error[256];
     ::strerror_r(errno, stat_error, sizeof(stat_error));
     snprintf(err_str, err_len, "%s (%s)", stat_error, path);
     return INVALID_NUB_PROCESS;
   }
 
   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, launch_flavor, disable_aslr,
-                                          event_data, launch_err);
+    pid_t pid = processSP->LaunchForDebug(
+        path, argv, envp, working_directory, stdin_path, stdout_path,
+        stderr_path, no_stdio, launch_flavor, disable_aslr, event_data,
+        unmask_signals, 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,
-                                     char *err_str, size_t err_len) {
+                                     bool unmask_signals, 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,
-                          err_str, err_len);
+                          unmask_signals, err_str, err_len);
 }
 
 nub_process_t DNBProcessAttach(nub_process_t attach_pid,
-                               struct timespec *timeout, char *err_str,
-                               size_t err_len) {
+                               struct timespec *timeout, bool unmask_signals,
+                               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;
     size_t bufsize = sizeof(processInfo);
if (getenv("LLDB_DEBUGSERVER_PATH") == NULL) {
     }
   }
 
   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, err_str, err_len);
+    pid =
+        processSP->AttachForDebug(attach_pid, unmask_signals, 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);
     }
   }
GetAllInfosMatchingName(const char *full_process_name,
   }
   // return the newly added matches.
   return matching_proc_infos.size();
 }
 
 nub_process_t DNBProcessAttachWait(
     const char *waitfor_process_name, nub_launch_flavor_t launch_flavor,
     bool ignore_existing, struct timespec *timeout_abstime,
-    useconds_t waitfor_interval, char *err_str, size_t err_len,
-    DNBShouldCancelCallback should_cancel_callback, void *callback_data) {
+    useconds_t waitfor_interval, bool unmask_signals, char *err_str,
+    size_t err_len, DNBShouldCancelCallback should_cancel_callback,
+    void *callback_data) {
   DNBError prepare_error;
   std::vector<struct kinfo_proc> exclude_proc_infos;
   size_t num_exclude_proc_infos;
 
   // If the PrepareForAttach returns a valid token, use  MachProcess to check
   // for the process, otherwise scan the process table.
 
   const void *attach_token = MachProcess::PrepareForAttach(
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, err_str, err_len);
+    waitfor_pid = DNBProcessAttach(waitfor_pid, timeout_abstime, unmask_signals,
+                                   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/MachProcess.h

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, char *err_str, size_t err_len);
+  pid_t AttachForDebug(pid_t pid, bool unmask_signals, 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, DNBError &err);
+                       int disable_aslr, const char *event_data,
+                       bool unmask_signals, 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, 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,
+                                   const char *event_data, bool unmask_signals,
                                    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);
   static std::string GetMacCatalystVersionString();
 #ifdef WITH_BKS
   static void BKSCleanupAfterAttach(const void *attach_token,
                                     DNBError &err_str);
 #endif // WITH_BKS
 #ifdef WITH_FBS
   static void FBSCleanupAfterAttach(const void *attach_token,
                                     DNBError &err_str);
 #endif // WITH_FBS
 #ifdef WITH_SPRINGBOARD
   pid_t SBLaunchForDebug(const char *app_bundle_path, char const *argv[],
                          char const *envp[], bool no_stdio, bool disable_aslr,
-                         DNBError &launch_err);
+                         bool unmask_signals, DNBError &launch_err);
   static pid_t SBForkChildForPTraceDebugging(const char *path,
                                              char const *argv[],
                                              char const *envp[], bool no_stdio,
                                              MachProcess *process,
                                              DNBError &launch_err);
 #endif // WITH_SPRINGBOARD
   nub_addr_t LookupSymbol(const char *name, const char *shlib);
   void SetNameToAddressCallback(DNBCallbackNameToAddress callback,

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, char *err_str, size_t err_len) {
+pid_t MachProcess::AttachForDebug(pid_t pid, bool unmask_signals, 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");
       DNBLogError ("MachProcess::AttachForDebug pid %d does not exist", pid);
       return INVALID_NUB_PROCESS;
     }
 
     SetState(eStateAttaching);
     m_pid = pid;
-    if (!m_task.StartExceptionThread(err)) {
+    if (!m_task.StartExceptionThread(unmask_signals, 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 ("MachProcess::AttachForDebug failed to start exception thread: %s", err_str);
       m_pid = INVALID_NUB_PROCESS;
       return INVALID_NUB_PROCESS;
     }

 }
 
 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) {
+    const char *event_data, bool unmask_signals, 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,
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);
+    m_task.StartExceptionThread(unmask_signals, 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, DNBError &launch_err) {
+                                    bool disable_aslr, bool unmask_signals,
+                                    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(launch_err);
+    m_task.StartExceptionThread(unmask_signals, 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, DNBError &launch_err) {
+    bool disable_aslr, const char *event_data, bool unmask_signals,
+    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);
+    m_task.StartExceptionThread(unmask_signals, 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;

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

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(DNBError &err);
+  bool StartExceptionThread(bool unmask_signals, 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(DNBError &err) {
+bool MachTask::StartExceptionThread(bool unmask_signals, 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);
+    }
+
     // 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, "
                       "exception_mask = 0x%8.8x, new_port = 0x%4.4x, behavior "
                       "= 0x%8.8x, new_flavor = 0x%8.8x )",

lldb/tools/debugserver/source/RNBContext.h

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 GetUnmaskSignals() { return m_unmask_signals; }
+
 protected:
   // Classes that inherit from RNBContext can see and modify these
   nub_process_t m_pid;
   std::string m_stdin;
   std::string m_stdout;
   std::string m_stderr;
   std::string m_working_dir;
   nub_size_t m_pid_stop_count;
   PThreadEvent m_events; // Threaded events that we can wait for
   pthread_t m_pid_pthread;
   nub_launch_flavor_t m_launch_flavor; // How to launch our inferior process
   DNBError
       m_launch_status; // This holds the status from the last launch attempt.
   std::vector<std::string> m_arg_vec;
   std::vector<std::string>
       m_env_vec; // This will be unparsed - entries FOO=value
   std::string m_working_directory;
   std::string m_process_event;
   bool m_detach_on_error;
 
   void StartProcessStatusThread();
   void StopProcessStatusThread();
   static void *ThreadFunctionProcessStatus(void *arg);
+  bool m_unmask_signals;
 
 private:
   RNBContext(const RNBContext &rhs) = delete;
   RNBContext &operator=(const RNBContext &rhs) = delete;
 };
 
 #endif // LLDB_TOOLS_DEBUGSERVER_SOURCE_RNBCONTEXT_H

lldb/tools/debugserver/source/RNBRemote.cpp

if (strstr(p, "vAttachWait;") == p) {
       p += strlen("vAttachWait;");
       if (!GetProcessNameFrom_vAttach(p, attach_name)) {
         return HandlePacket_ILLFORMED(
             __FILE__, __LINE__, p, "non-hex char in arg on 'vAttachWait' pkt");
       }
       const bool ignore_existing = true;
       attach_pid = DNBProcessAttachWait(
           attach_name.c_str(), m_ctx.LaunchFlavor(), ignore_existing, NULL,
-          1000, err_str, sizeof(err_str), RNBRemoteShouldCancelCallback);
+          1000, Context().GetUnmaskSignals(), err_str, sizeof(err_str),
+          RNBRemoteShouldCancelCallback);
 
     } else if (strstr(p, "vAttachOrWait;") == p) {
       p += strlen("vAttachOrWait;");
       if (!GetProcessNameFrom_vAttach(p, attach_name)) {
         return HandlePacket_ILLFORMED(
             __FILE__, __LINE__, p,
             "non-hex char in arg on 'vAttachOrWait' pkt");
       }
       const bool ignore_existing = false;
       attach_pid = DNBProcessAttachWait(
           attach_name.c_str(), m_ctx.LaunchFlavor(), ignore_existing, NULL,
-          1000, err_str, sizeof(err_str), RNBRemoteShouldCancelCallback);
+          1000, Context().GetUnmaskSignals(), err_str, sizeof(err_str),
+          RNBRemoteShouldCancelCallback);
     } else if (strstr(p, "vAttachName;") == p) {
       p += strlen("vAttachName;");
       if (!GetProcessNameFrom_vAttach(p, attach_name)) {
         return HandlePacket_ILLFORMED(
             __FILE__, __LINE__, p, "non-hex char in arg on 'vAttachName' pkt");
       }
 
-      attach_pid = DNBProcessAttachByName(attach_name.c_str(), NULL, err_str,
+      attach_pid = DNBProcessAttachByName(attach_name.c_str(), NULL,
+                                          Context().GetUnmaskSignals(), 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);
         attach_pid = DNBProcessAttach(pid_attaching_to, &attach_timeout_abstime,
-                                      err_str, sizeof(err_str));
+                                      false, err_str, sizeof(err_str));
       }
     } else {
       return HandlePacket_UNIMPLEMENTED(p);
     }
 
     if (attach_pid != INVALID_NUB_PROCESS) {
       if (m_ctx.ProcessID() != attach_pid)
         m_ctx.SetProcessID(attach_pid);

lldb/tools/debugserver/source/debugserver.cpp

RNBRunLoopMode RNBRunLoopLaunchInferior(RNBRemote *remote,
   launch_err_str[0] = '\0';
   const char *cwd =
       (ctx.GetWorkingDirPath() != NULL ? ctx.GetWorkingDirPath()
                                        : ctx.GetWorkingDirectory());
   const char *process_event = ctx.GetProcessEvent();
   nub_process_t pid = DNBProcessLaunch(
       resolved_path, &inferior_argv[0], &inferior_envp[0], cwd, stdin_path,
       stdout_path, stderr_path, no_stdio, launch_flavor, g_disable_aslr,
-      process_event, launch_err_str, sizeof(launch_err_str));
+      process_event, ctx.GetUnmaskSignals(), launch_err_str,
+      sizeof(launch_err_str));
 
   g_pid = pid;
 
   if (pid == INVALID_NUB_PROCESS && strlen(launch_err_str) > 0) {
     DNBLogThreaded("%s DNBProcessLaunch() returned error: '%s'", __FUNCTION__,
                    launch_err_str);
     ctx.LaunchStatus().SetError(-1, DNBError::Generic);
     ctx.LaunchStatus().SetErrorString(launch_err_str);

 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, err_str, sizeof(err_str));
+  pid = DNBProcessAttach(attach_pid, NULL, ctx.GetUnmaskSignals(), 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;
   } else {
static struct option g_long_options[] = {
     {"env", required_argument, NULL,
      'e'}, // When debugserver launches the process, set a single environment
            // entry as specified by the option value ("./debugserver -e FOO=1 -e
            // BAR=2 localhost:1234 -- /bin/ls")
     {"forward-env", no_argument, NULL,
      'F'}, // When debugserver launches the process, forward debugserver's
            // current environment variables to the child process ("./debugserver
            // -F localhost:1234 -- /bin/ls"
+    {"unmask-signals", no_argument, NULL,
+     'U'}, // debugserver will ignore EXC_MASK_BAD_ACCESS,
+           // EXC_MASK_BAD_INSTRUCTION and EXC_MASK_ARITHMETIC, which results in
+           // SIGSEGV, SIGILL and SIGFPE being propagated to the target process.
     {NULL, 0, NULL, 0}};
 
 int communication_fd = -1;
 
 // main
 int main(int argc, char *argv[]) {
   // If debugserver is launched with DYLD_INSERT_LIBRARIES, unset it so we
   // don't spawn child processes with this enabled.
case 'e':
       // gets launched
       remote->Context().PushEnvironment(optarg);
       break;
 
     case 'F':
       forward_env = true;
       break;
 
+    case 'U':
+      ctx.SetUnmaskSignals(true);
+      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:
           launch_flavor = default_launch_flavor(waitfor_pid_name.c_str());
 
         ctx.SetLaunchFlavor(launch_flavor);
         bool ignore_existing = false;
         RNBLogSTDOUT("Waiting to attach to process %s...\n",
                      waitfor_pid_name.c_str());
         nub_process_t pid = DNBProcessAttachWait(
             waitfor_pid_name.c_str(), launch_flavor, ignore_existing,
-            timeout_ptr, waitfor_interval, err_str, sizeof(err_str));
+            timeout_ptr, waitfor_interval, ctx.GetUnmaskSignals(), 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);
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, err_str, sizeof(err_str));
+            attach_pid_name.c_str(), timeout_ptr, ctx.GetUnmaskSignals(),
+            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);
           mode = eRNBRunLoopModeExit;