[lldb] Add Swift exception breakpoint frame recognizer

Author: kastiglione

lldb/source/Plugins/Language/Swift/SwiftFrameRecognizers.cpp

@@ -3,11 +3,14 @@
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrameRecognizer.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 
@@ -220,6 +223,55 @@ class SwiftHiddenFrameRecognizer : public StackFrameRecognizer {
   }
 };
 
+/// A frame recognizer for Swift exception breakpoints.
+class SwiftExceptionBreakpointFrameRecognizer : public StackFrameRecognizer {
+public:
+  class SwiftExceptionFrame : public RecognizedStackFrame {
+  public:
+    SwiftExceptionFrame(StackFrameSP frame) : m_frame_sp(frame) {
+      m_stop_desc = "Swift exception breakpoint";
+    }
+
+    StackFrameSP GetMostRelevantFrame() override {
+      if (!m_frame_sp)
+        return {};
+
+      auto thread_sp = m_frame_sp->GetThread();
+      if (!thread_sp)
+        return {};
+
+      StackFrameSP frame_sp;
+      StringRef name = m_frame_sp->GetFunctionName();
+      if (name == "swift_willThrow")
+        frame_sp = thread_sp->GetStackFrameAtIndex(1);
+      else if (name == "swift_willThrowTypedImpl")
+        frame_sp = thread_sp->GetStackFrameAtIndex(2);
+      else {
+        assert(false && "unexpected frame name");
+        return {};
+      }
+
+      // Check if source is available for the identified frame.
+      SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextCompUnit);
+      if (!sc.comp_unit)
+        return {};
+
+      return frame_sp;
+    }
+
+  private:
+    StackFrameSP m_frame_sp;
+  };
+
+  RecognizedStackFrameSP RecognizeFrame(StackFrameSP frame) override {
+    return std::make_shared<SwiftExceptionFrame>(frame);
+  };
+
+  std::string GetName() override {
+    return "Swift exception breakpoint frame recognizer";
+  }
+};
+
 void RegisterSwiftFrameRecognizers(Process &process) {
   RegularExpressionSP module_regex_sp = nullptr;
   auto &manager = process.GetTarget().GetFrameRecognizerManager();
@@ -245,6 +297,16 @@ void RegisterSwiftFrameRecognizers(Process &process) {
     manager.AddRecognizer(srf_sp, module_regex_sp, symbol_regex_sp,
                           Mangled::NamePreference::ePreferMangled, false);
   }
+  {
+    auto srf_sp = std::make_shared<SwiftExceptionBreakpointFrameRecognizer>();
+    ConstString module_name = ConstString("swiftCore");
+    if (auto platform_sp = process.GetTarget().GetPlatform())
+      module_name = platform_sp->GetFullNameForDylib(module_name);
+    manager.AddRecognizer(srf_sp, module_name,
+                          {ConstString("swift_willThrow"),
+                           ConstString("swift_willThrowTypedImpl")},
+                          Mangled::NamePreference::ePreferMangled, false);
+  }
 }
 
 } // namespace lldb_private

lldb/test/API/lang/swift/exception_breakpoint_recognizer/Makefile

@@ -0,0 +1,3 @@
+SWIFT_SOURCES := main.swift
+SWIFTFLAGS_EXTRAS := -parse-as-library
+include Makefile.rules

lldb/test/API/lang/swift/exception_breakpoint_recognizer/TestSwiftExceptionBreakpointRecognizer.py

@@ -0,0 +1,28 @@
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+from lldbsuite.test import lldbutil
+
+
+class TestCase(TestBase):
+    def test(self):
+        self.build()
+
+        target = lldbutil.run_to_breakpoint_make_target(self)
+        bp = target.BreakpointCreateForException(lldb.eLanguageTypeSwift, False, True)
+
+        # First breakpoint in an untyped throws function.
+        _, process, _, _ = lldbutil.run_to_breakpoint_do_run(self, target, bp)
+        thread = process.selected_thread
+        stop_desc = thread.GetStopDescription(128)
+        self.assertEqual(stop_desc, "Swift exception breakpoint")
+        self.assertEqual(thread.frame[0].name, "swift_willThrow")
+        self.assertEqual(thread.selected_frame.idx, 1)
+
+        # Second breakpoint in an typed throws function.
+        process.Continue()
+        thread = process.selected_thread
+        stop_desc = thread.GetStopDescription(128)
+        self.assertEqual(stop_desc, "Swift exception breakpoint")
+        self.assertEqual(thread.frame[0].name, "swift_willThrowTypedImpl")
+        self.assertEqual(thread.selected_frame.idx, 2)

lldb/test/API/lang/swift/exception_breakpoint_recognizer/main.swift

@@ -0,0 +1,20 @@
+struct OpaqueError: Error {}
+
+func untyped() throws {
+    throw OpaqueError()
+}
+
+func typed() throws(OpaqueError) {
+    throw OpaqueError()
+}
+
+@main struct Entry {
+    static func main() {
+        do {
+            try untyped()
+        } catch {}
+        do {
+            try typed()
+        } catch {}
+    }
+}