Add a darwin platform setting to specify which exceptions debugserver

should not receive as exceptions (some will get converted to BSD
signals instead).  This is really the only stable way to ensure that
a Mach exception gets converted to it's equivalent BSD signal.  For
programs that rely on BSD signal handlers, this has to happen or you
can't even get the program to invoke the signal handler when under
the debugger.

This builds on a previous solution to this problem which required you
start debugserver with the -U flag.  This was not very discoverable
and required lldb be the one to launch debugserver, which is not always
the case.

Differential Revision: https://reviews.llvm.org/D125434

Author: jimingham

lldb/include/lldb/Interpreter/OptionValueString.h

@@ -109,6 +109,11 @@ class OptionValueString : public Cloneable<OptionValueString, OptionValue> {
   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;

lldb/include/lldb/Target/Platform.h

@@ -847,6 +847,8 @@ class Platform : public PluginInterface {
   }
 
   virtual CompilerType GetSiginfoType(const llvm::Triple &triple);
+  
+  virtual Args GetExtraStartupCommands();
 
 protected:
   /// Create a list of ArchSpecs with the given OS and a architectures. The

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

@@ -174,6 +174,7 @@ class StringExtractorGDBRemote : public StringExtractor {
     eServerPacketType_QMemTags, // write memory tags
 
     eServerPacketType_qLLDBSaveCore,
+    eServerPacketType_QSetIgnoredExceptions
   };
 
   ServerPacketType GetServerPacketType() const;

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

@@ -19,11 +19,15 @@
 #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"
@@ -48,12 +52,137 @@
 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,

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

@@ -48,6 +48,18 @@ class PlatformDarwin : public 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;
 
@@ -96,6 +108,8 @@ class PlatformDarwin : public PlatformPOSIX {
   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);

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

@@ -5,3 +5,12 @@ let Definition = "platformdarwinkernel" in {
     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

@@ -954,12 +954,23 @@ Status ProcessGDBRemote::ConnectToDebugserver(llvm::StringRef connect_url) {
   m_gdb_comm.GetVAttachOrWaitSupported();
   m_gdb_comm.EnableErrorStringInPacket();
 
-  size_t num_cmds = GetExtraStartupCommands().GetArgumentCount();
-  for (size_t idx = 0; idx < num_cmds; idx++) {
-    StringExtractorGDBRemote response;
-    m_gdb_comm.SendPacketAndWaitForResponse(
-        GetExtraStartupCommands().GetArgumentAtIndex(idx), response);
+  // 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(
+          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;
 }
 

lldb/source/Target/Platform.cpp

@@ -1945,6 +1945,10 @@ 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) {

lldb/source/Utility/StringExtractorGDBRemote.cpp

@@ -126,6 +126,8 @@ StringExtractorGDBRemote::GetServerPacketType() const {
         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:"))

lldb/test/API/macosx/ignore_exceptions/Makefile

@@ -0,0 +1,4 @@
+C_SOURCES := main.c
+CFLAGS_EXTRAS := -std=c99
+
+include Makefile.rules

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

@@ -0,0 +1,60 @@
+"""
+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

@@ -0,0 +1,27 @@
+#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
+}