[lldb/API] Add Breakpoint::SerializeToStructuredData to SBAPI

[mib]

Summary

This patch adds a way to fetch breakpoint metadatas as a serialized
Structured Data format (JSON). This can be used by IDEs to update
their UI when a breakpoint is set or modified from the console.

rdar://11013798

Signed-off-by: Med Ismail Bennani <[e-mail]>

[DavidSpickett]

lldb/test/API/functionalities/breakpoint/serialize/TestBreakpointSerialization.py

77

How many other fields does a breakpoint contain? Might be worth adding one test showing the full result.

Unless Breakpoint::SerializeToStructuredData already has test coverage, just want to check that new fields don't get missed from this output.

88

Can you also check what happens if you serialize an invalid breakpoint?

[mib]

lldb/test/API/functionalities/breakpoint/serialize/TestBreakpointSerialization.py

77

This feature exists since 2016 and has been used to export breakpoints to a file using the breakpoint write command. If you look at the rest of the test file, the API is pretty well tested.

[mib]

Add invalid breakpoint test case.

[DavidSpickett]

This LGTM but I don't know the API standards very well. Some else should give a final review.

[JDevlieghere]

The reproducer instrumentation part LGTM.

[jingham]

LGTM

lldb/bindings/interface/SBBreakpoint.i

public:
 
     bool
     GetDescription(lldb::SBStream &description, bool include_locations);
 
     // Can only be called from a ScriptedBreakpointResolver...
     SBError
     AddLocation(SBAddress &address);
 
+    SBStructuredData SBBreakpoint::SerializeToStructuredData();
+
     static bool
     EventIsBreakpointEvent (const lldb::SBEvent &event);
 
     static lldb::BreakpointEventType
     GetBreakpointEventTypeFromEvent (const lldb::SBEvent& event);
 
     static lldb::SBBreakpoint
     GetBreakpointFromEvent (const lldb::SBEvent& event);

lldb/include/lldb/API/SBBreakpoint.h

 //===-- SBBreakpoint.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_API_SBBREAKPOINT_H
 #define LLDB_API_SBBREAKPOINT_H
 
 #include "lldb/API/SBDefines.h"
 
 class SBBreakpointListImpl;
 
 namespace lldb {
 
 class LLDB_API SBBreakpoint {
 public:
 
public:
   static uint32_t
   GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event_sp);
 
   bool IsHardware() const;
 
   // Can only be called from a ScriptedBreakpointResolver...
   SBError
   AddLocation(SBAddress &address);
-  
+  SBStructuredData SerializeToStructuredData();
+
 private:
   friend class SBBreakpointList;
   friend class SBBreakpointLocation;
   friend class SBBreakpointName;
   friend class SBTarget;
 
   lldb::BreakpointSP GetSP() const;
 

lldb/source/API/SBBreakpoint.cpp

 //===-- SBBreakpoint.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBBreakpoint.h"
 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBBreakpointLocation.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBStructuredData.h"
else {
     address.get()->Dump(&s, &bkpt_sp->GetTarget(),
                         Address::DumpStyleModuleWithFileAddress);
     error.SetErrorStringWithFormat("Address: %s didn't pass the filter.",
                                    s.GetData());
   }
   return LLDB_RECORD_RESULT(error);
 }
 
-void SBBreakpoint ::SetCallback(SBBreakpointHitCallback callback, void *baton) {
+SBStructuredData SBBreakpoint::SerializeToStructuredData() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBBreakpoint,
+                             SerializeToStructuredData);
+
+  SBStructuredData data;
+  BreakpointSP bkpt_sp = GetSP();
+
+  if (!bkpt_sp)
+    return LLDB_RECORD_RESULT(data);
+
+  StructuredData::ObjectSP bkpt_dict = bkpt_sp->SerializeToStructuredData();
+  data.m_impl_up->SetObjectSP(bkpt_dict);
+  return LLDB_RECORD_RESULT(data);
+}
+
+void SBBreakpoint::SetCallback(SBBreakpointHitCallback callback, void *baton) {
   LLDB_RECORD_DUMMY(void, SBBreakpoint, SetCallback,
                     (lldb::SBBreakpointHitCallback, void *), callback, baton);
 
   BreakpointSP bkpt_sp = GetSP();
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
void RegisterMethods<SBBreakpoint>(Registry &R) {
   LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
                        (lldb::SBStringList &));
   LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
                        (lldb::SBStream &));
   LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
                        (lldb::SBStream &, bool));
   LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
                        (lldb::SBAddress &));
+  LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBBreakpoint,
+                       SerializeToStructuredData, ());
   LLDB_REGISTER_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
                        (const char *));
   LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackFunction,
                        (const char *, SBStructuredData &));
   LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
                        (const char *));
   LLDB_REGISTER_METHOD(bool, SBBreakpoint, AddName, (const char *));
   LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddNameWithErrorHandling,

lldb/test/API/functionalities/breakpoint/serialize/TestBreakpointSerialization.py

 """
 Test breakpoint serialization.
 """
 
 import os
+import json
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class BreakpointSerialization(TestBase):
 
def test_name_filters(self):
         self.do_check_names()
 
     @skipIfReproducer # side_effect bypasses reproducer
     def test_scripted_extra_args(self):
         self.build()
         self.setup_targets_and_cleanup()
         self.do_check_extra_args()
 
+    def test_structured_data_serialization(self):
+        target = self.dbg.GetDummyTarget()
+        self.assertTrue(target.IsValid(), VALID_TARGET)
+
+        interpreter = self.dbg.GetCommandInterpreter()
+        result = lldb.SBCommandReturnObject()
+        interpreter.HandleCommand("br set -f foo -l 42", result)
+        result = lldb.SBCommandReturnObject()
+        interpreter.HandleCommand("br set -c 'argc == 1' -n main", result)
+
+        bkp1 =  target.GetBreakpointAtIndex(0)
+        self.assertTrue(bkp1.IsValid(), VALID_BREAKPOINT)
+        stream = lldb.SBStream()
+        sd = bkp1.SerializeToStructuredData()
+        sd.GetAsJSON(stream)
+        serialized_data = json.loads(stream.GetData())
+        self.assertEqual(serialized_data["Breakpoint"]["BKPTResolver"]["Options"]["FileName"], "foo")
+        self.assertEqual(serialized_data["Breakpoint"]["BKPTResolver"]["Options"]["LineNumber"], 42)
+
+        bkp2 =  target.GetBreakpointAtIndex(1)
+        self.assertTrue(bkp2.IsValid(), VALID_BREAKPOINT)
+        stream = lldb.SBStream()
+        sd = bkp2.SerializeToStructuredData()
+        sd.GetAsJSON(stream)
+        serialized_data = json.loads(stream.GetData())
+        self.assertIn("main", serialized_data["Breakpoint"]["BKPTResolver"]["Options"]["SymbolNames"])
+        self.assertEqual(serialized_data["Breakpoint"]["BKPTOptions"]["ConditionText"],"argc == 1")
+
+
     def setup_targets_and_cleanup(self):
         def cleanup ():
             self.RemoveTempFile(self.bkpts_file_path)
 
             if self.orig_target.IsValid():
                 self.dbg.DeleteTarget(self.orig_target)
                 self.dbg.DeleteTarget(self.copy_target)