1 files changed, 96 insertions, 74 deletions

diff --git a/source/API/SBValueList.cpp b/source/API/SBValueList.cpp
index 82b464bab9b9..7e909df260d7 100644
--- a/source/API/SBValueList.cpp
+++ b/source/API/SBValueList.cpp
@@ -1,17 +1,16 @@
 //===-- SBValueList.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/SBValueList.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/Core/ValueObjectList.h"
-#include "lldb/Utility/Log.h"
 
 #include <vector>
 
@@ -68,142 +67,165 @@ private:
   std::vector<lldb::SBValue> m_values;
 };
 
-SBValueList::SBValueList() : m_opaque_ap() {}
+SBValueList::SBValueList() : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValueList);
+}
 
-SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_ap() {
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &), rhs);
 
   if (rhs.IsValid())
-    m_opaque_ap.reset(new ValueListImpl(*rhs));
-
-  if (log) {
-    log->Printf(
-        "SBValueList::SBValueList (rhs.ap=%p) => this.ap = %p",
-        static_cast<void *>(rhs.IsValid() ? rhs.m_opaque_ap.get() : NULL),
-        static_cast<void *>(m_opaque_ap.get()));
-  }
+    m_opaque_up.reset(new ValueListImpl(*rhs));
 }
 
-SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_ap() {
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
+SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() {
   if (lldb_object_ptr)
-    m_opaque_ap.reset(new ValueListImpl(*lldb_object_ptr));
-
-  if (log) {
-    log->Printf("SBValueList::SBValueList (lldb_object_ptr=%p) => this.ap = %p",
-                static_cast<const void *>(lldb_object_ptr),
-                static_cast<void *>(m_opaque_ap.get()));
-  }
+    m_opaque_up.reset(new ValueListImpl(*lldb_object_ptr));
 }
 
 SBValueList::~SBValueList() {}
 
-bool SBValueList::IsValid() const { return (m_opaque_ap != NULL); }
+bool SBValueList::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid);
+  return this->operator bool();
+}
+SBValueList::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, operator bool);
+
+  return (m_opaque_up != nullptr);
+}
 
-void SBValueList::Clear() { m_opaque_ap.reset(); }
+void SBValueList::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBValueList, Clear);
+
+  m_opaque_up.reset();
+}
 
 const SBValueList &SBValueList::operator=(const SBValueList &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBValueList &,
+                     SBValueList, operator=,(const lldb::SBValueList &), rhs);
+
   if (this != &rhs) {
     if (rhs.IsValid())
-      m_opaque_ap.reset(new ValueListImpl(*rhs));
+      m_opaque_up.reset(new ValueListImpl(*rhs));
     else
-      m_opaque_ap.reset();
+      m_opaque_up.reset();
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
-ValueListImpl *SBValueList::operator->() { return m_opaque_ap.get(); }
+ValueListImpl *SBValueList::operator->() { return m_opaque_up.get(); }
 
-ValueListImpl &SBValueList::operator*() { return *m_opaque_ap; }
+ValueListImpl &SBValueList::operator*() { return *m_opaque_up; }
 
 const ValueListImpl *SBValueList::operator->() const {
-  return m_opaque_ap.get();
+  return m_opaque_up.get();
 }
 
-const ValueListImpl &SBValueList::operator*() const { return *m_opaque_ap; }
+const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; }
 
 void SBValueList::Append(const SBValue &val_obj) {
+  LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValue &),
+                     val_obj);
+
   CreateIfNeeded();
-  m_opaque_ap->Append(val_obj);
+  m_opaque_up->Append(val_obj);
 }
 
 void SBValueList::Append(lldb::ValueObjectSP &val_obj_sp) {
   if (val_obj_sp) {
     CreateIfNeeded();
-    m_opaque_ap->Append(SBValue(val_obj_sp));
+    m_opaque_up->Append(SBValue(val_obj_sp));
   }
 }
 
 void SBValueList::Append(const lldb::SBValueList &value_list) {
+  LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &),
+                     value_list);
+
   if (value_list.IsValid()) {
     CreateIfNeeded();
-    m_opaque_ap->Append(*value_list);
+    m_opaque_up->Append(*value_list);
   }
 }
 
 SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
+                           (uint32_t), idx);
 
-  // if (log)
-  //    log->Printf ("SBValueList::GetValueAtIndex (uint32_t idx) idx = %d",
-  //    idx);
 
   SBValue sb_value;
-  if (m_opaque_ap)
-    sb_value = m_opaque_ap->GetValueAtIndex(idx);
-
-  if (log) {
-    SBStream sstr;
-    sb_value.GetDescription(sstr);
-    log->Printf("SBValueList::GetValueAtIndex (this.ap=%p, idx=%d) => SBValue "
-                "(this.sp = %p, '%s')",
-                static_cast<void *>(m_opaque_ap.get()), idx,
-                static_cast<void *>(sb_value.GetSP().get()), sstr.GetData());
-  }
+  if (m_opaque_up)
+    sb_value = m_opaque_up->GetValueAtIndex(idx);
 
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 uint32_t SBValueList::GetSize() const {
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  // if (log)
-  //    log->Printf ("SBValueList::GetSize ()");
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize);
 
   uint32_t size = 0;
-  if (m_opaque_ap)
-    size = m_opaque_ap->GetSize();
-
-  if (log)
-    log->Printf("SBValueList::GetSize (this.ap=%p) => %d",
-                static_cast<void *>(m_opaque_ap.get()), size);
+  if (m_opaque_up)
+    size = m_opaque_up->GetSize();
 
   return size;
 }
 
 void SBValueList::CreateIfNeeded() {
-  if (m_opaque_ap == NULL)
-    m_opaque_ap.reset(new ValueListImpl());
+  if (m_opaque_up == nullptr)
+    m_opaque_up.reset(new ValueListImpl());
 }
 
 SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
+                     (lldb::user_id_t), uid);
+
   SBValue sb_value;
-  if (m_opaque_ap)
-    sb_value = m_opaque_ap->FindValueByUID(uid);
-  return sb_value;
+  if (m_opaque_up)
+    sb_value = m_opaque_up->FindValueByUID(uid);
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 SBValue SBValueList::GetFirstValueByName(const char *name) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
+                           (const char *), name);
+
   SBValue sb_value;
-  if (m_opaque_ap)
-    sb_value = m_opaque_ap->GetFirstValueByName(name);
-  return sb_value;
+  if (m_opaque_up)
+    sb_value = m_opaque_up->GetFirstValueByName(name);
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
-void *SBValueList::opaque_ptr() { return m_opaque_ap.get(); }
+void *SBValueList::opaque_ptr() { return m_opaque_up.get(); }
 
 ValueListImpl &SBValueList::ref() {
   CreateIfNeeded();
-  return *m_opaque_ap;
+  return *m_opaque_up;
+}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBValueList>(Registry &R) {
+  LLDB_REGISTER_CONSTRUCTOR(SBValueList, ());
+  LLDB_REGISTER_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &));
+  LLDB_REGISTER_METHOD_CONST(bool, SBValueList, IsValid, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBValueList, operator bool, ());
+  LLDB_REGISTER_METHOD(void, SBValueList, Clear, ());
+  LLDB_REGISTER_METHOD(const lldb::SBValueList &,
+                       SBValueList, operator=,(const lldb::SBValueList &));
+  LLDB_REGISTER_METHOD(void, SBValueList, Append, (const lldb::SBValue &));
+  LLDB_REGISTER_METHOD(void, SBValueList, Append,
+                       (const lldb::SBValueList &));
+  LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
+                             (uint32_t));
+  LLDB_REGISTER_METHOD_CONST(uint32_t, SBValueList, GetSize, ());
+  LLDB_REGISTER_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
+                       (lldb::user_id_t));
+  LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
+                             (const char *));
+}
+
+}
 }