1 files changed, 103 insertions, 41 deletions

diff --git a/source/API/SBBroadcaster.cpp b/source/API/SBBroadcaster.cpp
index 7868c38a818a..e1efdf7baf61 100644
--- a/source/API/SBBroadcaster.cpp
+++ b/source/API/SBBroadcaster.cpp
@@ -1,14 +1,13 @@
 //===-- SBBroadcaster.cpp ---------------------------------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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 "SBReproducerPrivate.h"
 #include "lldb/Utility/Broadcaster.h"
-#include "lldb/Utility/Log.h"
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBEvent.h"
@@ -17,44 +16,44 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) {}
+SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(nullptr) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster);
+}
 
 SBBroadcaster::SBBroadcaster(const char *name)
-    : m_opaque_sp(new Broadcaster(NULL, name)), m_opaque_ptr(NULL) {
+    : m_opaque_sp(new Broadcaster(nullptr, name)), m_opaque_ptr(nullptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const char *), name);
+
   m_opaque_ptr = m_opaque_sp.get();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOGV(log, "(name=\"{0}\") => SBBroadcaster({1})", name, m_opaque_ptr);
 }
 
 SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
-    : m_opaque_sp(owns ? broadcaster : NULL), m_opaque_ptr(broadcaster) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOGV(log, "(broadcaster={0}, owns={1}) => SBBroadcaster({2})",
-            broadcaster, owns, m_opaque_ptr);
-}
+    : m_opaque_sp(owns ? broadcaster : nullptr), m_opaque_ptr(broadcaster) {}
 
 SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {}
+    : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &), rhs);
+}
 
 const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBBroadcaster &,
+                     SBBroadcaster, operator=,(const lldb::SBBroadcaster &),
+                     rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
     m_opaque_ptr = rhs.m_opaque_ptr;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
-SBBroadcaster::~SBBroadcaster() { reset(NULL, false); }
+SBBroadcaster::~SBBroadcaster() { reset(nullptr, false); }
 
 void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBBroadcaster(%p)::BroadcastEventByType (event_type=0x%8.8x, "
-                "unique=%i)",
-                static_cast<void *>(m_opaque_ptr), event_type, unique);
+  LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType,
+                     (uint32_t, bool), event_type, unique);
 
-  if (m_opaque_ptr == NULL)
+  if (m_opaque_ptr == nullptr)
     return;
 
   if (unique)
@@ -64,15 +63,10 @@ void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
 }
 
 void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent,
+                     (const lldb::SBEvent &, bool), event, unique);
 
-  if (log)
-    log->Printf(
-        "SBBroadcaster(%p)::BroadcastEventByType (SBEvent(%p), unique=%i)",
-        static_cast<void *>(m_opaque_ptr), static_cast<void *>(event.get()),
-        unique);
-
-  if (m_opaque_ptr == NULL)
+  if (m_opaque_ptr == nullptr)
     return;
 
   EventSP event_sp = event.GetSP();
@@ -84,12 +78,10 @@ void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
 
 void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
                                                uint32_t requested_events) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBroadcaster(%p)::AddInitialEventsToListener "
-                "(SBListener(%p), event_mask=0x%8.8x)",
-                static_cast<void *>(m_opaque_ptr),
-                static_cast<void *>(listener.get()), requested_events);
+  LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
+                     (const lldb::SBListener &, uint32_t), listener,
+                     requested_events);
+
   if (m_opaque_ptr)
     m_opaque_ptr->AddInitialEventsToListener(listener.m_opaque_sp,
                                              requested_events);
@@ -97,18 +89,27 @@ void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
 
 uint32_t SBBroadcaster::AddListener(const SBListener &listener,
                                     uint32_t event_mask) {
+  LLDB_RECORD_METHOD(uint32_t, SBBroadcaster, AddListener,
+                     (const lldb::SBListener &, uint32_t), listener,
+                     event_mask);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->AddListener(listener.m_opaque_sp, event_mask);
   return 0;
 }
 
 const char *SBBroadcaster::GetName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBroadcaster, GetName);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->GetBroadcasterName().GetCString();
-  return NULL;
+  return nullptr;
 }
 
 bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
+  LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t),
+                     event_type);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->EventTypeHasListeners(event_type);
   return false;
@@ -116,6 +117,10 @@ bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
 
 bool SBBroadcaster::RemoveListener(const SBListener &listener,
                                    uint32_t event_mask) {
+  LLDB_RECORD_METHOD(bool, SBBroadcaster, RemoveListener,
+                     (const lldb::SBListener &, uint32_t), listener,
+                     event_mask);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask);
   return false;
@@ -131,21 +136,78 @@ void SBBroadcaster::reset(Broadcaster *broadcaster, bool owns) {
   m_opaque_ptr = broadcaster;
 }
 
-bool SBBroadcaster::IsValid() const { return m_opaque_ptr != NULL; }
+bool SBBroadcaster::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid);
+  return this->operator bool();
+}
+SBBroadcaster::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, operator bool);
+
+  return m_opaque_ptr != nullptr;
+}
 
 void SBBroadcaster::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear);
+
   m_opaque_sp.reset();
-  m_opaque_ptr = NULL;
+  m_opaque_ptr = nullptr;
 }
 
 bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const {
+  LLDB_RECORD_METHOD_CONST(
+      bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &), rhs);
+
   return m_opaque_ptr == rhs.m_opaque_ptr;
 }
 
 bool SBBroadcaster::operator!=(const SBBroadcaster &rhs) const {
+  LLDB_RECORD_METHOD_CONST(
+      bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &), rhs);
+
   return m_opaque_ptr != rhs.m_opaque_ptr;
 }
 
 bool SBBroadcaster::operator<(const SBBroadcaster &rhs) const {
+  LLDB_RECORD_METHOD_CONST(
+      bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &), rhs);
+
   return m_opaque_ptr < rhs.m_opaque_ptr;
 }
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBBroadcaster>(Registry &R) {
+  LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, ());
+  LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const char *));
+  LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &));
+  LLDB_REGISTER_METHOD(
+      const lldb::SBBroadcaster &,
+      SBBroadcaster, operator=,(const lldb::SBBroadcaster &));
+  LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEventByType,
+                       (uint32_t, bool));
+  LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEvent,
+                       (const lldb::SBEvent &, bool));
+  LLDB_REGISTER_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
+                       (const lldb::SBListener &, uint32_t));
+  LLDB_REGISTER_METHOD(uint32_t, SBBroadcaster, AddListener,
+                       (const lldb::SBListener &, uint32_t));
+  LLDB_REGISTER_METHOD_CONST(const char *, SBBroadcaster, GetName, ());
+  LLDB_REGISTER_METHOD(bool, SBBroadcaster, EventTypeHasListeners,
+                       (uint32_t));
+  LLDB_REGISTER_METHOD(bool, SBBroadcaster, RemoveListener,
+                       (const lldb::SBListener &, uint32_t));
+  LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, IsValid, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, operator bool, ());
+  LLDB_REGISTER_METHOD(void, SBBroadcaster, Clear, ());
+  LLDB_REGISTER_METHOD_CONST(
+      bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &));
+  LLDB_REGISTER_METHOD_CONST(
+      bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &));
+  LLDB_REGISTER_METHOD_CONST(
+      bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &));
+}
+
+}
+}