vendor/llvm-project/llvmorg-14-init-17616-g024a1fab5c35

1 files changed, 139 insertions, 313 deletions

diff --git a/lldb/source/API/SBValue.cpp b/lldb/source/API/SBValue.cpp
index e3325b8d36fa..20581cfabdd6 100644
--- a/lldb/source/API/SBValue.cpp
+++ b/lldb/source/API/SBValue.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBValue.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBDeclaration.h"
 #include "lldb/API/SBStream.h"
@@ -58,8 +58,8 @@ public:
   ValueImpl(lldb::ValueObjectSP in_valobj_sp,
             lldb::DynamicValueType use_dynamic, bool use_synthetic,
             const char *name = nullptr)
-      : m_valobj_sp(), m_use_dynamic(use_dynamic),
-        m_use_synthetic(use_synthetic), m_name(name) {
+      : m_use_dynamic(use_dynamic), m_use_synthetic(use_synthetic),
+        m_name(name) {
     if (in_valobj_sp) {
       if ((m_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable(
                lldb::eNoDynamicValues, false))) {
@@ -215,38 +215,37 @@ private:
   Status m_lock_error;
 };
 
-SBValue::SBValue() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValue); }
+SBValue::SBValue() { LLDB_INSTRUMENT_VA(this); }
 
 SBValue::SBValue(const lldb::ValueObjectSP &value_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &), value_sp);
+  LLDB_INSTRUMENT_VA(this, value_sp);
 
   SetSP(value_sp);
 }
 
 SBValue::SBValue(const SBValue &rhs) {
-  LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::SBValue &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   SetSP(rhs.m_opaque_sp);
 }
 
 SBValue &SBValue::operator=(const SBValue &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBValue &,
-                     SBValue, operator=,(const lldb::SBValue &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     SetSP(rhs.m_opaque_sp);
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBValue::~SBValue() = default;
 
 bool SBValue::IsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBValue::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValue, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   // If this function ever changes to anything that does more than just check
   // if the opaque shared pointer is non NULL, then we need to update all "if
@@ -256,13 +255,13 @@ SBValue::operator bool() const {
 }
 
 void SBValue::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBValue, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_sp.reset();
 }
 
 SBError SBValue::GetError() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBValue, GetError);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError sb_error;
 
@@ -274,11 +273,11 @@ SBError SBValue::GetError() {
     sb_error.SetErrorStringWithFormat("error: %s",
                                       locker.GetError().AsCString());
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 user_id_t SBValue::GetID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBValue, GetID);
+  LLDB_INSTRUMENT_VA(this);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -288,7 +287,7 @@ user_id_t SBValue::GetID() {
 }
 
 const char *SBValue::GetName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
   ValueLocker locker;
@@ -300,7 +299,7 @@ const char *SBValue::GetName() {
 }
 
 const char *SBValue::GetTypeName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
   ValueLocker locker;
@@ -313,7 +312,7 @@ const char *SBValue::GetTypeName() {
 }
 
 const char *SBValue::GetDisplayTypeName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
   ValueLocker locker;
@@ -326,7 +325,7 @@ const char *SBValue::GetDisplayTypeName() {
 }
 
 size_t SBValue::GetByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   size_t result = 0;
 
@@ -340,7 +339,7 @@ size_t SBValue::GetByteSize() {
 }
 
 bool SBValue::IsInScope() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope);
+  LLDB_INSTRUMENT_VA(this);
 
   bool result = false;
 
@@ -354,7 +353,7 @@ bool SBValue::IsInScope() {
 }
 
 const char *SBValue::GetValue() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetValue);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *cstr = nullptr;
   ValueLocker locker;
@@ -367,7 +366,7 @@ const char *SBValue::GetValue() {
 }
 
 ValueType SBValue::GetValueType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType);
+  LLDB_INSTRUMENT_VA(this);
 
   ValueType result = eValueTypeInvalid;
   ValueLocker locker;
@@ -379,7 +378,7 @@ ValueType SBValue::GetValueType() {
 }
 
 const char *SBValue::GetObjectDescription() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *cstr = nullptr;
   ValueLocker locker;
@@ -392,7 +391,7 @@ const char *SBValue::GetObjectDescription() {
 }
 
 SBType SBValue::GetType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType);
+  LLDB_INSTRUMENT_VA(this);
 
   SBType sb_type;
   ValueLocker locker;
@@ -403,11 +402,11 @@ SBType SBValue::GetType() {
     sb_type.SetSP(type_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_type);
+  return sb_type;
 }
 
 bool SBValue::GetValueDidChange() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange);
+  LLDB_INSTRUMENT_VA(this);
 
   bool result = false;
   ValueLocker locker;
@@ -421,7 +420,7 @@ bool SBValue::GetValueDidChange() {
 }
 
 const char *SBValue::GetSummary() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetSummary);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *cstr = nullptr;
   ValueLocker locker;
@@ -435,9 +434,7 @@ const char *SBValue::GetSummary() {
 
 const char *SBValue::GetSummary(lldb::SBStream &stream,
                                 lldb::SBTypeSummaryOptions &options) {
-  LLDB_RECORD_METHOD(const char *, SBValue, GetSummary,
-                     (lldb::SBStream &, lldb::SBTypeSummaryOptions &), stream,
-                     options);
+  LLDB_INSTRUMENT_VA(this, stream, options);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -451,7 +448,7 @@ const char *SBValue::GetSummary(lldb::SBStream &stream,
 }
 
 const char *SBValue::GetLocation() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetLocation);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *cstr = nullptr;
   ValueLocker locker;
@@ -464,16 +461,14 @@ const char *SBValue::GetLocation() {
 
 // Deprecated - use the one that takes an lldb::SBError
 bool SBValue::SetValueFromCString(const char *value_str) {
-  LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, (const char *),
-                     value_str);
+  LLDB_INSTRUMENT_VA(this, value_str);
 
   lldb::SBError dummy;
   return SetValueFromCString(value_str, dummy);
 }
 
 bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
-  LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString,
-                     (const char *, lldb::SBError &), value_str, error);
+  LLDB_INSTRUMENT_VA(this, value_str, error);
 
   bool success = false;
   ValueLocker locker;
@@ -488,7 +483,7 @@ bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
 }
 
 lldb::SBTypeFormat SBValue::GetTypeFormat() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBTypeFormat format;
   ValueLocker locker;
@@ -500,11 +495,11 @@ lldb::SBTypeFormat SBValue::GetTypeFormat() {
         format.SetSP(format_sp);
     }
   }
-  return LLDB_RECORD_RESULT(format);
+  return format;
 }
 
 lldb::SBTypeSummary SBValue::GetTypeSummary() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSummary, SBValue, GetTypeSummary);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBTypeSummary summary;
   ValueLocker locker;
@@ -516,11 +511,11 @@ lldb::SBTypeSummary SBValue::GetTypeSummary() {
         summary.SetSP(summary_sp);
     }
   }
-  return LLDB_RECORD_RESULT(summary);
+  return summary;
 }
 
 lldb::SBTypeFilter SBValue::GetTypeFilter() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFilter, SBValue, GetTypeFilter);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBTypeFilter filter;
   ValueLocker locker;
@@ -536,11 +531,11 @@ lldb::SBTypeFilter SBValue::GetTypeFilter() {
       }
     }
   }
-  return LLDB_RECORD_RESULT(filter);
+  return filter;
 }
 
 lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBTypeSynthetic synthetic;
   ValueLocker locker;
@@ -556,14 +551,12 @@ lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
       }
     }
   }
-  return LLDB_RECORD_RESULT(synthetic);
+  return synthetic;
 }
 
 lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
                                            SBType type) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset,
-                     (const char *, uint32_t, lldb::SBType), name, offset,
-                     type);
+  LLDB_INSTRUMENT_VA(this, name, offset, type);
 
   lldb::SBValue sb_value;
   ValueLocker locker;
@@ -577,11 +570,11 @@ lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
                      GetPreferDynamicValue(), GetPreferSyntheticValue(), name);
     }
   }
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 lldb::SBValue SBValue::Cast(SBType type) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type);
+  LLDB_INSTRUMENT_VA(this, type);
 
   lldb::SBValue sb_value;
   ValueLocker locker;
@@ -590,26 +583,22 @@ lldb::SBValue SBValue::Cast(SBType type) {
   if (value_sp && type_sp)
     sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)),
                    GetPreferDynamicValue(), GetPreferSyntheticValue());
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
                                                  const char *expression) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
-                     (const char *, const char *), name, expression);
+  LLDB_INSTRUMENT_VA(this, name, expression);
 
   SBExpressionOptions options;
   options.ref().SetKeepInMemory(true);
-  return LLDB_RECORD_RESULT(
-      CreateValueFromExpression(name, expression, options));
+  return CreateValueFromExpression(name, expression, options);
 }
 
 lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
                                                  const char *expression,
                                                  SBExpressionOptions &options) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
-                     (const char *, const char *, lldb::SBExpressionOptions &),
-                     name, expression, options);
+  LLDB_INSTRUMENT_VA(this, name, expression, options);
 
   lldb::SBValue sb_value;
   ValueLocker locker;
@@ -623,15 +612,13 @@ lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
       new_value_sp->SetName(ConstString(name));
   }
   sb_value.SetSP(new_value_sp);
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
                                               lldb::addr_t address,
                                               SBType sb_type) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress,
-                     (const char *, lldb::addr_t, lldb::SBType), name, address,
-                     sb_type);
+  LLDB_INSTRUMENT_VA(this, name, address, sb_type);
 
   lldb::SBValue sb_value;
   ValueLocker locker;
@@ -645,14 +632,12 @@ lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
                                                              exe_ctx, ast_type);
   }
   sb_value.SetSP(new_value_sp);
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
                                            SBType sb_type) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromData,
-                     (const char *, lldb::SBData, lldb::SBType), name, data,
-                     sb_type);
+  LLDB_INSTRUMENT_VA(this, name, data, sb_type);
 
   lldb::SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
@@ -666,11 +651,11 @@ lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
     new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
   }
   sb_value.SetSP(new_value_sp);
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 SBValue SBValue::GetChildAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   const bool can_create_synthetic = false;
   lldb::DynamicValueType use_dynamic = eNoDynamicValues;
@@ -681,16 +666,13 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx) {
   if (target_sp)
     use_dynamic = target_sp->GetPreferDynamicValue();
 
-  return LLDB_RECORD_RESULT(
-      GetChildAtIndex(idx, use_dynamic, can_create_synthetic));
+  return GetChildAtIndex(idx, use_dynamic, can_create_synthetic);
 }
 
 SBValue SBValue::GetChildAtIndex(uint32_t idx,
                                  lldb::DynamicValueType use_dynamic,
                                  bool can_create_synthetic) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex,
-                     (uint32_t, lldb::DynamicValueType, bool), idx, use_dynamic,
-                     can_create_synthetic);
+  LLDB_INSTRUMENT_VA(this, idx, use_dynamic, can_create_synthetic);
 
   lldb::ValueObjectSP child_sp;
 
@@ -707,12 +689,11 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx,
   SBValue sb_value;
   sb_value.SetSP(child_sp, use_dynamic, GetPreferSyntheticValue());
 
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
-  LLDB_RECORD_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, (const char *),
-                     name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   uint32_t idx = UINT32_MAX;
   ValueLocker locker;
@@ -724,8 +705,7 @@ uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
 }
 
 SBValue SBValue::GetChildMemberWithName(const char *name) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
-                     (const char *), name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
   TargetSP target_sp;
@@ -734,15 +714,13 @@ SBValue SBValue::GetChildMemberWithName(const char *name) {
 
   if (target_sp)
     use_dynamic_value = target_sp->GetPreferDynamicValue();
-  return LLDB_RECORD_RESULT(GetChildMemberWithName(name, use_dynamic_value));
+  return GetChildMemberWithName(name, use_dynamic_value);
 }
 
 SBValue
 SBValue::GetChildMemberWithName(const char *name,
                                 lldb::DynamicValueType use_dynamic_value) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
-                     (const char *, lldb::DynamicValueType), name,
-                     use_dynamic_value);
+  LLDB_INSTRUMENT_VA(this, name, use_dynamic_value);
 
   lldb::ValueObjectSP child_sp;
   const ConstString str_name(name);
@@ -756,12 +734,11 @@ SBValue::GetChildMemberWithName(const char *name,
   SBValue sb_value;
   sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue());
 
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
-                     (lldb::DynamicValueType), use_dynamic);
+  LLDB_INSTRUMENT_VA(this, use_dynamic);
 
   SBValue value_sb;
   if (IsValid()) {
@@ -769,11 +746,11 @@ lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
                                        m_opaque_sp->GetUseSynthetic()));
     value_sb.SetSP(proxy_sp);
   }
-  return LLDB_RECORD_RESULT(value_sb);
+  return value_sb;
 }
 
 lldb::SBValue SBValue::GetStaticValue() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetStaticValue);
+  LLDB_INSTRUMENT_VA(this);
 
   SBValue value_sb;
   if (IsValid()) {
@@ -782,11 +759,11 @@ lldb::SBValue SBValue::GetStaticValue() {
                                        m_opaque_sp->GetUseSynthetic()));
     value_sb.SetSP(proxy_sp);
   }
-  return LLDB_RECORD_RESULT(value_sb);
+  return value_sb;
 }
 
 lldb::SBValue SBValue::GetNonSyntheticValue() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetNonSyntheticValue);
+  LLDB_INSTRUMENT_VA(this);
 
   SBValue value_sb;
   if (IsValid()) {
@@ -794,12 +771,11 @@ lldb::SBValue SBValue::GetNonSyntheticValue() {
                                        m_opaque_sp->GetUseDynamic(), false));
     value_sb.SetSP(proxy_sp);
   }
-  return LLDB_RECORD_RESULT(value_sb);
+  return value_sb;
 }
 
 lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::DynamicValueType, SBValue,
-                             GetPreferDynamicValue);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return eNoDynamicValues;
@@ -807,15 +783,14 @@ lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
 }
 
 void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) {
-  LLDB_RECORD_METHOD(void, SBValue, SetPreferDynamicValue,
-                     (lldb::DynamicValueType), use_dynamic);
+  LLDB_INSTRUMENT_VA(this, use_dynamic);
 
   if (IsValid())
     return m_opaque_sp->SetUseDynamic(use_dynamic);
 }
 
 bool SBValue::GetPreferSyntheticValue() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetPreferSyntheticValue);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -823,15 +798,14 @@ bool SBValue::GetPreferSyntheticValue() {
 }
 
 void SBValue::SetPreferSyntheticValue(bool use_synthetic) {
-  LLDB_RECORD_METHOD(void, SBValue, SetPreferSyntheticValue, (bool),
-                     use_synthetic);
+  LLDB_INSTRUMENT_VA(this, use_synthetic);
 
   if (IsValid())
     return m_opaque_sp->SetUseSynthetic(use_synthetic);
 }
 
 bool SBValue::IsDynamic() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsDynamic);
+  LLDB_INSTRUMENT_VA(this);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -841,7 +815,7 @@ bool SBValue::IsDynamic() {
 }
 
 bool SBValue::IsSynthetic() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic);
+  LLDB_INSTRUMENT_VA(this);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -851,7 +825,7 @@ bool SBValue::IsSynthetic() {
 }
 
 bool SBValue::IsSyntheticChildrenGenerated() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated);
+  LLDB_INSTRUMENT_VA(this);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -861,7 +835,7 @@ bool SBValue::IsSyntheticChildrenGenerated() {
 }
 
 void SBValue::SetSyntheticChildrenGenerated(bool is) {
-  LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is);
+  LLDB_INSTRUMENT_VA(this, is);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -870,8 +844,7 @@ void SBValue::SetSyntheticChildrenGenerated(bool is) {
 }
 
 lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
-                     (const char *), expr_path);
+  LLDB_INSTRUMENT_VA(this, expr_path);
 
   lldb::ValueObjectSP child_sp;
   ValueLocker locker;
@@ -884,12 +857,11 @@ lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
   SBValue sb_value;
   sb_value.SetSP(child_sp, GetPreferDynamicValue(), GetPreferSyntheticValue());
 
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
-  LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned,
-                     (lldb::SBError &, int64_t), error, fail_value);
+  LLDB_INSTRUMENT_VA(this, error, fail_value);
 
   error.Clear();
   ValueLocker locker;
@@ -909,8 +881,7 @@ int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
 }
 
 uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
-  LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
-                     (lldb::SBError &, uint64_t), error, fail_value);
+  LLDB_INSTRUMENT_VA(this, error, fail_value);
 
   error.Clear();
   ValueLocker locker;
@@ -930,7 +901,7 @@ uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
 }
 
 int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
-  LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), fail_value);
+  LLDB_INSTRUMENT_VA(this, fail_value);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -941,8 +912,7 @@ int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
 }
 
 uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
-  LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t),
-                     fail_value);
+  LLDB_INSTRUMENT_VA(this, fail_value);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -953,7 +923,7 @@ uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
 }
 
 bool SBValue::MightHaveChildren() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren);
+  LLDB_INSTRUMENT_VA(this);
 
   bool has_children = false;
   ValueLocker locker;
@@ -965,7 +935,7 @@ bool SBValue::MightHaveChildren() {
 }
 
 bool SBValue::IsRuntimeSupportValue() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue);
+  LLDB_INSTRUMENT_VA(this);
 
   bool is_support = false;
   ValueLocker locker;
@@ -977,13 +947,13 @@ bool SBValue::IsRuntimeSupportValue() {
 }
 
 uint32_t SBValue::GetNumChildren() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBValue, GetNumChildren);
+  LLDB_INSTRUMENT_VA(this);
 
   return GetNumChildren(UINT32_MAX);
 }
 
 uint32_t SBValue::GetNumChildren(uint32_t max) {
-  LLDB_RECORD_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t), max);
+  LLDB_INSTRUMENT_VA(this, max);
 
   uint32_t num_children = 0;
 
@@ -996,7 +966,7 @@ uint32_t SBValue::GetNumChildren(uint32_t max) {
 }
 
 SBValue SBValue::Dereference() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference);
+  LLDB_INSTRUMENT_VA(this);
 
   SBValue sb_value;
   ValueLocker locker;
@@ -1006,18 +976,18 @@ SBValue SBValue::Dereference() {
     sb_value = value_sp->Dereference(error);
   }
 
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 // Deprecated - please use GetType().IsPointerType() instead.
 bool SBValue::TypeIsPointerType() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, TypeIsPointerType);
+  LLDB_INSTRUMENT_VA(this);
 
   return GetType().IsPointerType();
 }
 
 void *SBValue::GetOpaqueType() {
-  LLDB_RECORD_METHOD_NO_ARGS(void *, SBValue, GetOpaqueType);
+  LLDB_INSTRUMENT_VA(this);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1027,7 +997,7 @@ void *SBValue::GetOpaqueType() {
 }
 
 lldb::SBTarget SBValue::GetTarget() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget);
+  LLDB_INSTRUMENT_VA(this);
 
   SBTarget sb_target;
   TargetSP target_sp;
@@ -1036,11 +1006,11 @@ lldb::SBTarget SBValue::GetTarget() {
     sb_target.SetSP(target_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 lldb::SBProcess SBValue::GetProcess() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBValue, GetProcess);
+  LLDB_INSTRUMENT_VA(this);
 
   SBProcess sb_process;
   ProcessSP process_sp;
@@ -1049,11 +1019,11 @@ lldb::SBProcess SBValue::GetProcess() {
     sb_process.SetSP(process_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_process);
+  return sb_process;
 }
 
 lldb::SBThread SBValue::GetThread() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBValue, GetThread);
+  LLDB_INSTRUMENT_VA(this);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -1062,11 +1032,11 @@ lldb::SBThread SBValue::GetThread() {
     sb_thread.SetThread(thread_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 lldb::SBFrame SBValue::GetFrame() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBValue, GetFrame);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFrame sb_frame;
   StackFrameSP frame_sp;
@@ -1075,7 +1045,7 @@ lldb::SBFrame SBValue::GetFrame() {
     sb_frame.SetFrameSP(frame_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_frame);
+  return sb_frame;
 }
 
 lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {
@@ -1087,10 +1057,10 @@ lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {
 }
 
 lldb::ValueObjectSP SBValue::GetSP() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP);
+  LLDB_INSTRUMENT_VA(this);
 
   ValueLocker locker;
-  return LLDB_RECORD_RESULT(GetSP(locker));
+  return GetSP(locker);
 }
 
 void SBValue::SetSP(ValueImplSP impl_sp) { m_opaque_sp = impl_sp; }
@@ -1148,8 +1118,7 @@ void SBValue::SetSP(const lldb::ValueObjectSP &sp,
 }
 
 bool SBValue::GetExpressionPath(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1162,8 +1131,7 @@ bool SBValue::GetExpressionPath(SBStream &description) {
 
 bool SBValue::GetExpressionPath(SBStream &description,
                                 bool qualify_cxx_base_classes) {
-  LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &, bool),
-                     description, qualify_cxx_base_classes);
+  LLDB_INSTRUMENT_VA(this, description, qualify_cxx_base_classes);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1175,59 +1143,52 @@ bool SBValue::GetExpressionPath(SBStream &description,
 }
 
 lldb::SBValue SBValue::EvaluateExpression(const char *expr) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
-                           (const char *), expr);
+  LLDB_INSTRUMENT_VA(this, expr);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (!value_sp)
-    return LLDB_RECORD_RESULT(SBValue());
+    return SBValue();
 
   lldb::TargetSP target_sp = value_sp->GetTargetSP();
   if (!target_sp)
-    return LLDB_RECORD_RESULT(SBValue());
+    return SBValue();
 
   lldb::SBExpressionOptions options;
   options.SetFetchDynamicValue(target_sp->GetPreferDynamicValue());
   options.SetUnwindOnError(true);
   options.SetIgnoreBreakpoints(true);
 
-  return LLDB_RECORD_RESULT(EvaluateExpression(expr, options, nullptr));
+  return EvaluateExpression(expr, options, nullptr);
 }
 
 lldb::SBValue
 SBValue::EvaluateExpression(const char *expr,
                             const SBExpressionOptions &options) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
-                           (const char *, const lldb::SBExpressionOptions &),
-                           expr, options);
+  LLDB_INSTRUMENT_VA(this, expr, options);
 
-  return LLDB_RECORD_RESULT(EvaluateExpression(expr, options, nullptr));
+  return EvaluateExpression(expr, options, nullptr);
 }
 
 lldb::SBValue SBValue::EvaluateExpression(const char *expr,
                                           const SBExpressionOptions &options,
                                           const char *name) const {
-  LLDB_RECORD_METHOD_CONST(
-      lldb::SBValue, SBValue, EvaluateExpression,
-      (const char *, const lldb::SBExpressionOptions &, const char *), expr,
-      options, name);
-
+  LLDB_INSTRUMENT_VA(this, expr, options, name);
 
   if (!expr || expr[0] == '\0') {
-    return LLDB_RECORD_RESULT(SBValue());
+    return SBValue();
   }
 
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (!value_sp) {
-    return LLDB_RECORD_RESULT(SBValue());
+    return SBValue();
   }
 
   lldb::TargetSP target_sp = value_sp->GetTargetSP();
   if (!target_sp) {
-    return LLDB_RECORD_RESULT(SBValue());
+    return SBValue();
   }
 
   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
@@ -1235,7 +1196,7 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr,
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   if (!frame) {
-    return LLDB_RECORD_RESULT(SBValue());
+    return SBValue();
   }
 
   ValueObjectSP res_val_sp;
@@ -1247,12 +1208,11 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr,
 
   SBValue result;
   result.SetSP(res_val_sp, options.GetFetchDynamicValue());
-  return LLDB_RECORD_RESULT(result);
+  return result;
 }
 
 bool SBValue::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -1267,7 +1227,7 @@ bool SBValue::GetDescription(SBStream &description) {
 }
 
 lldb::Format SBValue::GetFormat() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat);
+  LLDB_INSTRUMENT_VA(this);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1277,7 +1237,7 @@ lldb::Format SBValue::GetFormat() {
 }
 
 void SBValue::SetFormat(lldb::Format format) {
-  LLDB_RECORD_METHOD(void, SBValue, SetFormat, (lldb::Format), format);
+  LLDB_INSTRUMENT_VA(this, format);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1286,7 +1246,7 @@ void SBValue::SetFormat(lldb::Format format) {
 }
 
 lldb::SBValue SBValue::AddressOf() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf);
+  LLDB_INSTRUMENT_VA(this);
 
   SBValue sb_value;
   ValueLocker locker;
@@ -1297,11 +1257,11 @@ lldb::SBValue SBValue::AddressOf() {
                    GetPreferSyntheticValue());
   }
 
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 lldb::addr_t SBValue::GetLoadAddress() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBValue, GetLoadAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::addr_t value = LLDB_INVALID_ADDRESS;
   ValueLocker locker;
@@ -1331,7 +1291,7 @@ lldb::addr_t SBValue::GetLoadAddress() {
 }
 
 lldb::SBAddress SBValue::GetAddress() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   Address addr;
   ValueLocker locker;
@@ -1356,12 +1316,11 @@ lldb::SBAddress SBValue::GetAddress() {
     }
   }
 
-  return LLDB_RECORD_RESULT(SBAddress(addr));
+  return SBAddress(addr);
 }
 
 lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
-  LLDB_RECORD_METHOD(lldb::SBData, SBValue, GetPointeeData,
-                     (uint32_t, uint32_t), item_idx, item_count);
+  LLDB_INSTRUMENT_VA(this, item_idx, item_count);
 
   lldb::SBData sb_data;
   ValueLocker locker;
@@ -1376,11 +1335,11 @@ lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_data);
+  return sb_data;
 }
 
 lldb::SBData SBValue::GetData() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBData sb_data;
   ValueLocker locker;
@@ -1393,12 +1352,11 @@ lldb::SBData SBValue::GetData() {
       *sb_data = data_sp;
   }
 
-  return LLDB_RECORD_RESULT(sb_data);
+  return sb_data;
 }
 
 bool SBValue::SetData(lldb::SBData &data, SBError &error) {
-  LLDB_RECORD_METHOD(bool, SBValue, SetData, (lldb::SBData &, lldb::SBError &),
-                     data, error);
+  LLDB_INSTRUMENT_VA(this, data, error);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1432,7 +1390,7 @@ bool SBValue::SetData(lldb::SBData &data, SBError &error) {
 }
 
 lldb::SBValue SBValue::Clone(const char *new_name) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Clone, (const char *), new_name);
+  LLDB_INSTRUMENT_VA(this, new_name);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1444,7 +1402,7 @@ lldb::SBValue SBValue::Clone(const char *new_name) {
 }
 
 lldb::SBDeclaration SBValue::GetDeclaration() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration);
+  LLDB_INSTRUMENT_VA(this);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1454,14 +1412,12 @@ lldb::SBDeclaration SBValue::GetDeclaration() {
     if (value_sp->GetDeclaration(decl))
       decl_sb.SetDeclaration(decl);
   }
-  return LLDB_RECORD_RESULT(decl_sb);
+  return decl_sb;
 }
 
 lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
                                   SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch,
-                     (bool, bool, bool, lldb::SBError &), resolve_location,
-                     read, write, error);
+  LLDB_INSTRUMENT_VA(this, resolve_location, read, write, error);
 
   SBWatchpoint sb_watchpoint;
 
@@ -1472,18 +1428,18 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
   if (value_sp && target_sp) {
     // Read and Write cannot both be false.
     if (!read && !write)
-      return LLDB_RECORD_RESULT(sb_watchpoint);
+      return sb_watchpoint;
 
     // If the value is not in scope, don't try and watch and invalid value
     if (!IsInScope())
-      return LLDB_RECORD_RESULT(sb_watchpoint);
+      return sb_watchpoint;
 
     addr_t addr = GetLoadAddress();
     if (addr == LLDB_INVALID_ADDRESS)
-      return LLDB_RECORD_RESULT(sb_watchpoint);
+      return sb_watchpoint;
     size_t byte_size = GetByteSize();
     if (byte_size == 0)
-      return LLDB_RECORD_RESULT(sb_watchpoint);
+      return sb_watchpoint;
 
     uint32_t watch_type = 0;
     if (read)
@@ -1516,7 +1472,7 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
     error.SetErrorString("could not set watchpoint, a target is required");
   }
 
-  return LLDB_RECORD_RESULT(sb_watchpoint);
+  return sb_watchpoint;
 }
 
 // FIXME: Remove this method impl (as well as the decl in .h) once it is no
@@ -1524,27 +1480,24 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
 // Backward compatibility fix in the interim.
 lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
                                   bool write) {
-  LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch, (bool, bool, bool),
-                     resolve_location, read, write);
+  LLDB_INSTRUMENT_VA(this, resolve_location, read, write);
 
   SBError error;
-  return LLDB_RECORD_RESULT(Watch(resolve_location, read, write, error));
+  return Watch(resolve_location, read, write, error);
 }
 
 lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read,
                                          bool write, SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee,
-                     (bool, bool, bool, lldb::SBError &), resolve_location,
-                     read, write, error);
+  LLDB_INSTRUMENT_VA(this, resolve_location, read, write, error);
 
   SBWatchpoint sb_watchpoint;
   if (IsInScope() && GetType().IsPointerType())
     sb_watchpoint = Dereference().Watch(resolve_location, read, write, error);
-  return LLDB_RECORD_RESULT(sb_watchpoint);
+  return sb_watchpoint;
 }
 
 lldb::SBValue SBValue::Persist() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Persist);
+  LLDB_INSTRUMENT_VA(this);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1552,132 +1505,5 @@ lldb::SBValue SBValue::Persist() {
   if (value_sp) {
     persisted_sb.SetSP(value_sp->Persist());
   }
-  return LLDB_RECORD_RESULT(persisted_sb);
-}
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBValue>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBValue, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &));
-  LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::SBValue &));
-  LLDB_REGISTER_METHOD(lldb::SBValue &,
-                       SBValue, operator=,(const lldb::SBValue &));
-  LLDB_REGISTER_METHOD(bool, SBValue, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBValue, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBValue, Clear, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBValue, GetError, ());
-  LLDB_REGISTER_METHOD(lldb::user_id_t, SBValue, GetID, ());
-  LLDB_REGISTER_METHOD(const char *, SBValue, GetName, ());
-  LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeName, ());
-  LLDB_REGISTER_METHOD(const char *, SBValue, GetDisplayTypeName, ());
-  LLDB_REGISTER_METHOD(size_t, SBValue, GetByteSize, ());
-  LLDB_REGISTER_METHOD(bool, SBValue, IsInScope, ());
-  LLDB_REGISTER_METHOD(const char *, SBValue, GetValue, ());
-  LLDB_REGISTER_METHOD(lldb::ValueType, SBValue, GetValueType, ());
-  LLDB_REGISTER_METHOD(const char *, SBValue, GetObjectDescription, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBValue, GetType, ());
-  LLDB_REGISTER_METHOD(bool, SBValue, GetValueDidChange, ());
-  LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, ());
-  LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary,
-                       (lldb::SBStream &, lldb::SBTypeSummaryOptions &));
-  LLDB_REGISTER_METHOD(const char *, SBValue, GetLocation, ());
-  LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, (const char *));
-  LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString,
-                       (const char *, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBValue, GetTypeFormat, ());
-  LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBValue, GetTypeSummary, ());
-  LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBValue, GetTypeFilter, ());
-  LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic, ());
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset,
-                       (const char *, uint32_t, lldb::SBType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
-                       (const char *, const char *));
-  LLDB_REGISTER_METHOD(
-      lldb::SBValue, SBValue, CreateValueFromExpression,
-      (const char *, const char *, lldb::SBExpressionOptions &));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress,
-                       (const char *, lldb::addr_t, lldb::SBType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromData,
-                       (const char *, lldb::SBData, lldb::SBType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex,
-                       (uint32_t, lldb::DynamicValueType, bool));
-  LLDB_REGISTER_METHOD(uint32_t, SBValue, GetIndexOfChildWithName,
-                       (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
-                       (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
-                       (const char *, lldb::DynamicValueType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
-                       (lldb::DynamicValueType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetStaticValue, ());
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetNonSyntheticValue, ());
-  LLDB_REGISTER_METHOD(lldb::DynamicValueType, SBValue, GetPreferDynamicValue,
-                       ());
-  LLDB_REGISTER_METHOD(void, SBValue, SetPreferDynamicValue,
-                       (lldb::DynamicValueType));
-  LLDB_REGISTER_METHOD(bool, SBValue, GetPreferSyntheticValue, ());
-  LLDB_REGISTER_METHOD(void, SBValue, SetPreferSyntheticValue, (bool));
-  LLDB_REGISTER_METHOD(bool, SBValue, IsDynamic, ());
-  LLDB_REGISTER_METHOD(bool, SBValue, IsSynthetic, ());
-  LLDB_REGISTER_METHOD(bool, SBValue, IsSyntheticChildrenGenerated, ());
-  LLDB_REGISTER_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
-                       (const char *));
-  LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned,
-                       (lldb::SBError &, int64_t));
-  LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
-                       (lldb::SBError &, uint64_t));
-  LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t));
-  LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t));
-  LLDB_REGISTER_METHOD(bool, SBValue, MightHaveChildren, ());
-  LLDB_REGISTER_METHOD(bool, SBValue, IsRuntimeSupportValue, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Dereference, ());
-  LLDB_REGISTER_METHOD(bool, SBValue, TypeIsPointerType, ());
-  LLDB_REGISTER_METHOD(void *, SBValue, GetOpaqueType, ());
-  LLDB_REGISTER_METHOD(lldb::SBTarget, SBValue, GetTarget, ());
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBValue, GetProcess, ());
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBValue, GetThread, ());
-  LLDB_REGISTER_METHOD(lldb::SBFrame, SBValue, GetFrame, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::ValueObjectSP, SBValue, GetSP, ());
-  LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath,
-                       (lldb::SBStream &, bool));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
-                             (const char *));
-  LLDB_REGISTER_METHOD_CONST(
-      lldb::SBValue, SBValue, EvaluateExpression,
-      (const char *, const lldb::SBExpressionOptions &));
-  LLDB_REGISTER_METHOD_CONST(
-      lldb::SBValue, SBValue, EvaluateExpression,
-      (const char *, const lldb::SBExpressionOptions &, const char *));
-  LLDB_REGISTER_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(lldb::Format, SBValue, GetFormat, ());
-  LLDB_REGISTER_METHOD(void, SBValue, SetFormat, (lldb::Format));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, AddressOf, ());
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBValue, GetLoadAddress, ());
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBValue, GetAddress, ());
-  LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetPointeeData,
-                       (uint32_t, uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetData, ());
-  LLDB_REGISTER_METHOD(bool, SBValue, SetData,
-                       (lldb::SBData &, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Clone, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBDeclaration, SBValue, GetDeclaration, ());
-  LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
-                       (bool, bool, bool, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
-                       (bool, bool, bool));
-  LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee,
-                       (bool, bool, bool, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Persist, ());
-}
-
-}
+  return persisted_sb;
 }