1 files changed, 52 insertions, 3 deletions

diff --git a/lldb/source/API/SBBroadcaster.cpp b/lldb/source/API/SBBroadcaster.cpp
index 2252e402671..17911dc72ee 100644
--- a/lldb/source/API/SBBroadcaster.cpp
+++ b/lldb/source/API/SBBroadcaster.cpp
@@ -6,6 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Log.h"
 
@@ -16,10 +17,14 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) {}
+SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster);
+}
 
 SBBroadcaster::SBBroadcaster(const char *name)
     : m_opaque_sp(new Broadcaster(NULL, name)), m_opaque_ptr(NULL) {
+  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);
@@ -33,9 +38,15 @@ SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
 }
 
 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;
@@ -46,6 +57,9 @@ const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
 SBBroadcaster::~SBBroadcaster() { reset(NULL, false); }
 
 void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
+  LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType,
+                     (uint32_t, bool), event_type, unique);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
@@ -63,6 +77,9 @@ void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
 }
 
 void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
+  LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent,
+                     (const lldb::SBEvent &, bool), event, unique);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
@@ -83,6 +100,10 @@ void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
 
 void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
                                                uint32_t requested_events) {
+  LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
+                     (const lldb::SBListener &, uint32_t), listener,
+                     requested_events);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBBroadcaster(%p)::AddInitialEventsToListener "
@@ -96,18 +117,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;
 }
 
 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;
@@ -115,6 +145,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;
@@ -130,21 +164,36 @@ 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 m_opaque_ptr != NULL;
+}
 
 void SBBroadcaster::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear);
+
   m_opaque_sp.reset();
   m_opaque_ptr = NULL;
 }
 
 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;
 }