1 files changed, 103 insertions, 64 deletions

diff --git a/source/API/SBError.cpp b/source/API/SBError.cpp
index 04433bb1aab0..7256e8e55de9 100644
--- a/source/API/SBError.cpp
+++ b/source/API/SBError.cpp
@@ -1,15 +1,15 @@
 //===-- SBError.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/SBError.h"
+#include "SBReproducerPrivate.h"
+#include "Utils.h"
 #include "lldb/API/SBStream.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 
 #include <stdarg.h>
@@ -17,157 +17,196 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBError::SBError() : m_opaque_ap() {}
+SBError::SBError() : m_opaque_up() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBError); }
+
+SBError::SBError(const SBError &rhs) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBError, (const lldb::SBError &), rhs);
 
-SBError::SBError(const SBError &rhs) : m_opaque_ap() {
-  if (rhs.IsValid())
-    m_opaque_ap.reset(new Status(*rhs));
+  m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 SBError::~SBError() {}
 
 const SBError &SBError::operator=(const SBError &rhs) {
-  if (rhs.IsValid()) {
-    if (m_opaque_ap)
-      *m_opaque_ap = *rhs;
-    else
-      m_opaque_ap.reset(new Status(*rhs));
-  } else
-    m_opaque_ap.reset();
+  LLDB_RECORD_METHOD(const lldb::SBError &,
+                     SBError, operator=,(const lldb::SBError &), rhs);
 
-  return *this;
+  if (this != &rhs)
+    m_opaque_up = clone(rhs.m_opaque_up);
+  return LLDB_RECORD_RESULT(*this);
 }
 
 const char *SBError::GetCString() const {
-  if (m_opaque_ap)
-    return m_opaque_ap->AsCString();
-  return NULL;
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBError, GetCString);
+
+  if (m_opaque_up)
+    return m_opaque_up->AsCString();
+  return nullptr;
 }
 
 void SBError::Clear() {
-  if (m_opaque_ap)
-    m_opaque_ap->Clear();
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBError, Clear);
+
+  if (m_opaque_up)
+    m_opaque_up->Clear();
 }
 
 bool SBError::Fail() const {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Fail);
 
   bool ret_value = false;
-  if (m_opaque_ap)
-    ret_value = m_opaque_ap->Fail();
+  if (m_opaque_up)
+    ret_value = m_opaque_up->Fail();
 
-  if (log)
-    log->Printf("SBError(%p)::Fail () => %i",
-                static_cast<void *>(m_opaque_ap.get()), ret_value);
 
   return ret_value;
 }
 
 bool SBError::Success() const {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  bool ret_value = true;
-  if (m_opaque_ap)
-    ret_value = m_opaque_ap->Success();
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Success);
 
-  if (log)
-    log->Printf("SBError(%p)::Success () => %i",
-                static_cast<void *>(m_opaque_ap.get()), ret_value);
+  bool ret_value = true;
+  if (m_opaque_up)
+    ret_value = m_opaque_up->Success();
 
   return ret_value;
 }
 
 uint32_t SBError::GetError() const {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBError, GetError);
+
 
   uint32_t err = 0;
-  if (m_opaque_ap)
-    err = m_opaque_ap->GetError();
+  if (m_opaque_up)
+    err = m_opaque_up->GetError();
 
-  if (log)
-    log->Printf("SBError(%p)::GetError () => 0x%8.8x",
-                static_cast<void *>(m_opaque_ap.get()), err);
 
   return err;
 }
 
 ErrorType SBError::GetType() const {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  ErrorType err_type = eErrorTypeInvalid;
-  if (m_opaque_ap)
-    err_type = m_opaque_ap->GetType();
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType);
 
-  if (log)
-    log->Printf("SBError(%p)::GetType () => %i",
-                static_cast<void *>(m_opaque_ap.get()), err_type);
+  ErrorType err_type = eErrorTypeInvalid;
+  if (m_opaque_up)
+    err_type = m_opaque_up->GetType();
 
   return err_type;
 }
 
 void SBError::SetError(uint32_t err, ErrorType type) {
+  LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err,
+                     type);
+
   CreateIfNeeded();
-  m_opaque_ap->SetError(err, type);
+  m_opaque_up->SetError(err, type);
 }
 
 void SBError::SetError(const Status &lldb_error) {
   CreateIfNeeded();
-  *m_opaque_ap = lldb_error;
+  *m_opaque_up = lldb_error;
 }
 
 void SBError::SetErrorToErrno() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToErrno);
+
   CreateIfNeeded();
-  m_opaque_ap->SetErrorToErrno();
+  m_opaque_up->SetErrorToErrno();
 }
 
 void SBError::SetErrorToGenericError() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToGenericError);
+
   CreateIfNeeded();
-  m_opaque_ap->SetErrorToErrno();
+  m_opaque_up->SetErrorToErrno();
 }
 
 void SBError::SetErrorString(const char *err_str) {
+  LLDB_RECORD_METHOD(void, SBError, SetErrorString, (const char *), err_str);
+
   CreateIfNeeded();
-  m_opaque_ap->SetErrorString(err_str);
+  m_opaque_up->SetErrorString(err_str);
 }
 
 int SBError::SetErrorStringWithFormat(const char *format, ...) {
   CreateIfNeeded();
   va_list args;
   va_start(args, format);
-  int num_chars = m_opaque_ap->SetErrorStringWithVarArg(format, args);
+  int num_chars = m_opaque_up->SetErrorStringWithVarArg(format, args);
   va_end(args);
   return num_chars;
 }
 
-bool SBError::IsValid() const { return m_opaque_ap != NULL; }
+bool SBError::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, IsValid);
+  return this->operator bool();
+}
+SBError::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, operator bool);
+
+  return m_opaque_up != nullptr;
+}
 
 void SBError::CreateIfNeeded() {
-  if (m_opaque_ap == NULL)
-    m_opaque_ap.reset(new Status());
+  if (m_opaque_up == nullptr)
+    m_opaque_up.reset(new Status());
 }
 
-lldb_private::Status *SBError::operator->() { return m_opaque_ap.get(); }
+lldb_private::Status *SBError::operator->() { return m_opaque_up.get(); }
 
-lldb_private::Status *SBError::get() { return m_opaque_ap.get(); }
+lldb_private::Status *SBError::get() { return m_opaque_up.get(); }
 
 lldb_private::Status &SBError::ref() {
   CreateIfNeeded();
-  return *m_opaque_ap;
+  return *m_opaque_up;
 }
 
 const lldb_private::Status &SBError::operator*() const {
   // Be sure to call "IsValid()" before calling this function or it will crash
-  return *m_opaque_ap;
+  return *m_opaque_up;
 }
 
 bool SBError::GetDescription(SBStream &description) {
-  if (m_opaque_ap) {
-    if (m_opaque_ap->Success())
+  LLDB_RECORD_METHOD(bool, SBError, GetDescription, (lldb::SBStream &),
+                     description);
+
+  if (m_opaque_up) {
+    if (m_opaque_up->Success())
       description.Printf("success");
     else {
       const char *err_string = GetCString();
-      description.Printf("error: %s", (err_string != NULL ? err_string : ""));
+      description.Printf("error: %s",
+                         (err_string != nullptr ? err_string : ""));
     }
   } else
     description.Printf("error: <NULL>");
 
   return true;
 }
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBError>(Registry &R) {
+  LLDB_REGISTER_CONSTRUCTOR(SBError, ());
+  LLDB_REGISTER_CONSTRUCTOR(SBError, (const lldb::SBError &));
+  LLDB_REGISTER_METHOD(const lldb::SBError &,
+                       SBError, operator=,(const lldb::SBError &));
+  LLDB_REGISTER_METHOD_CONST(const char *, SBError, GetCString, ());
+  LLDB_REGISTER_METHOD(void, SBError, Clear, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBError, Fail, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBError, Success, ());
+  LLDB_REGISTER_METHOD_CONST(uint32_t, SBError, GetError, ());
+  LLDB_REGISTER_METHOD_CONST(lldb::ErrorType, SBError, GetType, ());
+  LLDB_REGISTER_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType));
+  LLDB_REGISTER_METHOD(void, SBError, SetErrorToErrno, ());
+  LLDB_REGISTER_METHOD(void, SBError, SetErrorToGenericError, ());
+  LLDB_REGISTER_METHOD(void, SBError, SetErrorString, (const char *));
+  LLDB_REGISTER_METHOD_CONST(bool, SBError, IsValid, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBError, operator bool, ());
+  LLDB_REGISTER_METHOD(bool, SBError, GetDescription, (lldb::SBStream &));
+}
+
+}
+}