1 files changed, 89 insertions, 129 deletions

diff --git a/source/API/SBCommunication.cpp b/source/API/SBCommunication.cpp
index 63b672efe3c0..90df70bde72f 100644
--- a/source/API/SBCommunication.cpp
+++ b/source/API/SBCommunication.cpp
@@ -1,65 +1,77 @@
 //===-- SBCommunication.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 "lldb/API/SBCommunication.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
-#include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) {}
+SBCommunication::SBCommunication() : m_opaque(nullptr), m_opaque_owned(false) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommunication);
+}
 
 SBCommunication::SBCommunication(const char *broadcaster_name)
     : m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBCommunication::SBCommunication (broadcaster_name=\"%s\") => "
-                "SBCommunication(%p)",
-                broadcaster_name, static_cast<void *>(m_opaque));
+  LLDB_RECORD_CONSTRUCTOR(SBCommunication, (const char *), broadcaster_name);
 }
 
 SBCommunication::~SBCommunication() {
   if (m_opaque && m_opaque_owned)
     delete m_opaque;
-  m_opaque = NULL;
+  m_opaque = nullptr;
   m_opaque_owned = false;
 }
 
-bool SBCommunication::IsValid() const { return m_opaque != NULL; }
+bool SBCommunication::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid);
+  return this->operator bool();
+}
+SBCommunication::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, operator bool);
+
+  return m_opaque != nullptr;
+}
 
 bool SBCommunication::GetCloseOnEOF() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, GetCloseOnEOF);
+
   if (m_opaque)
     return m_opaque->GetCloseOnEOF();
   return false;
 }
 
 void SBCommunication::SetCloseOnEOF(bool b) {
+  LLDB_RECORD_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b);
+
   if (m_opaque)
     m_opaque->SetCloseOnEOF(b);
 }
 
 ConnectionStatus SBCommunication::Connect(const char *url) {
+  LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
+                     (const char *), url);
+
   if (m_opaque) {
     if (!m_opaque->HasConnection())
       m_opaque->SetConnection(Host::CreateDefaultConnection(url).release());
-    return m_opaque->Connect(url, NULL);
+    return m_opaque->Connect(url, nullptr);
   }
   return eConnectionStatusNoConnection;
 }
 
 ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication,
+                     AdoptFileDesriptor, (int, bool), fd, owns_fd);
 
   ConnectionStatus status = eConnectionStatusNoConnection;
   if (m_opaque) {
@@ -73,183 +85,131 @@ ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
     else
       status = eConnectionStatusLostConnection;
   }
-
-  if (log)
-    log->Printf(
-        "SBCommunication(%p)::AdoptFileDescriptor (fd=%d, ownd_fd=%i) => %s",
-        static_cast<void *>(m_opaque), fd, owns_fd,
-        Communication::ConnectionStatusAsCString(status));
-
   return status;
 }
 
 ConnectionStatus SBCommunication::Disconnect() {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication,
+                             Disconnect);
 
   ConnectionStatus status = eConnectionStatusNoConnection;
   if (m_opaque)
     status = m_opaque->Disconnect();
-
-  if (log)
-    log->Printf("SBCommunication(%p)::Disconnect () => %s",
-                static_cast<void *>(m_opaque),
-                Communication::ConnectionStatusAsCString(status));
-
   return status;
 }
 
 bool SBCommunication::IsConnected() const {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  bool result = false;
-  if (m_opaque)
-    result = m_opaque->IsConnected();
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected);
 
-  if (log)
-    log->Printf("SBCommunication(%p)::IsConnected () => %i",
-                static_cast<void *>(m_opaque), result);
-
-  return false;
+  return m_opaque ? m_opaque->IsConnected() : false;
 }
 
 size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
                              ConnectionStatus &status) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBCommunication(%p)::Read (dst=%p, dst_len=%" PRIu64
-                ", timeout_usec=%u, &status)...",
-                static_cast<void *>(m_opaque), static_cast<void *>(dst),
-                static_cast<uint64_t>(dst_len), timeout_usec);
+  LLDB_RECORD_DUMMY(size_t, SBCommunication, Read,
+                    (void *, size_t, uint32_t, lldb::ConnectionStatus &), dst,
+                    dst_len, timeout_usec, status);
+
   size_t bytes_read = 0;
   Timeout<std::micro> timeout = timeout_usec == UINT32_MAX
                                     ? Timeout<std::micro>(llvm::None)
                                     : std::chrono::microseconds(timeout_usec);
   if (m_opaque)
-    bytes_read = m_opaque->Read(dst, dst_len, timeout, status, NULL);
+    bytes_read = m_opaque->Read(dst, dst_len, timeout, status, nullptr);
   else
     status = eConnectionStatusNoConnection;
 
-  if (log)
-    log->Printf("SBCommunication(%p)::Read (dst=%p, dst_len=%" PRIu64
-                ", timeout_usec=%u, &status=%s) => %" PRIu64,
-                static_cast<void *>(m_opaque), static_cast<void *>(dst),
-                static_cast<uint64_t>(dst_len), timeout_usec,
-                Communication::ConnectionStatusAsCString(status),
-                static_cast<uint64_t>(bytes_read));
   return bytes_read;
 }
 
 size_t SBCommunication::Write(const void *src, size_t src_len,
                               ConnectionStatus &status) {
+  LLDB_RECORD_DUMMY(size_t, SBCommunication, Write,
+                    (const void *, size_t, lldb::ConnectionStatus &), src,
+                    src_len, status);
+
   size_t bytes_written = 0;
   if (m_opaque)
-    bytes_written = m_opaque->Write(src, src_len, status, NULL);
+    bytes_written = m_opaque->Write(src, src_len, status, nullptr);
   else
     status = eConnectionStatusNoConnection;
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBCommunication(%p)::Write (src=%p, src_len=%" PRIu64
-                ", &status=%s) => %" PRIu64,
-                static_cast<void *>(m_opaque), static_cast<const void *>(src),
-                static_cast<uint64_t>(src_len),
-                Communication::ConnectionStatusAsCString(status),
-                static_cast<uint64_t>(bytes_written));
-
-  return 0;
+  return bytes_written;
 }
 
 bool SBCommunication::ReadThreadStart() {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  bool success = false;
-  if (m_opaque)
-    success = m_opaque->StartReadThread();
-
-  if (log)
-    log->Printf("SBCommunication(%p)::ReadThreadStart () => %i",
-                static_cast<void *>(m_opaque), success);
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart);
 
-  return success;
+  return m_opaque ? m_opaque->StartReadThread() : false;
 }
 
 bool SBCommunication::ReadThreadStop() {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBCommunication(%p)::ReadThreadStop ()...",
-                static_cast<void *>(m_opaque));
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop);
 
-  bool success = false;
-  if (m_opaque)
-    success = m_opaque->StopReadThread();
-
-  if (log)
-    log->Printf("SBCommunication(%p)::ReadThreadStop () => %i",
-                static_cast<void *>(m_opaque), success);
-
-  return success;
+  return m_opaque ? m_opaque->StopReadThread() : false;
 }
 
 bool SBCommunication::ReadThreadIsRunning() {
-  bool result = false;
-  if (m_opaque)
-    result = m_opaque->ReadThreadIsRunning();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBCommunication(%p)::ReadThreadIsRunning () => %i",
-                static_cast<void *>(m_opaque), result);
-  return result;
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning);
+
+  return m_opaque ? m_opaque->ReadThreadIsRunning() : false;
 }
 
 bool SBCommunication::SetReadThreadBytesReceivedCallback(
     ReadThreadBytesReceived callback, void *callback_baton) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_DUMMY(bool, SBCommunication, SetReadThreadBytesReceivedCallback,
+                    (lldb::SBCommunication::ReadThreadBytesReceived, void *),
+                    callback, callback_baton);
 
   bool result = false;
   if (m_opaque) {
     m_opaque->SetReadThreadBytesReceivedCallback(callback, callback_baton);
     result = true;
   }
-
-  if (log)
-    log->Printf("SBCommunication(%p)::SetReadThreadBytesReceivedCallback "
-                "(callback=%p, baton=%p) => %i",
-                static_cast<void *>(m_opaque),
-                reinterpret_cast<void *>(reinterpret_cast<intptr_t>(callback)),
-                static_cast<void *>(callback_baton), result);
-
   return result;
 }
 
 SBBroadcaster SBCommunication::GetBroadcaster() {
-  SBBroadcaster broadcaster(m_opaque, false);
-
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication,
+                             GetBroadcaster);
 
-  if (log)
-    log->Printf("SBCommunication(%p)::GetBroadcaster () => SBBroadcaster (%p)",
-                static_cast<void *>(m_opaque),
-                static_cast<void *>(broadcaster.get()));
-
-  return broadcaster;
+  SBBroadcaster broadcaster(m_opaque, false);
+  return LLDB_RECORD_RESULT(broadcaster);
 }
 
 const char *SBCommunication::GetBroadcasterClass() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommunication,
+                                    GetBroadcasterClass);
+
   return Communication::GetStaticBroadcasterClass().AsCString();
 }
 
-//
-// void
-// SBCommunication::CreateIfNeeded ()
-//{
-//    if (m_opaque == NULL)
-//    {
-//        static uint32_t g_broadcaster_num;
-//        char broadcaster_name[256];
-//        ::snprintf (name, broadcaster_name, "%p SBCommunication", this);
-//        m_opaque = new Communication (broadcaster_name);
-//        m_opaque_owned = true;
-//    }
-//    assert (m_opaque);
-//}
-//
-//
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBCommunication>(Registry &R) {
+  LLDB_REGISTER_CONSTRUCTOR(SBCommunication, ());
+  LLDB_REGISTER_CONSTRUCTOR(SBCommunication, (const char *));
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsValid, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, operator bool, ());
+  LLDB_REGISTER_METHOD(bool, SBCommunication, GetCloseOnEOF, ());
+  LLDB_REGISTER_METHOD(void, SBCommunication, SetCloseOnEOF, (bool));
+  LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
+                       (const char *));
+  LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication,
+                       AdoptFileDesriptor, (int, bool));
+  LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Disconnect,
+                       ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsConnected, ());
+  LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStart, ());
+  LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStop, ());
+  LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadIsRunning, ());
+  LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommunication, GetBroadcaster,
+                       ());
+  LLDB_REGISTER_STATIC_METHOD(const char *, SBCommunication,
+                              GetBroadcasterClass, ());
+}
+
+}
+}