[lldb] Add SBBreakpointLocation::SetCallback

[lauralcg]

Summary

• Include SetCallback in SBBreakpointLocation, similar as in SBBreakpoint.
• Add test_breakpoint_location_callback test as part of TestMultithreaded.

[werat]

Look good to me, but giving some time for others to take a look.

[JDevlieghere]

LGTM

lldb/include/lldb/API/SBBreakpointLocation.h

public:
 
   uint32_t GetIgnoreCount();
 
   void SetIgnoreCount(uint32_t n);
 
   void SetCondition(const char *condition);
 
   const char *GetCondition();
-   
   void SetAutoContinue(bool auto_continue);
 
   bool GetAutoContinue();
 
+  void SetCallback(SBBreakpointHitCallback callback, void *baton);
+
   void SetScriptCallbackFunction(const char *callback_function_name);
 
   SBError SetScriptCallbackFunction(const char *callback_function_name,
                                     lldb::SBStructuredData &extra_args);
 
   SBError SetScriptCallbackBody(const char *script_body_text);
   
   void SetCommandLineCommands(lldb::SBStringList &commands);

lldb/source/API/SBBreakpointLocation.cpp

 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
+#include "SBBreakpointOptionCommon.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 SBBreakpointLocation::SBBreakpointLocation() { LLDB_INSTRUMENT_VA(this); }
 
 SBBreakpointLocation::SBBreakpointLocation(
     const lldb::BreakpointLocationSP &break_loc_sp)
     : m_opaque_wp(break_loc_sp) {
bool SBBreakpointLocation::GetAutoContinue() {
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->IsAutoContinue();
   }
   return false;
 }
 
+void SBBreakpointLocation::SetCallback(SBBreakpointHitCallback callback,
+                                       void *baton) {
+  LLDB_INSTRUMENT_VA(this, callback, baton);
+
+  BreakpointLocationSP loc_sp = GetSP();
+
+  if (loc_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        loc_sp->GetTarget().GetAPIMutex());
+    BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton));
+    loc_sp->SetCallback(SBBreakpointCallbackBaton::PrivateBreakpointHitCallback,
+                        baton_sp, false);
+  }
+}
+
 void SBBreakpointLocation::SetScriptCallbackFunction(
   const char *callback_function_name) {
   LLDB_INSTRUMENT_VA(this, callback_function_name);
 }
 
 SBError SBBreakpointLocation::SetScriptCallbackFunction(
     const char *callback_function_name,
     SBStructuredData &extra_args) {

lldb/test/API/api/multithreaded/TestMultithreaded.py

class SBBreakpointCallbackCase(TestBase):
 
     NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         TestBase.setUp(self)
         self.generateSource('driver.cpp')
         self.generateSource('listener_test.cpp')
         self.generateSource('test_breakpoint_callback.cpp')
+        self.generateSource('test_breakpoint_location_callback.cpp')
         self.generateSource('test_listener_event_description.cpp')
         self.generateSource('test_listener_event_process_state.cpp')
         self.generateSource('test_listener_resume.cpp')
         self.generateSource('test_stop-hook.cpp')
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfRemote
def test_breakpoint_callback(self):
         """Test the that SBBreakpoint callback is invoked when a breakpoint is hit. """
         self.build_and_test('driver.cpp test_breakpoint_callback.cpp',
                             'test_breakpoint_callback')
 
     @skipIfRemote
     @skipIfNoSBHeaders
     # clang-cl does not support throw or catch (llvm.org/pr24538)
     @skipIfWindows
+    def test_breakpoint_location_callback(self):
+        """Test the that SBBreakpointLocation callback is invoked when a breakpoint is hit. """
+        self.build_and_test('driver.cpp test_breakpoint_location_callback.cpp',
+                            'test_breakpoint_location_callback')
+
+    @skipIfRemote
+    @skipIfNoSBHeaders
+    # clang-cl does not support throw or catch (llvm.org/pr24538)
+    @skipIfWindows
     @expectedFlakeyFreeBSD
     def test_sb_api_listener_event_description(self):
         """ Test the description of an SBListener breakpoint event is valid."""
         self.build_and_test(
             'driver.cpp listener_test.cpp test_listener_event_description.cpp',
             'test_listener_event_description')
 
     @skipIfRemote

lldb/test/API/api/multithreaded/test_breakpoint_location_callback.cpp.template

+
+// LLDB C++ API Test: verify that the function registered with
+// SBBreakpoint.SetCallback() is invoked when a breakpoint is hit.
+
+#include <mutex>
+#include <iostream>
+#include <vector>
+#include <string>
+
+%include_SB_APIs%
+
+#include "common.h"
+
+using namespace std;
+using namespace lldb;
+
+mutex g_mutex;
+condition_variable g_condition;
+int g_breakpoint_hit_count = 0;
+
+bool BPCallback (void *baton,
+                 SBProcess &process,
+                 SBThread &thread,
+                 SBBreakpointLocation &location) {
+  lock_guard<mutex> lock(g_mutex);
+  g_breakpoint_hit_count += 1;
+  g_condition.notify_all();
+  return true;
+}
+
+void test(SBDebugger &dbg, vector<string> args) {
+  dbg.SetAsync(false);
+  SBTarget target = dbg.CreateTarget(args.at(0).c_str());
+  if (!target.IsValid()) throw Exception("invalid target");
+
+  SBBreakpoint breakpoint = target.BreakpointCreateByName("next");
+  if (!breakpoint.IsValid()) throw Exception("invalid breakpoint");
+
+  if(breakpoint.GetNumLocations() != 1) throw Exception("unexpected amount of breakpoint locations");
+  SBBreakpointLocation breakpoint_location = breakpoint.GetLocationAtIndex(0);
+  breakpoint_location.SetCallback(BPCallback, 0);
+
+  std::unique_ptr<char> working_dir(get_working_dir());
+  SBProcess process = target.LaunchSimple (0, 0, working_dir.get());
+
+  {
+    unique_lock<mutex> lock(g_mutex);
+    g_condition.wait_for(lock, chrono::seconds(5));
+    if (g_breakpoint_hit_count != 1)
+      throw Exception("Breakpoint hit count expected to be 1");
+  }
+}