[lldb] Expose diagnostic events through the SB API

[JDevlieghere]

Summary

Expose diagnostic events through the SB API. Unlike the progress events, I chose to use a SBStructuredData so that we can add fields in the future.

[mib]

LGTM! We should have chosen to return a StructuredData for ProgressEvents as well

[JDevlieghere]

Use the minidump warning to check for an actual event.

[jingham]

Yes, if we had had the SBStructuredData class from the start, that would have been a clearer, more robust and flexible way to do the event data in general. But at this point the event data word meanings are API so we can't really remove the old way.

lldb/bindings/interface/SBDebugger.i

to do this is: ::
     process = target.AttachToProcessWithName(debugger.GetListener(), 'PROCESS_NAME', False, error)
 
 or the equivalent arguments for :py:class:`SBTarget.AttachToProcessWithID` .") SBDebugger;
 class SBDebugger
 {
 public:
     enum
     {
-        eBroadcastBitProgress = (1 << 0)
+        eBroadcastBitProgress = (1 << 0),
+        eBroadcastBitWarning = (1 << 1),
+        eBroadcastBitError = (1 << 2),
     };
 
 
     static const char *GetProgressFromEvent(const lldb::SBEvent &event,
                                         uint64_t &OUTPUT,
                                         uint64_t &OUTPUT,
                                         uint64_t &OUTPUT,
                                         bool &OUTPUT);
 
+    lldb::SBStructuredData GetDiagnosticFromEvent(const lldb::SBEvent &event);
+
     SBBroadcaster GetBroadcaster();
 
     static void
     Initialize();
 
     static SBError
     InitializeWithErrorHandling();
 

lldb/include/lldb/API/SBDebugger.h

SBError Initialize(lldb::SBDebugger &sb_debugger,
                      void *a, lldb::InputReaderGranularity b, char const *c,
                      char const *d, bool e);
   void SetIsDone(bool);
   bool IsActive() const;
 };
 
 class LLDB_API SBDebugger {
 public:
-  FLAGS_ANONYMOUS_ENUM(){eBroadcastBitProgress = (1 << 0)};
+  FLAGS_ANONYMOUS_ENUM(){
+      eBroadcastBitProgress = (1 << 0),
+      eBroadcastBitWarning = (1 << 1),
+      eBroadcastBitError = (1 << 2),
+  };
 
   SBDebugger();
 
   SBDebugger(const lldb::SBDebugger &rhs);
 
   SBDebugger(const lldb::DebuggerSP &debugger_sp);
 
   ~SBDebugger();
public:
   ///
   /// \return The message for the progress. If the returned value is NULL, then
   ///   \a event was not a eBroadcastBitProgress event.
   static const char *GetProgressFromEvent(const lldb::SBEvent &event,
                                           uint64_t &progress_id,
                                           uint64_t &completed, uint64_t &total,
                                           bool &is_debugger_specific);
 
+  lldb::SBStructuredData GetDiagnosticFromEvent(const lldb::SBEvent &event);
+
   lldb::SBDebugger &operator=(const lldb::SBDebugger &rhs);
 
   static void Initialize();
 
   static lldb::SBError InitializeWithErrorHandling();
 
   static void Terminate();
 

lldb/include/lldb/Core/DebuggerEvents.h

enum class Type {
     Error,
   };
   DiagnosticEventData(Type type, std::string message, bool debugger_specific)
       : m_message(std::move(message)), m_type(type),
         m_debugger_specific(debugger_specific) {}
   ~DiagnosticEventData() {}
 
   const std::string &GetMessage() const { return m_message; }
+  bool IsDebuggerSpecific() const { return m_debugger_specific; }
   Type GetType() const { return m_type; }
 
   llvm::StringRef GetPrefix() const;
 
   void Dump(Stream *s) const override;
 
   static ConstString GetFlavorString();
   ConstString GetFlavor() const override;

lldb/source/API/SBDebugger.cpp

if (progress_data == nullptr)
     return nullptr;
   progress_id = progress_data->GetID();
   completed = progress_data->GetCompleted();
   total = progress_data->GetTotal();
   is_debugger_specific = progress_data->IsDebuggerSpecific();
   return progress_data->GetMessage().c_str();
 }
 
+lldb::SBStructuredData
+SBDebugger::GetDiagnosticFromEvent(const lldb::SBEvent &event) {
+  LLDB_INSTRUMENT_VA(event);
+
+  const DiagnosticEventData *diagnostic_data =
+      DiagnosticEventData::GetEventDataFromEvent(event.get());
+  if (!diagnostic_data)
+    return {};
+
+  auto dictionary = std::make_unique<StructuredData::Dictionary>();
+  dictionary->AddStringItem("message", diagnostic_data->GetMessage());
+  dictionary->AddStringItem("type", diagnostic_data->GetPrefix());
+  dictionary->AddBooleanItem("debugger_specific",
+                             diagnostic_data->IsDebuggerSpecific());
+
+  SBStructuredData data;
+  data.m_impl_up->SetObjectSP(std::move(dictionary));
+  return data;
+}
+
 SBBroadcaster SBDebugger::GetBroadcaster() {
   LLDB_INSTRUMENT_VA(this);
   SBBroadcaster broadcaster(&m_opaque_sp->GetBroadcaster(), false);
   return broadcaster;
 }
 
 void SBDebugger::Initialize() {
   LLDB_INSTRUMENT();

lldb/test/API/functionalities/diagnostic_reporting/Makefile

+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/functionalities/diagnostic_reporting/TestDiagnosticReporting.py

+"""
+Test that we are able to broadcast and receive diagnostic events from lldb
+"""
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+import threading
+
+
+class TestDiagnosticReporting(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    eBroadcastBitStopDiagnosticThread = (1 << 0)
+
+    def setUp(self):
+        TestBase.setUp(self)
+        self.diagnostic_events = []
+
+    def fetch_events(self):
+        event = lldb.SBEvent()
+
+        done = False
+        while not done:
+            if self.listener.WaitForEvent(1, event):
+                event_mask = event.GetType()
+                if event.BroadcasterMatchesRef(self.test_broadcaster):
+                    if event_mask & self.eBroadcastBitStopDiagnosticThread:
+                        done = True
+                elif event.BroadcasterMatchesRef(self.diagnostic_broadcaster):
+                    ret_args = lldb.SBDebugger().GetDiagnosticFromEvent(event)
+                    self.assertGreater(len(ret_args), 1)
+
+                    message = ret_args[0]
+                    if message:
+                        self.diagnostic_events.append((message, event))
+
+    def test_dwarf_symbol_loading_diagnostic_report(self):
+        """Test that we are able to fetch dwarf symbol loading diagnostic events"""
+        self.build()
+
+        self.listener = lldb.SBListener("lldb.diagnostic.listener")
+        self.test_broadcaster = lldb.SBBroadcaster('lldb.broadcaster.test')
+        self.listener.StartListeningForEvents(
+            self.test_broadcaster, self.eBroadcastBitStopDiagnosticThread)
+
+        self.diagnostic_broadcaster = self.dbg.GetBroadcaster()
+        self.diagnostic_broadcaster.AddListener(
+            self.listener, lldb.SBDebugger.eBroadcastBitWarning)
+        self.diagnostic_broadcaster.AddListener(
+            self.listener, lldb.SBDebugger.eBroadcastBitError)
+
+        listener_thread = threading.Thread(target=self.fetch_events)
+        listener_thread.start()
+
+        lldbutil.run_to_source_breakpoint(self, 'break here',
+                                          lldb.SBFileSpec('main.c'))
+
+        self.test_broadcaster.BroadcastEventByType(
+            self.eBroadcastBitStopDiagnosticThread)
+        listener_thread.join()
+
+        # Not the most useful tests. We except no diagnostics.
+        self.assertEquals(len(self.diagnostic_events), 0)

lldb/test/API/functionalities/diagnostic_reporting/main.c

+int bar(int b) { return b * b; }
+
+int foo(int f) {
+  int b = bar(f); // break here
+  return b;
+}
+
+int main() {
+  int f = foo(42);
+  return f;
+}