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

71 files changed, 3039 insertions, 8255 deletions

diff --git a/lldb/source/API/SBAddress.cpp b/lldb/source/API/SBAddress.cpp
index 7c102270a87c..e519f0bcc83c 100644
--- a/lldb/source/API/SBAddress.cpp
+++ b/lldb/source/API/SBAddress.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBAddress.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBSection.h"
@@ -16,35 +15,34 @@
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBAddress::SBAddress() : m_opaque_up(new Address()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAddress);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBAddress::SBAddress(const Address &address)
     : m_opaque_up(std::make_unique<Address>(address)) {}
 
 SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) {
-  LLDB_RECORD_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 SBAddress::SBAddress(lldb::SBSection section, lldb::addr_t offset)
     : m_opaque_up(new Address(section.GetSP(), offset)) {
-  LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t), section,
-                          offset);
+  LLDB_INSTRUMENT_VA(this, section, offset);
 }
 
 // Create an address by resolving a load address using the supplied target
 SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target)
     : m_opaque_up(new Address()) {
-  LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &),
-                          load_addr, target);
+  LLDB_INSTRUMENT_VA(this, load_addr, target);
 
   SetLoadAddress(load_addr, target);
 }
@@ -52,12 +50,11 @@ SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target)
 SBAddress::~SBAddress() = default;
 
 const SBAddress &SBAddress::operator=(const SBAddress &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBAddress &,
-                     SBAddress, operator=,(const lldb::SBAddress &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) {
@@ -67,31 +64,29 @@ bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) {
 }
 
 bool SBAddress::operator!=(const SBAddress &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBAddress, operator!=,(const SBAddress &),
-                           &rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return !(*this == rhs);
 }
 
 bool SBAddress::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBAddress::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up != nullptr && m_opaque_up->IsValid();
 }
 
 void SBAddress::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBAddress, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_up = std::make_unique<Address>();
 }
 
 void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) {
-  LLDB_RECORD_METHOD(void, SBAddress, SetAddress,
-                     (lldb::SBSection, lldb::addr_t), section, offset);
+  LLDB_INSTRUMENT_VA(this, section, offset);
 
   Address &addr = ref();
   addr.SetSection(section.GetSP());
@@ -101,7 +96,7 @@ void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) {
 void SBAddress::SetAddress(const Address &address) { ref() = address; }
 
 lldb::addr_t SBAddress::GetFileAddress() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBAddress, GetFileAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up->IsValid())
     return m_opaque_up->GetFileAddress();
@@ -110,8 +105,7 @@ lldb::addr_t SBAddress::GetFileAddress() const {
 }
 
 lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
-  LLDB_RECORD_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
-                           (const lldb::SBTarget &), target);
+  LLDB_INSTRUMENT_VA(this, target);
 
   lldb::addr_t addr = LLDB_INVALID_ADDRESS;
   TargetSP target_sp(target.GetSP());
@@ -126,8 +120,7 @@ lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
 }
 
 void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) {
-  LLDB_RECORD_METHOD(void, SBAddress, SetLoadAddress,
-                     (lldb::addr_t, lldb::SBTarget &), load_addr, target);
+  LLDB_INSTRUMENT_VA(this, load_addr, target);
 
   // Create the address object if we don't already have one
   ref();
@@ -144,7 +137,7 @@ void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) {
 }
 
 bool SBAddress::OffsetAddress(addr_t offset) {
-  LLDB_RECORD_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t), offset);
+  LLDB_INSTRUMENT_VA(this, offset);
 
   if (m_opaque_up->IsValid()) {
     addr_t addr_offset = m_opaque_up->GetOffset();
@@ -157,16 +150,16 @@ bool SBAddress::OffsetAddress(addr_t offset) {
 }
 
 lldb::SBSection SBAddress::GetSection() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBAddress, GetSection);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBSection sb_section;
   if (m_opaque_up->IsValid())
     sb_section.SetSP(m_opaque_up->GetSection());
-  return LLDB_RECORD_RESULT(sb_section);
+  return sb_section;
 }
 
 lldb::addr_t SBAddress::GetOffset() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBAddress, GetOffset);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up->IsValid())
     return m_opaque_up->GetOffset();
@@ -193,8 +186,7 @@ const Address &SBAddress::ref() const {
 Address *SBAddress::get() { return m_opaque_up.get(); }
 
 bool SBAddress::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   // Call "ref()" on the stream to make sure it creates a backing stream in
   // case there isn't one already...
@@ -209,63 +201,62 @@ bool SBAddress::GetDescription(SBStream &description) {
 }
 
 SBModule SBAddress::GetModule() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBAddress, GetModule);
+  LLDB_INSTRUMENT_VA(this);
 
   SBModule sb_module;
   if (m_opaque_up->IsValid())
     sb_module.SetSP(m_opaque_up->GetModule());
-  return LLDB_RECORD_RESULT(sb_module);
+  return sb_module;
 }
 
 SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
-  LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
-                     (uint32_t), resolve_scope);
+  LLDB_INSTRUMENT_VA(this, resolve_scope);
 
   SBSymbolContext sb_sc;
   SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
   if (m_opaque_up->IsValid())
     m_opaque_up->CalculateSymbolContext(&sb_sc.ref(), scope);
-  return LLDB_RECORD_RESULT(sb_sc);
+  return sb_sc;
 }
 
 SBCompileUnit SBAddress::GetCompileUnit() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBAddress, GetCompileUnit);
+  LLDB_INSTRUMENT_VA(this);
 
   SBCompileUnit sb_comp_unit;
   if (m_opaque_up->IsValid())
     sb_comp_unit.reset(m_opaque_up->CalculateSymbolContextCompileUnit());
-  return LLDB_RECORD_RESULT(sb_comp_unit);
+  return sb_comp_unit;
 }
 
 SBFunction SBAddress::GetFunction() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBAddress, GetFunction);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFunction sb_function;
   if (m_opaque_up->IsValid())
     sb_function.reset(m_opaque_up->CalculateSymbolContextFunction());
-  return LLDB_RECORD_RESULT(sb_function);
+  return sb_function;
 }
 
 SBBlock SBAddress::GetBlock() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBAddress, GetBlock);
+  LLDB_INSTRUMENT_VA(this);
 
   SBBlock sb_block;
   if (m_opaque_up->IsValid())
     sb_block.SetPtr(m_opaque_up->CalculateSymbolContextBlock());
-  return LLDB_RECORD_RESULT(sb_block);
+  return sb_block;
 }
 
 SBSymbol SBAddress::GetSymbol() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBAddress, GetSymbol);
+  LLDB_INSTRUMENT_VA(this);
 
   SBSymbol sb_symbol;
   if (m_opaque_up->IsValid())
     sb_symbol.reset(m_opaque_up->CalculateSymbolContextSymbol());
-  return LLDB_RECORD_RESULT(sb_symbol);
+  return sb_symbol;
 }
 
 SBLineEntry SBAddress::GetLineEntry() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBAddress, GetLineEntry);
+  LLDB_INSTRUMENT_VA(this);
 
   SBLineEntry sb_line_entry;
   if (m_opaque_up->IsValid()) {
@@ -273,45 +264,5 @@ SBLineEntry SBAddress::GetLineEntry() {
     if (m_opaque_up->CalculateSymbolContextLineEntry(line_entry))
       sb_line_entry.SetLineEntry(line_entry);
   }
-  return LLDB_RECORD_RESULT(sb_line_entry);
-}
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBAddress>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBAddress, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &));
-  LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t));
-  LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &));
-  LLDB_REGISTER_METHOD(const lldb::SBAddress &,
-                       SBAddress, operator=,(const lldb::SBAddress &));
-  LLDB_REGISTER_METHOD_CONST(bool,
-                             SBAddress, operator!=,(const lldb::SBAddress &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBAddress, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBAddress, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBAddress, Clear, ());
-  LLDB_REGISTER_METHOD(void, SBAddress, SetAddress,
-                       (lldb::SBSection, lldb::addr_t));
-  LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetFileAddress, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
-                             (const lldb::SBTarget &));
-  LLDB_REGISTER_METHOD(void, SBAddress, SetLoadAddress,
-                       (lldb::addr_t, lldb::SBTarget &));
-  LLDB_REGISTER_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t));
-  LLDB_REGISTER_METHOD(lldb::SBSection, SBAddress, GetSection, ());
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBAddress, GetOffset, ());
-  LLDB_REGISTER_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(lldb::SBModule, SBAddress, GetModule, ());
-  LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBAddress, GetCompileUnit, ());
-  LLDB_REGISTER_METHOD(lldb::SBFunction, SBAddress, GetFunction, ());
-  LLDB_REGISTER_METHOD(lldb::SBBlock, SBAddress, GetBlock, ());
-  LLDB_REGISTER_METHOD(lldb::SBSymbol, SBAddress, GetSymbol, ());
-  LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBAddress, GetLineEntry, ());
-}
-
-}
+  return sb_line_entry;
 }
diff --git a/lldb/source/API/SBAttachInfo.cpp b/lldb/source/API/SBAttachInfo.cpp
index b21589cf2708..edb4f7104d41 100644
--- a/lldb/source/API/SBAttachInfo.cpp
+++ b/lldb/source/API/SBAttachInfo.cpp
@@ -7,29 +7,29 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBAttachInfo.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAttachInfo);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBAttachInfo::SBAttachInfo(lldb::pid_t pid)
     : m_opaque_sp(new ProcessAttachInfo()) {
-  LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t), pid);
+  LLDB_INSTRUMENT_VA(this, pid);
 
   m_opaque_sp->SetProcessID(pid);
 }
 
 SBAttachInfo::SBAttachInfo(const char *path, bool wait_for)
     : m_opaque_sp(new ProcessAttachInfo()) {
-  LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool), path, wait_for);
+  LLDB_INSTRUMENT_VA(this, path, wait_for);
 
   if (path && path[0])
     m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
@@ -38,8 +38,7 @@ SBAttachInfo::SBAttachInfo(const char *path, bool wait_for)
 
 SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async)
     : m_opaque_sp(new ProcessAttachInfo()) {
-  LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool), path,
-                          wait_for, async);
+  LLDB_INSTRUMENT_VA(this, path, wait_for, async);
 
   if (path && path[0])
     m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
@@ -49,7 +48,7 @@ SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async)
 
 SBAttachInfo::SBAttachInfo(const SBAttachInfo &rhs)
     : m_opaque_sp(new ProcessAttachInfo()) {
-  LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_sp = clone(rhs.m_opaque_sp);
 }
@@ -59,53 +58,51 @@ SBAttachInfo::~SBAttachInfo() = default;
 lldb_private::ProcessAttachInfo &SBAttachInfo::ref() { return *m_opaque_sp; }
 
 SBAttachInfo &SBAttachInfo::operator=(const SBAttachInfo &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBAttachInfo &,
-                     SBAttachInfo, operator=,(const lldb::SBAttachInfo &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_sp = clone(rhs.m_opaque_sp);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 lldb::pid_t SBAttachInfo::GetProcessID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetProcessID();
 }
 
 void SBAttachInfo::SetProcessID(lldb::pid_t pid) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t), pid);
+  LLDB_INSTRUMENT_VA(this, pid);
 
   m_opaque_sp->SetProcessID(pid);
 }
 
 uint32_t SBAttachInfo::GetResumeCount() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetResumeCount);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetResumeCount();
 }
 
 void SBAttachInfo::SetResumeCount(uint32_t c) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c);
+  LLDB_INSTRUMENT_VA(this, c);
 
   m_opaque_sp->SetResumeCount(c);
 }
 
 const char *SBAttachInfo::GetProcessPluginName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBAttachInfo, GetProcessPluginName);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetProcessPluginName();
 }
 
 void SBAttachInfo::SetProcessPluginName(const char *plugin_name) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessPluginName, (const char *),
-                     plugin_name);
+  LLDB_INSTRUMENT_VA(this, plugin_name);
 
   return m_opaque_sp->SetProcessPluginName(plugin_name);
 }
 
 void SBAttachInfo::SetExecutable(const char *path) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (const char *), path);
+  LLDB_INSTRUMENT_VA(this, path);
 
   if (path && path[0])
     m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
@@ -114,8 +111,7 @@ void SBAttachInfo::SetExecutable(const char *path) {
 }
 
 void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec),
-                     exe_file);
+  LLDB_INSTRUMENT_VA(this, exe_file);
 
   if (exe_file.IsValid())
     m_opaque_sp->GetExecutableFile() = exe_file.ref();
@@ -124,185 +120,134 @@ void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
 }
 
 bool SBAttachInfo::GetWaitForLaunch() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetWaitForLaunch);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetWaitForLaunch();
 }
 
 void SBAttachInfo::SetWaitForLaunch(bool b) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b);
+  LLDB_INSTRUMENT_VA(this, b);
 
   m_opaque_sp->SetWaitForLaunch(b);
 }
 
 void SBAttachInfo::SetWaitForLaunch(bool b, bool async) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool), b,
-                     async);
+  LLDB_INSTRUMENT_VA(this, b, async);
 
   m_opaque_sp->SetWaitForLaunch(b);
   m_opaque_sp->SetAsync(async);
 }
 
 bool SBAttachInfo::GetIgnoreExisting() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetIgnoreExisting);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetIgnoreExisting();
 }
 
 void SBAttachInfo::SetIgnoreExisting(bool b) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b);
+  LLDB_INSTRUMENT_VA(this, b);
 
   m_opaque_sp->SetIgnoreExisting(b);
 }
 
 uint32_t SBAttachInfo::GetUserID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetUserID();
 }
 
 uint32_t SBAttachInfo::GetGroupID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetGroupID();
 }
 
 bool SBAttachInfo::UserIDIsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->UserIDIsValid();
 }
 
 bool SBAttachInfo::GroupIDIsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GroupIDIsValid();
 }
 
 void SBAttachInfo::SetUserID(uint32_t uid) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid);
+  LLDB_INSTRUMENT_VA(this, uid);
 
   m_opaque_sp->SetUserID(uid);
 }
 
 void SBAttachInfo::SetGroupID(uint32_t gid) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid);
+  LLDB_INSTRUMENT_VA(this, gid);
 
   m_opaque_sp->SetGroupID(gid);
 }
 
 uint32_t SBAttachInfo::GetEffectiveUserID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveUserID);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetEffectiveUserID();
 }
 
 uint32_t SBAttachInfo::GetEffectiveGroupID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveGroupID);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetEffectiveGroupID();
 }
 
 bool SBAttachInfo::EffectiveUserIDIsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveUserIDIsValid);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->EffectiveUserIDIsValid();
 }
 
 bool SBAttachInfo::EffectiveGroupIDIsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveGroupIDIsValid);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->EffectiveGroupIDIsValid();
 }
 
 void SBAttachInfo::SetEffectiveUserID(uint32_t uid) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), uid);
+  LLDB_INSTRUMENT_VA(this, uid);
 
   m_opaque_sp->SetEffectiveUserID(uid);
 }
 
 void SBAttachInfo::SetEffectiveGroupID(uint32_t gid) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), gid);
+  LLDB_INSTRUMENT_VA(this, gid);
 
   m_opaque_sp->SetEffectiveGroupID(gid);
 }
 
 lldb::pid_t SBAttachInfo::GetParentProcessID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetParentProcessID);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetParentProcessID();
 }
 
 void SBAttachInfo::SetParentProcessID(lldb::pid_t pid) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t),
-                     pid);
+  LLDB_INSTRUMENT_VA(this, pid);
 
   m_opaque_sp->SetParentProcessID(pid);
 }
 
 bool SBAttachInfo::ParentProcessIDIsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, ParentProcessIDIsValid);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->ParentProcessIDIsValid();
 }
 
 SBListener SBAttachInfo::GetListener() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBAttachInfo, GetListener);
+  LLDB_INSTRUMENT_VA(this);
 
-  return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener()));
+  return SBListener(m_opaque_sp->GetListener());
 }
 
 void SBAttachInfo::SetListener(SBListener &listener) {
-  LLDB_RECORD_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &),
-                     listener);
+  LLDB_INSTRUMENT_VA(this, listener);
 
   m_opaque_sp->SetListener(listener.GetSP());
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBAttachInfo>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t));
-  LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool));
-  LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool));
-  LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &));
-  LLDB_REGISTER_METHOD(lldb::SBAttachInfo &,
-                       SBAttachInfo, operator=,(const lldb::SBAttachInfo &));
-  LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetProcessID, ());
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetResumeCount, ());
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t));
-  LLDB_REGISTER_METHOD(const char *, SBAttachInfo, GetProcessPluginName, ());
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessPluginName,
-                       (const char *));
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (const char *));
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec));
-  LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetWaitForLaunch, ());
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool));
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool));
-  LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetIgnoreExisting, ());
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool));
-  LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetUserID, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetGroupID, ());
-  LLDB_REGISTER_METHOD(bool, SBAttachInfo, UserIDIsValid, ());
-  LLDB_REGISTER_METHOD(bool, SBAttachInfo, GroupIDIsValid, ());
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetUserID, (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveUserID, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveGroupID, ());
-  LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveUserIDIsValid, ());
-  LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveGroupIDIsValid, ());
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetParentProcessID, ());
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t));
-  LLDB_REGISTER_METHOD(bool, SBAttachInfo, ParentProcessIDIsValid, ());
-  LLDB_REGISTER_METHOD(lldb::SBListener, SBAttachInfo, GetListener, ());
-  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBBlock.cpp b/lldb/source/API/SBBlock.cpp
index 5c49053dd972..7d7565340836 100644
--- a/lldb/source/API/SBBlock.cpp
+++ b/lldb/source/API/SBBlock.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBBlock.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFrame.h"
@@ -21,41 +20,41 @@
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBBlock::SBBlock() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBlock); }
+SBBlock::SBBlock() { LLDB_INSTRUMENT_VA(this); }
 
 SBBlock::SBBlock(lldb_private::Block *lldb_object_ptr)
     : m_opaque_ptr(lldb_object_ptr) {}
 
 SBBlock::SBBlock(const SBBlock &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
-  LLDB_RECORD_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBBlock &,
-                     SBBlock, operator=,(const lldb::SBBlock &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_ptr = rhs.m_opaque_ptr;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBBlock::~SBBlock() { m_opaque_ptr = nullptr; }
 
 bool SBBlock::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBBlock::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_ptr != nullptr;
 }
 
 bool SBBlock::IsInlined() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->GetInlinedFunctionInfo() != nullptr;
@@ -63,7 +62,7 @@ bool SBBlock::IsInlined() const {
 }
 
 const char *SBBlock::GetInlinedName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBlock, GetInlinedName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr) {
     const InlineFunctionInfo *inlined_info =
@@ -76,8 +75,7 @@ const char *SBBlock::GetInlinedName() const {
 }
 
 SBFileSpec SBBlock::GetInlinedCallSiteFile() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBBlock,
-                                   GetInlinedCallSiteFile);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFileSpec sb_file;
   if (m_opaque_ptr) {
@@ -86,11 +84,11 @@ SBFileSpec SBBlock::GetInlinedCallSiteFile() const {
     if (inlined_info)
       sb_file.SetFileSpec(inlined_info->GetCallSite().GetFile());
   }
-  return LLDB_RECORD_RESULT(sb_file);
+  return sb_file;
 }
 
 uint32_t SBBlock::GetInlinedCallSiteLine() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteLine);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr) {
     const InlineFunctionInfo *inlined_info =
@@ -102,7 +100,7 @@ uint32_t SBBlock::GetInlinedCallSiteLine() const {
 }
 
 uint32_t SBBlock::GetInlinedCallSiteColumn() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteColumn);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr) {
     const InlineFunctionInfo *inlined_info =
@@ -123,39 +121,39 @@ void SBBlock::AppendVariables(bool can_create, bool get_parent_variables,
 }
 
 SBBlock SBBlock::GetParent() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetParent);
+  LLDB_INSTRUMENT_VA(this);
 
   SBBlock sb_block;
   if (m_opaque_ptr)
     sb_block.m_opaque_ptr = m_opaque_ptr->GetParent();
-  return LLDB_RECORD_RESULT(sb_block);
+  return sb_block;
 }
 
 lldb::SBBlock SBBlock::GetContainingInlinedBlock() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetContainingInlinedBlock);
+  LLDB_INSTRUMENT_VA(this);
 
   SBBlock sb_block;
   if (m_opaque_ptr)
     sb_block.m_opaque_ptr = m_opaque_ptr->GetContainingInlinedBlock();
-  return LLDB_RECORD_RESULT(sb_block);
+  return sb_block;
 }
 
 SBBlock SBBlock::GetSibling() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetSibling);
+  LLDB_INSTRUMENT_VA(this);
 
   SBBlock sb_block;
   if (m_opaque_ptr)
     sb_block.m_opaque_ptr = m_opaque_ptr->GetSibling();
-  return LLDB_RECORD_RESULT(sb_block);
+  return sb_block;
 }
 
 SBBlock SBBlock::GetFirstChild() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetFirstChild);
+  LLDB_INSTRUMENT_VA(this);
 
   SBBlock sb_block;
   if (m_opaque_ptr)
     sb_block.m_opaque_ptr = m_opaque_ptr->GetFirstChild();
-  return LLDB_RECORD_RESULT(sb_block);
+  return sb_block;
 }
 
 lldb_private::Block *SBBlock::GetPtr() { return m_opaque_ptr; }
@@ -163,8 +161,7 @@ lldb_private::Block *SBBlock::GetPtr() { return m_opaque_ptr; }
 void SBBlock::SetPtr(lldb_private::Block *block) { m_opaque_ptr = block; }
 
 bool SBBlock::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -188,7 +185,7 @@ bool SBBlock::GetDescription(SBStream &description) {
 }
 
 uint32_t SBBlock::GetNumRanges() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBlock, GetNumRanges);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->GetNumRanges();
@@ -196,8 +193,7 @@ uint32_t SBBlock::GetNumRanges() {
 }
 
 lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, (uint32_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   lldb::SBAddress sb_addr;
   if (m_opaque_ptr) {
@@ -206,12 +202,11 @@ lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
       sb_addr.ref() = range.GetBaseAddress();
     }
   }
-  return LLDB_RECORD_RESULT(sb_addr);
+  return sb_addr;
 }
 
 lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, (uint32_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   lldb::SBAddress sb_addr;
   if (m_opaque_ptr) {
@@ -221,12 +216,11 @@ lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
       sb_addr.ref().Slide(range.GetByteSize());
     }
   }
-  return LLDB_RECORD_RESULT(sb_addr);
+  return sb_addr;
 }
 
 uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
-  LLDB_RECORD_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
-                     (lldb::SBAddress), block_addr);
+  LLDB_INSTRUMENT_VA(this, block_addr);
 
   if (m_opaque_ptr && block_addr.IsValid()) {
     return m_opaque_ptr->GetRangeIndexContainingAddress(block_addr.ref());
@@ -238,10 +232,7 @@ uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
 lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments,
                                         bool locals, bool statics,
                                         lldb::DynamicValueType use_dynamic) {
-  LLDB_RECORD_METHOD(
-      lldb::SBValueList, SBBlock, GetVariables,
-      (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType), frame,
-      arguments, locals, statics, use_dynamic);
+  LLDB_INSTRUMENT_VA(this, frame, arguments, locals, statics, use_dynamic);
 
   Block *block = GetPtr();
   SBValueList value_list;
@@ -289,14 +280,12 @@ lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments,
       }
     }
   }
-  return LLDB_RECORD_RESULT(value_list);
+  return value_list;
 }
 
 lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments,
                                         bool locals, bool statics) {
-  LLDB_RECORD_METHOD(lldb::SBValueList, SBBlock, GetVariables,
-                     (lldb::SBTarget &, bool, bool, bool), target, arguments,
-                     locals, statics);
+  LLDB_INSTRUMENT_VA(this, target, arguments, locals, statics);
 
   Block *block = GetPtr();
 
@@ -341,44 +330,5 @@ lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments,
       }
     }
   }
-  return LLDB_RECORD_RESULT(value_list);
-}
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBBlock>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBBlock, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &));
-  LLDB_REGISTER_METHOD(const lldb::SBBlock &,
-                       SBBlock, operator=,(const lldb::SBBlock &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBBlock, operator bool, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsInlined, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBBlock, GetInlinedName, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBBlock,
-                             GetInlinedCallSiteFile, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteLine, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteColumn, ());
-  LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetParent, ());
-  LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetContainingInlinedBlock, ());
-  LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetSibling, ());
-  LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetFirstChild, ());
-  LLDB_REGISTER_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetNumRanges, ());
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
-                       (lldb::SBAddress));
-  LLDB_REGISTER_METHOD(
-      lldb::SBValueList, SBBlock, GetVariables,
-      (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType));
-  LLDB_REGISTER_METHOD(lldb::SBValueList, SBBlock, GetVariables,
-                       (lldb::SBTarget &, bool, bool, bool));
-}
-
-}
+  return value_list;
 }
diff --git a/lldb/source/API/SBBreakpoint.cpp b/lldb/source/API/SBBreakpoint.cpp
index 0f0a93519993..5fe8f7fe0583 100644
--- a/lldb/source/API/SBBreakpoint.cpp
+++ b/lldb/source/API/SBBreakpoint.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBBreakpoint.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBBreakpointLocation.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
@@ -16,6 +15,7 @@
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBThread.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
@@ -45,54 +45,51 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBBreakpoint::SBBreakpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpoint); }
+SBBreakpoint::SBBreakpoint() { LLDB_INSTRUMENT_VA(this); }
 
 SBBreakpoint::SBBreakpoint(const SBBreakpoint &rhs)
     : m_opaque_wp(rhs.m_opaque_wp) {
-  LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBBreakpoint::SBBreakpoint(const lldb::BreakpointSP &bp_sp)
     : m_opaque_wp(bp_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &), bp_sp);
+  LLDB_INSTRUMENT_VA(this, bp_sp);
 }
 
 SBBreakpoint::~SBBreakpoint() = default;
 
 const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBBreakpoint &,
-                     SBBreakpoint, operator=,(const lldb::SBBreakpoint &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_wp = rhs.m_opaque_wp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBBreakpoint::operator==(const lldb::SBBreakpoint &rhs) {
-  LLDB_RECORD_METHOD(
-      bool, SBBreakpoint, operator==,(const lldb::SBBreakpoint &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_wp.lock() == rhs.m_opaque_wp.lock();
 }
 
 bool SBBreakpoint::operator!=(const lldb::SBBreakpoint &rhs) {
-  LLDB_RECORD_METHOD(
-      bool, SBBreakpoint, operator!=,(const lldb::SBBreakpoint &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_wp.lock() != rhs.m_opaque_wp.lock();
 }
 
 SBTarget SBBreakpoint::GetTarget() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBBreakpoint, GetTarget);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp)
-    return LLDB_RECORD_RESULT(SBTarget(bkpt_sp->GetTargetSP()));
+    return SBTarget(bkpt_sp->GetTargetSP());
 
-  return LLDB_RECORD_RESULT(SBTarget());
+  return SBTarget();
 }
 
 break_id_t SBBreakpoint::GetID() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::break_id_t, SBBreakpoint, GetID);
+  LLDB_INSTRUMENT_VA(this);
 
   break_id_t break_id = LLDB_INVALID_BREAK_ID;
   BreakpointSP bkpt_sp = GetSP();
@@ -103,11 +100,11 @@ break_id_t SBBreakpoint::GetID() const {
 }
 
 bool SBBreakpoint::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBBreakpoint::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointSP bkpt_sp = GetSP();
   if (!bkpt_sp)
@@ -119,7 +116,7 @@ SBBreakpoint::operator bool() const {
 }
 
 void SBBreakpoint::ClearAllBreakpointSites() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpoint, ClearAllBreakpointSites);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
@@ -130,8 +127,7 @@ void SBBreakpoint::ClearAllBreakpointSites() {
 }
 
 SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
-                     FindLocationByAddress, (lldb::addr_t), vm_addr);
+  LLDB_INSTRUMENT_VA(this, vm_addr);
 
   SBBreakpointLocation sb_bp_location;
 
@@ -148,12 +144,11 @@ SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
       sb_bp_location.SetLocation(bkpt_sp->FindLocationByAddress(address));
     }
   }
-  return LLDB_RECORD_RESULT(sb_bp_location);
+  return sb_bp_location;
 }
 
 break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) {
-  LLDB_RECORD_METHOD(lldb::break_id_t, SBBreakpoint, FindLocationIDByAddress,
-                     (lldb::addr_t), vm_addr);
+  LLDB_INSTRUMENT_VA(this, vm_addr);
 
   break_id_t break_id = LLDB_INVALID_BREAK_ID;
   BreakpointSP bkpt_sp = GetSP();
@@ -173,8 +168,7 @@ break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) {
 }
 
 SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, FindLocationByID,
-                     (lldb::break_id_t), bp_loc_id);
+  LLDB_INSTRUMENT_VA(this, bp_loc_id);
 
   SBBreakpointLocation sb_bp_location;
   BreakpointSP bkpt_sp = GetSP();
@@ -185,12 +179,11 @@ SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
     sb_bp_location.SetLocation(bkpt_sp->FindLocationByID(bp_loc_id));
   }
 
-  return LLDB_RECORD_RESULT(sb_bp_location);
+  return sb_bp_location;
 }
 
 SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
-                     GetLocationAtIndex, (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   SBBreakpointLocation sb_bp_location;
   BreakpointSP bkpt_sp = GetSP();
@@ -201,11 +194,11 @@ SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
     sb_bp_location.SetLocation(bkpt_sp->GetLocationAtIndex(index));
   }
 
-  return LLDB_RECORD_RESULT(sb_bp_location);
+  return sb_bp_location;
 }
 
 void SBBreakpoint::SetEnabled(bool enable) {
-  LLDB_RECORD_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable);
+  LLDB_INSTRUMENT_VA(this, enable);
 
   BreakpointSP bkpt_sp = GetSP();
 
@@ -217,7 +210,7 @@ void SBBreakpoint::SetEnabled(bool enable) {
 }
 
 bool SBBreakpoint::IsEnabled() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsEnabled);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
@@ -229,7 +222,7 @@ bool SBBreakpoint::IsEnabled() {
 }
 
 void SBBreakpoint::SetOneShot(bool one_shot) {
-  LLDB_RECORD_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot);
+  LLDB_INSTRUMENT_VA(this, one_shot);
 
   BreakpointSP bkpt_sp = GetSP();
 
@@ -241,7 +234,7 @@ void SBBreakpoint::SetOneShot(bool one_shot) {
 }
 
 bool SBBreakpoint::IsOneShot() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsOneShot);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
@@ -253,7 +246,7 @@ bool SBBreakpoint::IsOneShot() const {
 }
 
 bool SBBreakpoint::IsInternal() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsInternal);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
@@ -265,7 +258,7 @@ bool SBBreakpoint::IsInternal() {
 }
 
 void SBBreakpoint::SetIgnoreCount(uint32_t count) {
-  LLDB_RECORD_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count);
+  LLDB_INSTRUMENT_VA(this, count);
 
   BreakpointSP bkpt_sp = GetSP();
 
@@ -277,8 +270,7 @@ void SBBreakpoint::SetIgnoreCount(uint32_t count) {
 }
 
 void SBBreakpoint::SetCondition(const char *condition) {
-  LLDB_RECORD_METHOD(void, SBBreakpoint, SetCondition, (const char *),
-                     condition);
+  LLDB_INSTRUMENT_VA(this, condition);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
@@ -289,7 +281,7 @@ void SBBreakpoint::SetCondition(const char *condition) {
 }
 
 const char *SBBreakpoint::GetCondition() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpoint, GetCondition);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
@@ -301,8 +293,7 @@ const char *SBBreakpoint::GetCondition() {
 }
 
 void SBBreakpoint::SetAutoContinue(bool auto_continue) {
-  LLDB_RECORD_METHOD(void, SBBreakpoint, SetAutoContinue, (bool),
-                     auto_continue);
+  LLDB_INSTRUMENT_VA(this, auto_continue);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
@@ -313,7 +304,7 @@ void SBBreakpoint::SetAutoContinue(bool auto_continue) {
 }
 
 bool SBBreakpoint::GetAutoContinue() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, GetAutoContinue);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
@@ -325,7 +316,7 @@ bool SBBreakpoint::GetAutoContinue() {
 }
 
 uint32_t SBBreakpoint::GetHitCount() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetHitCount);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t count = 0;
   BreakpointSP bkpt_sp = GetSP();
@@ -339,7 +330,7 @@ uint32_t SBBreakpoint::GetHitCount() const {
 }
 
 uint32_t SBBreakpoint::GetIgnoreCount() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetIgnoreCount);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t count = 0;
   BreakpointSP bkpt_sp = GetSP();
@@ -353,7 +344,7 @@ uint32_t SBBreakpoint::GetIgnoreCount() const {
 }
 
 void SBBreakpoint::SetThreadID(tid_t tid) {
-  LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t), tid);
+  LLDB_INSTRUMENT_VA(this, tid);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
@@ -364,7 +355,7 @@ void SBBreakpoint::SetThreadID(tid_t tid) {
 }
 
 tid_t SBBreakpoint::GetThreadID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpoint, GetThreadID);
+  LLDB_INSTRUMENT_VA(this);
 
   tid_t tid = LLDB_INVALID_THREAD_ID;
   BreakpointSP bkpt_sp = GetSP();
@@ -378,7 +369,7 @@ tid_t SBBreakpoint::GetThreadID() {
 }
 
 void SBBreakpoint::SetThreadIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
@@ -389,7 +380,7 @@ void SBBreakpoint::SetThreadIndex(uint32_t index) {
 }
 
 uint32_t SBBreakpoint::GetThreadIndex() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetThreadIndex);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t thread_idx = UINT32_MAX;
   BreakpointSP bkpt_sp = GetSP();
@@ -406,8 +397,7 @@ uint32_t SBBreakpoint::GetThreadIndex() const {
 }
 
 void SBBreakpoint::SetThreadName(const char *thread_name) {
-  LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadName, (const char *),
-                     thread_name);
+  LLDB_INSTRUMENT_VA(this, thread_name);
 
   BreakpointSP bkpt_sp = GetSP();
 
@@ -419,7 +409,7 @@ void SBBreakpoint::SetThreadName(const char *thread_name) {
 }
 
 const char *SBBreakpoint::GetThreadName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetThreadName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
   BreakpointSP bkpt_sp = GetSP();
@@ -436,8 +426,7 @@ const char *SBBreakpoint::GetThreadName() const {
 }
 
 void SBBreakpoint::SetQueueName(const char *queue_name) {
-  LLDB_RECORD_METHOD(void, SBBreakpoint, SetQueueName, (const char *),
-                     queue_name);
+  LLDB_INSTRUMENT_VA(this, queue_name);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
@@ -448,7 +437,7 @@ void SBBreakpoint::SetQueueName(const char *queue_name) {
 }
 
 const char *SBBreakpoint::GetQueueName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetQueueName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
   BreakpointSP bkpt_sp = GetSP();
@@ -465,8 +454,7 @@ const char *SBBreakpoint::GetQueueName() const {
 }
 
 size_t SBBreakpoint::GetNumResolvedLocations() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint,
-                                   GetNumResolvedLocations);
+  LLDB_INSTRUMENT_VA(this);
 
   size_t num_resolved = 0;
   BreakpointSP bkpt_sp = GetSP();
@@ -479,7 +467,7 @@ size_t SBBreakpoint::GetNumResolvedLocations() const {
 }
 
 size_t SBBreakpoint::GetNumLocations() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, GetNumLocations);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointSP bkpt_sp = GetSP();
   size_t num_locs = 0;
@@ -492,8 +480,7 @@ size_t SBBreakpoint::GetNumLocations() const {
 }
 
 void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
-  LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands,
-                     (lldb::SBStringList &), commands);
+  LLDB_INSTRUMENT_VA(this, commands);
 
   BreakpointSP bkpt_sp = GetSP();
   if (!bkpt_sp)
@@ -510,8 +497,7 @@ void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
 }
 
 bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
-  LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
-                     (lldb::SBStringList &), commands);
+  LLDB_INSTRUMENT_VA(this, commands);
 
   BreakpointSP bkpt_sp = GetSP();
   if (!bkpt_sp)
@@ -525,14 +511,13 @@ bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
 }
 
 bool SBBreakpoint::GetDescription(SBStream &s) {
-  LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription, (lldb::SBStream &), s);
+  LLDB_INSTRUMENT_VA(this, s);
 
   return GetDescription(s, true);
 }
 
 bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) {
-  LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription,
-                     (lldb::SBStream &, bool), s, include_locations);
+  LLDB_INSTRUMENT_VA(this, s, include_locations);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
@@ -552,25 +537,24 @@ bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) {
 }
 
 SBError SBBreakpoint::AddLocation(SBAddress &address) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
-                     (lldb::SBAddress &), address);
+  LLDB_INSTRUMENT_VA(this, address);
 
   BreakpointSP bkpt_sp = GetSP();
   SBError error;
 
   if (!address.IsValid()) {
     error.SetErrorString("Can't add an invalid address.");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
 
   if (!bkpt_sp) {
     error.SetErrorString("No breakpoint to add a location to.");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
 
   if (!llvm::isa<BreakpointResolverScripted>(bkpt_sp->GetResolver().get())) {
     error.SetErrorString("Only a scripted resolver can add locations.");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
 
   if (bkpt_sp->GetSearchFilter()->AddressPasses(address.ref()))
@@ -582,27 +566,25 @@ SBError SBBreakpoint::AddLocation(SBAddress &address) {
     error.SetErrorStringWithFormat("Address: %s didn't pass the filter.",
                                    s.GetData());
   }
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 SBStructuredData SBBreakpoint::SerializeToStructuredData() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBBreakpoint,
-                             SerializeToStructuredData);
+  LLDB_INSTRUMENT_VA(this);
 
   SBStructuredData data;
   BreakpointSP bkpt_sp = GetSP();
 
   if (!bkpt_sp)
-    return LLDB_RECORD_RESULT(data);
+    return data;
 
   StructuredData::ObjectSP bkpt_dict = bkpt_sp->SerializeToStructuredData();
   data.m_impl_up->SetObjectSP(bkpt_dict);
-  return LLDB_RECORD_RESULT(data);
+  return data;
 }
 
 void SBBreakpoint::SetCallback(SBBreakpointHitCallback callback, void *baton) {
-  LLDB_RECORD_DUMMY(void, SBBreakpoint, SetCallback,
-                    (lldb::SBBreakpointHitCallback, void *), callback, baton);
+  LLDB_INSTRUMENT_VA(this, callback, baton);
 
   BreakpointSP bkpt_sp = GetSP();
 
@@ -618,8 +600,7 @@ void SBBreakpoint::SetCallback(SBBreakpointHitCallback callback, void *baton) {
 
 void SBBreakpoint::SetScriptCallbackFunction(
   const char *callback_function_name) {
-LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
-                   (const char *), callback_function_name);
+  LLDB_INSTRUMENT_VA(this, callback_function_name);
   SBStructuredData empty_args;
   SetScriptCallbackFunction(callback_function_name, empty_args);
 }
@@ -627,8 +608,7 @@ LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
 SBError SBBreakpoint::SetScriptCallbackFunction(
     const char *callback_function_name,
     SBStructuredData &extra_args) {
-  LLDB_RECORD_METHOD(SBError, SBBreakpoint, SetScriptCallbackFunction,
-  (const char *, SBStructuredData &), callback_function_name, extra_args);
+  LLDB_INSTRUMENT_VA(this, callback_function_name, extra_args);
   SBError sb_error;
   BreakpointSP bkpt_sp = GetSP();
 
@@ -647,13 +627,12 @@ SBError SBBreakpoint::SetScriptCallbackFunction(
     sb_error.SetError(error);
   } else
     sb_error.SetErrorString("invalid breakpoint");
-  
-  return LLDB_RECORD_RESULT(sb_error);
+
+  return sb_error;
 }
 
 SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
-                     (const char *), callback_body_text);
+  LLDB_INSTRUMENT_VA(this, callback_body_text);
 
   BreakpointSP bkpt_sp = GetSP();
 
@@ -671,19 +650,18 @@ SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
   } else
     sb_error.SetErrorString("invalid breakpoint");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 bool SBBreakpoint::AddName(const char *new_name) {
-  LLDB_RECORD_METHOD(bool, SBBreakpoint, AddName, (const char *), new_name);
+  LLDB_INSTRUMENT_VA(this, new_name);
 
   SBError status = AddNameWithErrorHandling(new_name);
   return status.Success();
 }
 
 SBError SBBreakpoint::AddNameWithErrorHandling(const char *new_name) {
-  LLDB_RECORD_METHOD(SBError, SBBreakpoint, AddNameWithErrorHandling,
-                     (const char *), new_name);
+  LLDB_INSTRUMENT_VA(this, new_name);
 
   BreakpointSP bkpt_sp = GetSP();
 
@@ -698,12 +676,11 @@ SBError SBBreakpoint::AddNameWithErrorHandling(const char *new_name) {
     status.SetErrorString("invalid breakpoint");
   }
 
-  return LLDB_RECORD_RESULT(status);
+  return status;
 }
 
 void SBBreakpoint::RemoveName(const char *name_to_remove) {
-  LLDB_RECORD_METHOD(void, SBBreakpoint, RemoveName, (const char *),
-                     name_to_remove);
+  LLDB_INSTRUMENT_VA(this, name_to_remove);
 
   BreakpointSP bkpt_sp = GetSP();
 
@@ -716,7 +693,7 @@ void SBBreakpoint::RemoveName(const char *name_to_remove) {
 }
 
 bool SBBreakpoint::MatchesName(const char *name) {
-  LLDB_RECORD_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   BreakpointSP bkpt_sp = GetSP();
 
@@ -730,8 +707,7 @@ bool SBBreakpoint::MatchesName(const char *name) {
 }
 
 void SBBreakpoint::GetNames(SBStringList &names) {
-  LLDB_RECORD_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &),
-                     names);
+  LLDB_INSTRUMENT_VA(this, names);
 
   BreakpointSP bkpt_sp = GetSP();
 
@@ -747,8 +723,7 @@ void SBBreakpoint::GetNames(SBStringList &names) {
 }
 
 bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   return Breakpoint::BreakpointEventData::GetEventDataFromEvent(event.get()) !=
          nullptr;
@@ -756,9 +731,7 @@ bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) {
 
 BreakpointEventType
 SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint,
-                            GetBreakpointEventTypeFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   if (event.IsValid())
     return Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
@@ -767,37 +740,30 @@ SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) {
 }
 
 SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint,
-                            GetBreakpointFromEvent, (const lldb::SBEvent &),
-                            event);
+  LLDB_INSTRUMENT_VA(event);
 
   if (event.IsValid())
-    return LLDB_RECORD_RESULT(
-        SBBreakpoint(Breakpoint::BreakpointEventData::GetBreakpointFromEvent(
-            event.GetSP())));
-  return LLDB_RECORD_RESULT(SBBreakpoint());
+    return SBBreakpoint(
+        Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event.GetSP()));
+  return SBBreakpoint();
 }
 
 SBBreakpointLocation
 SBBreakpoint::GetBreakpointLocationAtIndexFromEvent(const lldb::SBEvent &event,
                                                     uint32_t loc_idx) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
-                            GetBreakpointLocationAtIndexFromEvent,
-                            (const lldb::SBEvent &, uint32_t), event, loc_idx);
+  LLDB_INSTRUMENT_VA(event, loc_idx);
 
   SBBreakpointLocation sb_breakpoint_loc;
   if (event.IsValid())
     sb_breakpoint_loc.SetLocation(
         Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent(
             event.GetSP(), loc_idx));
-  return LLDB_RECORD_RESULT(sb_breakpoint_loc);
+  return sb_breakpoint_loc;
 }
 
 uint32_t
 SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(uint32_t, SBBreakpoint,
-                            GetNumBreakpointLocationsFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   uint32_t num_locations = 0;
   if (event.IsValid())
@@ -808,7 +774,7 @@ SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) {
 }
 
 bool SBBreakpoint::IsHardware() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsHardware);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp)
@@ -821,7 +787,7 @@ BreakpointSP SBBreakpoint::GetSP() const { return m_opaque_wp.lock(); }
 // This is simple collection of breakpoint id's and their target.
 class SBBreakpointListImpl {
 public:
-  SBBreakpointListImpl(lldb::TargetSP target_sp) : m_target_wp() {
+  SBBreakpointListImpl(lldb::TargetSP target_sp) {
     if (target_sp && target_sp->IsValid())
       m_target_wp = target_sp;
   }
@@ -904,13 +870,13 @@ private:
 
 SBBreakpointList::SBBreakpointList(SBTarget &target)
     : m_opaque_sp(new SBBreakpointListImpl(target.GetSP())) {
-  LLDB_RECORD_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &), target);
+  LLDB_INSTRUMENT_VA(this, target);
 }
 
 SBBreakpointList::~SBBreakpointList() = default;
 
 size_t SBBreakpointList::GetSize() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpointList, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!m_opaque_sp)
     return 0;
@@ -919,29 +885,26 @@ size_t SBBreakpointList::GetSize() const {
 }
 
 SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, GetBreakpointAtIndex,
-                     (size_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   if (!m_opaque_sp)
-    return LLDB_RECORD_RESULT(SBBreakpoint());
+    return SBBreakpoint();
 
   BreakpointSP bkpt_sp = m_opaque_sp->GetBreakpointAtIndex(idx);
-  return LLDB_RECORD_RESULT(SBBreakpoint(bkpt_sp));
+  return SBBreakpoint(bkpt_sp);
 }
 
 SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, FindBreakpointByID,
-                     (lldb::break_id_t), id);
+  LLDB_INSTRUMENT_VA(this, id);
 
   if (!m_opaque_sp)
-    return LLDB_RECORD_RESULT(SBBreakpoint());
+    return SBBreakpoint();
   BreakpointSP bkpt_sp = m_opaque_sp->FindBreakpointByID(id);
-  return LLDB_RECORD_RESULT(SBBreakpoint(bkpt_sp));
+  return SBBreakpoint(bkpt_sp);
 }
 
 void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) {
-  LLDB_RECORD_METHOD(void, SBBreakpointList, Append,
-                     (const lldb::SBBreakpoint &), sb_bkpt);
+  LLDB_INSTRUMENT_VA(this, sb_bkpt);
 
   if (!sb_bkpt.IsValid())
     return;
@@ -951,8 +914,7 @@ void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) {
 }
 
 void SBBreakpointList::AppendByID(lldb::break_id_t id) {
-  LLDB_RECORD_METHOD(void, SBBreakpointList, AppendByID, (lldb::break_id_t),
-                     id);
+  LLDB_INSTRUMENT_VA(this, id);
 
   if (!m_opaque_sp)
     return;
@@ -960,8 +922,7 @@ void SBBreakpointList::AppendByID(lldb::break_id_t id) {
 }
 
 bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {
-  LLDB_RECORD_METHOD(bool, SBBreakpointList, AppendIfUnique,
-                     (const lldb::SBBreakpoint &), sb_bkpt);
+  LLDB_INSTRUMENT_VA(this, sb_bkpt);
 
   if (!sb_bkpt.IsValid())
     return false;
@@ -971,7 +932,7 @@ bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {
 }
 
 void SBBreakpointList::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpointList, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     m_opaque_sp->Clear();
@@ -982,114 +943,3 @@ void SBBreakpointList::CopyToBreakpointIDList(
   if (m_opaque_sp)
     m_opaque_sp->CopyToBreakpointIDList(bp_id_list);
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBBreakpoint>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &));
-  LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &));
-  LLDB_REGISTER_METHOD(const lldb::SBBreakpoint &,
-                       SBBreakpoint, operator=,(const lldb::SBBreakpoint &));
-  LLDB_REGISTER_METHOD(bool,
-                       SBBreakpoint, operator==,(const lldb::SBBreakpoint &));
-  LLDB_REGISTER_METHOD(bool,
-                       SBBreakpoint, operator!=,(const lldb::SBBreakpoint &));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBBreakpoint, GetTarget, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::break_id_t, SBBreakpoint, GetID, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, ClearAllBreakpointSites, ());
-  LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
-                       FindLocationByAddress, (lldb::addr_t));
-  LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpoint,
-                       FindLocationIDByAddress, (lldb::addr_t));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
-                       FindLocationByID, (lldb::break_id_t));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
-                       GetLocationAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, SetEnabled, (bool));
-  LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsEnabled, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, SetOneShot, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsOneShot, ());
-  LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsInternal, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCondition, (const char *));
-  LLDB_REGISTER_METHOD(const char *, SBBreakpoint, GetCondition, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, SetAutoContinue, (bool));
-  LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetAutoContinue, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetHitCount, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetIgnoreCount, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t));
-  LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpoint, GetThreadID, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetThreadIndex, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadName, (const char *));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetThreadName, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, SetQueueName, (const char *));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetQueueName, ());
-  LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumResolvedLocations,
-                             ());
-  LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumLocations, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCommandLineCommands,
-                       (lldb::SBStringList &));
-  LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
-                       (lldb::SBStringList &));
-  LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
-                       (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
-                       (lldb::SBStream &, bool));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
-                       (lldb::SBAddress &));
-  LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBBreakpoint,
-                       SerializeToStructuredData, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
-                       (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackFunction,
-                       (const char *, SBStructuredData &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
-                       (const char *));
-  LLDB_REGISTER_METHOD(bool, SBBreakpoint, AddName, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddNameWithErrorHandling,
-                       (const char *));
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, RemoveName, (const char *));
-  LLDB_REGISTER_METHOD(bool, SBBreakpoint, MatchesName, (const char *));
-  LLDB_REGISTER_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint,
-                              GetBreakpointEventTypeFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint,
-                              GetBreakpointFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
-                              GetBreakpointLocationAtIndexFromEvent,
-                              (const lldb::SBEvent &, uint32_t));
-  LLDB_REGISTER_STATIC_METHOD(uint32_t, SBBreakpoint,
-                              GetNumBreakpointLocationsFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsHardware, ());
-}
-
-template <>
-void RegisterMethods<SBBreakpointList>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &));
-  LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpointList, GetSize, ());
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
-                       GetBreakpointAtIndex, (size_t));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
-                       FindBreakpointByID, (lldb::break_id_t));
-  LLDB_REGISTER_METHOD(void, SBBreakpointList, Append,
-                       (const lldb::SBBreakpoint &));
-  LLDB_REGISTER_METHOD(void, SBBreakpointList, AppendByID,
-                       (lldb::break_id_t));
-  LLDB_REGISTER_METHOD(bool, SBBreakpointList, AppendIfUnique,
-                       (const lldb::SBBreakpoint &));
-  LLDB_REGISTER_METHOD(void, SBBreakpointList, Clear, ());
-}
-
-}
-}
diff --git a/lldb/source/API/SBBreakpointLocation.cpp b/lldb/source/API/SBBreakpointLocation.cpp
index 175120429925..914317437723 100644
--- a/lldb/source/API/SBBreakpointLocation.cpp
+++ b/lldb/source/API/SBBreakpointLocation.cpp
@@ -7,13 +7,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBBreakpointLocation.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBStream.h"
-#include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBStringList.h"
+#include "lldb/API/SBStructuredData.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
@@ -31,32 +31,25 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBBreakpointLocation::SBBreakpointLocation() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointLocation);
-}
+SBBreakpointLocation::SBBreakpointLocation() { LLDB_INSTRUMENT_VA(this); }
 
 SBBreakpointLocation::SBBreakpointLocation(
     const lldb::BreakpointLocationSP &break_loc_sp)
     : m_opaque_wp(break_loc_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
-                          (const lldb::BreakpointLocationSP &), break_loc_sp);
+  LLDB_INSTRUMENT_VA(this, break_loc_sp);
 }
 
 SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs)
     : m_opaque_wp(rhs.m_opaque_wp) {
-  LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
-                          (const lldb::SBBreakpointLocation &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const SBBreakpointLocation &SBBreakpointLocation::
 operator=(const SBBreakpointLocation &rhs) {
-  LLDB_RECORD_METHOD(
-      const lldb::SBBreakpointLocation &,
-      SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &),
-      rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_wp = rhs.m_opaque_wp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBBreakpointLocation::~SBBreakpointLocation() = default;
@@ -66,29 +59,28 @@ BreakpointLocationSP SBBreakpointLocation::GetSP() const {
 }
 
 bool SBBreakpointLocation::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBBreakpointLocation::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return bool(GetSP());
 }
 
 SBAddress SBBreakpointLocation::GetAddress() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
-    return LLDB_RECORD_RESULT(SBAddress(loc_sp->GetAddress()));
+    return SBAddress(loc_sp->GetAddress());
   }
 
-  return LLDB_RECORD_RESULT(SBAddress());
+  return SBAddress();
 }
 
 addr_t SBBreakpointLocation::GetLoadAddress() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation,
-                             GetLoadAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   addr_t ret_addr = LLDB_INVALID_ADDRESS;
   BreakpointLocationSP loc_sp = GetSP();
@@ -103,7 +95,7 @@ addr_t SBBreakpointLocation::GetLoadAddress() {
 }
 
 void SBBreakpointLocation::SetEnabled(bool enabled) {
-  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), enabled);
+  LLDB_INSTRUMENT_VA(this, enabled);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -114,7 +106,7 @@ void SBBreakpointLocation::SetEnabled(bool enabled) {
 }
 
 bool SBBreakpointLocation::IsEnabled() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsEnabled);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -126,7 +118,7 @@ bool SBBreakpointLocation::IsEnabled() {
 }
 
 uint32_t SBBreakpointLocation::GetHitCount() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetHitCount);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -138,7 +130,7 @@ uint32_t SBBreakpointLocation::GetHitCount() {
 }
 
 uint32_t SBBreakpointLocation::GetIgnoreCount() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetIgnoreCount);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -150,7 +142,7 @@ uint32_t SBBreakpointLocation::GetIgnoreCount() {
 }
 
 void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
-  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), n);
+  LLDB_INSTRUMENT_VA(this, n);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -161,8 +153,7 @@ void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
 }
 
 void SBBreakpointLocation::SetCondition(const char *condition) {
-  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCondition, (const char *),
-                     condition);
+  LLDB_INSTRUMENT_VA(this, condition);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -173,7 +164,7 @@ void SBBreakpointLocation::SetCondition(const char *condition) {
 }
 
 const char *SBBreakpointLocation::GetCondition() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointLocation, GetCondition);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -185,8 +176,7 @@ const char *SBBreakpointLocation::GetCondition() {
 }
 
 void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
-  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool),
-                     auto_continue);
+  LLDB_INSTRUMENT_VA(this, auto_continue);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -197,7 +187,7 @@ void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
 }
 
 bool SBBreakpointLocation::GetAutoContinue() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, GetAutoContinue);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -210,16 +200,13 @@ bool SBBreakpointLocation::GetAutoContinue() {
 
 void SBBreakpointLocation::SetScriptCallbackFunction(
   const char *callback_function_name) {
-LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
-                   (const char *), callback_function_name);
+  LLDB_INSTRUMENT_VA(this, callback_function_name);
 }
 
 SBError SBBreakpointLocation::SetScriptCallbackFunction(
     const char *callback_function_name,
     SBStructuredData &extra_args) {
-  LLDB_RECORD_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction,
-                     (const char *, SBStructuredData &), callback_function_name,
-                     extra_args);
+  LLDB_INSTRUMENT_VA(this, callback_function_name, extra_args);
   SBError sb_error;
   BreakpointLocationSP loc_sp = GetSP();
 
@@ -240,13 +227,12 @@ SBError SBBreakpointLocation::SetScriptCallbackFunction(
     } else
       sb_error.SetErrorString("invalid breakpoint");
 
-    return LLDB_RECORD_RESULT(sb_error);
+    return sb_error;
 }
 
 SBError
 SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody,
-                     (const char *), callback_body_text);
+  LLDB_INSTRUMENT_VA(this, callback_body_text);
 
   BreakpointLocationSP loc_sp = GetSP();
 
@@ -265,12 +251,11 @@ SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
   } else
     sb_error.SetErrorString("invalid breakpoint");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
-  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
-                     (lldb::SBStringList &), commands);
+  LLDB_INSTRUMENT_VA(this, commands);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (!loc_sp)
@@ -287,8 +272,7 @@ void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
 }
 
 bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
-  LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
-                     (lldb::SBStringList &), commands);
+  LLDB_INSTRUMENT_VA(this, commands);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (!loc_sp)
@@ -302,8 +286,7 @@ bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
 }
 
 void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
-  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t),
-                     thread_id);
+  LLDB_INSTRUMENT_VA(this, thread_id);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -314,7 +297,7 @@ void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
 }
 
 tid_t SBBreakpointLocation::GetThreadID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointLocation, GetThreadID);
+  LLDB_INSTRUMENT_VA(this);
 
   tid_t tid = LLDB_INVALID_THREAD_ID;
   BreakpointLocationSP loc_sp = GetSP();
@@ -327,8 +310,7 @@ tid_t SBBreakpointLocation::GetThreadID() {
 }
 
 void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t),
-                     index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -339,8 +321,7 @@ void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
 }
 
 uint32_t SBBreakpointLocation::GetThreadIndex() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointLocation,
-                                   GetThreadIndex);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t thread_idx = UINT32_MAX;
   BreakpointLocationSP loc_sp = GetSP();
@@ -353,8 +334,7 @@ uint32_t SBBreakpointLocation::GetThreadIndex() const {
 }
 
 void SBBreakpointLocation::SetThreadName(const char *thread_name) {
-  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadName, (const char *),
-                     thread_name);
+  LLDB_INSTRUMENT_VA(this, thread_name);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -365,8 +345,7 @@ void SBBreakpointLocation::SetThreadName(const char *thread_name) {
 }
 
 const char *SBBreakpointLocation::GetThreadName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
-                                   GetThreadName);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -378,8 +357,7 @@ const char *SBBreakpointLocation::GetThreadName() const {
 }
 
 void SBBreakpointLocation::SetQueueName(const char *queue_name) {
-  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetQueueName, (const char *),
-                     queue_name);
+  LLDB_INSTRUMENT_VA(this, queue_name);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -390,8 +368,7 @@ void SBBreakpointLocation::SetQueueName(const char *queue_name) {
 }
 
 const char *SBBreakpointLocation::GetQueueName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
-                                   GetQueueName);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -403,7 +380,7 @@ const char *SBBreakpointLocation::GetQueueName() const {
 }
 
 bool SBBreakpointLocation::IsResolved() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsResolved);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -422,9 +399,7 @@ void SBBreakpointLocation::SetLocation(
 
 bool SBBreakpointLocation::GetDescription(SBStream &description,
                                           DescriptionLevel level) {
-  LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     level);
+  LLDB_INSTRUMENT_VA(this, description, level);
 
   Stream &strm = description.ref();
   BreakpointLocationSP loc_sp = GetSP();
@@ -441,7 +416,7 @@ bool SBBreakpointLocation::GetDescription(SBStream &description,
 }
 
 break_id_t SBBreakpointLocation::GetID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::break_id_t, SBBreakpointLocation, GetID);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
@@ -453,8 +428,7 @@ break_id_t SBBreakpointLocation::GetID() {
 }
 
 SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation,
-                             GetBreakpoint);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointLocationSP loc_sp = GetSP();
 
@@ -465,70 +439,5 @@ SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
     sb_bp = loc_sp->GetBreakpoint().shared_from_this();
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
-}
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBBreakpointLocation>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
-                            (const lldb::BreakpointLocationSP &));
-  LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
-                            (const lldb::SBBreakpointLocation &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBBreakpointLocation &,
-      SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, operator bool, ());
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBBreakpointLocation, GetAddress, ());
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBBreakpointLocation, GetLoadAddress,
-                       ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetEnabled, (bool));
-  LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsEnabled, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetHitCount, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetIgnoreCount, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetIgnoreCount,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCondition,
-                       (const char *));
-  LLDB_REGISTER_METHOD(const char *, SBBreakpointLocation, GetCondition, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool));
-  LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetAutoContinue, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
-                       (const char *));
-  LLDB_REGISTER_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction,
-                       (const char *, SBStructuredData &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointLocation,
-                       SetScriptCallbackBody, (const char *));
-  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
-                       (lldb::SBStringList &));
-  LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
-                       (lldb::SBStringList &));
-  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadID,
-                       (lldb::tid_t));
-  LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointLocation, GetThreadID, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointLocation, GetThreadIndex,
-                             ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadName,
-                       (const char *));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation,
-                             GetThreadName, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetQueueName,
-                       (const char *));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, GetQueueName,
-                             ());
-  LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsResolved, ());
-  LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-  LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpointLocation, GetID, ());
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointLocation,
-                       GetBreakpoint, ());
-}
-
-}
+  return sb_bp;
 }
diff --git a/lldb/source/API/SBBreakpointName.cpp b/lldb/source/API/SBBreakpointName.cpp
index b5c700c78bbb..796229d04ce4 100644
--- a/lldb/source/API/SBBreakpointName.cpp
+++ b/lldb/source/API/SBBreakpointName.cpp
@@ -7,13 +7,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBBreakpointName.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBTarget.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/Breakpoint/BreakpointName.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
@@ -107,13 +107,10 @@ lldb_private::BreakpointName *SBBreakpointNameImpl::GetBreakpointName() const {
 
 } // namespace lldb
 
-SBBreakpointName::SBBreakpointName() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointName);
-}
+SBBreakpointName::SBBreakpointName() { LLDB_INSTRUMENT_VA(this); }
 
 SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) {
-  LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (lldb::SBTarget &, const char *),
-                          sb_target, name);
+  LLDB_INSTRUMENT_VA(this, sb_target, name);
 
   m_impl_up = std::make_unique<SBBreakpointNameImpl>(sb_target, name);
   // Call FindBreakpointName here to make sure the name is valid, reset if not:
@@ -123,8 +120,7 @@ SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) {
 }
 
 SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) {
-  LLDB_RECORD_CONSTRUCTOR(SBBreakpointName,
-                          (lldb::SBBreakpoint &, const char *), sb_bkpt, name);
+  LLDB_INSTRUMENT_VA(this, sb_bkpt, name);
 
   if (!sb_bkpt.IsValid()) {
     m_impl_up.reset();
@@ -149,8 +145,7 @@ SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) {
 }
 
 SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) {
-  LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &),
-                          rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!rhs.m_impl_up)
     return;
@@ -163,40 +158,36 @@ SBBreakpointName::~SBBreakpointName() = default;
 
 const SBBreakpointName &SBBreakpointName::
 operator=(const SBBreakpointName &rhs) {
-  LLDB_RECORD_METHOD(
-      const lldb::SBBreakpointName &,
-      SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!rhs.m_impl_up) {
     m_impl_up.reset();
-    return LLDB_RECORD_RESULT(*this);
+    return *this;
   }
 
   m_impl_up = std::make_unique<SBBreakpointNameImpl>(rhs.m_impl_up->GetTarget(),
                                                      rhs.m_impl_up->GetName());
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) {
-  LLDB_RECORD_METHOD(
-      bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return *m_impl_up == *rhs.m_impl_up;
 }
 
 bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) {
-  LLDB_RECORD_METHOD(
-      bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return *m_impl_up != *rhs.m_impl_up;
 }
 
 bool SBBreakpointName::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBBreakpointName::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!m_impl_up)
     return false;
@@ -204,7 +195,7 @@ SBBreakpointName::operator bool() const {
 }
 
 const char *SBBreakpointName::GetName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!m_impl_up)
     return "<Invalid Breakpoint Name Object>";
@@ -212,7 +203,7 @@ const char *SBBreakpointName::GetName() const {
 }
 
 void SBBreakpointName::SetEnabled(bool enable) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable);
+  LLDB_INSTRUMENT_VA(this, enable);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -236,7 +227,7 @@ void SBBreakpointName::UpdateName(BreakpointName &bp_name) {
 }
 
 bool SBBreakpointName::IsEnabled() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -249,7 +240,7 @@ bool SBBreakpointName::IsEnabled() {
 }
 
 void SBBreakpointName::SetOneShot(bool one_shot) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot);
+  LLDB_INSTRUMENT_VA(this, one_shot);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -263,7 +254,7 @@ void SBBreakpointName::SetOneShot(bool one_shot) {
 }
 
 bool SBBreakpointName::IsOneShot() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot);
+  LLDB_INSTRUMENT_VA(this);
 
   const BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -276,7 +267,7 @@ bool SBBreakpointName::IsOneShot() const {
 }
 
 void SBBreakpointName::SetIgnoreCount(uint32_t count) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count);
+  LLDB_INSTRUMENT_VA(this, count);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -290,7 +281,7 @@ void SBBreakpointName::SetIgnoreCount(uint32_t count) {
 }
 
 uint32_t SBBreakpointName::GetIgnoreCount() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -303,8 +294,7 @@ uint32_t SBBreakpointName::GetIgnoreCount() const {
 }
 
 void SBBreakpointName::SetCondition(const char *condition) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *),
-                     condition);
+  LLDB_INSTRUMENT_VA(this, condition);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -318,7 +308,7 @@ void SBBreakpointName::SetCondition(const char *condition) {
 }
 
 const char *SBBreakpointName::GetCondition() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -331,8 +321,7 @@ const char *SBBreakpointName::GetCondition() {
 }
 
 void SBBreakpointName::SetAutoContinue(bool auto_continue) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool),
-                     auto_continue);
+  LLDB_INSTRUMENT_VA(this, auto_continue);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -346,7 +335,7 @@ void SBBreakpointName::SetAutoContinue(bool auto_continue) {
 }
 
 bool SBBreakpointName::GetAutoContinue() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -359,7 +348,7 @@ bool SBBreakpointName::GetAutoContinue() {
 }
 
 void SBBreakpointName::SetThreadID(tid_t tid) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid);
+  LLDB_INSTRUMENT_VA(this, tid);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -373,7 +362,7 @@ void SBBreakpointName::SetThreadID(tid_t tid) {
 }
 
 tid_t SBBreakpointName::GetThreadID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -386,7 +375,7 @@ tid_t SBBreakpointName::GetThreadID() {
 }
 
 void SBBreakpointName::SetThreadIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -400,7 +389,7 @@ void SBBreakpointName::SetThreadIndex(uint32_t index) {
 }
 
 uint32_t SBBreakpointName::GetThreadIndex() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -413,8 +402,7 @@ uint32_t SBBreakpointName::GetThreadIndex() const {
 }
 
 void SBBreakpointName::SetThreadName(const char *thread_name) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *),
-                     thread_name);
+  LLDB_INSTRUMENT_VA(this, thread_name);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -428,8 +416,7 @@ void SBBreakpointName::SetThreadName(const char *thread_name) {
 }
 
 const char *SBBreakpointName::GetThreadName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
-                                   GetThreadName);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -442,8 +429,7 @@ const char *SBBreakpointName::GetThreadName() const {
 }
 
 void SBBreakpointName::SetQueueName(const char *queue_name) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *),
-                     queue_name);
+  LLDB_INSTRUMENT_VA(this, queue_name);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -457,8 +443,7 @@ void SBBreakpointName::SetQueueName(const char *queue_name) {
 }
 
 const char *SBBreakpointName::GetQueueName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
-                                   GetQueueName);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -471,8 +456,7 @@ const char *SBBreakpointName::GetQueueName() const {
 }
 
 void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands,
-                     (lldb::SBStringList &), commands);
+  LLDB_INSTRUMENT_VA(this, commands);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -491,8 +475,7 @@ void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
 }
 
 bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
-  LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
-                     (lldb::SBStringList &), commands);
+  LLDB_INSTRUMENT_VA(this, commands);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -507,8 +490,7 @@ bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
 }
 
 const char *SBBreakpointName::GetHelpString() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
-                                   GetHelpString);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -518,8 +500,7 @@ const char *SBBreakpointName::GetHelpString() const {
 }
 
 void SBBreakpointName::SetHelpString(const char *help_string) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *),
-                     help_string);
+  LLDB_INSTRUMENT_VA(this, help_string);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -532,8 +513,7 @@ void SBBreakpointName::SetHelpString(const char *help_string) {
 }
 
 bool SBBreakpointName::GetDescription(SBStream &s) {
-  LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &),
-                     s);
+  LLDB_INSTRUMENT_VA(this, s);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -550,8 +530,7 @@ bool SBBreakpointName::GetDescription(SBStream &s) {
 
 void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
                                    void *baton) {
-  LLDB_RECORD_DUMMY(void, SBBreakpointName, SetCallback,
-                    (lldb::SBBreakpointHitCallback, void *), callback, baton);
+  LLDB_INSTRUMENT_VA(this, callback, baton);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -569,8 +548,7 @@ void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
 
 void SBBreakpointName::SetScriptCallbackFunction(
   const char *callback_function_name) {
-LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
-                   (const char *), callback_function_name);
+  LLDB_INSTRUMENT_VA(this, callback_function_name);
   SBStructuredData empty_args;
   SetScriptCallbackFunction(callback_function_name, empty_args);
 }
@@ -578,14 +556,12 @@ LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
 SBError SBBreakpointName::SetScriptCallbackFunction(
     const char *callback_function_name, 
     SBStructuredData &extra_args) {
-  LLDB_RECORD_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction,
-                     (const char *, SBStructuredData &), 
-                     callback_function_name, extra_args);
+  LLDB_INSTRUMENT_VA(this, callback_function_name, extra_args);
   SBError sb_error;
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name) {
     sb_error.SetErrorString("unrecognized breakpoint name");
-    return LLDB_RECORD_RESULT(sb_error);
+    return sb_error;
   }
 
   std::lock_guard<std::recursive_mutex> guard(
@@ -601,18 +577,17 @@ SBError SBBreakpointName::SetScriptCallbackFunction(
                   extra_args.m_impl_up->GetObjectSP());
   sb_error.SetError(error);
   UpdateName(*bp_name);
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError
 SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
-                     (const char *), callback_body_text);
+  LLDB_INSTRUMENT_VA(this, callback_body_text);
 
   SBError sb_error;
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
-    return LLDB_RECORD_RESULT(sb_error);
+    return sb_error;
 
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
@@ -627,11 +602,11 @@ SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
   if (!sb_error.Fail())
     UpdateName(*bp_name);
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 bool SBBreakpointName::GetAllowList() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -640,8 +615,7 @@ bool SBBreakpointName::GetAllowList() const {
 }
 
 void SBBreakpointName::SetAllowList(bool value) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value);
-
+  LLDB_INSTRUMENT_VA(this, value);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -650,7 +624,7 @@ void SBBreakpointName::SetAllowList(bool value) {
 }
 
 bool SBBreakpointName::GetAllowDelete() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -659,8 +633,7 @@ bool SBBreakpointName::GetAllowDelete() {
 }
 
 void SBBreakpointName::SetAllowDelete(bool value) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value);
-
+  LLDB_INSTRUMENT_VA(this, value);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -669,7 +642,7 @@ void SBBreakpointName::SetAllowDelete(bool value) {
 }
 
 bool SBBreakpointName::GetAllowDisable() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable);
+  LLDB_INSTRUMENT_VA(this);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -678,7 +651,7 @@ bool SBBreakpointName::GetAllowDisable() {
 }
 
 void SBBreakpointName::SetAllowDisable(bool value) {
-  LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value);
+  LLDB_INSTRUMENT_VA(this, value);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
@@ -692,72 +665,3 @@ lldb_private::BreakpointName *SBBreakpointName::GetBreakpointName() const
     return nullptr;
   return m_impl_up->GetBreakpointName();
 }
-
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBBreakpointName>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
-                            (lldb::SBTarget &, const char *));
-  LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
-                            (lldb::SBBreakpoint &, const char *));
-  LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
-                            (const lldb::SBBreakpointName &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBBreakpointName &,
-      SBBreakpointName, operator=,(const lldb::SBBreakpointName &));
-  LLDB_REGISTER_METHOD(
-      bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &));
-  LLDB_REGISTER_METHOD(
-      bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, operator bool, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool));
-  LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *));
-  LLDB_REGISTER_METHOD(const char *, SBBreakpointName, GetCondition, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAutoContinue, (bool));
-  LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAutoContinue, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t));
-  LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointName, GetThreadID, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetThreadIndex, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadName, (const char *));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetThreadName,
-                             ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetQueueName, (const char *));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetQueueName,
-                             ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCommandLineCommands,
-                       (lldb::SBStringList &));
-  LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
-                       (lldb::SBStringList &));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetHelpString,
-                             ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetHelpString, (const char *));
-  LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetDescription,
-                       (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
-                       (const char *));
-  LLDB_REGISTER_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction,
-                       (const char *, SBStructuredData &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
-                       (const char *));
-  LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, GetAllowList, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowList, (bool));
-  LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDelete, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDelete, (bool));
-  LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDisable, ());
-  LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDisable, (bool));
-}
-
-}
-}
diff --git a/lldb/source/API/SBBreakpointOptionCommon.cpp b/lldb/source/API/SBBreakpointOptionCommon.cpp
index 2ee47ff7795c..685ed172c820 100644
--- a/lldb/source/API/SBBreakpointOptionCommon.cpp
+++ b/lldb/source/API/SBBreakpointOptionCommon.cpp
@@ -26,6 +26,7 @@
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
@@ -38,19 +39,18 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBBreakpointCallbackBaton::SBBreakpointCallbackBaton(SBBreakpointHitCallback 
-                                                         callback,
-                                                     void *baton)
-      : TypedBaton(std::make_unique<CallbackData>()) {
-    getItem()->callback = callback;
-    getItem()->callback_baton = baton;
-  }
+SBBreakpointCallbackBaton::SBBreakpointCallbackBaton(
+    SBBreakpointHitCallback callback, void *baton)
+    : TypedBaton(std::make_unique<CallbackData>()) {
+  LLDB_INSTRUMENT_VA(this, callback, baton);
+  getItem()->callback = callback;
+  getItem()->callback_baton = baton;
+}
 
- bool SBBreakpointCallbackBaton::PrivateBreakpointHitCallback(void *baton,
-                                                  StoppointCallbackContext *ctx,
-                                                  lldb::user_id_t break_id,
-                                                  lldb::user_id_t break_loc_id)
-{
+bool SBBreakpointCallbackBaton::PrivateBreakpointHitCallback(
+    void *baton, StoppointCallbackContext *ctx, lldb::user_id_t break_id,
+    lldb::user_id_t break_loc_id) {
+  LLDB_INSTRUMENT_VA(baton, ctx, break_id, break_loc_id);
   ExecutionContext exe_ctx(ctx->exe_ctx_ref);
   BreakpointSP bp_sp(
       exe_ctx.GetTargetRef().GetBreakpointList().FindBreakpointByID(break_id));
diff --git a/lldb/source/API/SBBroadcaster.cpp b/lldb/source/API/SBBroadcaster.cpp
index 2e6d837f102b..f145bc6e99d8 100644
--- a/lldb/source/API/SBBroadcaster.cpp
+++ b/lldb/source/API/SBBroadcaster.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "SBReproducerPrivate.h"
 #include "lldb/Utility/Broadcaster.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBEvent.h"
@@ -16,13 +16,11 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBBroadcaster::SBBroadcaster() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster);
-}
+SBBroadcaster::SBBroadcaster() { LLDB_INSTRUMENT_VA(this); }
 
 SBBroadcaster::SBBroadcaster(const char *name)
     : m_opaque_sp(new Broadcaster(nullptr, name)), m_opaque_ptr(nullptr) {
-  LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const char *), name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   m_opaque_ptr = m_opaque_sp.get();
 }
@@ -32,26 +30,23 @@ 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) {
-  LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBBroadcaster &,
-                     SBBroadcaster, operator=,(const lldb::SBBroadcaster &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
     m_opaque_ptr = rhs.m_opaque_ptr;
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBBroadcaster::~SBBroadcaster() { reset(nullptr, false); }
 
 void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
-  LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType,
-                     (uint32_t, bool), event_type, unique);
+  LLDB_INSTRUMENT_VA(this, event_type, unique);
 
   if (m_opaque_ptr == nullptr)
     return;
@@ -63,8 +58,7 @@ 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);
+  LLDB_INSTRUMENT_VA(this, event, unique);
 
   if (m_opaque_ptr == nullptr)
     return;
@@ -78,9 +72,7 @@ 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);
+  LLDB_INSTRUMENT_VA(this, listener, requested_events);
 
   if (m_opaque_ptr)
     m_opaque_ptr->AddInitialEventsToListener(listener.m_opaque_sp,
@@ -89,9 +81,7 @@ 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);
+  LLDB_INSTRUMENT_VA(this, listener, event_mask);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->AddListener(listener.m_opaque_sp, event_mask);
@@ -99,7 +89,7 @@ uint32_t SBBroadcaster::AddListener(const SBListener &listener,
 }
 
 const char *SBBroadcaster::GetName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBroadcaster, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->GetBroadcasterName().GetCString();
@@ -107,8 +97,7 @@ const char *SBBroadcaster::GetName() const {
 }
 
 bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
-  LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t),
-                     event_type);
+  LLDB_INSTRUMENT_VA(this, event_type);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->EventTypeHasListeners(event_type);
@@ -117,9 +106,7 @@ 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);
+  LLDB_INSTRUMENT_VA(this, listener, event_mask);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask);
@@ -137,77 +124,36 @@ void SBBroadcaster::reset(Broadcaster *broadcaster, bool owns) {
 }
 
 bool SBBroadcaster::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBBroadcaster::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_ptr != nullptr;
 }
 
 void SBBroadcaster::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_sp.reset();
   m_opaque_ptr = nullptr;
 }
 
 bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &), rhs);
+  LLDB_INSTRUMENT_VA(this, 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);
+  LLDB_INSTRUMENT_VA(this, 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);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_ptr < rhs.m_opaque_ptr;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBBroadcaster>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const char *));
-  LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBBroadcaster &,
-      SBBroadcaster, operator=,(const lldb::SBBroadcaster &));
-  LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEventByType,
-                       (uint32_t, bool));
-  LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEvent,
-                       (const lldb::SBEvent &, bool));
-  LLDB_REGISTER_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
-                       (const lldb::SBListener &, uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBBroadcaster, AddListener,
-                       (const lldb::SBListener &, uint32_t));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBBroadcaster, GetName, ());
-  LLDB_REGISTER_METHOD(bool, SBBroadcaster, EventTypeHasListeners,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBBroadcaster, RemoveListener,
-                       (const lldb::SBListener &, uint32_t));
-  LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBBroadcaster, Clear, ());
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &));
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &));
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBCommandInterpreter.cpp b/lldb/source/API/SBCommandInterpreter.cpp
index 3830f6ed80ba..073c1a1b042c 100644
--- a/lldb/source/API/SBCommandInterpreter.cpp
+++ b/lldb/source/API/SBCommandInterpreter.cpp
@@ -8,11 +8,11 @@
 
 #include "lldb/lldb-types.h"
 
-#include "SBReproducerPrivate.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Listener.h"
 
 #include "lldb/API/SBBroadcaster.h"
@@ -78,71 +78,62 @@ protected:
 
 SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
     : m_opaque_ptr(interpreter) {
-  LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
-                          (lldb_private::CommandInterpreter *), interpreter);
-
+  LLDB_INSTRUMENT_VA(this, interpreter);
 }
 
 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
     : m_opaque_ptr(rhs.m_opaque_ptr) {
-  LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
-                          (const lldb::SBCommandInterpreter &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBCommandInterpreter::~SBCommandInterpreter() = default;
 
 const SBCommandInterpreter &SBCommandInterpreter::
 operator=(const SBCommandInterpreter &rhs) {
-  LLDB_RECORD_METHOD(
-      const lldb::SBCommandInterpreter &,
-      SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &),
-      rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_ptr = rhs.m_opaque_ptr;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBCommandInterpreter::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBCommandInterpreter::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_ptr != nullptr;
 }
 
 bool SBCommandInterpreter::CommandExists(const char *cmd) {
-  LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *),
-                     cmd);
+  LLDB_INSTRUMENT_VA(this, cmd);
 
   return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd)
                                           : false);
 }
 
 bool SBCommandInterpreter::AliasExists(const char *cmd) {
-  LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *),
-                     cmd);
+  LLDB_INSTRUMENT_VA(this, cmd);
 
   return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd)
                                           : false);
 }
 
 bool SBCommandInterpreter::IsActive() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive);
+  LLDB_INSTRUMENT_VA(this);
 
   return (IsValid() ? m_opaque_ptr->IsActive() : false);
 }
 
 bool SBCommandInterpreter::WasInterrupted() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, WasInterrupted);
+  LLDB_INSTRUMENT_VA(this);
 
   return (IsValid() ? m_opaque_ptr->WasInterrupted() : false);
 }
 
 const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) {
-  LLDB_RECORD_METHOD(const char *, SBCommandInterpreter,
-                     GetIOHandlerControlSequence, (char), ch);
+  LLDB_INSTRUMENT_VA(this, ch);
 
   return (IsValid()
               ? m_opaque_ptr->GetDebugger()
@@ -155,9 +146,7 @@ lldb::ReturnStatus
 SBCommandInterpreter::HandleCommand(const char *command_line,
                                     SBCommandReturnObject &result,
                                     bool add_to_history) {
-  LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
-                     (const char *, lldb::SBCommandReturnObject &, bool),
-                     command_line, result, add_to_history);
+  LLDB_INSTRUMENT_VA(this, command_line, result, add_to_history);
 
   SBExecutionContext sb_exe_ctx;
   return HandleCommand(command_line, sb_exe_ctx, result, add_to_history);
@@ -166,10 +155,8 @@ SBCommandInterpreter::HandleCommand(const char *command_line,
 lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
     const char *command_line, SBExecutionContext &override_context,
     SBCommandReturnObject &result, bool add_to_history) {
-  LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
-                     (const char *, lldb::SBExecutionContext &,
-                      lldb::SBCommandReturnObject &, bool),
-                     command_line, override_context, result, add_to_history);
+  LLDB_INSTRUMENT_VA(this, command_line, override_context, result,
+                     add_to_history);
 
   result.Clear();
   if (command_line && IsValid()) {
@@ -194,11 +181,7 @@ void SBCommandInterpreter::HandleCommandsFromFile(
     lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
     lldb::SBCommandInterpreterRunOptions &options,
     lldb::SBCommandReturnObject result) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
-                     (lldb::SBFileSpec &, lldb::SBExecutionContext &,
-                      lldb::SBCommandInterpreterRunOptions &,
-                      lldb::SBCommandReturnObject),
-                     file, override_context, options, result);
+  LLDB_INSTRUMENT_VA(this, file, override_context, options, result);
 
   if (!IsValid()) {
     result->AppendError("SBCommandInterpreter is not valid.");
@@ -225,10 +208,7 @@ void SBCommandInterpreter::HandleCommandsFromFile(
 int SBCommandInterpreter::HandleCompletion(
     const char *current_line, const char *cursor, const char *last_char,
     int match_start_point, int max_return_elements, SBStringList &matches) {
-  LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
-                     (const char *, const char *, const char *, int, int,
-                      lldb::SBStringList &),
-                     current_line, cursor, last_char, match_start_point,
+  LLDB_INSTRUMENT_VA(this, current_line, cursor, last_char, match_start_point,
                      max_return_elements, matches);
 
   SBStringList dummy_descriptions;
@@ -241,11 +221,7 @@ int SBCommandInterpreter::HandleCompletionWithDescriptions(
     const char *current_line, const char *cursor, const char *last_char,
     int match_start_point, int max_return_elements, SBStringList &matches,
     SBStringList &descriptions) {
-  LLDB_RECORD_METHOD(int, SBCommandInterpreter,
-                     HandleCompletionWithDescriptions,
-                     (const char *, const char *, const char *, int, int,
-                      lldb::SBStringList &, lldb::SBStringList &),
-                     current_line, cursor, last_char, match_start_point,
+  LLDB_INSTRUMENT_VA(this, current_line, cursor, last_char, match_start_point,
                      max_return_elements, matches, descriptions);
 
   // Sanity check the arguments that are passed in: cursor & last_char have to
@@ -311,11 +287,7 @@ int SBCommandInterpreter::HandleCompletionWithDescriptions(
     const char *current_line, uint32_t cursor_pos, int match_start_point,
     int max_return_elements, SBStringList &matches,
     SBStringList &descriptions) {
-  LLDB_RECORD_METHOD(int, SBCommandInterpreter,
-                     HandleCompletionWithDescriptions,
-                     (const char *, uint32_t, int, int, lldb::SBStringList &,
-                      lldb::SBStringList &),
-                     current_line, cursor_pos, match_start_point,
+  LLDB_INSTRUMENT_VA(this, current_line, cursor_pos, match_start_point,
                      max_return_elements, matches, descriptions);
 
   const char *cursor = current_line + cursor_pos;
@@ -330,9 +302,7 @@ int SBCommandInterpreter::HandleCompletion(const char *current_line,
                                            int match_start_point,
                                            int max_return_elements,
                                            lldb::SBStringList &matches) {
-  LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
-                     (const char *, uint32_t, int, int, lldb::SBStringList &),
-                     current_line, cursor_pos, match_start_point,
+  LLDB_INSTRUMENT_VA(this, current_line, cursor_pos, match_start_point,
                      max_return_elements, matches);
 
   const char *cursor = current_line + cursor_pos;
@@ -342,25 +312,25 @@ int SBCommandInterpreter::HandleCompletion(const char *current_line,
 }
 
 bool SBCommandInterpreter::HasCommands() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands);
+  LLDB_INSTRUMENT_VA(this);
 
   return (IsValid() ? m_opaque_ptr->HasCommands() : false);
 }
 
 bool SBCommandInterpreter::HasAliases() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases);
+  LLDB_INSTRUMENT_VA(this);
 
   return (IsValid() ? m_opaque_ptr->HasAliases() : false);
 }
 
 bool SBCommandInterpreter::HasAliasOptions() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions);
+  LLDB_INSTRUMENT_VA(this);
 
   return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false);
 }
 
 SBProcess SBCommandInterpreter::GetProcess() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, GetProcess);
+  LLDB_INSTRUMENT_VA(this);
 
   SBProcess sb_process;
   ProcessSP process_sp;
@@ -373,43 +343,41 @@ SBProcess SBCommandInterpreter::GetProcess() {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_process);
+  return sb_process;
 }
 
 SBDebugger SBCommandInterpreter::GetDebugger() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter,
-                             GetDebugger);
+  LLDB_INSTRUMENT_VA(this);
 
   SBDebugger sb_debugger;
   if (IsValid())
     sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this());
 
-  return LLDB_RECORD_RESULT(sb_debugger);
+  return sb_debugger;
 }
 
 bool SBCommandInterpreter::GetPromptOnQuit() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit);
+  LLDB_INSTRUMENT_VA(this);
 
   return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false);
 }
 
 void SBCommandInterpreter::SetPromptOnQuit(bool b) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b);
+  LLDB_INSTRUMENT_VA(this, b);
 
   if (IsValid())
     m_opaque_ptr->SetPromptOnQuit(b);
 }
 
 void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool),
-                     allow);
+  LLDB_INSTRUMENT_VA(this, allow);
 
   if (m_opaque_ptr)
     m_opaque_ptr->AllowExitCodeOnQuit(allow);
 }
 
 bool SBCommandInterpreter::HasCustomQuitExitCode() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode);
+  LLDB_INSTRUMENT_VA(this);
 
   bool exited = false;
   if (m_opaque_ptr)
@@ -418,7 +386,7 @@ bool SBCommandInterpreter::HasCustomQuitExitCode() {
 }
 
 int SBCommandInterpreter::GetQuitStatus() {
-  LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus);
+  LLDB_INSTRUMENT_VA(this);
 
   bool exited = false;
   return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0);
@@ -426,9 +394,7 @@ int SBCommandInterpreter::GetQuitStatus() {
 
 void SBCommandInterpreter::ResolveCommand(const char *command_line,
                                           SBCommandReturnObject &result) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand,
-                     (const char *, lldb::SBCommandReturnObject &),
-                     command_line, result);
+  LLDB_INSTRUMENT_VA(this, command_line, result);
 
   result.Clear();
   if (command_line && IsValid()) {
@@ -453,8 +419,7 @@ void SBCommandInterpreter::reset(
 
 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
     SBCommandReturnObject &result) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
-                     (lldb::SBCommandReturnObject &), result);
+  LLDB_INSTRUMENT_VA(this, result);
 
   result.Clear();
   if (IsValid()) {
@@ -470,8 +435,7 @@ void SBCommandInterpreter::SourceInitFileInHomeDirectory(
 
 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
     SBCommandReturnObject &result, bool is_repl) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
-                     (lldb::SBCommandReturnObject &, bool), result, is_repl);
+  LLDB_INSTRUMENT_VA(this, result, is_repl);
 
   result.Clear();
   if (IsValid()) {
@@ -487,9 +451,7 @@ void SBCommandInterpreter::SourceInitFileInHomeDirectory(
 
 void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
     SBCommandReturnObject &result) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreter,
-                     SourceInitFileInCurrentWorkingDirectory,
-                     (lldb::SBCommandReturnObject &), result);
+  LLDB_INSTRUMENT_VA(this, result);
 
   result.Clear();
   if (IsValid()) {
@@ -504,46 +466,36 @@ void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
 }
 
 SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter,
-                             GetBroadcaster);
-
+  LLDB_INSTRUMENT_VA(this);
 
   SBBroadcaster broadcaster(m_opaque_ptr, false);
 
-
-  return LLDB_RECORD_RESULT(broadcaster);
+  return broadcaster;
 }
 
 const char *SBCommandInterpreter::GetBroadcasterClass() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter,
-                                    GetBroadcasterClass);
+  LLDB_INSTRUMENT();
 
   return CommandInterpreter::GetStaticBroadcasterClass().AsCString();
 }
 
 const char *SBCommandInterpreter::GetArgumentTypeAsCString(
     const lldb::CommandArgumentType arg_type) {
-  LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter,
-                            GetArgumentTypeAsCString,
-                            (const lldb::CommandArgumentType), arg_type);
+  LLDB_INSTRUMENT_VA(arg_type);
 
   return CommandObject::GetArgumentTypeAsCString(arg_type);
 }
 
 const char *SBCommandInterpreter::GetArgumentDescriptionAsCString(
     const lldb::CommandArgumentType arg_type) {
-  LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter,
-                            GetArgumentDescriptionAsCString,
-                            (const lldb::CommandArgumentType), arg_type);
+  LLDB_INSTRUMENT_VA(arg_type);
 
   return CommandObject::GetArgumentDescriptionAsCString(arg_type);
 }
 
 bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
     const lldb::SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBCommandInterpreter,
-                            EventIsCommandInterpreterEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   return event.GetBroadcasterClass() ==
          SBCommandInterpreter::GetBroadcasterClass();
@@ -552,9 +504,7 @@ bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
 bool SBCommandInterpreter::SetCommandOverrideCallback(
     const char *command_name, lldb::CommandOverrideCallback callback,
     void *baton) {
-  LLDB_RECORD_DUMMY(bool, SBCommandInterpreter, SetCommandOverrideCallback,
-                    (const char *, lldb::CommandOverrideCallback, void *),
-                    command_name, callback, baton);
+  LLDB_INSTRUMENT_VA(this, command_name, callback, baton);
 
   if (command_name && command_name[0] && IsValid()) {
     llvm::StringRef command_name_str = command_name;
@@ -571,48 +521,37 @@ bool SBCommandInterpreter::SetCommandOverrideCallback(
 
 lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
                                                           const char *help) {
-  LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand,
-                     (const char *, const char *), name, help);
+  LLDB_INSTRUMENT_VA(this, name, help);
 
   lldb::CommandObjectSP new_command_sp(
       new CommandObjectMultiword(*m_opaque_ptr, name, help));
   new_command_sp->GetAsMultiwordCommand()->SetRemovable(true);
   Status add_error = m_opaque_ptr->AddUserCommand(name, new_command_sp, true);
   if (add_error.Success())
-    return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
-  return LLDB_RECORD_RESULT(lldb::SBCommand());
+    return lldb::SBCommand(new_command_sp);
+  return lldb::SBCommand();
 }
 
 lldb::SBCommand SBCommandInterpreter::AddCommand(
     const char *name, lldb::SBCommandPluginInterface *impl, const char *help) {
-  LLDB_RECORD_METHOD(
-      lldb::SBCommand, SBCommandInterpreter, AddCommand,
-      (const char *, lldb::SBCommandPluginInterface *, const char *), name,
-      impl, help);
+  LLDB_INSTRUMENT_VA(this, name, impl, help);
 
-  return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr,
-                                       /*auto_repeat_command=*/""))
+  return AddCommand(name, impl, help, /*syntax=*/nullptr,
+                    /*auto_repeat_command=*/"");
 }
 
 lldb::SBCommand
 SBCommandInterpreter::AddCommand(const char *name,
                                  lldb::SBCommandPluginInterface *impl,
                                  const char *help, const char *syntax) {
-  LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
-                     (const char *, lldb::SBCommandPluginInterface *,
-                      const char *, const char *),
-                     name, impl, help, syntax);
-  return LLDB_RECORD_RESULT(
-      AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/""))
+  LLDB_INSTRUMENT_VA(this, name, impl, help, syntax);
+  return AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/"");
 }
 
 lldb::SBCommand SBCommandInterpreter::AddCommand(
     const char *name, lldb::SBCommandPluginInterface *impl, const char *help,
     const char *syntax, const char *auto_repeat_command) {
-  LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
-                     (const char *, lldb::SBCommandPluginInterface *,
-                      const char *, const char *, const char *),
-                     name, impl, help, syntax, auto_repeat_command);
+  LLDB_INSTRUMENT_VA(this, name, impl, help, syntax, auto_repeat_command);
 
   lldb::CommandObjectSP new_command_sp;
   new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
@@ -621,53 +560,53 @@ lldb::SBCommand SBCommandInterpreter::AddCommand(
 
   Status add_error = m_opaque_ptr->AddUserCommand(name, new_command_sp, true);
   if (add_error.Success())
-    return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
-  return LLDB_RECORD_RESULT(lldb::SBCommand());
+    return lldb::SBCommand(new_command_sp);
+  return lldb::SBCommand();
 }
 
-SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); }
+SBCommand::SBCommand() { LLDB_INSTRUMENT_VA(this); }
 
 SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
 
 bool SBCommand::IsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBCommand::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 const char *SBCommand::GetName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
 }
 
 const char *SBCommand::GetHelp() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelp);
+  LLDB_INSTRUMENT_VA(this);
 
   return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString()
                     : nullptr);
 }
 
 const char *SBCommand::GetHelpLong() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong);
+  LLDB_INSTRUMENT_VA(this);
 
   return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString()
                     : nullptr);
 }
 
 void SBCommand::SetHelp(const char *help) {
-  LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help);
+  LLDB_INSTRUMENT_VA(this, help);
 
   if (IsValid())
     m_opaque_sp->SetHelp(help);
 }
 
 void SBCommand::SetHelpLong(const char *help) {
-  LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help);
+  LLDB_INSTRUMENT_VA(this, help);
 
   if (IsValid())
     m_opaque_sp->SetHelpLong(help);
@@ -675,193 +614,64 @@ void SBCommand::SetHelpLong(const char *help) {
 
 lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name,
                                                const char *help) {
-  LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
-                     (const char *, const char *), name, help);
+  LLDB_INSTRUMENT_VA(this, name, help);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(lldb::SBCommand());
+    return lldb::SBCommand();
   if (!m_opaque_sp->IsMultiwordObject())
-    return LLDB_RECORD_RESULT(lldb::SBCommand());
+    return lldb::SBCommand();
   CommandObjectMultiword *new_command = new CommandObjectMultiword(
       m_opaque_sp->GetCommandInterpreter(), name, help);
   new_command->SetRemovable(true);
   lldb::CommandObjectSP new_command_sp(new_command);
   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
-    return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
-  return LLDB_RECORD_RESULT(lldb::SBCommand());
+    return lldb::SBCommand(new_command_sp);
+  return lldb::SBCommand();
 }
 
 lldb::SBCommand SBCommand::AddCommand(const char *name,
                                       lldb::SBCommandPluginInterface *impl,
                                       const char *help) {
-  LLDB_RECORD_METHOD(
-      lldb::SBCommand, SBCommand, AddCommand,
-      (const char *, lldb::SBCommandPluginInterface *, const char *), name,
-      impl, help);
-  return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr,
-                                       /*auto_repeat_command=*/""))
+  LLDB_INSTRUMENT_VA(this, name, impl, help);
+  return AddCommand(name, impl, help, /*syntax=*/nullptr,
+                    /*auto_repeat_command=*/"");
 }
 
 lldb::SBCommand SBCommand::AddCommand(const char *name,
                                       lldb::SBCommandPluginInterface *impl,
                                       const char *help, const char *syntax) {
-  LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand,
-                     (const char *, lldb::SBCommandPluginInterface *,
-                      const char *, const char *),
-                     name, impl, help, syntax);
-  return LLDB_RECORD_RESULT(
-      AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/""))
+  LLDB_INSTRUMENT_VA(this, name, impl, help, syntax);
+  return AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/"");
 }
 
 lldb::SBCommand SBCommand::AddCommand(const char *name,
                                       lldb::SBCommandPluginInterface *impl,
                                       const char *help, const char *syntax,
                                       const char *auto_repeat_command) {
-  LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand,
-                     (const char *, lldb::SBCommandPluginInterface *,
-                      const char *, const char *, const char *),
-                     name, impl, help, syntax, auto_repeat_command);
+  LLDB_INSTRUMENT_VA(this, name, impl, help, syntax, auto_repeat_command);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(lldb::SBCommand());
+    return lldb::SBCommand();
   if (!m_opaque_sp->IsMultiwordObject())
-    return LLDB_RECORD_RESULT(lldb::SBCommand());
+    return lldb::SBCommand();
   lldb::CommandObjectSP new_command_sp;
   new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
       m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax,
       /*flags=*/0, auto_repeat_command);
   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
-    return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
-  return LLDB_RECORD_RESULT(lldb::SBCommand());
+    return lldb::SBCommand(new_command_sp);
+  return lldb::SBCommand();
 }
 
 uint32_t SBCommand::GetFlags() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags);
+  LLDB_INSTRUMENT_VA(this);
 
   return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
 }
 
 void SBCommand::SetFlags(uint32_t flags) {
-  LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags);
+  LLDB_INSTRUMENT_VA(this, flags);
 
   if (IsValid())
     m_opaque_sp->GetFlags().Set(flags);
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <> void RegisterMethods<SBCommandInterpreter>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
-                            (lldb_private::CommandInterpreter *));
-  LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
-                            (const lldb::SBCommandInterpreter &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBCommandInterpreter &,
-      SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ());
-  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists,
-                       (const char *));
-  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists,
-                       (const char *));
-  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ());
-  LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter,
-                       GetIOHandlerControlSequence, (char));
-  LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
-                       HandleCommand,
-                       (const char *, lldb::SBCommandReturnObject &, bool));
-  LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
-                       HandleCommand,
-                       (const char *, lldb::SBExecutionContext &,
-                        lldb::SBCommandReturnObject &, bool));
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
-                       (lldb::SBFileSpec &, lldb::SBExecutionContext &,
-                        lldb::SBCommandInterpreterRunOptions &,
-                        lldb::SBCommandReturnObject));
-  LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion,
-                       (const char *, const char *, const char *, int, int,
-                        lldb::SBStringList &));
-  LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
-                       HandleCompletionWithDescriptions,
-                       (const char *, const char *, const char *, int, int,
-                        lldb::SBStringList &, lldb::SBStringList &));
-  LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
-                       HandleCompletionWithDescriptions,
-                       (const char *, uint32_t, int, int,
-                        lldb::SBStringList &, lldb::SBStringList &));
-  LLDB_REGISTER_METHOD(
-      int, SBCommandInterpreter, HandleCompletion,
-      (const char *, uint32_t, int, int, lldb::SBStringList &));
-  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ());
-  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ());
-  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ());
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBCommandInterpreter, GetProcess, ());
-  LLDB_REGISTER_METHOD(lldb::SBDebugger, SBCommandInterpreter, GetDebugger,
-                       ());
-  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool));
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit,
-                       (bool));
-  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ());
-  LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand,
-                       (const char *, lldb::SBCommandReturnObject &));
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
-                       SourceInitFileInHomeDirectory,
-                       (lldb::SBCommandReturnObject &));
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
-                       SourceInitFileInHomeDirectory,
-                       (lldb::SBCommandReturnObject &, bool));
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
-                       SourceInitFileInCurrentWorkingDirectory,
-                       (lldb::SBCommandReturnObject &));
-  LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter,
-                       GetBroadcaster, ());
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
-                              GetBroadcasterClass, ());
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
-                              GetArgumentTypeAsCString,
-                              (const lldb::CommandArgumentType));
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
-                              GetArgumentDescriptionAsCString,
-                              (const lldb::CommandArgumentType));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBCommandInterpreter,
-                              EventIsCommandInterpreterEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter,
-                       AddMultiwordCommand, (const char *, const char *));
-  LLDB_REGISTER_METHOD(
-      lldb::SBCommand, SBCommandInterpreter, AddCommand,
-      (const char *, lldb::SBCommandPluginInterface *, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
-                       (const char *, lldb::SBCommandPluginInterface *,
-                        const char *, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
-                       (const char *, lldb::SBCommandPluginInterface *,
-                        const char *, const char *, const char *));
-  LLDB_REGISTER_CONSTRUCTOR(SBCommand, ());
-  LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ());
-  LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ());
-  LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ());
-  LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ());
-  LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *));
-  LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
-                       (const char *, const char *));
-  LLDB_REGISTER_METHOD(
-      lldb::SBCommand, SBCommand, AddCommand,
-      (const char *, lldb::SBCommandPluginInterface *, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
-                       (const char *, lldb::SBCommandPluginInterface *,
-                        const char *, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
-                       (const char *, lldb::SBCommandPluginInterface *,
-                        const char *, const char *, const char *));
-  LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
-  LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
-}
-}
-}
diff --git a/lldb/source/API/SBCommandInterpreterRunOptions.cpp b/lldb/source/API/SBCommandInterpreterRunOptions.cpp
index 317ec6d37127..6c6b2aa15a79 100644
--- a/lldb/source/API/SBCommandInterpreterRunOptions.cpp
+++ b/lldb/source/API/SBCommandInterpreterRunOptions.cpp
@@ -8,7 +8,7 @@
 
 #include "lldb/lldb-types.h"
 
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBCommandInterpreterRunOptions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
@@ -19,16 +19,14 @@ using namespace lldb;
 using namespace lldb_private;
 
 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_up = std::make_unique<CommandInterpreterRunOptions>();
 }
 
 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions(
-    const SBCommandInterpreterRunOptions &rhs)
-    : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreterRunOptions,
-                          (const lldb::SBCommandInterpreterRunOptions &), rhs);
+    const SBCommandInterpreterRunOptions &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = std::make_unique<CommandInterpreterRunOptions>(rhs.ref());
 }
@@ -37,153 +35,131 @@ SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
 
 SBCommandInterpreterRunOptions &SBCommandInterpreterRunOptions::operator=(
     const SBCommandInterpreterRunOptions &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunOptions &,
-                     SBCommandInterpreterRunOptions, operator=,
-                     (const lldb::SBCommandInterpreterRunOptions &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this == &rhs)
-    return LLDB_RECORD_RESULT(*this);
+    return *this;
   *m_opaque_up = *rhs.m_opaque_up;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetStopOnContinue);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetStopOnContinue();
 }
 
 void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
-                     (bool), stop_on_continue);
+  LLDB_INSTRUMENT_VA(this, stop_on_continue);
 
   m_opaque_up->SetStopOnContinue(stop_on_continue);
 }
 
 bool SBCommandInterpreterRunOptions::GetStopOnError() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetStopOnError);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetStopOnError();
 }
 
 void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
-                     (bool), stop_on_error);
+  LLDB_INSTRUMENT_VA(this, stop_on_error);
 
   m_opaque_up->SetStopOnError(stop_on_error);
 }
 
 bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetStopOnCrash);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetStopOnCrash();
 }
 
 void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
-                     (bool), stop_on_crash);
+  LLDB_INSTRUMENT_VA(this, stop_on_crash);
 
   m_opaque_up->SetStopOnCrash(stop_on_crash);
 }
 
 bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetEchoCommands);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetEchoCommands();
 }
 
 void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
-                     (bool), echo_commands);
+  LLDB_INSTRUMENT_VA(this, echo_commands);
 
   m_opaque_up->SetEchoCommands(echo_commands);
 }
 
 bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetEchoCommentCommands);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetEchoCommentCommands();
 }
 
 void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions,
-                     SetEchoCommentCommands, (bool), echo);
+  LLDB_INSTRUMENT_VA(this, echo);
 
   m_opaque_up->SetEchoCommentCommands(echo);
 }
 
 bool SBCommandInterpreterRunOptions::GetPrintResults() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetPrintResults);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetPrintResults();
 }
 
 void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
-                     (bool), print_results);
+  LLDB_INSTRUMENT_VA(this, print_results);
 
   m_opaque_up->SetPrintResults(print_results);
 }
 
 bool SBCommandInterpreterRunOptions::GetPrintErrors() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetPrintErrors);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetPrintErrors();
 }
 
 void SBCommandInterpreterRunOptions::SetPrintErrors(bool print_errors) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintErrors,
-                     (bool), print_errors);
+  LLDB_INSTRUMENT_VA(this, print_errors);
 
   m_opaque_up->SetPrintErrors(print_errors);
 }
 
 bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetAddToHistory);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetAddToHistory();
 }
 
 void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
-                     (bool), add_to_history);
+  LLDB_INSTRUMENT_VA(this, add_to_history);
 
   m_opaque_up->SetAddToHistory(add_to_history);
 }
 
 bool SBCommandInterpreterRunOptions::GetAutoHandleEvents() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetAutoHandleEvents);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetAutoHandleEvents();
 }
 
 void SBCommandInterpreterRunOptions::SetAutoHandleEvents(
     bool auto_handle_events) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAutoHandleEvents,
-                     (bool), auto_handle_events);
+  LLDB_INSTRUMENT_VA(this, auto_handle_events);
 
   m_opaque_up->SetAutoHandleEvents(auto_handle_events);
 }
 
 bool SBCommandInterpreterRunOptions::GetSpawnThread() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
-                                   GetSpawnThread);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetSpawnThread();
 }
 
 void SBCommandInterpreterRunOptions::SetSpawnThread(bool spawn_thread) {
-  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread,
-                     (bool), spawn_thread);
+  LLDB_INSTRUMENT_VA(this, spawn_thread);
 
   m_opaque_up->SetSpawnThread(spawn_thread);
 }
@@ -202,21 +178,19 @@ SBCommandInterpreterRunResult::SBCommandInterpreterRunResult()
     : m_opaque_up(new CommandInterpreterRunResult())
 
 {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunResult);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBCommandInterpreterRunResult::SBCommandInterpreterRunResult(
     const SBCommandInterpreterRunResult &rhs)
     : m_opaque_up(new CommandInterpreterRunResult()) {
-  LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreterRunResult,
-                          (const lldb::SBCommandInterpreterRunResult &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   *m_opaque_up = *rhs.m_opaque_up;
 }
 
 SBCommandInterpreterRunResult::SBCommandInterpreterRunResult(
-    const CommandInterpreterRunResult &rhs)
-    : m_opaque_up() {
+    const CommandInterpreterRunResult &rhs) {
   m_opaque_up = std::make_unique<CommandInterpreterRunResult>(rhs);
 }
 
@@ -224,92 +198,23 @@ SBCommandInterpreterRunResult::~SBCommandInterpreterRunResult() = default;
 
 SBCommandInterpreterRunResult &SBCommandInterpreterRunResult::operator=(
     const SBCommandInterpreterRunResult &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult &,
-                     SBCommandInterpreterRunResult, operator=,
-                     (const lldb::SBCommandInterpreterRunResult &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this == &rhs)
-    return LLDB_RECORD_RESULT(*this);
+    return *this;
   *m_opaque_up = *rhs.m_opaque_up;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 int SBCommandInterpreterRunResult::GetNumberOfErrors() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(int, SBCommandInterpreterRunResult,
-                                   GetNumberOfErrors);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetNumErrors();
 }
 
 lldb::CommandInterpreterResult
 SBCommandInterpreterRunResult::GetResult() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::CommandInterpreterResult,
-                                   SBCommandInterpreterRunResult, GetResult);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetResult();
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <> void RegisterMethods<SBCommandInterpreterRunOptions>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions,
-                            (const lldb::SBCommandInterpreterRunOptions &));
-  LLDB_REGISTER_METHOD(lldb::SBCommandInterpreterRunOptions &,
-                       SBCommandInterpreterRunOptions, operator=,
-                       (const lldb::SBCommandInterpreterRunOptions &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetStopOnContinue, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetStopOnError, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetStopOnCrash, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetEchoCommands, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetEchoCommentCommands, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
-                       SetEchoCommentCommands, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetPrintResults, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetPrintErrors, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintErrors,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetAddToHistory, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetAutoHandleEvents, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
-                       SetAutoHandleEvents, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
-                             GetSpawnThread, ());
-  LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread,
-                       (bool));
-  LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunResult, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunResult,
-                            (const lldb::SBCommandInterpreterRunResult &));
-  LLDB_REGISTER_METHOD(lldb::SBCommandInterpreterRunResult &,
-                       SBCommandInterpreterRunResult, operator=,
-                       (const lldb::SBCommandInterpreterRunResult &));
-  LLDB_REGISTER_METHOD_CONST(int, SBCommandInterpreterRunResult,
-                             GetNumberOfErrors, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::CommandInterpreterResult,
-                             SBCommandInterpreterRunResult, GetResult, ());
-}
-
-} // namespace repro
-} // namespace lldb_private
diff --git a/lldb/source/API/SBCommandReturnObject.cpp b/lldb/source/API/SBCommandReturnObject.cpp
index 00150d198fca..7d2c102b3d8c 100644
--- a/lldb/source/API/SBCommandReturnObject.cpp
+++ b/lldb/source/API/SBCommandReturnObject.cpp
@@ -7,13 +7,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBCommandReturnObject.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFile.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
@@ -46,76 +46,70 @@ private:
 
 SBCommandReturnObject::SBCommandReturnObject()
     : m_opaque_up(new SBCommandReturnObjectImpl()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandReturnObject);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject &ref)
     : m_opaque_up(new SBCommandReturnObjectImpl(ref)) {
-  LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
-                          (lldb_private::CommandReturnObject &), ref);
+  LLDB_INSTRUMENT_VA(this, ref);
 }
 
-SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs)
-    : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
-                          (const lldb::SBCommandReturnObject &), rhs);
+SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 SBCommandReturnObject &SBCommandReturnObject::
 operator=(const SBCommandReturnObject &rhs) {
-  LLDB_RECORD_METHOD(
-      lldb::SBCommandReturnObject &,
-      SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &),
-      rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBCommandReturnObject::~SBCommandReturnObject() = default;
 
 bool SBCommandReturnObject::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBCommandReturnObject::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   // This method is not useful but it needs to stay to keep SB API stable.
   return true;
 }
 
 const char *SBCommandReturnObject::GetOutput() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetOutput);
+  LLDB_INSTRUMENT_VA(this);
 
   ConstString output(ref().GetOutputData());
   return output.AsCString(/*value_if_empty*/ "");
 }
 
 const char *SBCommandReturnObject::GetError() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError);
+  LLDB_INSTRUMENT_VA(this);
 
   ConstString output(ref().GetErrorData());
   return output.AsCString(/*value_if_empty*/ "");
 }
 
 size_t SBCommandReturnObject::GetOutputSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetOutputSize);
+  LLDB_INSTRUMENT_VA(this);
 
   return ref().GetOutputData().size();
 }
 
 size_t SBCommandReturnObject::GetErrorSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize);
+  LLDB_INSTRUMENT_VA(this);
 
   return ref().GetErrorData().size();
 }
 
 size_t SBCommandReturnObject::PutOutput(FILE *fh) {
-  LLDB_RECORD_DUMMY(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh);
+  LLDB_INSTRUMENT_VA(this, fh);
   if (fh) {
     size_t num_bytes = GetOutputSize();
     if (num_bytes)
@@ -125,22 +119,21 @@ size_t SBCommandReturnObject::PutOutput(FILE *fh) {
 }
 
 size_t SBCommandReturnObject::PutOutput(FileSP file_sp) {
-  LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP),
-                     file_sp);
+  LLDB_INSTRUMENT_VA(this, file_sp);
   if (!file_sp)
     return 0;
   return file_sp->Printf("%s", GetOutput());
 }
 
 size_t SBCommandReturnObject::PutOutput(SBFile file) {
-  LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (SBFile), file);
+  LLDB_INSTRUMENT_VA(this, file);
   if (!file.m_opaque_sp)
     return 0;
   return file.m_opaque_sp->Printf("%s", GetOutput());
 }
 
 size_t SBCommandReturnObject::PutError(FILE *fh) {
-  LLDB_RECORD_DUMMY(size_t, SBCommandReturnObject, PutError, (FILE *), fh);
+  LLDB_INSTRUMENT_VA(this, fh);
   if (fh) {
     size_t num_bytes = GetErrorSize();
     if (num_bytes)
@@ -150,62 +143,57 @@ size_t SBCommandReturnObject::PutError(FILE *fh) {
 }
 
 size_t SBCommandReturnObject::PutError(FileSP file_sp) {
-  LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP),
-                     file_sp);
+  LLDB_INSTRUMENT_VA(this, file_sp);
   if (!file_sp)
     return 0;
   return file_sp->Printf("%s", GetError());
 }
 
 size_t SBCommandReturnObject::PutError(SBFile file) {
-  LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (SBFile), file);
+  LLDB_INSTRUMENT_VA(this, file);
   if (!file.m_opaque_sp)
     return 0;
   return file.m_opaque_sp->Printf("%s", GetError());
 }
 
 void SBCommandReturnObject::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBCommandReturnObject, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   ref().Clear();
 }
 
 lldb::ReturnStatus SBCommandReturnObject::GetStatus() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject,
-                             GetStatus);
+  LLDB_INSTRUMENT_VA(this);
 
   return ref().GetStatus();
 }
 
 void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) {
-  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus,
-                     (lldb::ReturnStatus), status);
+  LLDB_INSTRUMENT_VA(this, status);
 
   ref().SetStatus(status);
 }
 
 bool SBCommandReturnObject::Succeeded() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, Succeeded);
+  LLDB_INSTRUMENT_VA(this);
 
   return ref().Succeeded();
 }
 
 bool SBCommandReturnObject::HasResult() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, HasResult);
+  LLDB_INSTRUMENT_VA(this);
 
   return ref().HasResult();
 }
 
 void SBCommandReturnObject::AppendMessage(const char *message) {
-  LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendMessage, (const char *),
-                     message);
+  LLDB_INSTRUMENT_VA(this, message);
 
   ref().AppendMessage(message);
 }
 
 void SBCommandReturnObject::AppendWarning(const char *message) {
-  LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *),
-                     message);
+  LLDB_INSTRUMENT_VA(this, message);
 
   ref().AppendWarning(message);
 }
@@ -227,8 +215,7 @@ CommandReturnObject &SBCommandReturnObject::ref() const {
 }
 
 bool SBCommandReturnObject::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription,
-                     (lldb::SBStream &), description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -253,62 +240,53 @@ bool SBCommandReturnObject::GetDescription(SBStream &description) {
 }
 
 void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) {
-  LLDB_RECORD_DUMMY(void, SBCommandReturnObject, SetImmediateOutputFile,
-                    (FILE *), fh);
+  LLDB_INSTRUMENT_VA(this, fh);
 
   SetImmediateOutputFile(fh, false);
 }
 
 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) {
-  LLDB_RECORD_DUMMY(void, SBCommandReturnObject, SetImmediateErrorFile,
-                    (FILE *), fh);
+  LLDB_INSTRUMENT_VA(this, fh);
 
   SetImmediateErrorFile(fh, false);
 }
 
 void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh,
                                                    bool transfer_ownership) {
-  LLDB_RECORD_DUMMY(void, SBCommandReturnObject, SetImmediateOutputFile,
-                    (FILE *, bool), fh, transfer_ownership);
+  LLDB_INSTRUMENT_VA(this, fh, transfer_ownership);
   FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership);
   ref().SetImmediateOutputFile(file);
 }
 
 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh,
                                                   bool transfer_ownership) {
-  LLDB_RECORD_DUMMY(void, SBCommandReturnObject, SetImmediateErrorFile,
-                    (FILE *, bool), fh, transfer_ownership);
+  LLDB_INSTRUMENT_VA(this, fh, transfer_ownership);
   FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership);
   ref().SetImmediateErrorFile(file);
 }
 
 void SBCommandReturnObject::SetImmediateOutputFile(SBFile file) {
-  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
-                     (SBFile), file);
+  LLDB_INSTRUMENT_VA(this, file);
   ref().SetImmediateOutputFile(file.m_opaque_sp);
 }
 
 void SBCommandReturnObject::SetImmediateErrorFile(SBFile file) {
-  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
-                     (SBFile), file);
+  LLDB_INSTRUMENT_VA(this, file);
   ref().SetImmediateErrorFile(file.m_opaque_sp);
 }
 
 void SBCommandReturnObject::SetImmediateOutputFile(FileSP file_sp) {
-  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
-                     (FileSP), file_sp);
+  LLDB_INSTRUMENT_VA(this, file_sp);
   SetImmediateOutputFile(SBFile(file_sp));
 }
 
 void SBCommandReturnObject::SetImmediateErrorFile(FileSP file_sp) {
-  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
-                     (FileSP), file_sp);
+  LLDB_INSTRUMENT_VA(this, file_sp);
   SetImmediateErrorFile(SBFile(file_sp));
 }
 
 void SBCommandReturnObject::PutCString(const char *string, int len) {
-  LLDB_RECORD_METHOD(void, SBCommandReturnObject, PutCString,
-                     (const char *, int), string, len);
+  LLDB_INSTRUMENT_VA(this, string, len);
 
   if (len == 0 || string == nullptr || *string == 0) {
     return;
@@ -320,8 +298,7 @@ void SBCommandReturnObject::PutCString(const char *string, int len) {
 }
 
 const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
-  LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool),
-                     only_if_no_immediate);
+  LLDB_INSTRUMENT_VA(this, only_if_no_immediate);
 
   if (!only_if_no_immediate ||
       ref().GetImmediateOutputStream().get() == nullptr)
@@ -330,8 +307,7 @@ const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
 }
 
 const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) {
-  LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetError, (bool),
-                     only_if_no_immediate);
+  LLDB_INSTRUMENT_VA(this, only_if_no_immediate);
 
   if (!only_if_no_immediate || ref().GetImmediateErrorStream().get() == nullptr)
     return GetError();
@@ -348,9 +324,7 @@ size_t SBCommandReturnObject::Printf(const char *format, ...) {
 
 void SBCommandReturnObject::SetError(lldb::SBError &error,
                                      const char *fallback_error_cstr) {
-  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError,
-                     (lldb::SBError &, const char *), error,
-                     fallback_error_cstr);
+  LLDB_INSTRUMENT_VA(this, error, fallback_error_cstr);
 
   if (error.IsValid())
     ref().SetError(error.ref(), fallback_error_cstr);
@@ -359,76 +333,8 @@ void SBCommandReturnObject::SetError(lldb::SBError &error,
 }
 
 void SBCommandReturnObject::SetError(const char *error_cstr) {
-  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *),
-                     error_cstr);
+  LLDB_INSTRUMENT_VA(this, error_cstr);
 
   if (error_cstr)
     ref().AppendError(error_cstr);
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBCommandReturnObject>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
-                            (lldb_private::CommandReturnObject &));
-  LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
-                            (const lldb::SBCommandReturnObject &));
-  LLDB_REGISTER_METHOD(
-      lldb::SBCommandReturnObject &,
-      SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, operator bool, ());
-  LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, ());
-  LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, ());
-  LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetOutputSize, ());
-  LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetErrorSize, ());
-  LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *));
-  LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *));
-  LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (SBFile));
-  LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (SBFile));
-  LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP));
-  LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, Clear, ());
-  LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandReturnObject, GetStatus,
-                       ());
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetStatus,
-                       (lldb::ReturnStatus));
-  LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, Succeeded, ());
-  LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, HasResult, ());
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendMessage,
-                       (const char *));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendWarning,
-                       (const char *));
-  LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, GetDescription,
-                       (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
-                       (FILE *));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
-                       (FILE *));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
-                       (SBFile));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
-                       (SBFile));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
-                       (FileSP));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
-                       (FileSP));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
-                       (FILE *, bool));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
-                       (FILE *, bool));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, PutCString,
-                       (const char *, int));
-  LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput,
-                       (bool));
-  LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, (bool));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError,
-                       (lldb::SBError &, const char *));
-  LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, (const char *));
-}
-
-}
-}
diff --git a/lldb/source/API/SBCommunication.cpp b/lldb/source/API/SBCommunication.cpp
index 9a2ab89d5e4e..0a1dad1e2e8f 100644
--- a/lldb/source/API/SBCommunication.cpp
+++ b/lldb/source/API/SBCommunication.cpp
@@ -7,22 +7,20 @@
 //===----------------------------------------------------------------------===//
 
 #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/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBCommunication::SBCommunication() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommunication);
-}
+SBCommunication::SBCommunication() { LLDB_INSTRUMENT_VA(this); }
 
 SBCommunication::SBCommunication(const char *broadcaster_name)
     : m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) {
-  LLDB_RECORD_CONSTRUCTOR(SBCommunication, (const char *), broadcaster_name);
+  LLDB_INSTRUMENT_VA(this, broadcaster_name);
 }
 
 SBCommunication::~SBCommunication() {
@@ -33,17 +31,17 @@ SBCommunication::~SBCommunication() {
 }
 
 bool SBCommunication::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBCommunication::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque != nullptr;
 }
 
 bool SBCommunication::GetCloseOnEOF() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, GetCloseOnEOF);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque)
     return m_opaque->GetCloseOnEOF();
@@ -51,15 +49,14 @@ bool SBCommunication::GetCloseOnEOF() {
 }
 
 void SBCommunication::SetCloseOnEOF(bool b) {
-  LLDB_RECORD_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b);
+  LLDB_INSTRUMENT_VA(this, b);
 
   if (m_opaque)
     m_opaque->SetCloseOnEOF(b);
 }
 
 ConnectionStatus SBCommunication::Connect(const char *url) {
-  LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
-                     (const char *), url);
+  LLDB_INSTRUMENT_VA(this, url);
 
   if (m_opaque) {
     if (!m_opaque->HasConnection())
@@ -70,8 +67,7 @@ ConnectionStatus SBCommunication::Connect(const char *url) {
 }
 
 ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
-  LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication,
-                     AdoptFileDesriptor, (int, bool), fd, owns_fd);
+  LLDB_INSTRUMENT_VA(this, fd, owns_fd);
 
   ConnectionStatus status = eConnectionStatusNoConnection;
   if (m_opaque) {
@@ -90,8 +86,7 @@ ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
 }
 
 ConnectionStatus SBCommunication::Disconnect() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication,
-                             Disconnect);
+  LLDB_INSTRUMENT_VA(this);
 
   ConnectionStatus status = eConnectionStatusNoConnection;
   if (m_opaque)
@@ -100,16 +95,14 @@ ConnectionStatus SBCommunication::Disconnect() {
 }
 
 bool SBCommunication::IsConnected() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque ? m_opaque->IsConnected() : false;
 }
 
 size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
                              ConnectionStatus &status) {
-  LLDB_RECORD_DUMMY(size_t, SBCommunication, Read,
-                    (void *, size_t, uint32_t, lldb::ConnectionStatus &), dst,
-                    dst_len, timeout_usec, status);
+  LLDB_INSTRUMENT_VA(this, dst, dst_len, timeout_usec, status);
 
   size_t bytes_read = 0;
   Timeout<std::micro> timeout = timeout_usec == UINT32_MAX
@@ -125,9 +118,7 @@ size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
 
 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);
+  LLDB_INSTRUMENT_VA(this, src, src_len, status);
 
   size_t bytes_written = 0;
   if (m_opaque)
@@ -139,28 +130,26 @@ size_t SBCommunication::Write(const void *src, size_t src_len,
 }
 
 bool SBCommunication::ReadThreadStart() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque ? m_opaque->StartReadThread() : false;
 }
 
 bool SBCommunication::ReadThreadStop() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque ? m_opaque->StopReadThread() : false;
 }
 
 bool SBCommunication::ReadThreadIsRunning() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque ? m_opaque->ReadThreadIsRunning() : false;
 }
 
 bool SBCommunication::SetReadThreadBytesReceivedCallback(
     ReadThreadBytesReceived callback, void *callback_baton) {
-  LLDB_RECORD_DUMMY(bool, SBCommunication, SetReadThreadBytesReceivedCallback,
-                    (lldb::SBCommunication::ReadThreadBytesReceived, void *),
-                    callback, callback_baton);
+  LLDB_INSTRUMENT_VA(this, callback, callback_baton);
 
   bool result = false;
   if (m_opaque) {
@@ -171,46 +160,14 @@ bool SBCommunication::SetReadThreadBytesReceivedCallback(
 }
 
 SBBroadcaster SBCommunication::GetBroadcaster() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication,
-                             GetBroadcaster);
+  LLDB_INSTRUMENT_VA(this);
 
   SBBroadcaster broadcaster(m_opaque, false);
-  return LLDB_RECORD_RESULT(broadcaster);
+  return broadcaster;
 }
 
 const char *SBCommunication::GetBroadcasterClass() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommunication,
-                                    GetBroadcasterClass);
+  LLDB_INSTRUMENT();
 
   return Communication::GetStaticBroadcasterClass().AsCString();
 }
-
-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, ());
-}
-
-}
-}
diff --git a/lldb/source/API/SBCompileUnit.cpp b/lldb/source/API/SBCompileUnit.cpp
index a44d3b897110..46a319c6b7a3 100644
--- a/lldb/source/API/SBCompileUnit.cpp
+++ b/lldb/source/API/SBCompileUnit.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBCompileUnit.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Module.h"
@@ -17,45 +16,41 @@
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBCompileUnit::SBCompileUnit() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCompileUnit);
-}
+SBCompileUnit::SBCompileUnit() { LLDB_INSTRUMENT_VA(this); }
 
 SBCompileUnit::SBCompileUnit(lldb_private::CompileUnit *lldb_object_ptr)
     : m_opaque_ptr(lldb_object_ptr) {}
 
 SBCompileUnit::SBCompileUnit(const SBCompileUnit &rhs)
     : m_opaque_ptr(rhs.m_opaque_ptr) {
-  LLDB_RECORD_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBCompileUnit &,
-                     SBCompileUnit, operator=,(const lldb::SBCompileUnit &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_ptr = rhs.m_opaque_ptr;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = nullptr; }
 
 SBFileSpec SBCompileUnit::GetFileSpec() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit,
-                                   GetFileSpec);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFileSpec file_spec;
   if (m_opaque_ptr)
     file_spec.SetFileSpec(m_opaque_ptr->GetPrimaryFile());
-  return LLDB_RECORD_RESULT(file_spec);
+  return file_spec;
 }
 
 uint32_t SBCompileUnit::GetNumLineEntries() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumLineEntries);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr) {
     LineTable *line_table = m_opaque_ptr->GetLineTable();
@@ -67,8 +62,7 @@ uint32_t SBCompileUnit::GetNumLineEntries() const {
 }
 
 SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
-                           GetLineEntryAtIndex, (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBLineEntry sb_line_entry;
   if (m_opaque_ptr) {
@@ -80,14 +74,12 @@ SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_line_entry);
+  return sb_line_entry;
 }
 
 uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
                                            SBFileSpec *inline_file_spec) const {
-  LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
-                           (uint32_t, uint32_t, lldb::SBFileSpec *), start_idx,
-                           line, inline_file_spec);
+  LLDB_INSTRUMENT_VA(this, start_idx, line, inline_file_spec);
 
   const bool exact = true;
   return FindLineEntryIndex(start_idx, line, inline_file_spec, exact);
@@ -96,9 +88,7 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
 uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
                                            SBFileSpec *inline_file_spec,
                                            bool exact) const {
-  LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
-                           (uint32_t, uint32_t, lldb::SBFileSpec *, bool),
-                           start_idx, line, inline_file_spec, exact);
+  LLDB_INSTRUMENT_VA(this, start_idx, line, inline_file_spec, exact);
 
   uint32_t index = UINT32_MAX;
   if (m_opaque_ptr) {
@@ -118,7 +108,7 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
 }
 
 uint32_t SBCompileUnit::GetNumSupportFiles() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->GetSupportFiles().GetSize();
@@ -127,32 +117,30 @@ uint32_t SBCompileUnit::GetNumSupportFiles() const {
 }
 
 lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) {
-  LLDB_RECORD_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t),
-                     type_mask);
+  LLDB_INSTRUMENT_VA(this, type_mask);
 
   SBTypeList sb_type_list;
 
   if (!m_opaque_ptr)
-    return LLDB_RECORD_RESULT(sb_type_list);
+    return sb_type_list;
 
   ModuleSP module_sp(m_opaque_ptr->GetModule());
   if (!module_sp)
-    return LLDB_RECORD_RESULT(sb_type_list);
+    return sb_type_list;
 
   SymbolFile *symfile = module_sp->GetSymbolFile();
   if (!symfile)
-    return LLDB_RECORD_RESULT(sb_type_list);
+    return sb_type_list;
 
   TypeClass type_class = static_cast<TypeClass>(type_mask);
   TypeList type_list;
   symfile->GetTypes(m_opaque_ptr, type_class, type_list);
   sb_type_list.m_opaque_up->Append(type_list);
-  return LLDB_RECORD_RESULT(sb_type_list);
+  return sb_type_list;
 }
 
 SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
-                           GetSupportFileAtIndex, (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBFileSpec sb_file_spec;
   if (m_opaque_ptr) {
@@ -160,16 +148,13 @@ SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const {
     sb_file_spec.SetFileSpec(spec);
   }
 
-
-  return LLDB_RECORD_RESULT(sb_file_spec);
+  return sb_file_spec;
 }
 
 uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx,
                                              const SBFileSpec &sb_file,
                                              bool full) {
-  LLDB_RECORD_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,
-                     (uint32_t, const lldb::SBFileSpec &, bool), start_idx,
-                     sb_file, full);
+  LLDB_INSTRUMENT_VA(this, start_idx, sb_file, full);
 
   if (m_opaque_ptr) {
     const FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
@@ -179,7 +164,7 @@ uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx,
 }
 
 lldb::LanguageType SBCompileUnit::GetLanguage() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBCompileUnit, GetLanguage);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->GetLanguage();
@@ -187,25 +172,23 @@ lldb::LanguageType SBCompileUnit::GetLanguage() {
 }
 
 bool SBCompileUnit::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBCompileUnit::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_ptr != nullptr;
 }
 
 bool SBCompileUnit::operator==(const SBCompileUnit &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_ptr == rhs.m_opaque_ptr;
 }
 
 bool SBCompileUnit::operator!=(const SBCompileUnit &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_ptr != rhs.m_opaque_ptr;
 }
@@ -225,8 +208,7 @@ void SBCompileUnit::reset(lldb_private::CompileUnit *lldb_object_ptr) {
 }
 
 bool SBCompileUnit::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -237,42 +219,3 @@ bool SBCompileUnit::GetDescription(SBStream &description) {
 
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBCompileUnit>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBCompileUnit &,
-      SBCompileUnit, operator=,(const lldb::SBCompileUnit &));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, GetFileSpec,
-                             ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumLineEntries, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
-                             GetLineEntryAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
-                             (uint32_t, uint32_t, lldb::SBFileSpec *));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
-                             (uint32_t, uint32_t, lldb::SBFileSpec *, bool));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumSupportFiles, ());
-  LLDB_REGISTER_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
-                             GetSupportFileAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,
-                       (uint32_t, const lldb::SBFileSpec &, bool));
-  LLDB_REGISTER_METHOD(lldb::LanguageType, SBCompileUnit, GetLanguage, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, operator bool, ());
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &));
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &));
-  LLDB_REGISTER_METHOD(bool, SBCompileUnit, GetDescription,
-                       (lldb::SBStream &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBData.cpp b/lldb/source/API/SBData.cpp
index 9fc590578bce..5232bdde1ded 100644
--- a/lldb/source/API/SBData.cpp
+++ b/lldb/source/API/SBData.cpp
@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBData.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Utility/DataBufferHeap.h"
@@ -23,22 +23,21 @@ using namespace lldb;
 using namespace lldb_private;
 
 SBData::SBData() : m_opaque_sp(new DataExtractor()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBData);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBData::SBData(const lldb::DataExtractorSP &data_sp) : m_opaque_sp(data_sp) {}
 
 SBData::SBData(const SBData &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBData, (const lldb::SBData &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const SBData &SBData::operator=(const SBData &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBData &,
-                     SBData, operator=,(const lldb::SBData &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBData::~SBData() = default;
@@ -58,17 +57,17 @@ lldb::DataExtractorSP &SBData::operator*() { return m_opaque_sp; }
 const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; }
 
 bool SBData::IsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBData, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBData::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBData, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 uint8_t SBData::GetAddressByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint8_t, SBData, GetAddressByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   uint8_t value = 0;
   if (m_opaque_sp.get())
@@ -77,22 +76,21 @@ uint8_t SBData::GetAddressByteSize() {
 }
 
 void SBData::SetAddressByteSize(uint8_t addr_byte_size) {
-  LLDB_RECORD_METHOD(void, SBData, SetAddressByteSize, (uint8_t),
-                     addr_byte_size);
+  LLDB_INSTRUMENT_VA(this, addr_byte_size);
 
   if (m_opaque_sp.get())
     m_opaque_sp->SetAddressByteSize(addr_byte_size);
 }
 
 void SBData::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBData, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp.get())
     m_opaque_sp->Clear();
 }
 
 size_t SBData::GetByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBData, GetByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   size_t value = 0;
   if (m_opaque_sp.get())
@@ -101,7 +99,7 @@ size_t SBData::GetByteSize() {
 }
 
 lldb::ByteOrder SBData::GetByteOrder() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBData, GetByteOrder);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::ByteOrder value = eByteOrderInvalid;
   if (m_opaque_sp.get())
@@ -110,15 +108,14 @@ lldb::ByteOrder SBData::GetByteOrder() {
 }
 
 void SBData::SetByteOrder(lldb::ByteOrder endian) {
-  LLDB_RECORD_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), endian);
+  LLDB_INSTRUMENT_VA(this, endian);
 
   if (m_opaque_sp.get())
     m_opaque_sp->SetByteOrder(endian);
 }
 
 float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(float, SBData, GetFloat, (lldb::SBError &, lldb::offset_t),
-                     error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   float value = 0;
   if (!m_opaque_sp.get()) {
@@ -133,8 +130,7 @@ float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) {
 }
 
 double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(double, SBData, GetDouble,
-                     (lldb::SBError &, lldb::offset_t), error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   double value = 0;
   if (!m_opaque_sp.get()) {
@@ -149,8 +145,7 @@ double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) {
 }
 
 long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(long double, SBData, GetLongDouble,
-                     (lldb::SBError &, lldb::offset_t), error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   long double value = 0;
   if (!m_opaque_sp.get()) {
@@ -165,8 +160,7 @@ long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) {
 }
 
 lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(lldb::addr_t, SBData, GetAddress,
-                     (lldb::SBError &, lldb::offset_t), error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   lldb::addr_t value = 0;
   if (!m_opaque_sp.get()) {
@@ -181,8 +175,7 @@ lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) {
 }
 
 uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(uint8_t, SBData, GetUnsignedInt8,
-                     (lldb::SBError &, lldb::offset_t), error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   uint8_t value = 0;
   if (!m_opaque_sp.get()) {
@@ -197,8 +190,7 @@ uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) {
 }
 
 uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(uint16_t, SBData, GetUnsignedInt16,
-                     (lldb::SBError &, lldb::offset_t), error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   uint16_t value = 0;
   if (!m_opaque_sp.get()) {
@@ -213,8 +205,7 @@ uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) {
 }
 
 uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(uint32_t, SBData, GetUnsignedInt32,
-                     (lldb::SBError &, lldb::offset_t), error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   uint32_t value = 0;
   if (!m_opaque_sp.get()) {
@@ -229,8 +220,7 @@ uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) {
 }
 
 uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(uint64_t, SBData, GetUnsignedInt64,
-                     (lldb::SBError &, lldb::offset_t), error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   uint64_t value = 0;
   if (!m_opaque_sp.get()) {
@@ -245,8 +235,7 @@ uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) {
 }
 
 int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(int8_t, SBData, GetSignedInt8,
-                     (lldb::SBError &, lldb::offset_t), error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   int8_t value = 0;
   if (!m_opaque_sp.get()) {
@@ -261,8 +250,7 @@ int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) {
 }
 
 int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(int16_t, SBData, GetSignedInt16,
-                     (lldb::SBError &, lldb::offset_t), error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   int16_t value = 0;
   if (!m_opaque_sp.get()) {
@@ -277,8 +265,7 @@ int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) {
 }
 
 int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(int32_t, SBData, GetSignedInt32,
-                     (lldb::SBError &, lldb::offset_t), error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   int32_t value = 0;
   if (!m_opaque_sp.get()) {
@@ -293,8 +280,7 @@ int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) {
 }
 
 int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(int64_t, SBData, GetSignedInt64,
-                     (lldb::SBError &, lldb::offset_t), error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   int64_t value = 0;
   if (!m_opaque_sp.get()) {
@@ -309,8 +295,7 @@ int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) {
 }
 
 const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
-  LLDB_RECORD_METHOD(const char *, SBData, GetString,
-                     (lldb::SBError &, lldb::offset_t), error, offset);
+  LLDB_INSTRUMENT_VA(this, error, offset);
 
   const char *value = nullptr;
   if (!m_opaque_sp.get()) {
@@ -326,8 +311,7 @@ const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
 
 bool SBData::GetDescription(lldb::SBStream &description,
                             lldb::addr_t base_addr) {
-  LLDB_RECORD_METHOD(bool, SBData, GetDescription,
-                     (lldb::SBStream &, lldb::addr_t), description, base_addr);
+  LLDB_INSTRUMENT_VA(this, description, base_addr);
 
   Stream &strm = description.ref();
 
@@ -342,9 +326,7 @@ bool SBData::GetDescription(lldb::SBStream &description,
 
 size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset,
                            void *buf, size_t size) {
-  LLDB_RECORD_DUMMY(size_t, SBData, ReadRawData,
-                    (lldb::SBError &, lldb::offset_t, void *, size_t), error,
-                    offset, buf, size);
+  LLDB_INSTRUMENT_VA(this, error, offset, buf, size);
 
   void *ok = nullptr;
   if (!m_opaque_sp.get()) {
@@ -360,10 +342,7 @@ size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset,
 
 void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
                      lldb::ByteOrder endian, uint8_t addr_size) {
-  LLDB_RECORD_DUMMY(
-      void, SBData, SetData,
-      (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t), error,
-      buf, size, endian, addr_size);
+  LLDB_INSTRUMENT_VA(this, error, buf, size, endian, addr_size);
 
   if (!m_opaque_sp.get())
     m_opaque_sp = std::make_shared<DataExtractor>(buf, size, endian, addr_size);
@@ -377,10 +356,7 @@ void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
 void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf,
                                   size_t size, lldb::ByteOrder endian,
                                   uint8_t addr_size) {
-  LLDB_RECORD_DUMMY(
-      void, SBData, SetData,
-      (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t, bool),
-      error, buf, size, endian, addr_size, copy);
+  LLDB_INSTRUMENT_VA(this, error, buf, size, endian, addr_size);
 
   lldb::DataBufferSP buffer_sp = std::make_shared<DataBufferHeap>(buf, size);
 
@@ -394,7 +370,7 @@ void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf,
 }
 
 bool SBData::Append(const SBData &rhs) {
-  LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   bool value = false;
   if (m_opaque_sp.get() && rhs.m_opaque_sp.get())
@@ -405,12 +381,10 @@ bool SBData::Append(const SBData &rhs) {
 lldb::SBData SBData::CreateDataFromCString(lldb::ByteOrder endian,
                                            uint32_t addr_byte_size,
                                            const char *data) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString,
-                            (lldb::ByteOrder, uint32_t, const char *), endian,
-                            addr_byte_size, data);
+  LLDB_INSTRUMENT_VA(endian, addr_byte_size, data);
 
   if (!data || !data[0])
-    return LLDB_RECORD_RESULT(SBData());
+    return SBData();
 
   uint32_t data_len = strlen(data);
 
@@ -420,19 +394,17 @@ lldb::SBData SBData::CreateDataFromCString(lldb::ByteOrder endian,
 
   SBData ret(data_sp);
 
-  return LLDB_RECORD_RESULT(ret);
+  return ret;
 }
 
 lldb::SBData SBData::CreateDataFromUInt64Array(lldb::ByteOrder endian,
                                                uint32_t addr_byte_size,
                                                uint64_t *array,
                                                size_t array_len) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt64Array,
-                            (lldb::ByteOrder, uint32_t, uint64_t *, size_t),
-                            endian, addr_byte_size, array, array_len);
+  LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
 
   if (!array || array_len == 0)
-    return LLDB_RECORD_RESULT(SBData());
+    return SBData();
 
   size_t data_len = array_len * sizeof(uint64_t);
 
@@ -442,19 +414,17 @@ lldb::SBData SBData::CreateDataFromUInt64Array(lldb::ByteOrder endian,
 
   SBData ret(data_sp);
 
-  return LLDB_RECORD_RESULT(ret);
+  return ret;
 }
 
 lldb::SBData SBData::CreateDataFromUInt32Array(lldb::ByteOrder endian,
                                                uint32_t addr_byte_size,
                                                uint32_t *array,
                                                size_t array_len) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt32Array,
-                            (lldb::ByteOrder, uint32_t, uint32_t *, size_t),
-                            endian, addr_byte_size, array, array_len);
+  LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
 
   if (!array || array_len == 0)
-    return LLDB_RECORD_RESULT(SBData());
+    return SBData();
 
   size_t data_len = array_len * sizeof(uint32_t);
 
@@ -464,19 +434,17 @@ lldb::SBData SBData::CreateDataFromUInt32Array(lldb::ByteOrder endian,
 
   SBData ret(data_sp);
 
-  return LLDB_RECORD_RESULT(ret);
+  return ret;
 }
 
 lldb::SBData SBData::CreateDataFromSInt64Array(lldb::ByteOrder endian,
                                                uint32_t addr_byte_size,
                                                int64_t *array,
                                                size_t array_len) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array,
-                            (lldb::ByteOrder, uint32_t, int64_t *, size_t),
-                            endian, addr_byte_size, array, array_len);
+  LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
 
   if (!array || array_len == 0)
-    return LLDB_RECORD_RESULT(SBData());
+    return SBData();
 
   size_t data_len = array_len * sizeof(int64_t);
 
@@ -486,19 +454,17 @@ lldb::SBData SBData::CreateDataFromSInt64Array(lldb::ByteOrder endian,
 
   SBData ret(data_sp);
 
-  return LLDB_RECORD_RESULT(ret);
+  return ret;
 }
 
 lldb::SBData SBData::CreateDataFromSInt32Array(lldb::ByteOrder endian,
                                                uint32_t addr_byte_size,
                                                int32_t *array,
                                                size_t array_len) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array,
-                            (lldb::ByteOrder, uint32_t, int32_t *, size_t),
-                            endian, addr_byte_size, array, array_len);
+  LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
 
   if (!array || array_len == 0)
-    return LLDB_RECORD_RESULT(SBData());
+    return SBData();
 
   size_t data_len = array_len * sizeof(int32_t);
 
@@ -508,19 +474,17 @@ lldb::SBData SBData::CreateDataFromSInt32Array(lldb::ByteOrder endian,
 
   SBData ret(data_sp);
 
-  return LLDB_RECORD_RESULT(ret);
+  return ret;
 }
 
 lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian,
                                                uint32_t addr_byte_size,
                                                double *array,
                                                size_t array_len) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray,
-                            (lldb::ByteOrder, uint32_t, double *, size_t),
-                            endian, addr_byte_size, array, array_len);
+  LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
 
   if (!array || array_len == 0)
-    return LLDB_RECORD_RESULT(SBData());
+    return SBData();
 
   size_t data_len = array_len * sizeof(double);
 
@@ -530,12 +494,11 @@ lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian,
 
   SBData ret(data_sp);
 
-  return LLDB_RECORD_RESULT(ret);
+  return ret;
 }
 
 bool SBData::SetDataFromCString(const char *data) {
-  LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data);
-
+  LLDB_INSTRUMENT_VA(this, data);
 
   if (!data) {
     return false;
@@ -556,9 +519,7 @@ bool SBData::SetDataFromCString(const char *data) {
 }
 
 bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
-  LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt64Array, (uint64_t *, size_t),
-                     array, array_len);
-
+  LLDB_INSTRUMENT_VA(this, array, array_len);
 
   if (!array || array_len == 0) {
     return false;
@@ -579,9 +540,7 @@ bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
 }
 
 bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
-  LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt32Array, (uint32_t *, size_t),
-                     array, array_len);
-
+  LLDB_INSTRUMENT_VA(this, array, array_len);
 
   if (!array || array_len == 0) {
     return false;
@@ -601,9 +560,7 @@ bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
 }
 
 bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
-  LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt64Array, (int64_t *, size_t),
-                     array, array_len);
-
+  LLDB_INSTRUMENT_VA(this, array, array_len);
 
   if (!array || array_len == 0) {
     return false;
@@ -623,9 +580,7 @@ bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
 }
 
 bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
-  LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt32Array, (int32_t *, size_t),
-                     array, array_len);
-
+  LLDB_INSTRUMENT_VA(this, array, array_len);
 
   if (!array || array_len == 0) {
     return false;
@@ -645,9 +600,7 @@ bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
 }
 
 bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) {
-  LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t),
-                     array, array_len);
-
+  LLDB_INSTRUMENT_VA(this, array, array_len);
 
   if (!array || array_len == 0) {
     return false;
@@ -665,79 +618,3 @@ bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) {
 
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBData>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBData, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBData, (const lldb::SBData &));
-  LLDB_REGISTER_METHOD(const lldb::SBData &,
-                       SBData, operator=,(const lldb::SBData &));
-  LLDB_REGISTER_METHOD(bool, SBData, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBData, operator bool, ());
-  LLDB_REGISTER_METHOD(uint8_t, SBData, GetAddressByteSize, ());
-  LLDB_REGISTER_METHOD(void, SBData, SetAddressByteSize, (uint8_t));
-  LLDB_REGISTER_METHOD(void, SBData, Clear, ());
-  LLDB_REGISTER_METHOD(size_t, SBData, GetByteSize, ());
-  LLDB_REGISTER_METHOD(lldb::ByteOrder, SBData, GetByteOrder, ());
-  LLDB_REGISTER_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder));
-  LLDB_REGISTER_METHOD(float, SBData, GetFloat,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(double, SBData, GetDouble,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(long double, SBData, GetLongDouble,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBData, GetAddress,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(uint8_t, SBData, GetUnsignedInt8,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(uint16_t, SBData, GetUnsignedInt16,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBData, GetUnsignedInt32,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(uint64_t, SBData, GetUnsignedInt64,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(int8_t, SBData, GetSignedInt8,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(int16_t, SBData, GetSignedInt16,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(int32_t, SBData, GetSignedInt32,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(int64_t, SBData, GetSignedInt64,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(const char *, SBData, GetString,
-                       (lldb::SBError &, lldb::offset_t));
-  LLDB_REGISTER_METHOD(bool, SBData, GetDescription,
-                       (lldb::SBStream &, lldb::addr_t));
-  LLDB_REGISTER_METHOD(bool, SBData, Append, (const lldb::SBData &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString,
-                              (lldb::ByteOrder, uint32_t, const char *));
-  LLDB_REGISTER_STATIC_METHOD(
-      lldb::SBData, SBData, CreateDataFromUInt64Array,
-      (lldb::ByteOrder, uint32_t, uint64_t *, size_t));
-  LLDB_REGISTER_STATIC_METHOD(
-      lldb::SBData, SBData, CreateDataFromUInt32Array,
-      (lldb::ByteOrder, uint32_t, uint32_t *, size_t));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array,
-                              (lldb::ByteOrder, uint32_t, int64_t *, size_t));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array,
-                              (lldb::ByteOrder, uint32_t, int32_t *, size_t));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray,
-                              (lldb::ByteOrder, uint32_t, double *, size_t));
-  LLDB_REGISTER_METHOD(bool, SBData, SetDataFromCString, (const char *));
-  LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt64Array,
-                       (uint64_t *, size_t));
-  LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt32Array,
-                       (uint32_t *, size_t));
-  LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt64Array,
-                       (int64_t *, size_t));
-  LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt32Array,
-                       (int32_t *, size_t));
-  LLDB_REGISTER_METHOD(bool, SBData, SetDataFromDoubleArray,
-                       (double *, size_t));
-}
-
-}
-}
diff --git a/lldb/source/API/SBDebugger.cpp b/lldb/source/API/SBDebugger.cpp
index fa5dcb57de7e..8b09d6a8e435 100644
--- a/lldb/source/API/SBDebugger.cpp
+++ b/lldb/source/API/SBDebugger.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "SBReproducerPrivate.h"
 #include "SystemInitializerFull.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBDebugger.h"
 
@@ -105,53 +105,43 @@ SBError SBInputReader::Initialize(
                               unsigned long),
     void *a, lldb::InputReaderGranularity b, char const *c, char const *d,
     bool e) {
-  LLDB_RECORD_DUMMY(
-      lldb::SBError, SBInputReader, Initialize,
-      (lldb::SBDebugger &,
-       unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction,
-                         const char *, unsigned long),
-       void *, lldb::InputReaderGranularity, const char *, const char *, bool),
-      sb_debugger, callback, a, b, c, d, e);
+  LLDB_INSTRUMENT_VA(this, sb_debugger, callback, a, b, c, d, e);
 
   return SBError();
 }
 
-void SBInputReader::SetIsDone(bool b) {
-  LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b);
-}
+void SBInputReader::SetIsDone(bool b) { LLDB_INSTRUMENT_VA(this, b); }
 
 bool SBInputReader::IsActive() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive);
+  LLDB_INSTRUMENT_VA(this);
 
   return false;
 }
 
-SBDebugger::SBDebugger() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDebugger); }
+SBDebugger::SBDebugger() { LLDB_INSTRUMENT_VA(this); }
 
 SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp)
     : m_opaque_sp(debugger_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp);
+  LLDB_INSTRUMENT_VA(this, debugger_sp);
 }
 
 SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBDebugger::~SBDebugger() = default;
 
 SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBDebugger &,
-                     SBDebugger, operator=,(const lldb::SBDebugger &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 const char *SBDebugger::GetBroadcasterClass() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger,
-                                    GetBroadcasterClass);
+  LLDB_INSTRUMENT();
 
   return Debugger::GetStaticBroadcasterClass().AsCString();
 }
@@ -161,6 +151,8 @@ const char *SBDebugger::GetProgressFromEvent(const lldb::SBEvent &event,
                                              uint64_t &completed,
                                              uint64_t &total,
                                              bool &is_debugger_specific) {
+  LLDB_INSTRUMENT_VA(event, progress_id, completed, total,
+                     is_debugger_specific);
   const Debugger::ProgressEventData *progress_data =
       Debugger::ProgressEventData::GetEventDataFromEvent(event.get());
   if (progress_data == nullptr)
@@ -169,46 +161,39 @@ const char *SBDebugger::GetProgressFromEvent(const lldb::SBEvent &event,
   completed = progress_data->GetCompleted();
   total = progress_data->GetTotal();
   is_debugger_specific = progress_data->IsDebuggerSpecific();
-  // We must record the static method _after_ the out parameters have been
-  // filled in.
-  LLDB_RECORD_STATIC_METHOD(
-      const char *, SBDebugger, GetProgressFromEvent,
-      (const lldb::SBEvent &, uint64_t &, uint64_t &, uint64_t &, bool &),
-      event, progress_id, completed, total, is_debugger_specific);
-  return LLDB_RECORD_RESULT(progress_data->GetMessage().c_str())
+  return progress_data->GetMessage().c_str();
 }
 
 SBBroadcaster SBDebugger::GetBroadcaster() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBDebugger, GetBroadcaster);
+  LLDB_INSTRUMENT_VA(this);
   SBBroadcaster broadcaster(&m_opaque_sp->GetBroadcaster(), false);
-  return LLDB_RECORD_RESULT(broadcaster);
+  return broadcaster;
 }
 
 void SBDebugger::Initialize() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize);
+  LLDB_INSTRUMENT();
   SBError ignored = SBDebugger::InitializeWithErrorHandling();
 }
 
 lldb::SBError SBDebugger::InitializeWithErrorHandling() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger,
-                                    InitializeWithErrorHandling);
+  LLDB_INSTRUMENT();
 
   SBError error;
   if (auto e = g_debugger_lifetime->Initialize(
           std::make_unique<SystemInitializerFull>(), LoadPlugin)) {
     error.SetError(Status(std::move(e)));
   }
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 void SBDebugger::Terminate() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate);
+  LLDB_INSTRUMENT();
 
   g_debugger_lifetime->Terminate();
 }
 
 void SBDebugger::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     m_opaque_sp->ClearIOHandlers();
@@ -217,26 +202,22 @@ void SBDebugger::Clear() {
 }
 
 SBDebugger SBDebugger::Create() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBDebugger, SBDebugger, Create);
+  LLDB_INSTRUMENT();
 
-  return LLDB_RECORD_RESULT(SBDebugger::Create(false, nullptr, nullptr));
+  return SBDebugger::Create(false, nullptr, nullptr);
 }
 
 SBDebugger SBDebugger::Create(bool source_init_files) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool),
-                            source_init_files);
+  LLDB_INSTRUMENT_VA(source_init_files);
 
-  return LLDB_RECORD_RESULT(
-      SBDebugger::Create(source_init_files, nullptr, nullptr));
+  return SBDebugger::Create(source_init_files, nullptr, nullptr);
 }
 
 SBDebugger SBDebugger::Create(bool source_init_files,
                               lldb::LogOutputCallback callback, void *baton)
 
 {
-  LLDB_RECORD_DUMMY(lldb::SBDebugger, SBDebugger, Create,
-                    (bool, lldb::LogOutputCallback, void *), source_init_files,
-                    callback, baton);
+  LLDB_INSTRUMENT_VA(source_init_files, callback, baton);
 
   SBDebugger debugger;
 
@@ -264,8 +245,7 @@ SBDebugger SBDebugger::Create(bool source_init_files,
 }
 
 void SBDebugger::Destroy(SBDebugger &debugger) {
-  LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &),
-                            debugger);
+  LLDB_INSTRUMENT_VA(debugger);
 
   Debugger::Destroy(debugger.m_opaque_sp);
 
@@ -274,7 +254,7 @@ void SBDebugger::Destroy(SBDebugger &debugger) {
 }
 
 void SBDebugger::MemoryPressureDetected() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, MemoryPressureDetected);
+  LLDB_INSTRUMENT();
 
   // Since this function can be call asynchronously, we allow it to be non-
   // mandatory. We have seen deadlocks with this function when called so we
@@ -287,226 +267,222 @@ void SBDebugger::MemoryPressureDetected() {
 }
 
 bool SBDebugger::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBDebugger::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 void SBDebugger::SetAsync(bool b) {
-  LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b);
+  LLDB_INSTRUMENT_VA(this, b);
 
   if (m_opaque_sp)
     m_opaque_sp->SetAsyncExecution(b);
 }
 
 bool SBDebugger::GetAsync() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetAsync);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
 }
 
 void SBDebugger::SkipLLDBInitFiles(bool b) {
-  LLDB_RECORD_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b);
+  LLDB_INSTRUMENT_VA(this, b);
 
   if (m_opaque_sp)
     m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b);
 }
 
 void SBDebugger::SkipAppInitFiles(bool b) {
-  LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b);
+  LLDB_INSTRUMENT_VA(this, b);
 
   if (m_opaque_sp)
     m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
 }
 
 void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
-  LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh,
-                     transfer_ownership);
+  LLDB_INSTRUMENT_VA(this, fh, transfer_ownership);
   if (m_opaque_sp)
     m_opaque_sp->SetInputFile(
         (FileSP)std::make_shared<NativeFile>(fh, transfer_ownership));
 }
 
 SBError SBDebugger::SetInputString(const char *data) {
-  LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputString, (const char *), data);
+  LLDB_INSTRUMENT_VA(this, data);
   SBError sb_error;
   if (data == nullptr) {
     sb_error.SetErrorString("String data is null");
-    return LLDB_RECORD_RESULT(sb_error);
+    return sb_error;
   }
 
   size_t size = strlen(data);
   if (size == 0) {
     sb_error.SetErrorString("String data is empty");
-    return LLDB_RECORD_RESULT(sb_error);
+    return sb_error;
   }
 
   if (!m_opaque_sp) {
     sb_error.SetErrorString("invalid debugger");
-    return LLDB_RECORD_RESULT(sb_error);
+    return sb_error;
   }
 
   sb_error.SetError(m_opaque_sp->SetInputString(data));
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 // Shouldn't really be settable after initialization as this could cause lots
 // of problems; don't want users trying to switch modes in the middle of a
 // debugging session.
 SBError SBDebugger::SetInputFile(SBFile file) {
-  LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (SBFile), file);
+  LLDB_INSTRUMENT_VA(this, file);
 
   SBError error;
   if (!m_opaque_sp) {
     error.ref().SetErrorString("invalid debugger");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
   error.SetError(m_opaque_sp->SetInputFile(file.m_opaque_sp));
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 SBError SBDebugger::SetInputFile(FileSP file_sp) {
-  LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (FileSP), file_sp);
-  return LLDB_RECORD_RESULT(SetInputFile(SBFile(file_sp)));
+  LLDB_INSTRUMENT_VA(this, file_sp);
+  return SetInputFile(SBFile(file_sp));
 }
 
 SBError SBDebugger::SetOutputFile(FileSP file_sp) {
-  LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (FileSP), file_sp);
-  return LLDB_RECORD_RESULT(SetOutputFile(SBFile(file_sp)));
+  LLDB_INSTRUMENT_VA(this, file_sp);
+  return SetOutputFile(SBFile(file_sp));
 }
 
 void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
-  LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh,
-                     transfer_ownership);
+  LLDB_INSTRUMENT_VA(this, fh, transfer_ownership);
   SetOutputFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership));
 }
 
 SBError SBDebugger::SetOutputFile(SBFile file) {
-  LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (SBFile file), file);
+  LLDB_INSTRUMENT_VA(this, file);
   SBError error;
   if (!m_opaque_sp) {
     error.ref().SetErrorString("invalid debugger");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
   if (!file) {
     error.ref().SetErrorString("invalid file");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
   m_opaque_sp->SetOutputFile(file.m_opaque_sp);
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
-  LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh,
-                     transfer_ownership);
+  LLDB_INSTRUMENT_VA(this, fh, transfer_ownership);
   SetErrorFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership));
 }
 
 SBError SBDebugger::SetErrorFile(FileSP file_sp) {
-  LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (FileSP), file_sp);
-  return LLDB_RECORD_RESULT(SetErrorFile(SBFile(file_sp)));
+  LLDB_INSTRUMENT_VA(this, file_sp);
+  return SetErrorFile(SBFile(file_sp));
 }
 
 SBError SBDebugger::SetErrorFile(SBFile file) {
-  LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (SBFile file), file);
+  LLDB_INSTRUMENT_VA(this, file);
   SBError error;
   if (!m_opaque_sp) {
     error.ref().SetErrorString("invalid debugger");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
   if (!file) {
     error.ref().SetErrorString("invalid file");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
   m_opaque_sp->SetErrorFile(file.m_opaque_sp);
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 FILE *SBDebugger::GetInputFileHandle() {
-  LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle);
+  LLDB_INSTRUMENT_VA(this);
   if (m_opaque_sp) {
     File &file_sp = m_opaque_sp->GetInputFile();
-    return LLDB_RECORD_RESULT(file_sp.GetStream());
+    return file_sp.GetStream();
   }
-  return LLDB_RECORD_RESULT(nullptr);
+  return nullptr;
 }
 
 SBFile SBDebugger::GetInputFile() {
-  LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetInputFile);
+  LLDB_INSTRUMENT_VA(this);
   if (m_opaque_sp) {
-    return LLDB_RECORD_RESULT(SBFile(m_opaque_sp->GetInputFileSP()));
+    return SBFile(m_opaque_sp->GetInputFileSP());
   }
-  return LLDB_RECORD_RESULT(SBFile());
+  return SBFile();
 }
 
 FILE *SBDebugger::GetOutputFileHandle() {
-  LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle);
+  LLDB_INSTRUMENT_VA(this);
   if (m_opaque_sp) {
     StreamFile &stream_file = m_opaque_sp->GetOutputStream();
-    return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream());
+    return stream_file.GetFile().GetStream();
   }
-  return LLDB_RECORD_RESULT(nullptr);
+  return nullptr;
 }
 
 SBFile SBDebugger::GetOutputFile() {
-  LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetOutputFile);
+  LLDB_INSTRUMENT_VA(this);
   if (m_opaque_sp) {
     SBFile file(m_opaque_sp->GetOutputStream().GetFileSP());
-    return LLDB_RECORD_RESULT(file);
+    return file;
   }
-  return LLDB_RECORD_RESULT(SBFile());
+  return SBFile();
 }
 
 FILE *SBDebugger::GetErrorFileHandle() {
-  LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp) {
     StreamFile &stream_file = m_opaque_sp->GetErrorStream();
-    return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream());
+    return stream_file.GetFile().GetStream();
   }
-  return LLDB_RECORD_RESULT(nullptr);
+  return nullptr;
 }
 
 SBFile SBDebugger::GetErrorFile() {
-  LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetErrorFile);
+  LLDB_INSTRUMENT_VA(this);
   SBFile file;
   if (m_opaque_sp) {
     SBFile file(m_opaque_sp->GetErrorStream().GetFileSP());
-    return LLDB_RECORD_RESULT(file);
+    return file;
   }
-  return LLDB_RECORD_RESULT(SBFile());
+  return SBFile();
 }
 
 void SBDebugger::SaveInputTerminalState() {
-  LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, SaveInputTerminalState);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     m_opaque_sp->SaveInputTerminalState();
 }
 
 void SBDebugger::RestoreInputTerminalState() {
-  LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, RestoreInputTerminalState);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     m_opaque_sp->RestoreInputTerminalState();
 }
 SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger,
-                             GetCommandInterpreter);
+  LLDB_INSTRUMENT_VA(this);
 
   SBCommandInterpreter sb_interpreter;
   if (m_opaque_sp)
     sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter());
 
-  return LLDB_RECORD_RESULT(sb_interpreter);
+  return sb_interpreter;
 }
 
 void SBDebugger::HandleCommand(const char *command) {
-  LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command);
+  LLDB_INSTRUMENT_VA(this, command);
 
   if (m_opaque_sp) {
     TargetSP target_sp(m_opaque_sp->GetSelectedTarget());
@@ -539,22 +515,19 @@ void SBDebugger::HandleCommand(const char *command) {
 }
 
 SBListener SBDebugger::GetListener() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener);
+  LLDB_INSTRUMENT_VA(this);
 
   SBListener sb_listener;
   if (m_opaque_sp)
     sb_listener.reset(m_opaque_sp->GetListener());
 
-  return LLDB_RECORD_RESULT(sb_listener);
+  return sb_listener;
 }
 
 void SBDebugger::HandleProcessEvent(const SBProcess &process,
                                     const SBEvent &event, SBFile out,
                                     SBFile err) {
-  LLDB_RECORD_METHOD(
-      void, SBDebugger, HandleProcessEvent,
-      (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile), process,
-      event, out, err);
+  LLDB_INSTRUMENT_VA(this, process, event, out, err);
 
   return HandleProcessEvent(process, event, out.m_opaque_sp, err.m_opaque_sp);
 }
@@ -562,10 +535,7 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process,
 void SBDebugger::HandleProcessEvent(const SBProcess &process,
                                     const SBEvent &event, FILE *out,
                                     FILE *err) {
-  LLDB_RECORD_METHOD(
-      void, SBDebugger, HandleProcessEvent,
-      (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *), process,
-      event, out, err);
+  LLDB_INSTRUMENT_VA(this, process, event, out, err);
 
   FileSP outfile = std::make_shared<NativeFile>(out, false);
   FileSP errfile = std::make_shared<NativeFile>(err, false);
@@ -576,10 +546,7 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process,
                                     const SBEvent &event, FileSP out_sp,
                                     FileSP err_sp) {
 
-  LLDB_RECORD_METHOD(
-      void, SBDebugger, HandleProcessEvent,
-      (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP), process,
-      event, out_sp, err_sp);
+  LLDB_INSTRUMENT_VA(this, process, event, out_sp, err_sp);
 
   if (!process.IsValid())
     return;
@@ -623,17 +590,14 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process,
 }
 
 SBSourceManager SBDebugger::GetSourceManager() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger,
-                             GetSourceManager);
+  LLDB_INSTRUMENT_VA(this);
 
   SBSourceManager sb_source_manager(*this);
-  return LLDB_RECORD_RESULT(sb_source_manager);
+  return sb_source_manager;
 }
 
 bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
-  LLDB_RECORD_CHAR_PTR_STATIC_METHOD(bool, SBDebugger, GetDefaultArchitecture,
-                                     (char *, size_t), arch_name, "",
-                                     arch_name_len);
+  LLDB_INSTRUMENT_VA(arch_name, arch_name_len);
 
   if (arch_name && arch_name_len) {
     ArchSpec default_arch = Target::GetDefaultArchitecture();
@@ -654,8 +618,7 @@ bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
 }
 
 bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
-                            (const char *), arch_name);
+  LLDB_INSTRUMENT_VA(arch_name);
 
   if (arch_name) {
     ArchSpec arch(arch_name);
@@ -669,8 +632,7 @@ bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
 
 ScriptLanguage
 SBDebugger::GetScriptingLanguage(const char *script_language_name) {
-  LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
-                     (const char *), script_language_name);
+  LLDB_INSTRUMENT_VA(this, script_language_name);
 
   if (!script_language_name)
     return eScriptLanguageDefault;
@@ -680,8 +642,7 @@ SBDebugger::GetScriptingLanguage(const char *script_language_name) {
 
 SBStructuredData
 SBDebugger::GetScriptInterpreterInfo(lldb::ScriptLanguage language) {
-  LLDB_RECORD_METHOD(SBStructuredData, SBDebugger, GetScriptInterpreterInfo,
-                     (lldb::ScriptLanguage), language);
+  LLDB_INSTRUMENT_VA(this, language);
   SBStructuredData data;
   if (m_opaque_sp) {
     lldb_private::ScriptInterpreter *interp =
@@ -690,18 +651,17 @@ SBDebugger::GetScriptInterpreterInfo(lldb::ScriptLanguage language) {
       data.m_impl_up->SetObjectSP(interp->GetInterpreterInfo());
     }
   }
-  return LLDB_RECORD_RESULT(data);
+  return data;
 }
 
 const char *SBDebugger::GetVersionString() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, GetVersionString);
+  LLDB_INSTRUMENT();
 
   return lldb_private::GetVersion();
 }
 
 const char *SBDebugger::StateAsCString(StateType state) {
-  LLDB_RECORD_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
-                            (lldb::StateType), state);
+  LLDB_INSTRUMENT_VA(state);
 
   return lldb_private::StateAsCString(state);
 }
@@ -727,8 +687,7 @@ static void AddLLVMTargets(StructuredData::Dictionary &dict) {
 }
 
 SBStructuredData SBDebugger::GetBuildConfiguration() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger,
-                                    GetBuildConfiguration);
+  LLDB_INSTRUMENT();
 
   auto config_up = std::make_unique<StructuredData::Dictionary>();
   AddBoolConfigEntry(
@@ -756,12 +715,11 @@ SBStructuredData SBDebugger::GetBuildConfiguration() {
 
   SBStructuredData data;
   data.m_impl_up->SetObjectSP(std::move(config_up));
-  return LLDB_RECORD_RESULT(data);
+  return data;
 }
 
 bool SBDebugger::StateIsRunningState(StateType state) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
-                            (lldb::StateType), state);
+  LLDB_INSTRUMENT_VA(state);
 
   const bool result = lldb_private::StateIsRunningState(state);
 
@@ -769,8 +727,7 @@ bool SBDebugger::StateIsRunningState(StateType state) {
 }
 
 bool SBDebugger::StateIsStoppedState(StateType state) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
-                            (lldb::StateType), state);
+  LLDB_INSTRUMENT_VA(state);
 
   const bool result = lldb_private::StateIsStoppedState(state, false);
 
@@ -782,10 +739,8 @@ lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
                                         const char *platform_name,
                                         bool add_dependent_modules,
                                         lldb::SBError &sb_error) {
-  LLDB_RECORD_METHOD(
-      lldb::SBTarget, SBDebugger, CreateTarget,
-      (const char *, const char *, const char *, bool, lldb::SBError &),
-      filename, target_triple, platform_name, add_dependent_modules, sb_error);
+  LLDB_INSTRUMENT_VA(this, filename, target_triple, platform_name,
+                     add_dependent_modules, sb_error);
 
   SBTarget sb_target;
   TargetSP target_sp;
@@ -814,15 +769,13 @@ lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
             platform_name, add_dependent_modules, sb_error.GetCString(),
             static_cast<void *>(target_sp.get()));
 
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 SBTarget
 SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
                                                 const char *target_triple) {
-  LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger,
-                     CreateTargetWithFileAndTargetTriple,
-                     (const char *, const char *), filename, target_triple);
+  LLDB_INSTRUMENT_VA(this, filename, target_triple);
 
   SBTarget sb_target;
   TargetSP target_sp;
@@ -842,13 +795,12 @@ SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
             static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
             static_cast<void *>(target_sp.get()));
 
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
                                                  const char *arch_cstr) {
-  LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch,
-                     (const char *, const char *), filename, arch_cstr);
+  LLDB_INSTRUMENT_VA(this, filename, arch_cstr);
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
@@ -860,16 +812,18 @@ SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
       // The version of CreateTarget that takes an ArchSpec won't accept an
       // empty ArchSpec, so when the arch hasn't been specified, we need to
       // call the target triple version.
-      error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename, 
-          arch_cstr, eLoadDependentsYes, nullptr, target_sp);
+      error = m_opaque_sp->GetTargetList().CreateTarget(
+          *m_opaque_sp, filename, arch_cstr, eLoadDependentsYes, nullptr,
+          target_sp);
     } else {
-      PlatformSP platform_sp = m_opaque_sp->GetPlatformList()
-          .GetSelectedPlatform();
-      ArchSpec arch = Platform::GetAugmentedArchSpec(platform_sp.get(), 
-          arch_cstr);
+      PlatformSP platform_sp =
+          m_opaque_sp->GetPlatformList().GetSelectedPlatform();
+      ArchSpec arch =
+          Platform::GetAugmentedArchSpec(platform_sp.get(), arch_cstr);
       if (arch.IsValid())
-        error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename, 
-            arch, eLoadDependentsYes, platform_sp, target_sp);
+        error = m_opaque_sp->GetTargetList().CreateTarget(
+            *m_opaque_sp, filename, arch, eLoadDependentsYes, platform_sp,
+            target_sp);
       else
         error.SetErrorStringWithFormat("invalid arch_cstr: %s", arch_cstr);
     }
@@ -885,12 +839,11 @@ SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
             arch_cstr ? arch_cstr : "<unspecified>",
             static_cast<void *>(target_sp.get()));
 
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 SBTarget SBDebugger::CreateTarget(const char *filename) {
-  LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *),
-                     filename);
+  LLDB_INSTRUMENT_VA(this, filename);
 
   SBTarget sb_target;
   TargetSP target_sp;
@@ -910,11 +863,11 @@ SBTarget SBDebugger::CreateTarget(const char *filename) {
             "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
             static_cast<void *>(m_opaque_sp.get()), filename,
             static_cast<void *>(target_sp.get()));
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 SBTarget SBDebugger::GetDummyTarget() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget);
+  LLDB_INSTRUMENT_VA(this);
 
   SBTarget sb_target;
   if (m_opaque_sp) {
@@ -924,12 +877,11 @@ SBTarget SBDebugger::GetDummyTarget() {
   LLDB_LOGF(log, "SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)",
             static_cast<void *>(m_opaque_sp.get()),
             static_cast<void *>(sb_target.GetSP().get()));
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
-  LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &),
-                     target);
+  LLDB_INSTRUMENT_VA(this, target);
 
   bool result = false;
   if (m_opaque_sp) {
@@ -951,20 +903,18 @@ bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
 }
 
 SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBTarget sb_target;
   if (m_opaque_sp) {
     // No need to lock, the target list is thread safe
     sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx));
   }
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
-  LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget),
-                     target);
+  LLDB_INSTRUMENT_VA(this, target);
 
   lldb::TargetSP target_sp = target.GetSP();
   if (!target_sp)
@@ -977,21 +927,19 @@ uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
 }
 
 SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
-  LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
-                     (lldb::pid_t), pid);
+  LLDB_INSTRUMENT_VA(this, pid);
 
   SBTarget sb_target;
   if (m_opaque_sp) {
     // No need to lock, the target list is thread safe
     sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid));
   }
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
                                                const char *arch_name) {
-  LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
-                     (const char *, const char *), filename, arch_name);
+  LLDB_INSTRUMENT_VA(this, filename, arch_name);
 
   SBTarget sb_target;
   if (m_opaque_sp && filename && filename[0]) {
@@ -1003,7 +951,7 @@ SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
             FileSpec(filename), arch_name ? &arch : nullptr));
     sb_target.SetSP(target_sp);
   }
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
@@ -1017,7 +965,7 @@ SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
 }
 
 uint32_t SBDebugger::GetNumTargets() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp) {
     // No need to lock, the target list is thread safe
@@ -1027,7 +975,7 @@ uint32_t SBDebugger::GetNumTargets() {
 }
 
 SBTarget SBDebugger::GetSelectedTarget() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget);
+  LLDB_INSTRUMENT_VA(this);
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
@@ -1047,12 +995,11 @@ SBTarget SBDebugger::GetSelectedTarget() {
               static_cast<void *>(target_sp.get()), sstr.GetData());
   }
 
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
-  LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &),
-                     sb_target);
+  LLDB_INSTRUMENT_VA(this, sb_target);
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
@@ -1070,7 +1017,7 @@ void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
 }
 
 SBPlatform SBDebugger::GetSelectedPlatform() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform);
+  LLDB_INSTRUMENT_VA(this);
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
@@ -1083,12 +1030,11 @@ SBPlatform SBDebugger::GetSelectedPlatform() {
             static_cast<void *>(m_opaque_sp.get()),
             static_cast<void *>(sb_platform.GetSP().get()),
             sb_platform.GetName());
-  return LLDB_RECORD_RESULT(sb_platform);
+  return sb_platform;
 }
 
 void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
-  LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform,
-                     (lldb::SBPlatform &), sb_platform);
+  LLDB_INSTRUMENT_VA(this, sb_platform);
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
@@ -1104,7 +1050,7 @@ void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
 }
 
 uint32_t SBDebugger::GetNumPlatforms() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp) {
     // No need to lock, the platform list is thread safe
@@ -1114,19 +1060,18 @@ uint32_t SBDebugger::GetNumPlatforms() {
 }
 
 SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
-                     (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBPlatform sb_platform;
   if (m_opaque_sp) {
     // No need to lock, the platform list is thread safe
     sb_platform.SetSP(m_opaque_sp->GetPlatformList().GetAtIndex(idx));
   }
-  return LLDB_RECORD_RESULT(sb_platform);
+  return sb_platform;
 }
 
 uint32_t SBDebugger::GetNumAvailablePlatforms() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t idx = 0;
   while (true) {
@@ -1140,8 +1085,7 @@ uint32_t SBDebugger::GetNumAvailablePlatforms() {
 }
 
 SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger,
-                     GetAvailablePlatformInfoAtIndex, (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBStructuredData data;
   auto platform_dict = std::make_unique<StructuredData::Dictionary>();
@@ -1156,7 +1100,7 @@ SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
     llvm::StringRef plugin_name =
         PluginManager::GetPlatformPluginNameAtIndex(idx - 1);
     if (plugin_name.empty()) {
-      return LLDB_RECORD_RESULT(data);
+      return data;
     }
     platform_dict->AddStringItem(name_str, llvm::StringRef(plugin_name));
 
@@ -1167,19 +1111,17 @@ SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
 
   data.m_impl_up->SetObjectSP(
       StructuredData::ObjectSP(platform_dict.release()));
-  return LLDB_RECORD_RESULT(data);
+  return data;
 }
 
 void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) {
-  LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput,
-                    (void *, const void *, size_t), baton, data, data_len);
+  LLDB_INSTRUMENT_VA(this, baton, data, data_len);
 
   DispatchInput(data, data_len);
 }
 
 void SBDebugger::DispatchInput(const void *data, size_t data_len) {
-  LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, (const void *, size_t),
-                    data, data_len);
+  LLDB_INSTRUMENT_VA(this, data, data_len);
 
   //    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
   //
@@ -1196,28 +1138,26 @@ void SBDebugger::DispatchInput(const void *data, size_t data_len) {
 }
 
 void SBDebugger::DispatchInputInterrupt() {
-  LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, DispatchInputInterrupt);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     m_opaque_sp->DispatchInputInterrupt();
 }
 
 void SBDebugger::DispatchInputEndOfFile() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     m_opaque_sp->DispatchInputEndOfFile();
 }
 
 void SBDebugger::PushInputReader(SBInputReader &reader) {
-  LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &),
-                     reader);
+  LLDB_INSTRUMENT_VA(this, reader);
 }
 
 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
                                        bool spawn_thread) {
-  LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool),
-                     auto_handle_events, spawn_thread);
+  LLDB_INSTRUMENT_VA(this, auto_handle_events, spawn_thread);
 
   if (m_opaque_sp) {
     CommandInterpreterRunOptions options;
@@ -1234,11 +1174,8 @@ void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
                                        bool &stopped_for_crash)
 
 {
-  LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter,
-                     (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &,
-                      bool &, bool &),
-                     auto_handle_events, spawn_thread, options, num_errors,
-                     quit_requested, stopped_for_crash);
+  LLDB_INSTRUMENT_VA(this, auto_handle_events, spawn_thread, options,
+                     num_errors, quit_requested, stopped_for_crash);
 
   if (m_opaque_sp) {
     options.SetAutoHandleEvents(auto_handle_events);
@@ -1256,32 +1193,28 @@ void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
 
 SBCommandInterpreterRunResult SBDebugger::RunCommandInterpreter(
     const SBCommandInterpreterRunOptions &options) {
-  LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger,
-                     RunCommandInterpreter,
-                     (const lldb::SBCommandInterpreterRunOptions &), options);
+  LLDB_INSTRUMENT_VA(this, options);
 
   if (!m_opaque_sp)
-    return LLDB_RECORD_RESULT(SBCommandInterpreterRunResult());
+    return SBCommandInterpreterRunResult();
 
   CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
   CommandInterpreterRunResult result =
       interp.RunCommandInterpreter(options.ref());
 
-  return LLDB_RECORD_RESULT(SBCommandInterpreterRunResult(result));
+  return SBCommandInterpreterRunResult(result);
 }
 
 SBError SBDebugger::RunREPL(lldb::LanguageType language,
                             const char *repl_options) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL,
-                     (lldb::LanguageType, const char *), language,
-                     repl_options);
+  LLDB_INSTRUMENT_VA(this, language, repl_options);
 
   SBError error;
   if (m_opaque_sp)
     error.ref() = m_opaque_sp->RunREPL(language, repl_options);
   else
     error.SetErrorString("invalid debugger");
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 void SBDebugger::reset(const DebuggerSP &debugger_sp) {
@@ -1298,28 +1231,25 @@ Debugger &SBDebugger::ref() const {
 const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; }
 
 SBDebugger SBDebugger::FindDebuggerWithID(int id) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID,
-                            (int), id);
+  LLDB_INSTRUMENT_VA(id);
 
   // No need to lock, the debugger list is thread safe
   SBDebugger sb_debugger;
   DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id);
   if (debugger_sp)
     sb_debugger.reset(debugger_sp);
-  return LLDB_RECORD_RESULT(sb_debugger);
+  return sb_debugger;
 }
 
 const char *SBDebugger::GetInstanceName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
 }
 
 SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
                                         const char *debugger_instance_name) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
-                            (const char *, const char *, const char *),
-                            var_name, value, debugger_instance_name);
+  LLDB_INSTRUMENT_VA(var_name, value, debugger_instance_name);
 
   SBError sb_error;
   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
@@ -1336,15 +1266,13 @@ SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
   }
   if (error.Fail())
     sb_error.SetError(error);
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBStringList
 SBDebugger::GetInternalVariableValue(const char *var_name,
                                      const char *debugger_instance_name) {
-  LLDB_RECORD_STATIC_METHOD(
-      lldb::SBStringList, SBDebugger, GetInternalVariableValue,
-      (const char *, const char *), var_name, debugger_instance_name);
+  LLDB_INSTRUMENT_VA(var_name, debugger_instance_name);
 
   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
       ConstString(debugger_instance_name)));
@@ -1361,28 +1289,28 @@ SBDebugger::GetInternalVariableValue(const char *var_name,
       if (!value_str.empty()) {
         StringList string_list;
         string_list.SplitIntoLines(value_str);
-        return LLDB_RECORD_RESULT(SBStringList(&string_list));
+        return SBStringList(&string_list);
       }
     }
   }
-  return LLDB_RECORD_RESULT(SBStringList());
+  return SBStringList();
 }
 
 uint32_t SBDebugger::GetTerminalWidth() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
 }
 
 void SBDebugger::SetTerminalWidth(uint32_t term_width) {
-  LLDB_RECORD_DUMMY(void, SBDebugger, SetTerminalWidth, (uint32_t), term_width);
+  LLDB_INSTRUMENT_VA(this, term_width);
 
   if (m_opaque_sp)
     m_opaque_sp->SetTerminalWidth(term_width);
 }
 
 const char *SBDebugger::GetPrompt() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt);
+  LLDB_INSTRUMENT_VA(this);
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
@@ -1395,14 +1323,14 @@ const char *SBDebugger::GetPrompt() const {
 }
 
 void SBDebugger::SetPrompt(const char *prompt) {
-  LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt);
+  LLDB_INSTRUMENT_VA(this, prompt);
 
   if (m_opaque_sp)
     m_opaque_sp->SetPrompt(llvm::StringRef(prompt));
 }
 
 const char *SBDebugger::GetReproducerPath() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_sp
               ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString()
@@ -1410,60 +1338,71 @@ const char *SBDebugger::GetReproducerPath() const {
 }
 
 ScriptLanguage SBDebugger::GetScriptLanguage() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger,
-                                   GetScriptLanguage);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
 }
 
 void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
-  LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage,
-                     (lldb::ScriptLanguage), script_lang);
+  LLDB_INSTRUMENT_VA(this, script_lang);
 
   if (m_opaque_sp) {
     m_opaque_sp->SetScriptLanguage(script_lang);
   }
 }
 
+LanguageType SBDebugger::GetREPLLanguage() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return (m_opaque_sp ? m_opaque_sp->GetREPLLanguage() : eLanguageTypeUnknown);
+}
+
+void SBDebugger::SetREPLLanguage(LanguageType repl_lang) {
+  LLDB_INSTRUMENT_VA(this, repl_lang);
+
+  if (m_opaque_sp) {
+    m_opaque_sp->SetREPLLanguage(repl_lang);
+  }
+}
+
 bool SBDebugger::SetUseExternalEditor(bool value) {
-  LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value);
+  LLDB_INSTRUMENT_VA(this, value);
 
   return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
 }
 
 bool SBDebugger::GetUseExternalEditor() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
 }
 
 bool SBDebugger::SetUseColor(bool value) {
-  LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value);
+  LLDB_INSTRUMENT_VA(this, value);
 
   return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
 }
 
 bool SBDebugger::GetUseColor() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
 }
 
 bool SBDebugger::SetUseSourceCache(bool value) {
-  LLDB_RECORD_METHOD(bool, SBDebugger, SetUseSourceCache, (bool), value);
+  LLDB_INSTRUMENT_VA(this, value);
 
   return (m_opaque_sp ? m_opaque_sp->SetUseSourceCache(value) : false);
 }
 
 bool SBDebugger::GetUseSourceCache() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseSourceCache);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_sp ? m_opaque_sp->GetUseSourceCache() : false);
 }
 
 bool SBDebugger::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -1478,14 +1417,13 @@ bool SBDebugger::GetDescription(SBStream &description) {
 }
 
 user_id_t SBDebugger::GetID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
 }
 
 SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
-                     (const char *), platform_name_cstr);
+  LLDB_INSTRUMENT_VA(this, platform_name_cstr);
 
   SBError sb_error;
   if (m_opaque_sp) {
@@ -1511,91 +1449,77 @@ SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
   } else {
     sb_error.ref().SetErrorString("invalid debugger");
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
-  LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
-                     (const char *), sysroot);
+  LLDB_INSTRUMENT_VA(this, sysroot);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (m_opaque_sp) {
-    PlatformSP platform_sp(
-        m_opaque_sp->GetPlatformList().GetSelectedPlatform());
-
-    if (platform_sp) {
-      if (log && sysroot)
-        LLDB_LOGF(log, "SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")",
-                  sysroot);
-      platform_sp->SetSDKRootDirectory(ConstString(sysroot));
-      return true;
-    }
+  if (SBPlatform platform = GetSelectedPlatform()) {
+    platform.SetSDKRoot(sysroot);
+    return true;
   }
   return false;
 }
 
 bool SBDebugger::GetCloseInputOnEOF() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
 }
 
 void SBDebugger::SetCloseInputOnEOF(bool b) {
-  LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b);
+  LLDB_INSTRUMENT_VA(this, b);
 
   if (m_opaque_sp)
     m_opaque_sp->SetCloseInputOnEOF(b);
 }
 
 SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
-  LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
-                     (const char *), category_name);
+  LLDB_INSTRUMENT_VA(this, category_name);
 
   if (!category_name || *category_name == 0)
-    return LLDB_RECORD_RESULT(SBTypeCategory());
+    return SBTypeCategory();
 
   TypeCategoryImplSP category_sp;
 
   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
                                                  category_sp, false)) {
-    return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
+    return SBTypeCategory(category_sp);
   } else {
-    return LLDB_RECORD_RESULT(SBTypeCategory());
+    return SBTypeCategory();
   }
 }
 
 SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
-  LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
-                     (lldb::LanguageType), lang_type);
+  LLDB_INSTRUMENT_VA(this, lang_type);
 
   TypeCategoryImplSP category_sp;
   if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) {
-    return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
+    return SBTypeCategory(category_sp);
   } else {
-    return LLDB_RECORD_RESULT(SBTypeCategory());
+    return SBTypeCategory();
   }
 }
 
 SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
-  LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
-                     (const char *), category_name);
+  LLDB_INSTRUMENT_VA(this, category_name);
 
   if (!category_name || *category_name == 0)
-    return LLDB_RECORD_RESULT(SBTypeCategory());
+    return SBTypeCategory();
 
   TypeCategoryImplSP category_sp;
 
   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
                                                  category_sp, true)) {
-    return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
+    return SBTypeCategory(category_sp);
   } else {
-    return LLDB_RECORD_RESULT(SBTypeCategory());
+    return SBTypeCategory();
   }
 }
 
 bool SBDebugger::DeleteCategory(const char *category_name) {
-  LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *),
-                     category_name);
+  LLDB_INSTRUMENT_VA(this, category_name);
 
   if (!category_name || *category_name == 0)
     return false;
@@ -1604,64 +1528,56 @@ bool SBDebugger::DeleteCategory(const char *category_name) {
 }
 
 uint32_t SBDebugger::GetNumCategories() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories);
+  LLDB_INSTRUMENT_VA(this);
 
   return DataVisualization::Categories::GetCount();
 }
 
 SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
-                     (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
-  return LLDB_RECORD_RESULT(
-      SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index)));
+  return SBTypeCategory(
+      DataVisualization::Categories::GetCategoryAtIndex(index));
 }
 
 SBTypeCategory SBDebugger::GetDefaultCategory() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger,
-                             GetDefaultCategory);
+  LLDB_INSTRUMENT_VA(this);
 
-  return LLDB_RECORD_RESULT(GetCategory("default"));
+  return GetCategory("default");
 }
 
 SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
-  LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
-                     (lldb::SBTypeNameSpecifier), type_name);
+  LLDB_INSTRUMENT_VA(this, type_name);
 
   SBTypeCategory default_category_sb = GetDefaultCategory();
   if (default_category_sb.GetEnabled())
-    return LLDB_RECORD_RESULT(default_category_sb.GetFormatForType(type_name));
-  return LLDB_RECORD_RESULT(SBTypeFormat());
+    return default_category_sb.GetFormatForType(type_name);
+  return SBTypeFormat();
 }
 
 SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
-  LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
-                     (lldb::SBTypeNameSpecifier), type_name);
+  LLDB_INSTRUMENT_VA(this, type_name);
 
   if (!type_name.IsValid())
-    return LLDB_RECORD_RESULT(SBTypeSummary());
-  return LLDB_RECORD_RESULT(
-      SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())));
+    return SBTypeSummary();
+  return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
 }
 
 SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
-  LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
-                     (lldb::SBTypeNameSpecifier), type_name);
+  LLDB_INSTRUMENT_VA(this, type_name);
 
   if (!type_name.IsValid())
-    return LLDB_RECORD_RESULT(SBTypeFilter());
-  return LLDB_RECORD_RESULT(
-      SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())));
+    return SBTypeFilter();
+  return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
 }
 
 SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
-  LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
-                     (lldb::SBTypeNameSpecifier), type_name);
+  LLDB_INSTRUMENT_VA(this, type_name);
 
   if (!type_name.IsValid())
-    return LLDB_RECORD_RESULT(SBTypeSynthetic());
-  return LLDB_RECORD_RESULT(SBTypeSynthetic(
-      DataVisualization::GetSyntheticForType(type_name.GetSP())));
+    return SBTypeSynthetic();
+  return SBTypeSynthetic(
+      DataVisualization::GetSyntheticForType(type_name.GetSP()));
 }
 
 static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) {
@@ -1674,8 +1590,7 @@ static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) {
 }
 
 bool SBDebugger::EnableLog(const char *channel, const char **categories) {
-  LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **),
-                     channel, categories);
+  LLDB_INSTRUMENT_VA(this, channel, categories);
 
   if (m_opaque_sp) {
     uint32_t log_options =
@@ -1690,224 +1605,9 @@ bool SBDebugger::EnableLog(const char *channel, const char **categories) {
 
 void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
                                     void *baton) {
-  LLDB_RECORD_DUMMY(void, SBDebugger, SetLoggingCallback,
-                    (lldb::LogOutputCallback, void *), log_callback, baton);
+  LLDB_INSTRUMENT_VA(this, log_callback, baton);
 
   if (m_opaque_sp) {
     return m_opaque_sp->SetLoggingCallback(log_callback, baton);
   }
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <> void RegisterMethods<SBInputReader>(Registry &R) {
-  LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ());
-}
-
-static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) {
-  // Do nothing.
-}
-
-static SBError SetFileRedirect(SBDebugger *, SBFile file) { return SBError(); }
-
-static SBError SetFileRedirect(SBDebugger *, FileSP file) { return SBError(); }
-
-template <> void RegisterMethods<SBDebugger>(Registry &R) {
-  // Custom implementation.
-  R.Register(&invoke<void (SBDebugger::*)(FILE *, bool)>::method<
-                 &SBDebugger::SetErrorFileHandle>::record,
-             &SetFileHandleRedirect);
-  R.Register(&invoke<void (SBDebugger::*)(FILE *, bool)>::method<
-                 &SBDebugger::SetOutputFileHandle>::record,
-             &SetFileHandleRedirect);
-
-  R.Register(&invoke<SBError (SBDebugger::*)(
-                 SBFile)>::method<&SBDebugger::SetInputFile>::record,
-             &SetFileRedirect);
-  R.Register(&invoke<SBError (SBDebugger::*)(
-                 SBFile)>::method<&SBDebugger::SetOutputFile>::record,
-             &SetFileRedirect);
-  R.Register(&invoke<SBError (SBDebugger::*)(
-                 SBFile)>::method<&SBDebugger::SetErrorFile>::record,
-             &SetFileRedirect);
-
-  R.Register(&invoke<SBError (SBDebugger::*)(
-                 FileSP)>::method<&SBDebugger::SetInputFile>::record,
-             &SetFileRedirect);
-  R.Register(&invoke<SBError (SBDebugger::*)(
-                 FileSP)>::method<&SBDebugger::SetOutputFile>::record,
-             &SetFileRedirect);
-  R.Register(&invoke<SBError (SBDebugger::*)(
-                 FileSP)>::method<&SBDebugger::SetErrorFile>::record,
-             &SetFileRedirect);
-
-  LLDB_REGISTER_CHAR_PTR_METHOD_STATIC(bool, SBDebugger,
-                                       GetDefaultArchitecture);
-
-  LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &));
-  LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &));
-  LLDB_REGISTER_METHOD(lldb::SBDebugger &,
-                       SBDebugger, operator=,(const lldb::SBDebugger &));
-  LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ());
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger,
-                              InitializeWithErrorHandling, ());
-  LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ());
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ());
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool));
-  LLDB_REGISTER_STATIC_METHOD(
-      const char *, SBDebugger, GetProgressFromEvent,
-      (const lldb::SBEvent &, uint64_t &, uint64_t &, uint64_t &, bool &));
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetBroadcasterClass,
-                              ());
-  LLDB_REGISTER_METHOD(SBBroadcaster, SBDebugger, GetBroadcaster, ());
-  LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &));
-  LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool,());
-  LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool));
-  LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool));
-  LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool));
-  LLDB_REGISTER_METHOD(SBError, SBDebugger, SetInputString, (const char *));
-  LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool));
-  LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ());
-  LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ());
-  LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ());
-  LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetInputFile, ());
-  LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetOutputFile, ());
-  LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetErrorFile, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ());
-  LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger,
-                       GetCommandInterpreter, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ());
-  LLDB_REGISTER_METHOD(
-      void, SBDebugger, HandleProcessEvent,
-      (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *));
-  LLDB_REGISTER_METHOD(
-      void, SBDebugger, HandleProcessEvent,
-      (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile));
-  LLDB_REGISTER_METHOD(
-      void, SBDebugger, HandleProcessEvent,
-      (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP));
-  LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager, ());
-  LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
-                              (const char *));
-  LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
-                       (const char *));
-  LLDB_REGISTER_METHOD(SBStructuredData, SBDebugger, GetScriptInterpreterInfo,
-                       (lldb::ScriptLanguage));
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ());
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
-                              (lldb::StateType));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger,
-                              GetBuildConfiguration, ());
-  LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
-                              (lldb::StateType));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
-                              (lldb::StateType));
-  LLDB_REGISTER_METHOD(
-      lldb::SBTarget, SBDebugger, CreateTarget,
-      (const char *, const char *, const char *, bool, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger,
-                       CreateTargetWithFileAndTargetTriple,
-                       (const char *, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch,
-                       (const char *, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget,
-                       (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ());
-  LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &));
-  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget,
-                       (lldb::SBTarget));
-  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
-                       (lldb::pid_t));
-  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
-                       (const char *, const char *));
-  LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ());
-  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &));
-  LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform,
-                       (lldb::SBPlatform &));
-  LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ());
-  LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ());
-  LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger,
-                       GetAvailablePlatformInfoAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader,
-                       (lldb::SBInputReader &));
-  LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool));
-  LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter,
-                       (bool, bool, lldb::SBCommandInterpreterRunOptions &,
-                        int &, bool &, bool &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL,
-                       (lldb::LanguageType, const char *));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID,
-                              (int));
-  LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ());
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
-                              (const char *, const char *, const char *));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger,
-                              GetInternalVariableValue,
-                              (const char *, const char *));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger,
-                             GetScriptLanguage, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage,
-                       (lldb::ScriptLanguage));
-  LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool));
-  LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ());
-  LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ());
-  LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
-                       (const char *));
-  LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
-                       (const char *));
-  LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ());
-  LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool));
-  LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
-                       (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
-                       (lldb::LanguageType));
-  LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
-                       (const char *));
-  LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *));
-  LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ());
-  LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory,
-                       ());
-  LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
-                       (lldb::SBTypeNameSpecifier));
-  LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
-                       (lldb::SBTypeNameSpecifier));
-  LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
-                       (lldb::SBTypeNameSpecifier));
-  LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
-                       (lldb::SBTypeNameSpecifier));
-  LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog,
-                       (const char *, const char **));
-  LLDB_REGISTER_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger,
-                       RunCommandInterpreter,
-                       (const lldb::SBCommandInterpreterRunOptions &));
-}
-
-} // namespace repro
-} // namespace lldb_private
diff --git a/lldb/source/API/SBDeclaration.cpp b/lldb/source/API/SBDeclaration.cpp
index 1496096e46d1..5b7def09b5cc 100644
--- a/lldb/source/API/SBDeclaration.cpp
+++ b/lldb/source/API/SBDeclaration.cpp
@@ -7,11 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBDeclaration.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Declaration.h"
 #include "lldb/Host/PosixApi.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Stream.h"
 
 #include <climits>
@@ -19,30 +19,25 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBDeclaration::SBDeclaration() : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDeclaration);
-}
+SBDeclaration::SBDeclaration() { LLDB_INSTRUMENT_VA(this); }
 
-SBDeclaration::SBDeclaration(const SBDeclaration &rhs) : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &), rhs);
+SBDeclaration::SBDeclaration(const SBDeclaration &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
-SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr)
-    : m_opaque_up() {
+SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr) {
   if (lldb_object_ptr)
     m_opaque_up = std::make_unique<Declaration>(*lldb_object_ptr);
 }
 
 const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBDeclaration &,
-                     SBDeclaration, operator=,(const lldb::SBDeclaration &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 void SBDeclaration::SetDeclaration(
@@ -53,31 +48,27 @@ void SBDeclaration::SetDeclaration(
 SBDeclaration::~SBDeclaration() = default;
 
 bool SBDeclaration::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBDeclaration::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up.get() && m_opaque_up->IsValid();
 }
 
 SBFileSpec SBDeclaration::GetFileSpec() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBDeclaration,
-                                   GetFileSpec);
-
+  LLDB_INSTRUMENT_VA(this);
 
   SBFileSpec sb_file_spec;
   if (m_opaque_up.get() && m_opaque_up->GetFile())
     sb_file_spec.SetFileSpec(m_opaque_up->GetFile());
 
-
-  return LLDB_RECORD_RESULT(sb_file_spec);
+  return sb_file_spec;
 }
 
 uint32_t SBDeclaration::GetLine() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetLine);
-
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t line = 0;
   if (m_opaque_up)
@@ -88,7 +79,7 @@ uint32_t SBDeclaration::GetLine() const {
 }
 
 uint32_t SBDeclaration::GetColumn() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetColumn);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up)
     return m_opaque_up->GetColumn();
@@ -96,8 +87,7 @@ uint32_t SBDeclaration::GetColumn() const {
 }
 
 void SBDeclaration::SetFileSpec(lldb::SBFileSpec filespec) {
-  LLDB_RECORD_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec),
-                     filespec);
+  LLDB_INSTRUMENT_VA(this, filespec);
 
   if (filespec.IsValid())
     ref().SetFile(filespec.ref());
@@ -105,20 +95,19 @@ void SBDeclaration::SetFileSpec(lldb::SBFileSpec filespec) {
     ref().SetFile(FileSpec());
 }
 void SBDeclaration::SetLine(uint32_t line) {
-  LLDB_RECORD_METHOD(void, SBDeclaration, SetLine, (uint32_t), line);
+  LLDB_INSTRUMENT_VA(this, line);
 
   ref().SetLine(line);
 }
 
 void SBDeclaration::SetColumn(uint32_t column) {
-  LLDB_RECORD_METHOD(void, SBDeclaration, SetColumn, (uint32_t), column);
+  LLDB_INSTRUMENT_VA(this, column);
 
   ref().SetColumn(column);
 }
 
 bool SBDeclaration::operator==(const SBDeclaration &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBDeclaration, operator==,(const lldb::SBDeclaration &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
   lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
@@ -130,8 +119,7 @@ bool SBDeclaration::operator==(const SBDeclaration &rhs) const {
 }
 
 bool SBDeclaration::operator!=(const SBDeclaration &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
   lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
@@ -157,8 +145,7 @@ const lldb_private::Declaration &SBDeclaration::ref() const {
 }
 
 bool SBDeclaration::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -175,33 +162,3 @@ bool SBDeclaration::GetDescription(SBStream &description) {
 }
 
 lldb_private::Declaration *SBDeclaration::get() { return m_opaque_up.get(); }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBDeclaration>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBDeclaration &,
-      SBDeclaration, operator=,(const lldb::SBDeclaration &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, operator bool, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBDeclaration, GetFileSpec,
-                             ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetLine, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetColumn, ());
-  LLDB_REGISTER_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec));
-  LLDB_REGISTER_METHOD(void, SBDeclaration, SetLine, (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBDeclaration, SetColumn, (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBDeclaration, operator==,(const lldb::SBDeclaration &));
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &));
-  LLDB_REGISTER_METHOD(bool, SBDeclaration, GetDescription,
-                       (lldb::SBStream &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBEnvironment.cpp b/lldb/source/API/SBEnvironment.cpp
index d4de89c32567..5fafabe02e01 100644
--- a/lldb/source/API/SBEnvironment.cpp
+++ b/lldb/source/API/SBEnvironment.cpp
@@ -7,22 +7,22 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBEnvironment.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Environment.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBEnvironment::SBEnvironment() : m_opaque_up(new Environment()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEnvironment);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBEnvironment::SBEnvironment(const SBEnvironment &rhs)
     : m_opaque_up(clone(rhs.m_opaque_up)) {
-  LLDB_RECORD_CONSTRUCTOR(SBEnvironment, (const lldb::SBEnvironment &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBEnvironment::SBEnvironment(Environment rhs)
@@ -31,23 +31,21 @@ SBEnvironment::SBEnvironment(Environment rhs)
 SBEnvironment::~SBEnvironment() = default;
 
 const SBEnvironment &SBEnvironment::operator=(const SBEnvironment &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBEnvironment &,
-                     SBEnvironment, operator=,(const lldb::SBEnvironment &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 size_t SBEnvironment::GetNumValues() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBEnvironment, GetNumValues);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->size();
 }
 
 const char *SBEnvironment::Get(const char *name) {
-  LLDB_RECORD_METHOD(const char *, SBEnvironment, Get, (const char *), name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   auto entry = m_opaque_up->find(name);
   if (entry == m_opaque_up->end()) {
@@ -57,8 +55,7 @@ const char *SBEnvironment::Get(const char *name) {
 }
 
 const char *SBEnvironment::GetNameAtIndex(size_t index) {
-  LLDB_RECORD_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t),
-                     index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (index >= GetNumValues())
     return nullptr;
@@ -67,8 +64,7 @@ const char *SBEnvironment::GetNameAtIndex(size_t index) {
 }
 
 const char *SBEnvironment::GetValueAtIndex(size_t index) {
-  LLDB_RECORD_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t),
-                     index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (index >= GetNumValues())
     return nullptr;
@@ -77,9 +73,7 @@ const char *SBEnvironment::GetValueAtIndex(size_t index) {
 }
 
 bool SBEnvironment::Set(const char *name, const char *value, bool overwrite) {
-  LLDB_RECORD_METHOD(bool, SBEnvironment, Set,
-                     (const char *, const char *, bool), name, value,
-                     overwrite);
+  LLDB_INSTRUMENT_VA(this, name, value, overwrite);
 
   if (overwrite) {
     m_opaque_up->insert_or_assign(name, std::string(value));
@@ -89,32 +83,30 @@ bool SBEnvironment::Set(const char *name, const char *value, bool overwrite) {
 }
 
 bool SBEnvironment::Unset(const char *name) {
-  LLDB_RECORD_METHOD(bool, SBEnvironment, Unset, (const char *), name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   return m_opaque_up->erase(name);
 }
 
 SBStringList SBEnvironment::GetEntries() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStringList, SBEnvironment, GetEntries);
+  LLDB_INSTRUMENT_VA(this);
 
   SBStringList entries;
   for (const auto &KV : *m_opaque_up) {
     entries.AppendString(Environment::compose(KV).c_str());
   }
-  return LLDB_RECORD_RESULT(entries);
+  return entries;
 }
 
 void SBEnvironment::PutEntry(const char *name_and_value) {
-  LLDB_RECORD_METHOD(void, SBEnvironment, PutEntry, (const char *),
-                     name_and_value);
+  LLDB_INSTRUMENT_VA(this, name_and_value);
 
   auto split = llvm::StringRef(name_and_value).split('=');
   m_opaque_up->insert_or_assign(split.first.str(), split.second.str());
 }
 
 void SBEnvironment::SetEntries(const SBStringList &entries, bool append) {
-  LLDB_RECORD_METHOD(void, SBEnvironment, SetEntries,
-                     (const lldb::SBStringList &, bool), entries, append);
+  LLDB_INSTRUMENT_VA(this, entries, append);
 
   if (!append)
     m_opaque_up->clear();
@@ -124,32 +116,9 @@ void SBEnvironment::SetEntries(const SBStringList &entries, bool append) {
 }
 
 void SBEnvironment::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBEnvironment, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_up->clear();
 }
 
 Environment &SBEnvironment::ref() const { return *m_opaque_up; }
-
-namespace lldb_private {
-namespace repro {
-template <> void RegisterMethods<SBEnvironment>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBEnvironment, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBEnvironment, (const lldb::SBEnvironment &));
-  LLDB_REGISTER_METHOD(const lldb::SBEnvironment &,
-                       SBEnvironment, operator=,(const lldb::SBEnvironment &));
-  LLDB_REGISTER_METHOD(size_t, SBEnvironment, GetNumValues, ());
-  LLDB_REGISTER_METHOD(const char *, SBEnvironment, Get, (const char *));
-  LLDB_REGISTER_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t));
-  LLDB_REGISTER_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t));
-  LLDB_REGISTER_METHOD(bool, SBEnvironment, Set,
-                       (const char *, const char *, bool));
-  LLDB_REGISTER_METHOD(bool, SBEnvironment, Unset, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBStringList, SBEnvironment, GetEntries, ());
-  LLDB_REGISTER_METHOD(void, SBEnvironment, PutEntry, (const char *));
-  LLDB_REGISTER_METHOD(void, SBEnvironment, SetEntries,
-                       (const lldb::SBStringList &, bool));
-  LLDB_REGISTER_METHOD(void, SBEnvironment, Clear, ());
-}
-} // namespace repro
-} // namespace lldb_private
diff --git a/lldb/source/API/SBError.cpp b/lldb/source/API/SBError.cpp
index 89b5f26fd80c..ef4f7266f083 100644
--- a/lldb/source/API/SBError.cpp
+++ b/lldb/source/API/SBError.cpp
@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBError.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Status.h"
 
 #include <cstdarg>
@@ -17,10 +17,10 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBError::SBError() : m_opaque_up() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBError); }
+SBError::SBError() { LLDB_INSTRUMENT_VA(this); }
 
-SBError::SBError(const SBError &rhs) : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBError, (const lldb::SBError &), rhs);
+SBError::SBError(const SBError &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
@@ -28,16 +28,15 @@ SBError::SBError(const SBError &rhs) : m_opaque_up() {
 SBError::~SBError() = default;
 
 const SBError &SBError::operator=(const SBError &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBError &,
-                     SBError, operator=,(const lldb::SBError &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 const char *SBError::GetCString() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBError, GetCString);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up)
     return m_opaque_up->AsCString();
@@ -45,14 +44,14 @@ const char *SBError::GetCString() const {
 }
 
 void SBError::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBError, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up)
     m_opaque_up->Clear();
 }
 
 bool SBError::Fail() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Fail);
+  LLDB_INSTRUMENT_VA(this);
 
   bool ret_value = false;
   if (m_opaque_up)
@@ -63,7 +62,7 @@ bool SBError::Fail() const {
 }
 
 bool SBError::Success() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Success);
+  LLDB_INSTRUMENT_VA(this);
 
   bool ret_value = true;
   if (m_opaque_up)
@@ -73,8 +72,7 @@ bool SBError::Success() const {
 }
 
 uint32_t SBError::GetError() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBError, GetError);
-
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t err = 0;
   if (m_opaque_up)
@@ -85,7 +83,7 @@ uint32_t SBError::GetError() const {
 }
 
 ErrorType SBError::GetType() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType);
+  LLDB_INSTRUMENT_VA(this);
 
   ErrorType err_type = eErrorTypeInvalid;
   if (m_opaque_up)
@@ -95,8 +93,7 @@ ErrorType SBError::GetType() const {
 }
 
 void SBError::SetError(uint32_t err, ErrorType type) {
-  LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err,
-                     type);
+  LLDB_INSTRUMENT_VA(this, err, type);
 
   CreateIfNeeded();
   m_opaque_up->SetError(err, type);
@@ -108,21 +105,21 @@ void SBError::SetError(const Status &lldb_error) {
 }
 
 void SBError::SetErrorToErrno() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToErrno);
+  LLDB_INSTRUMENT_VA(this);
 
   CreateIfNeeded();
   m_opaque_up->SetErrorToErrno();
 }
 
 void SBError::SetErrorToGenericError() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToGenericError);
+  LLDB_INSTRUMENT_VA(this);
 
   CreateIfNeeded();
   m_opaque_up->SetErrorToGenericError();
 }
 
 void SBError::SetErrorString(const char *err_str) {
-  LLDB_RECORD_METHOD(void, SBError, SetErrorString, (const char *), err_str);
+  LLDB_INSTRUMENT_VA(this, err_str);
 
   CreateIfNeeded();
   m_opaque_up->SetErrorString(err_str);
@@ -138,11 +135,11 @@ int SBError::SetErrorStringWithFormat(const char *format, ...) {
 }
 
 bool SBError::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBError::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up != nullptr;
 }
@@ -167,8 +164,7 @@ const lldb_private::Status &SBError::operator*() const {
 }
 
 bool SBError::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBError, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   if (m_opaque_up) {
     if (m_opaque_up->Success())
@@ -183,30 +179,3 @@ bool SBError::GetDescription(SBStream &description) {
 
   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 &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBEvent.cpp b/lldb/source/API/SBEvent.cpp
index a0b606e3812e..536680bd1c5e 100644
--- a/lldb/source/API/SBEvent.cpp
+++ b/lldb/source/API/SBEvent.cpp
@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBEvent.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBStream.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Core/StreamFile.h"
@@ -22,44 +22,42 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBEvent::SBEvent() : m_event_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEvent); }
+SBEvent::SBEvent() { LLDB_INSTRUMENT_VA(this); }
 
 SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len)
     : m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))),
       m_opaque_ptr(m_event_sp.get()) {
-  LLDB_RECORD_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t),
-                          event_type, cstr, cstr_len);
+  LLDB_INSTRUMENT_VA(this, event_type, cstr, cstr_len);
 }
 
 SBEvent::SBEvent(EventSP &event_sp)
     : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {
-  LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb::EventSP &), event_sp);
+  LLDB_INSTRUMENT_VA(this, event_sp);
 }
 
-SBEvent::SBEvent(Event *event_ptr) : m_event_sp(), m_opaque_ptr(event_ptr) {
-  LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb_private::Event *), event_ptr);
+SBEvent::SBEvent(Event *event_ptr) : m_opaque_ptr(event_ptr) {
+  LLDB_INSTRUMENT_VA(this, event_ptr);
 }
 
 SBEvent::SBEvent(const SBEvent &rhs)
     : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
-  LLDB_RECORD_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBEvent &,
-                     SBEvent, operator=,(const lldb::SBEvent &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_event_sp = rhs.m_event_sp;
     m_opaque_ptr = rhs.m_opaque_ptr;
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBEvent::~SBEvent() = default;
 
 const char *SBEvent::GetDataFlavor() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor);
+  LLDB_INSTRUMENT_VA(this);
 
   Event *lldb_event = get();
   if (lldb_event) {
@@ -71,8 +69,7 @@ const char *SBEvent::GetDataFlavor() {
 }
 
 uint32_t SBEvent::GetType() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType);
-
+  LLDB_INSTRUMENT_VA(this);
 
   const Event *lldb_event = get();
   uint32_t event_type = 0;
@@ -84,18 +81,17 @@ uint32_t SBEvent::GetType() const {
 }
 
 SBBroadcaster SBEvent::GetBroadcaster() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent,
-                                   GetBroadcaster);
+  LLDB_INSTRUMENT_VA(this);
 
   SBBroadcaster broadcaster;
   const Event *lldb_event = get();
   if (lldb_event)
     broadcaster.reset(lldb_event->GetBroadcaster(), false);
-  return LLDB_RECORD_RESULT(broadcaster);
+  return broadcaster;
 }
 
 const char *SBEvent::GetBroadcasterClass() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBEvent, GetBroadcasterClass);
+  LLDB_INSTRUMENT_VA(this);
 
   const Event *lldb_event = get();
   if (lldb_event)
@@ -105,8 +101,7 @@ const char *SBEvent::GetBroadcasterClass() const {
 }
 
 bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
-  LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
-                     (const lldb::SBBroadcaster *), broadcaster);
+  LLDB_INSTRUMENT_VA(this, broadcaster);
 
   if (broadcaster)
     return BroadcasterMatchesRef(*broadcaster);
@@ -114,8 +109,7 @@ bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
 }
 
 bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
-  LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef,
-                     (const lldb::SBBroadcaster &), broadcaster);
+  LLDB_INSTRUMENT_VA(this, broadcaster);
 
   Event *lldb_event = get();
   bool success = false;
@@ -127,7 +121,7 @@ bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
 }
 
 void SBEvent::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   Event *lldb_event = get();
   if (lldb_event)
@@ -158,11 +152,11 @@ void SBEvent::reset(Event *event_ptr) {
 }
 
 bool SBEvent::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBEvent::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
   // See comments in SBEvent::get()....
@@ -170,16 +164,14 @@ SBEvent::operator bool() const {
 }
 
 const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   return static_cast<const char *>(
       EventDataBytes::GetBytesFromEvent(event.get()));
 }
 
 bool SBEvent::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -192,8 +184,7 @@ bool SBEvent::GetDescription(SBStream &description) {
 }
 
 bool SBEvent::GetDescription(SBStream &description) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &),
-                           description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -204,37 +195,3 @@ bool SBEvent::GetDescription(SBStream &description) const {
 
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBEvent>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBEvent, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t));
-  LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb::EventSP &));
-  LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb_private::Event *));
-  LLDB_REGISTER_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(const lldb::SBEvent &,
-                       SBEvent, operator=,(const lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(const char *, SBEvent, GetDataFlavor, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBEvent, GetType, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBEvent, GetBroadcaster,
-                             ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBEvent, GetBroadcasterClass, ());
-  LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
-                       (const lldb::SBBroadcaster *));
-  LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesRef,
-                       (const lldb::SBBroadcaster &));
-  LLDB_REGISTER_METHOD(void, SBEvent, Clear, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBEvent, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBEvent, operator bool, ());
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBEvent, GetDescription,
-                             (lldb::SBStream &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBExecutionContext.cpp b/lldb/source/API/SBExecutionContext.cpp
index caf02b4164ea..a0b68e6efe38 100644
--- a/lldb/source/API/SBExecutionContext.cpp
+++ b/lldb/source/API/SBExecutionContext.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBExecutionContext.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
@@ -19,48 +19,43 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBExecutionContext::SBExecutionContext() : m_exe_ctx_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExecutionContext);
-}
+SBExecutionContext::SBExecutionContext() { LLDB_INSTRUMENT_VA(this); }
 
 SBExecutionContext::SBExecutionContext(const lldb::SBExecutionContext &rhs)
     : m_exe_ctx_sp(rhs.m_exe_ctx_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBExecutionContext,
-                          (const lldb::SBExecutionContext &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBExecutionContext::SBExecutionContext(
     lldb::ExecutionContextRefSP exe_ctx_ref_sp)
     : m_exe_ctx_sp(exe_ctx_ref_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (lldb::ExecutionContextRefSP),
-                          exe_ctx_ref_sp);
+  LLDB_INSTRUMENT_VA(this, exe_ctx_ref_sp);
 }
 
 SBExecutionContext::SBExecutionContext(const lldb::SBTarget &target)
     : m_exe_ctx_sp(new ExecutionContextRef()) {
-  LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &), target);
+  LLDB_INSTRUMENT_VA(this, target);
 
   m_exe_ctx_sp->SetTargetSP(target.GetSP());
 }
 
 SBExecutionContext::SBExecutionContext(const lldb::SBProcess &process)
     : m_exe_ctx_sp(new ExecutionContextRef()) {
-  LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &),
-                          process);
+  LLDB_INSTRUMENT_VA(this, process);
 
   m_exe_ctx_sp->SetProcessSP(process.GetSP());
 }
 
 SBExecutionContext::SBExecutionContext(lldb::SBThread thread)
     : m_exe_ctx_sp(new ExecutionContextRef()) {
-  LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread), thread);
+  LLDB_INSTRUMENT_VA(this, thread);
 
   m_exe_ctx_sp->SetThreadPtr(thread.get());
 }
 
 SBExecutionContext::SBExecutionContext(const lldb::SBFrame &frame)
     : m_exe_ctx_sp(new ExecutionContextRef()) {
-  LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &), frame);
+  LLDB_INSTRUMENT_VA(this, frame);
 
   m_exe_ctx_sp->SetFrameSP(frame.GetFrameSP());
 }
@@ -69,12 +64,10 @@ SBExecutionContext::~SBExecutionContext() = default;
 
 const SBExecutionContext &SBExecutionContext::
 operator=(const lldb::SBExecutionContext &rhs) {
-  LLDB_RECORD_METHOD(
-      const lldb::SBExecutionContext &,
-      SBExecutionContext, operator=,(const lldb::SBExecutionContext &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_exe_ctx_sp = rhs.m_exe_ctx_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 ExecutionContextRef *SBExecutionContext::get() const {
@@ -82,8 +75,7 @@ ExecutionContextRef *SBExecutionContext::get() const {
 }
 
 SBTarget SBExecutionContext::GetTarget() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBExecutionContext,
-                                   GetTarget);
+  LLDB_INSTRUMENT_VA(this);
 
   SBTarget sb_target;
   if (m_exe_ctx_sp) {
@@ -91,12 +83,11 @@ SBTarget SBExecutionContext::GetTarget() const {
     if (target_sp)
       sb_target.SetSP(target_sp);
   }
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 SBProcess SBExecutionContext::GetProcess() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBProcess, SBExecutionContext,
-                                   GetProcess);
+  LLDB_INSTRUMENT_VA(this);
 
   SBProcess sb_process;
   if (m_exe_ctx_sp) {
@@ -104,12 +95,11 @@ SBProcess SBExecutionContext::GetProcess() const {
     if (process_sp)
       sb_process.SetSP(process_sp);
   }
-  return LLDB_RECORD_RESULT(sb_process);
+  return sb_process;
 }
 
 SBThread SBExecutionContext::GetThread() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBExecutionContext,
-                                   GetThread);
+  LLDB_INSTRUMENT_VA(this);
 
   SBThread sb_thread;
   if (m_exe_ctx_sp) {
@@ -117,11 +107,11 @@ SBThread SBExecutionContext::GetThread() const {
     if (thread_sp)
       sb_thread.SetThread(thread_sp);
   }
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 SBFrame SBExecutionContext::GetFrame() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFrame, SBExecutionContext, GetFrame);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFrame sb_frame;
   if (m_exe_ctx_sp) {
@@ -129,34 +119,5 @@ SBFrame SBExecutionContext::GetFrame() const {
     if (frame_sp)
       sb_frame.SetFrameSP(frame_sp);
   }
-  return LLDB_RECORD_RESULT(sb_frame);
-}
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBExecutionContext>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext,
-                            (const lldb::SBExecutionContext &));
-  LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext,
-                            (lldb::ExecutionContextRefSP));
-  LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &));
-  LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &));
-  LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread));
-  LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBExecutionContext &,
-      SBExecutionContext, operator=,(const lldb::SBExecutionContext &));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBExecutionContext, GetTarget,
-                             ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBProcess, SBExecutionContext, GetProcess,
-                             ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBExecutionContext, GetThread,
-                             ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBFrame, SBExecutionContext, GetFrame, ());
-}
-
-}
+  return sb_frame;
 }
diff --git a/lldb/source/API/SBExpressionOptions.cpp b/lldb/source/API/SBExpressionOptions.cpp
index 217e8ad5c21b..191e38fe5cfc 100644
--- a/lldb/source/API/SBExpressionOptions.cpp
+++ b/lldb/source/API/SBExpressionOptions.cpp
@@ -7,113 +7,99 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBExpressionOptions.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBExpressionOptions::SBExpressionOptions()
     : m_opaque_up(new EvaluateExpressionOptions()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExpressionOptions);
+  LLDB_INSTRUMENT_VA(this);
 }
 
-SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs)
-    : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBExpressionOptions,
-                          (const lldb::SBExpressionOptions &), rhs);
+SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 const SBExpressionOptions &SBExpressionOptions::
 operator=(const SBExpressionOptions &rhs) {
-  LLDB_RECORD_METHOD(
-      const lldb::SBExpressionOptions &,
-      SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBExpressionOptions::~SBExpressionOptions() = default;
 
 bool SBExpressionOptions::GetCoerceResultToId() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
-                                   GetCoerceResultToId);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->DoesCoerceToId();
 }
 
 void SBExpressionOptions::SetCoerceResultToId(bool coerce) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCoerceResultToId, (bool),
-                     coerce);
+  LLDB_INSTRUMENT_VA(this, coerce);
 
   m_opaque_up->SetCoerceToId(coerce);
 }
 
 bool SBExpressionOptions::GetUnwindOnError() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetUnwindOnError);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->DoesUnwindOnError();
 }
 
 void SBExpressionOptions::SetUnwindOnError(bool unwind) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool),
-                     unwind);
+  LLDB_INSTRUMENT_VA(this, unwind);
 
   m_opaque_up->SetUnwindOnError(unwind);
 }
 
 bool SBExpressionOptions::GetIgnoreBreakpoints() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
-                                   GetIgnoreBreakpoints);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->DoesIgnoreBreakpoints();
 }
 
 void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, (bool),
-                     ignore);
+  LLDB_INSTRUMENT_VA(this, ignore);
 
   m_opaque_up->SetIgnoreBreakpoints(ignore);
 }
 
 lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBExpressionOptions,
-                                   GetFetchDynamicValue);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetUseDynamic();
 }
 
 void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
-                     (lldb::DynamicValueType), dynamic);
+  LLDB_INSTRUMENT_VA(this, dynamic);
 
   m_opaque_up->SetUseDynamic(dynamic);
 }
 
 uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions,
-                                   GetTimeoutInMicroSeconds);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetTimeout() ? m_opaque_up->GetTimeout()->count() : 0;
 }
 
 void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds,
-                     (uint32_t), timeout);
+  LLDB_INSTRUMENT_VA(this, timeout);
 
   m_opaque_up->SetTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None)
                                        : std::chrono::microseconds(timeout));
 }
 
 uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions,
-                                   GetOneThreadTimeoutInMicroSeconds);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetOneThreadTimeout()
              ? m_opaque_up->GetOneThreadTimeout()->count()
@@ -121,8 +107,7 @@ uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const {
 }
 
 void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions,
-                     SetOneThreadTimeoutInMicroSeconds, (uint32_t), timeout);
+  LLDB_INSTRUMENT_VA(this, timeout);
 
   m_opaque_up->SetOneThreadTimeout(timeout == 0
                                        ? Timeout<std::micro>(llvm::None)
@@ -130,148 +115,135 @@ void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) {
 }
 
 bool SBExpressionOptions::GetTryAllThreads() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetTryAllThreads);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetTryAllThreads();
 }
 
 void SBExpressionOptions::SetTryAllThreads(bool run_others) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool),
-                     run_others);
+  LLDB_INSTRUMENT_VA(this, run_others);
 
   m_opaque_up->SetTryAllThreads(run_others);
 }
 
 bool SBExpressionOptions::GetStopOthers() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetStopOthers);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetStopOthers();
 }
 
 void SBExpressionOptions::SetStopOthers(bool run_others) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetStopOthers, (bool),
-                     run_others);
+  LLDB_INSTRUMENT_VA(this, run_others);
 
   m_opaque_up->SetStopOthers(run_others);
 }
 
 bool SBExpressionOptions::GetTrapExceptions() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
-                                   GetTrapExceptions);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetTrapExceptions();
 }
 
 void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool),
-                     trap_exceptions);
+  LLDB_INSTRUMENT_VA(this, trap_exceptions);
 
   m_opaque_up->SetTrapExceptions(trap_exceptions);
 }
 
 void SBExpressionOptions::SetLanguage(lldb::LanguageType language) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetLanguage,
-                     (lldb::LanguageType), language);
+  LLDB_INSTRUMENT_VA(this, language);
 
   m_opaque_up->SetLanguage(language);
 }
 
 void SBExpressionOptions::SetCancelCallback(
     lldb::ExpressionCancelCallback callback, void *baton) {
-  LLDB_RECORD_DUMMY(void, SBExpressionOptions, SetCancelCallback,
-                    (lldb::ExpressionCancelCallback, void *), callback, baton);
+  LLDB_INSTRUMENT_VA(this, callback, baton);
 
   m_opaque_up->SetCancelCallback(callback, baton);
 }
 
 bool SBExpressionOptions::GetGenerateDebugInfo() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetGenerateDebugInfo);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetGenerateDebugInfo();
 }
 
 void SBExpressionOptions::SetGenerateDebugInfo(bool b) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, (bool),
-                     b);
+  LLDB_INSTRUMENT_VA(this, b);
 
   return m_opaque_up->SetGenerateDebugInfo(b);
 }
 
 bool SBExpressionOptions::GetSuppressPersistentResult() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions,
-                             GetSuppressPersistentResult);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetResultIsInternal();
 }
 
 void SBExpressionOptions::SetSuppressPersistentResult(bool b) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
-                     (bool), b);
+  LLDB_INSTRUMENT_VA(this, b);
 
   return m_opaque_up->SetResultIsInternal(b);
 }
 
 const char *SBExpressionOptions::GetPrefix() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBExpressionOptions,
-                                   GetPrefix);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetPrefix();
 }
 
 void SBExpressionOptions::SetPrefix(const char *prefix) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetPrefix, (const char *),
-                     prefix);
+  LLDB_INSTRUMENT_VA(this, prefix);
 
   return m_opaque_up->SetPrefix(prefix);
 }
 
 bool SBExpressionOptions::GetAutoApplyFixIts() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAutoApplyFixIts);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetAutoApplyFixIts();
 }
 
 void SBExpressionOptions::SetAutoApplyFixIts(bool b) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool), b);
+  LLDB_INSTRUMENT_VA(this, b);
 
   return m_opaque_up->SetAutoApplyFixIts(b);
 }
 
 uint64_t SBExpressionOptions::GetRetriesWithFixIts() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBExpressionOptions,
-                             GetRetriesWithFixIts);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetRetriesWithFixIts();
 }
 
 void SBExpressionOptions::SetRetriesWithFixIts(uint64_t retries) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetRetriesWithFixIts,
-                     (uint64_t), retries);
+  LLDB_INSTRUMENT_VA(this, retries);
 
   return m_opaque_up->SetRetriesWithFixIts(retries);
 }
 
 bool SBExpressionOptions::GetTopLevel() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetTopLevel);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetExecutionPolicy() == eExecutionPolicyTopLevel;
 }
 
 void SBExpressionOptions::SetTopLevel(bool b) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTopLevel, (bool), b);
+  LLDB_INSTRUMENT_VA(this, b);
 
   m_opaque_up->SetExecutionPolicy(b ? eExecutionPolicyTopLevel
                                     : m_opaque_up->default_execution_policy);
 }
 
 bool SBExpressionOptions::GetAllowJIT() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAllowJIT);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetExecutionPolicy() != eExecutionPolicyNever;
 }
 
 void SBExpressionOptions::SetAllowJIT(bool allow) {
-  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool), allow);
+  LLDB_INSTRUMENT_VA(this, allow);
 
   m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy
                                         : eExecutionPolicyNever);
@@ -284,69 +256,3 @@ EvaluateExpressionOptions *SBExpressionOptions::get() const {
 EvaluateExpressionOptions &SBExpressionOptions::ref() const {
   return *(m_opaque_up.get());
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBExpressionOptions>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions,
-                            (const lldb::SBExpressionOptions &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBExpressionOptions &,
-      SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetCoerceResultToId,
-                             ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetCoerceResultToId,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetUnwindOnError, ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetIgnoreBreakpoints,
-                             ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBExpressionOptions,
-                             GetFetchDynamicValue, ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
-                       (lldb::DynamicValueType));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions,
-                             GetTimeoutInMicroSeconds, ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions,
-                             GetOneThreadTimeoutInMicroSeconds, ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions,
-                       SetOneThreadTimeoutInMicroSeconds, (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTryAllThreads, ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetStopOthers, ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetStopOthers, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTrapExceptions,
-                             ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool));
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetLanguage,
-                       (lldb::LanguageType));
-  LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetGenerateDebugInfo, ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo,
-                       (bool));
-  LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetSuppressPersistentResult,
-                       ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
-                       (bool));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBExpressionOptions, GetPrefix,
-                             ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetPrefix, (const char *));
-  LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAutoApplyFixIts, ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool));
-  LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetTopLevel, ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTopLevel, (bool));
-  LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAllowJIT, ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool));
-  LLDB_REGISTER_METHOD(uint64_t, SBExpressionOptions, GetRetriesWithFixIts, ());
-  LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetRetriesWithFixIts,
-                       (uint64_t));
-}
-
-}
-}
diff --git a/lldb/source/API/SBFile.cpp b/lldb/source/API/SBFile.cpp
index 41ccdbe76b91..0db859c3b746 100644
--- a/lldb/source/API/SBFile.cpp
+++ b/lldb/source/API/SBFile.cpp
@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBFile.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/Host/File.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
@@ -19,33 +19,31 @@ SBFile::~SBFile() = default;
 SBFile::SBFile(FileSP file_sp) : m_opaque_sp(file_sp) {
   // We have no way to capture the incoming FileSP as the class isn't
   // instrumented, so pretend that it's always null.
-  LLDB_RECORD_CONSTRUCTOR(SBFile, (lldb::FileSP), nullptr);
+  LLDB_INSTRUMENT_VA(this, file_sp);
 }
 
 SBFile::SBFile(const SBFile &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBFile, (const lldb::SBFile&), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBFile &SBFile ::operator=(const SBFile &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBFile &,
-                     SBFile, operator=,(const lldb::SBFile &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
-SBFile::SBFile() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFile); }
+SBFile::SBFile() { LLDB_INSTRUMENT_VA(this); }
 
 SBFile::SBFile(FILE *file, bool transfer_ownership) {
-  LLDB_RECORD_CONSTRUCTOR(SBFile, (FILE *, bool), file, transfer_ownership);
+  LLDB_INSTRUMENT_VA(this, file, transfer_ownership);
 
   m_opaque_sp = std::make_shared<NativeFile>(file, transfer_ownership);
 }
 
 SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) {
-  LLDB_RECORD_CONSTRUCTOR(SBFile, (int, const char *, bool), fd, mode,
-                          transfer_owndership);
+  LLDB_INSTRUMENT_VA(this, fd, mode, transfer_owndership);
 
   auto options = File::GetOptionsFromMode(mode);
   if (!options) {
@@ -57,8 +55,7 @@ SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) {
 }
 
 SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBFile, Read, (uint8_t *, size_t, size_t *),
-                     buf, num_bytes, bytes_read);
+  LLDB_INSTRUMENT_VA(this, buf, num_bytes, bytes_read);
 
   SBError error;
   if (!m_opaque_sp) {
@@ -69,14 +66,12 @@ SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) {
     error.SetError(status);
     *bytes_read = num_bytes;
   }
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 SBError SBFile::Write(const uint8_t *buf, size_t num_bytes,
                       size_t *bytes_written) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBFile, Write,
-                     (const uint8_t *, size_t, size_t *), buf, num_bytes,
-                     bytes_written);
+  LLDB_INSTRUMENT_VA(this, buf, num_bytes, bytes_written);
 
   SBError error;
   if (!m_opaque_sp) {
@@ -87,11 +82,11 @@ SBError SBFile::Write(const uint8_t *buf, size_t num_bytes,
     error.SetError(status);
     *bytes_written = num_bytes;
   }
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 SBError SBFile::Flush() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Flush);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError error;
   if (!m_opaque_sp) {
@@ -100,59 +95,35 @@ SBError SBFile::Flush() {
     Status status = m_opaque_sp->Flush();
     error.SetError(status);
   }
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 bool SBFile::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return m_opaque_sp && m_opaque_sp->IsValid();
 }
 
 SBError SBFile::Close() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Close);
+  LLDB_INSTRUMENT_VA(this);
   SBError error;
   if (m_opaque_sp) {
     Status status = m_opaque_sp->Close();
     error.SetError(status);
   }
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 SBFile::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator bool);
+  LLDB_INSTRUMENT_VA(this);
   return IsValid();
 }
 
 bool SBFile::operator!() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator!);
+  LLDB_INSTRUMENT_VA(this);
   return !IsValid();
 }
 
 FileSP SBFile::GetFile() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(FileSP, SBFile, GetFile);
-  return LLDB_RECORD_RESULT(m_opaque_sp);
+  LLDB_INSTRUMENT_VA(this);
+  return m_opaque_sp;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <> void RegisterMethods<SBFile>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBFile, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBFile, (FileSP));
-  LLDB_REGISTER_CONSTRUCTOR(SBFile, (const SBFile&));
-  LLDB_REGISTER_CONSTRUCTOR(SBFile, (FILE *, bool));
-  LLDB_REGISTER_CONSTRUCTOR(SBFile, (int, const char *, bool));
-  LLDB_REGISTER_METHOD(SBFile&, SBFile, operator=,(const SBFile&));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Flush, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Read,
-                       (uint8_t *, size_t, size_t *));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Write,
-                       (const uint8_t *, size_t, size_t *));
-  LLDB_REGISTER_METHOD_CONST(bool, SBFile, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBFile, operator bool,());
-  LLDB_REGISTER_METHOD_CONST(bool, SBFile, operator!,());
-  LLDB_REGISTER_METHOD_CONST(FileSP, SBFile, GetFile, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Close, ());
-}
-} // namespace repro
-} // namespace lldb_private
diff --git a/lldb/source/API/SBFileSpec.cpp b/lldb/source/API/SBFileSpec.cpp
index 0a6b63bb460c..2bec9a7a1e77 100644
--- a/lldb/source/API/SBFileSpec.cpp
+++ b/lldb/source/API/SBFileSpec.cpp
@@ -7,12 +7,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBFileSpec.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/SmallString.h"
@@ -24,11 +24,11 @@ using namespace lldb;
 using namespace lldb_private;
 
 SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpec);
+  LLDB_INSTRUMENT_VA(this);
 }
 
-SBFileSpec::SBFileSpec(const SBFileSpec &rhs) : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &), rhs);
+SBFileSpec::SBFileSpec(const SBFileSpec &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
@@ -38,14 +38,14 @@ SBFileSpec::SBFileSpec(const lldb_private::FileSpec &fspec)
 
 // Deprecated!!!
 SBFileSpec::SBFileSpec(const char *path) : m_opaque_up(new FileSpec(path)) {
-  LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *), path);
+  LLDB_INSTRUMENT_VA(this, path);
 
   FileSystem::Instance().Resolve(*m_opaque_up);
 }
 
 SBFileSpec::SBFileSpec(const char *path, bool resolve)
     : m_opaque_up(new FileSpec(path)) {
-  LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *, bool), path, resolve);
+  LLDB_INSTRUMENT_VA(this, path, resolve);
 
   if (resolve)
     FileSystem::Instance().Resolve(*m_opaque_up);
@@ -54,55 +54,50 @@ SBFileSpec::SBFileSpec(const char *path, bool resolve)
 SBFileSpec::~SBFileSpec() = default;
 
 const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBFileSpec &,
-                     SBFileSpec, operator=,(const lldb::SBFileSpec &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBFileSpec::operator==(const SBFileSpec &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator==,(const SBFileSpec &rhs),
-                           rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return ref() == rhs.ref();
 }
 
 bool SBFileSpec::operator!=(const SBFileSpec &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator!=,(const SBFileSpec &rhs),
-                           rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return !(*this == rhs);
 }
 
 bool SBFileSpec::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBFileSpec::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->operator bool();
 }
 
 bool SBFileSpec::Exists() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, Exists);
+  LLDB_INSTRUMENT_VA(this);
 
   return FileSystem::Instance().Exists(*m_opaque_up);
 }
 
 bool SBFileSpec::ResolveExecutableLocation() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBFileSpec, ResolveExecutableLocation);
+  LLDB_INSTRUMENT_VA(this);
 
   return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_up);
 }
 
 int SBFileSpec::ResolvePath(const char *src_path, char *dst_path,
                             size_t dst_len) {
-  LLDB_RECORD_STATIC_METHOD(int, SBFileSpec, ResolvePath,
-                            (const char *, char *, size_t), src_path, dst_path,
-                            dst_len);
+  LLDB_INSTRUMENT_VA(src_path, dst_path, dst_len);
 
   llvm::SmallString<64> result(src_path);
   FileSystem::Instance().Resolve(result);
@@ -111,13 +106,13 @@ int SBFileSpec::ResolvePath(const char *src_path, char *dst_path,
 }
 
 const char *SBFileSpec::GetFilename() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetFilename);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetFilename().AsCString();
 }
 
 const char *SBFileSpec::GetDirectory() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetDirectory);
+  LLDB_INSTRUMENT_VA(this);
 
   FileSpec directory{*m_opaque_up};
   directory.GetFilename().Clear();
@@ -125,7 +120,7 @@ const char *SBFileSpec::GetDirectory() const {
 }
 
 void SBFileSpec::SetFilename(const char *filename) {
-  LLDB_RECORD_METHOD(void, SBFileSpec, SetFilename, (const char *), filename);
+  LLDB_INSTRUMENT_VA(this, filename);
 
   if (filename && filename[0])
     m_opaque_up->GetFilename().SetCString(filename);
@@ -134,7 +129,7 @@ void SBFileSpec::SetFilename(const char *filename) {
 }
 
 void SBFileSpec::SetDirectory(const char *directory) {
-  LLDB_RECORD_METHOD(void, SBFileSpec, SetDirectory, (const char *), directory);
+  LLDB_INSTRUMENT_VA(this, directory);
 
   if (directory && directory[0])
     m_opaque_up->GetDirectory().SetCString(directory);
@@ -143,8 +138,7 @@ void SBFileSpec::SetDirectory(const char *directory) {
 }
 
 uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const {
-  LLDB_RECORD_CHAR_PTR_METHOD_CONST(uint32_t, SBFileSpec, GetPath,
-                                    (char *, size_t), dst_path, "", dst_len);
+  LLDB_INSTRUMENT_VA(this, dst_path, dst_len);
 
   uint32_t result = m_opaque_up->GetPath(dst_path, dst_len);
 
@@ -172,8 +166,7 @@ void SBFileSpec::SetFileSpec(const lldb_private::FileSpec &fs) {
 }
 
 bool SBFileSpec::GetDescription(SBStream &description) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, GetDescription, (lldb::SBStream &),
-                           description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
   char path[PATH_MAX];
@@ -183,41 +176,7 @@ bool SBFileSpec::GetDescription(SBStream &description) const {
 }
 
 void SBFileSpec::AppendPathComponent(const char *fn) {
-  LLDB_RECORD_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), fn);
+  LLDB_INSTRUMENT_VA(this, fn);
 
   m_opaque_up->AppendPathComponent(fn);
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBFileSpec>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &));
-  LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *));
-  LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *, bool));
-  LLDB_REGISTER_METHOD(const lldb::SBFileSpec &,
-                       SBFileSpec, operator=,(const lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD_CONST(bool,
-                             SBFileSpec, operator==,(const lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD_CONST(bool,
-                             SBFileSpec, operator!=,(const lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, operator bool, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, Exists, ());
-  LLDB_REGISTER_METHOD(bool, SBFileSpec, ResolveExecutableLocation, ());
-  LLDB_REGISTER_STATIC_METHOD(int, SBFileSpec, ResolvePath,
-                              (const char *, char *, size_t));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetFilename, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetDirectory, ());
-  LLDB_REGISTER_METHOD(void, SBFileSpec, SetFilename, (const char *));
-  LLDB_REGISTER_METHOD(void, SBFileSpec, SetDirectory, (const char *));
-  LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, GetDescription,
-                             (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(void, SBFileSpec, AppendPathComponent, (const char *));
-  LLDB_REGISTER_CHAR_PTR_METHOD_CONST(uint32_t, SBFileSpec, GetPath);
-}
-
-}
-}
diff --git a/lldb/source/API/SBFileSpecList.cpp b/lldb/source/API/SBFileSpecList.cpp
index 768ff0affd15..cf81c4234087 100644
--- a/lldb/source/API/SBFileSpecList.cpp
+++ b/lldb/source/API/SBFileSpecList.cpp
@@ -7,13 +7,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBFileSpecList.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Stream.h"
 
 #include <climits>
@@ -22,12 +22,11 @@ using namespace lldb;
 using namespace lldb_private;
 
 SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpecList);
+  LLDB_INSTRUMENT_VA(this);
 }
 
-SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &), rhs);
-
+SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
@@ -35,57 +34,50 @@ SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_up() {
 SBFileSpecList::~SBFileSpecList() = default;
 
 const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBFileSpecList &,
-                     SBFileSpecList, operator=,(const lldb::SBFileSpecList &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 uint32_t SBFileSpecList::GetSize() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFileSpecList, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetSize();
 }
 
 void SBFileSpecList::Append(const SBFileSpec &sb_file) {
-  LLDB_RECORD_METHOD(void, SBFileSpecList, Append, (const lldb::SBFileSpec &),
-                     sb_file);
+  LLDB_INSTRUMENT_VA(this, sb_file);
 
   m_opaque_up->Append(sb_file.ref());
 }
 
 bool SBFileSpecList::AppendIfUnique(const SBFileSpec &sb_file) {
-  LLDB_RECORD_METHOD(bool, SBFileSpecList, AppendIfUnique,
-                     (const lldb::SBFileSpec &), sb_file);
+  LLDB_INSTRUMENT_VA(this, sb_file);
 
   return m_opaque_up->AppendIfUnique(sb_file.ref());
 }
 
 void SBFileSpecList::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBFileSpecList, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_up->Clear();
 }
 
 uint32_t SBFileSpecList::FindFileIndex(uint32_t idx, const SBFileSpec &sb_file,
                                        bool full) {
-  LLDB_RECORD_METHOD(uint32_t, SBFileSpecList, FindFileIndex,
-                     (uint32_t, const lldb::SBFileSpec &, bool), idx, sb_file,
-                     full);
+  LLDB_INSTRUMENT_VA(this, idx, sb_file, full);
 
   return m_opaque_up->FindFileIndex(idx, sb_file.ref(), full);
 }
 
 const SBFileSpec SBFileSpecList::GetFileSpecAtIndex(uint32_t idx) const {
-  LLDB_RECORD_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList,
-                           GetFileSpecAtIndex, (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBFileSpec new_spec;
   new_spec.SetFileSpec(m_opaque_up->GetFileSpecAtIndex(idx));
-  return LLDB_RECORD_RESULT(new_spec);
+  return new_spec;
 }
 
 const lldb_private::FileSpecList *SBFileSpecList::operator->() const {
@@ -105,8 +97,7 @@ const lldb_private::FileSpecList &SBFileSpecList::ref() const {
 }
 
 bool SBFileSpecList::GetDescription(SBStream &description) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBFileSpecList, GetDescription,
-                           (lldb::SBStream &), description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -123,30 +114,3 @@ bool SBFileSpecList::GetDescription(SBStream &description) const {
 
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBFileSpecList>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBFileSpecList &,
-      SBFileSpecList, operator=,(const lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpecList, GetSize, ());
-  LLDB_REGISTER_METHOD(void, SBFileSpecList, Append,
-                       (const lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(bool, SBFileSpecList, AppendIfUnique,
-                       (const lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(void, SBFileSpecList, Clear, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBFileSpecList, FindFileIndex,
-                       (uint32_t, const lldb::SBFileSpec &, bool));
-  LLDB_REGISTER_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList,
-                             GetFileSpecAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(bool, SBFileSpecList, GetDescription,
-                             (lldb::SBStream &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBFrame.cpp b/lldb/source/API/SBFrame.cpp
index c6bc3288c4b2..ffbbed00f8e2 100644
--- a/lldb/source/API/SBFrame.cpp
+++ b/lldb/source/API/SBFrame.cpp
@@ -14,7 +14,6 @@
 
 #include "lldb/lldb-types.h"
 
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/StreamFile.h"
@@ -38,6 +37,7 @@
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Stream.h"
 
 #include "lldb/API/SBAddress.h"
@@ -55,17 +55,16 @@ using namespace lldb;
 using namespace lldb_private;
 
 SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFrame);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBFrame::SBFrame(const StackFrameSP &lldb_object_sp)
     : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
-  LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &),
-                          lldb_object_sp);
+  LLDB_INSTRUMENT_VA(this, lldb_object_sp);
 }
 
-SBFrame::SBFrame(const SBFrame &rhs) : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &), rhs);
+SBFrame::SBFrame(const SBFrame &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_sp = clone(rhs.m_opaque_sp);
 }
@@ -73,12 +72,11 @@ SBFrame::SBFrame(const SBFrame &rhs) : m_opaque_sp() {
 SBFrame::~SBFrame() = default;
 
 const SBFrame &SBFrame::operator=(const SBFrame &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBFrame &,
-                     SBFrame, operator=,(const lldb::SBFrame &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_sp = clone(rhs.m_opaque_sp);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 StackFrameSP SBFrame::GetFrameSP() const {
@@ -90,11 +88,11 @@ void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) {
 }
 
 bool SBFrame::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBFrame::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -112,8 +110,7 @@ SBFrame::operator bool() const {
 }
 
 SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
-                           (uint32_t), resolve_scope);
+  LLDB_INSTRUMENT_VA(this, resolve_scope);
 
   SBSymbolContext sb_sym_ctx;
   std::unique_lock<std::recursive_mutex> lock;
@@ -129,11 +126,11 @@ SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_sym_ctx);
+  return sb_sym_ctx;
 }
 
 SBModule SBFrame::GetModule() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule);
+  LLDB_INSTRUMENT_VA(this);
 
   SBModule sb_module;
   ModuleSP module_sp;
@@ -154,12 +151,11 @@ SBModule SBFrame::GetModule() const {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_module);
+  return sb_module;
 }
 
 SBCompileUnit SBFrame::GetCompileUnit() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame,
-                                   GetCompileUnit);
+  LLDB_INSTRUMENT_VA(this);
 
   SBCompileUnit sb_comp_unit;
   std::unique_lock<std::recursive_mutex> lock;
@@ -179,11 +175,11 @@ SBCompileUnit SBFrame::GetCompileUnit() const {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_comp_unit);
+  return sb_comp_unit;
 }
 
 SBFunction SBFrame::GetFunction() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFunction sb_function;
   std::unique_lock<std::recursive_mutex> lock;
@@ -203,11 +199,11 @@ SBFunction SBFrame::GetFunction() const {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_function);
+  return sb_function;
 }
 
 SBSymbol SBFrame::GetSymbol() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol);
+  LLDB_INSTRUMENT_VA(this);
 
   SBSymbol sb_symbol;
   std::unique_lock<std::recursive_mutex> lock;
@@ -226,11 +222,11 @@ SBSymbol SBFrame::GetSymbol() const {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_symbol);
+  return sb_symbol;
 }
 
 SBBlock SBFrame::GetBlock() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock);
+  LLDB_INSTRUMENT_VA(this);
 
   SBBlock sb_block;
   std::unique_lock<std::recursive_mutex> lock;
@@ -247,11 +243,11 @@ SBBlock SBFrame::GetBlock() const {
         sb_block.SetPtr(frame->GetSymbolContext(eSymbolContextBlock).block);
     }
   }
-  return LLDB_RECORD_RESULT(sb_block);
+  return sb_block;
 }
 
 SBBlock SBFrame::GetFrameBlock() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock);
+  LLDB_INSTRUMENT_VA(this);
 
   SBBlock sb_block;
   std::unique_lock<std::recursive_mutex> lock;
@@ -268,11 +264,11 @@ SBBlock SBFrame::GetFrameBlock() const {
         sb_block.SetPtr(frame->GetFrameBlock());
     }
   }
-  return LLDB_RECORD_RESULT(sb_block);
+  return sb_block;
 }
 
 SBLineEntry SBFrame::GetLineEntry() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry);
+  LLDB_INSTRUMENT_VA(this);
 
   SBLineEntry sb_line_entry;
   std::unique_lock<std::recursive_mutex> lock;
@@ -291,11 +287,11 @@ SBLineEntry SBFrame::GetLineEntry() const {
       }
     }
   }
-  return LLDB_RECORD_RESULT(sb_line_entry);
+  return sb_line_entry;
 }
 
 uint32_t SBFrame::GetFrameID() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t frame_idx = UINT32_MAX;
 
@@ -310,7 +306,7 @@ uint32_t SBFrame::GetFrameID() const {
 }
 
 lldb::addr_t SBFrame::GetCFA() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA);
+  LLDB_INSTRUMENT_VA(this);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -322,7 +318,7 @@ lldb::addr_t SBFrame::GetCFA() const {
 }
 
 addr_t SBFrame::GetPC() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC);
+  LLDB_INSTRUMENT_VA(this);
 
   addr_t addr = LLDB_INVALID_ADDRESS;
   std::unique_lock<std::recursive_mutex> lock;
@@ -346,7 +342,7 @@ addr_t SBFrame::GetPC() const {
 }
 
 bool SBFrame::SetPC(addr_t new_pc) {
-  LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc);
+  LLDB_INSTRUMENT_VA(this, new_pc);
 
   bool ret_val = false;
   std::unique_lock<std::recursive_mutex> lock;
@@ -369,7 +365,7 @@ bool SBFrame::SetPC(addr_t new_pc) {
 }
 
 addr_t SBFrame::GetSP() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP);
+  LLDB_INSTRUMENT_VA(this);
 
   addr_t addr = LLDB_INVALID_ADDRESS;
   std::unique_lock<std::recursive_mutex> lock;
@@ -392,7 +388,7 @@ addr_t SBFrame::GetSP() const {
 }
 
 addr_t SBFrame::GetFP() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP);
+  LLDB_INSTRUMENT_VA(this);
 
   addr_t addr = LLDB_INVALID_ADDRESS;
   std::unique_lock<std::recursive_mutex> lock;
@@ -415,7 +411,7 @@ addr_t SBFrame::GetFP() const {
 }
 
 SBAddress SBFrame::GetPCAddress() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   SBAddress sb_addr;
   std::unique_lock<std::recursive_mutex> lock;
@@ -432,18 +428,17 @@ SBAddress SBFrame::GetPCAddress() const {
         sb_addr.SetAddress(frame->GetFrameCodeAddress());
     }
   }
-  return LLDB_RECORD_RESULT(sb_addr);
+  return sb_addr;
 }
 
 void SBFrame::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_sp->Clear();
 }
 
 lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
-                     (const char *), var_path);
+  LLDB_INSTRUMENT_VA(this, var_path);
 
   SBValue sb_value;
   std::unique_lock<std::recursive_mutex> lock;
@@ -456,18 +451,16 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
         frame->CalculateTarget()->GetPreferDynamicValue();
     sb_value = GetValueForVariablePath(var_path, use_dynamic);
   }
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
                                                DynamicValueType use_dynamic) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
-                     (const char *, lldb::DynamicValueType), var_path,
-                     use_dynamic);
+  LLDB_INSTRUMENT_VA(this, var_path, use_dynamic);
 
   SBValue sb_value;
   if (var_path == nullptr || var_path[0] == '\0') {
-    return LLDB_RECORD_RESULT(sb_value);
+    return sb_value;
   }
 
   std::unique_lock<std::recursive_mutex> lock;
@@ -492,12 +485,11 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
       }
     }
   }
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 SBValue SBFrame::FindVariable(const char *name) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *),
-                     name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   SBValue value;
   std::unique_lock<std::recursive_mutex> lock;
@@ -510,19 +502,18 @@ SBValue SBFrame::FindVariable(const char *name) {
         frame->CalculateTarget()->GetPreferDynamicValue();
     value = FindVariable(name, use_dynamic);
   }
-  return LLDB_RECORD_RESULT(value);
+  return value;
 }
 
 SBValue SBFrame::FindVariable(const char *name,
                               lldb::DynamicValueType use_dynamic) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable,
-                     (const char *, lldb::DynamicValueType), name, use_dynamic);
+  LLDB_INSTRUMENT_VA(this, name, use_dynamic);
 
   VariableSP var_sp;
   SBValue sb_value;
 
   if (name == nullptr || name[0] == '\0') {
-    return LLDB_RECORD_RESULT(sb_value);
+    return sb_value;
   }
 
   ValueObjectSP value_sp;
@@ -545,12 +536,11 @@ SBValue SBFrame::FindVariable(const char *name,
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
-                     (const char *, lldb::ValueType), name, value_type);
+  LLDB_INSTRUMENT_VA(this, name, value_type);
 
   SBValue value;
   std::unique_lock<std::recursive_mutex> lock;
@@ -563,19 +553,17 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
         frame->CalculateTarget()->GetPreferDynamicValue();
     value = FindValue(name, value_type, use_dynamic);
   }
-  return LLDB_RECORD_RESULT(value);
+  return value;
 }
 
 SBValue SBFrame::FindValue(const char *name, ValueType value_type,
                            lldb::DynamicValueType use_dynamic) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
-                     (const char *, lldb::ValueType, lldb::DynamicValueType),
-                     name, value_type, use_dynamic);
+  LLDB_INSTRUMENT_VA(this, name, value_type, use_dynamic);
 
   SBValue sb_value;
 
   if (name == nullptr || name[0] == '\0') {
-    return LLDB_RECORD_RESULT(sb_value);
+    return sb_value;
   }
 
   ValueObjectSP value_sp;
@@ -678,12 +666,11 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type,
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 bool SBFrame::IsEqual(const SBFrame &that) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &),
-                           that);
+  LLDB_INSTRUMENT_VA(this, that);
 
   lldb::StackFrameSP this_sp = GetFrameSP();
   lldb::StackFrameSP that_sp = that.GetFrameSP();
@@ -691,21 +678,19 @@ bool SBFrame::IsEqual(const SBFrame &that) const {
 }
 
 bool SBFrame::operator==(const SBFrame &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &),
-                           rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return IsEqual(rhs);
 }
 
 bool SBFrame::operator!=(const SBFrame &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &),
-                           rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return !IsEqual(rhs);
 }
 
 SBThread SBFrame::GetThread() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread);
+  LLDB_INSTRUMENT_VA(this);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -713,11 +698,11 @@ SBThread SBFrame::GetThread() const {
   ThreadSP thread_sp(exe_ctx.GetThreadSP());
   SBThread sb_thread(thread_sp);
 
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 const char *SBFrame::Disassemble() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *disassembly = nullptr;
   std::unique_lock<std::recursive_mutex> lock;
@@ -741,9 +726,7 @@ const char *SBFrame::Disassemble() const {
 
 SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
                                   bool in_scope_only) {
-  LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
-                     (bool, bool, bool, bool), arguments, locals, statics,
-                     in_scope_only);
+  LLDB_INSTRUMENT_VA(this, arguments, locals, statics, in_scope_only);
 
   SBValueList value_list;
   std::unique_lock<std::recursive_mutex> lock;
@@ -767,15 +750,14 @@ SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
 
     value_list = GetVariables(options);
   }
-  return LLDB_RECORD_RESULT(value_list);
+  return value_list;
 }
 
 lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
                                         bool statics, bool in_scope_only,
                                         lldb::DynamicValueType use_dynamic) {
-  LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
-                     (bool, bool, bool, bool, lldb::DynamicValueType),
-                     arguments, locals, statics, in_scope_only, use_dynamic);
+  LLDB_INSTRUMENT_VA(this, arguments, locals, statics, in_scope_only,
+                     use_dynamic);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -790,12 +772,11 @@ lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
   options.SetInScopeOnly(in_scope_only);
   options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
   options.SetUseDynamic(use_dynamic);
-  return LLDB_RECORD_RESULT(GetVariables(options));
+  return GetVariables(options);
 }
 
 SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
-  LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
-                     (const lldb::SBVariablesOptions &), options);
+  LLDB_INSTRUMENT_VA(this, options);
 
   SBValueList value_list;
   std::unique_lock<std::recursive_mutex> lock;
@@ -891,11 +872,11 @@ SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
     }
   }
 
-  return LLDB_RECORD_RESULT(value_list);
+  return value_list;
 }
 
 SBValueList SBFrame::GetRegisters() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters);
+  LLDB_INSTRUMENT_VA(this);
 
   SBValueList value_list;
   std::unique_lock<std::recursive_mutex> lock;
@@ -921,12 +902,11 @@ SBValueList SBFrame::GetRegisters() {
     }
   }
 
-  return LLDB_RECORD_RESULT(value_list);
+  return value_list;
 }
 
 SBValue SBFrame::FindRegister(const char *name) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *),
-                     name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   SBValue result;
   ValueObjectSP value_sp;
@@ -953,12 +933,11 @@ SBValue SBFrame::FindRegister(const char *name) {
     }
   }
 
-  return LLDB_RECORD_RESULT(result);
+  return result;
 }
 
 bool SBFrame::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -984,8 +963,7 @@ bool SBFrame::GetDescription(SBStream &description) {
 }
 
 SBValue SBFrame::EvaluateExpression(const char *expr) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *),
-                     expr);
+  LLDB_INSTRUMENT_VA(this, expr);
 
   SBValue result;
   std::unique_lock<std::recursive_mutex> lock;
@@ -1004,17 +982,15 @@ SBValue SBFrame::EvaluateExpression(const char *expr) {
       options.SetLanguage(target->GetLanguage());
     else
       options.SetLanguage(frame->GetLanguage());
-    return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
+    return EvaluateExpression(expr, options);
   }
-  return LLDB_RECORD_RESULT(result);
+  return result;
 }
 
 SBValue
 SBFrame::EvaluateExpression(const char *expr,
                             lldb::DynamicValueType fetch_dynamic_value) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
-                     (const char *, lldb::DynamicValueType), expr,
-                     fetch_dynamic_value);
+  LLDB_INSTRUMENT_VA(this, expr, fetch_dynamic_value);
 
   SBExpressionOptions options;
   options.SetFetchDynamicValue(fetch_dynamic_value);
@@ -1029,15 +1005,13 @@ SBFrame::EvaluateExpression(const char *expr,
     options.SetLanguage(target->GetLanguage());
   else if (frame)
     options.SetLanguage(frame->GetLanguage());
-  return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
+  return EvaluateExpression(expr, options);
 }
 
 SBValue SBFrame::EvaluateExpression(const char *expr,
                                     lldb::DynamicValueType fetch_dynamic_value,
                                     bool unwind_on_error) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
-                     (const char *, lldb::DynamicValueType, bool), expr,
-                     fetch_dynamic_value, unwind_on_error);
+  LLDB_INSTRUMENT_VA(this, expr, fetch_dynamic_value, unwind_on_error);
 
   SBExpressionOptions options;
   std::unique_lock<std::recursive_mutex> lock;
@@ -1052,21 +1026,19 @@ SBValue SBFrame::EvaluateExpression(const char *expr,
     options.SetLanguage(target->GetLanguage());
   else if (frame)
     options.SetLanguage(frame->GetLanguage());
-  return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
+  return EvaluateExpression(expr, options);
 }
 
 lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
                                           const SBExpressionOptions &options) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
-                     (const char *, const lldb::SBExpressionOptions &), expr,
-                     options);
+  LLDB_INSTRUMENT_VA(this, expr, options);
 
   Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   SBValue expr_result;
 
   if (expr == nullptr || expr[0] == '\0') {
-    return LLDB_RECORD_RESULT(expr_result);
+    return expr_result;
   }
 
   ValueObjectSP expr_value_sp;
@@ -1106,17 +1078,17 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
             "%s, summary %s **",
             expr_result.GetValue(), expr_result.GetSummary());
 
-  return LLDB_RECORD_RESULT(expr_result);
+  return expr_result;
 }
 
 bool SBFrame::IsInlined() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined);
+  LLDB_INSTRUMENT_VA(this);
 
   return static_cast<const SBFrame *>(this)->IsInlined();
 }
 
 bool SBFrame::IsInlined() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined);
+  LLDB_INSTRUMENT_VA(this);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1140,13 +1112,13 @@ bool SBFrame::IsInlined() const {
 }
 
 bool SBFrame::IsArtificial() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial);
+  LLDB_INSTRUMENT_VA(this);
 
   return static_cast<const SBFrame *>(this)->IsArtificial();
 }
 
 bool SBFrame::IsArtificial() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial);
+  LLDB_INSTRUMENT_VA(this);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1159,13 +1131,13 @@ bool SBFrame::IsArtificial() const {
 }
 
 const char *SBFrame::GetFunctionName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName);
+  LLDB_INSTRUMENT_VA(this);
 
   return static_cast<const SBFrame *>(this)->GetFunctionName();
 }
 
 lldb::LanguageType SBFrame::GuessLanguage() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage);
+  LLDB_INSTRUMENT_VA(this);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1186,7 +1158,7 @@ lldb::LanguageType SBFrame::GuessLanguage() const {
 }
 
 const char *SBFrame::GetFunctionName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
   std::unique_lock<std::recursive_mutex> lock;
@@ -1228,7 +1200,7 @@ const char *SBFrame::GetFunctionName() const {
 }
 
 const char *SBFrame::GetDisplayFunctionName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
 
@@ -1269,82 +1241,3 @@ const char *SBFrame::GetDisplayFunctionName() {
   }
   return name;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBFrame>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBFrame, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &));
-  LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &));
-  LLDB_REGISTER_METHOD(const lldb::SBFrame &,
-                       SBFrame, operator=,(const lldb::SBFrame &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBFrame, operator bool, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
-                             (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBModule, SBFrame, GetModule, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBCompileUnit, SBFrame, GetCompileUnit,
-                             ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBFunction, SBFrame, GetFunction, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBSymbol, SBFrame, GetSymbol, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetBlock, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetFrameBlock, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBFrame, GetLineEntry, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBFrame, GetFrameID, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetCFA, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetPC, ());
-  LLDB_REGISTER_METHOD(bool, SBFrame, SetPC, (lldb::addr_t));
-  LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetSP, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetFP, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBFrame, GetPCAddress, ());
-  LLDB_REGISTER_METHOD(void, SBFrame, Clear, ());
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
-                       (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
-                       (const char *, lldb::DynamicValueType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable,
-                       (const char *, lldb::DynamicValueType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindValue,
-                       (const char *, lldb::ValueType));
-  LLDB_REGISTER_METHOD(
-      lldb::SBValue, SBFrame, FindValue,
-      (const char *, lldb::ValueType, lldb::DynamicValueType));
-  LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &));
-  LLDB_REGISTER_METHOD_CONST(bool,
-                             SBFrame, operator==,(const lldb::SBFrame &));
-  LLDB_REGISTER_METHOD_CONST(bool,
-                             SBFrame, operator!=,(const lldb::SBFrame &));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBFrame, GetThread, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, Disassemble, ());
-  LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
-                       (bool, bool, bool, bool));
-  LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
-                       (bool, bool, bool, bool, lldb::DynamicValueType));
-  LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
-                       (const lldb::SBVariablesOptions &));
-  LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetRegisters, ());
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *));
-  LLDB_REGISTER_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
-                       (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
-                       (const char *, lldb::DynamicValueType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
-                       (const char *, lldb::DynamicValueType, bool));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
-                       (const char *, const lldb::SBExpressionOptions &));
-  LLDB_REGISTER_METHOD(bool, SBFrame, IsInlined, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsInlined, ());
-  LLDB_REGISTER_METHOD(bool, SBFrame, IsArtificial, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsArtificial, ());
-  LLDB_REGISTER_METHOD(const char *, SBFrame, GetFunctionName, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::LanguageType, SBFrame, GuessLanguage, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, GetFunctionName, ());
-  LLDB_REGISTER_METHOD(const char *, SBFrame, GetDisplayFunctionName, ());
-}
-
-}
-}
diff --git a/lldb/source/API/SBFunction.cpp b/lldb/source/API/SBFunction.cpp
index 2d0cb239de75..562cae4e8906 100644
--- a/lldb/source/API/SBFunction.cpp
+++ b/lldb/source/API/SBFunction.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBFunction.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Disassembler.h"
@@ -18,42 +17,42 @@
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBFunction::SBFunction() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFunction); }
+SBFunction::SBFunction() { LLDB_INSTRUMENT_VA(this); }
 
 SBFunction::SBFunction(lldb_private::Function *lldb_object_ptr)
     : m_opaque_ptr(lldb_object_ptr) {}
 
 SBFunction::SBFunction(const lldb::SBFunction &rhs)
     : m_opaque_ptr(rhs.m_opaque_ptr) {
-  LLDB_RECORD_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const SBFunction &SBFunction::operator=(const SBFunction &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBFunction &,
-                     SBFunction, operator=,(const lldb::SBFunction &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_ptr = rhs.m_opaque_ptr;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBFunction::~SBFunction() { m_opaque_ptr = nullptr; }
 
 bool SBFunction::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBFunction::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_ptr != nullptr;
 }
 
 const char *SBFunction::GetName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *cstr = nullptr;
   if (m_opaque_ptr)
@@ -63,7 +62,7 @@ const char *SBFunction::GetName() const {
 }
 
 const char *SBFunction::GetDisplayName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetDisplayName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *cstr = nullptr;
   if (m_opaque_ptr)
@@ -73,7 +72,7 @@ const char *SBFunction::GetDisplayName() const {
 }
 
 const char *SBFunction::GetMangledName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetMangledName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *cstr = nullptr;
   if (m_opaque_ptr)
@@ -82,21 +81,19 @@ const char *SBFunction::GetMangledName() const {
 }
 
 bool SBFunction::operator==(const SBFunction &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBFunction, operator==,(const lldb::SBFunction &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_ptr == rhs.m_opaque_ptr;
 }
 
 bool SBFunction::operator!=(const SBFunction &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBFunction, operator!=,(const lldb::SBFunction &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_ptr != rhs.m_opaque_ptr;
 }
 
 bool SBFunction::GetDescription(SBStream &s) {
-  LLDB_RECORD_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &), s);
+  LLDB_INSTRUMENT_VA(this, s);
 
   if (m_opaque_ptr) {
     s.Printf("SBFunction: id = 0x%8.8" PRIx64 ", name = %s",
@@ -111,16 +108,14 @@ bool SBFunction::GetDescription(SBStream &s) {
 }
 
 SBInstructionList SBFunction::GetInstructions(SBTarget target) {
-  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
-                     (lldb::SBTarget), target);
+  LLDB_INSTRUMENT_VA(this, target);
 
-  return LLDB_RECORD_RESULT(GetInstructions(target, nullptr));
+  return GetInstructions(target, nullptr);
 }
 
 SBInstructionList SBFunction::GetInstructions(SBTarget target,
                                               const char *flavor) {
-  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
-                     (lldb::SBTarget, const char *), target, flavor);
+  LLDB_INSTRUMENT_VA(this, target, flavor);
 
   SBInstructionList sb_instructions;
   if (m_opaque_ptr) {
@@ -136,7 +131,7 @@ SBInstructionList SBFunction::GetInstructions(SBTarget target,
           m_opaque_ptr->GetAddressRange(), force_live_memory));
     }
   }
-  return LLDB_RECORD_RESULT(sb_instructions);
+  return sb_instructions;
 }
 
 lldb_private::Function *SBFunction::get() { return m_opaque_ptr; }
@@ -146,16 +141,16 @@ void SBFunction::reset(lldb_private::Function *lldb_object_ptr) {
 }
 
 SBAddress SBFunction::GetStartAddress() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetStartAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   SBAddress addr;
   if (m_opaque_ptr)
     addr.SetAddress(m_opaque_ptr->GetAddressRange().GetBaseAddress());
-  return LLDB_RECORD_RESULT(addr);
+  return addr;
 }
 
 SBAddress SBFunction::GetEndAddress() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetEndAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   SBAddress addr;
   if (m_opaque_ptr) {
@@ -165,12 +160,11 @@ SBAddress SBFunction::GetEndAddress() {
       addr->Slide(byte_size);
     }
   }
-  return LLDB_RECORD_RESULT(addr);
+  return addr;
 }
 
 const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
-  LLDB_RECORD_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t),
-                     arg_idx);
+  LLDB_INSTRUMENT_VA(this, arg_idx);
 
   if (m_opaque_ptr) {
     Block &block = m_opaque_ptr->GetBlock(true);
@@ -188,7 +182,7 @@ const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
 }
 
 uint32_t SBFunction::GetPrologueByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBFunction, GetPrologueByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->GetPrologueByteSize();
@@ -196,7 +190,7 @@ uint32_t SBFunction::GetPrologueByteSize() {
 }
 
 SBType SBFunction::GetType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBFunction, GetType);
+  LLDB_INSTRUMENT_VA(this);
 
   SBType sb_type;
   if (m_opaque_ptr) {
@@ -204,20 +198,20 @@ SBType SBFunction::GetType() {
     if (function_type)
       sb_type.ref().SetType(function_type->shared_from_this());
   }
-  return LLDB_RECORD_RESULT(sb_type);
+  return sb_type;
 }
 
 SBBlock SBFunction::GetBlock() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBFunction, GetBlock);
+  LLDB_INSTRUMENT_VA(this);
 
   SBBlock sb_block;
   if (m_opaque_ptr)
     sb_block.SetPtr(&m_opaque_ptr->GetBlock(true));
-  return LLDB_RECORD_RESULT(sb_block);
+  return sb_block;
 }
 
 lldb::LanguageType SBFunction::GetLanguage() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBFunction, GetLanguage);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr) {
     if (m_opaque_ptr->GetCompileUnit())
@@ -227,7 +221,7 @@ lldb::LanguageType SBFunction::GetLanguage() {
 }
 
 bool SBFunction::GetIsOptimized() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBFunction, GetIsOptimized);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr) {
     if (m_opaque_ptr->GetCompileUnit())
@@ -235,39 +229,3 @@ bool SBFunction::GetIsOptimized() {
   }
   return false;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBFunction>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBFunction, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &));
-  LLDB_REGISTER_METHOD(const lldb::SBFunction &,
-                       SBFunction, operator=,(const lldb::SBFunction &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBFunction, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBFunction, operator bool, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetName, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetDisplayName, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetMangledName, ());
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBFunction, operator==,(const lldb::SBFunction &));
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBFunction, operator!=,(const lldb::SBFunction &));
-  LLDB_REGISTER_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
-                       (lldb::SBTarget));
-  LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
-                       (lldb::SBTarget, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetStartAddress, ());
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetEndAddress, ());
-  LLDB_REGISTER_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBFunction, GetPrologueByteSize, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBFunction, GetType, ());
-  LLDB_REGISTER_METHOD(lldb::SBBlock, SBFunction, GetBlock, ());
-  LLDB_REGISTER_METHOD(lldb::LanguageType, SBFunction, GetLanguage, ());
-  LLDB_REGISTER_METHOD(bool, SBFunction, GetIsOptimized, ());
-}
-
-}
-}
diff --git a/lldb/source/API/SBHostOS.cpp b/lldb/source/API/SBHostOS.cpp
index deca4ac81a1a..06cf654031a1 100644
--- a/lldb/source/API/SBHostOS.cpp
+++ b/lldb/source/API/SBHostOS.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBHostOS.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/FileSystem.h"
@@ -17,6 +16,7 @@
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangHost.h"
 #if LLDB_ENABLE_PYTHON
@@ -30,24 +30,21 @@ using namespace lldb;
 using namespace lldb_private;
 
 SBFileSpec SBHostOS::GetProgramFileSpec() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
-                                    GetProgramFileSpec);
+  LLDB_INSTRUMENT();
 
   SBFileSpec sb_filespec;
   sb_filespec.SetFileSpec(HostInfo::GetProgramFileSpec());
-  return LLDB_RECORD_RESULT(sb_filespec);
+  return sb_filespec;
 }
 
 SBFileSpec SBHostOS::GetLLDBPythonPath() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
-                                    GetLLDBPythonPath);
+  LLDB_INSTRUMENT();
 
-  return LLDB_RECORD_RESULT(GetLLDBPath(ePathTypePythonDir));
+  return GetLLDBPath(ePathTypePythonDir);
 }
 
 SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath,
-                            (lldb::PathType), path_type);
+  LLDB_INSTRUMENT_VA(path_type);
 
   FileSpec fspec;
   switch (path_type) {
@@ -84,12 +81,11 @@ SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) {
 
   SBFileSpec sb_fspec;
   sb_fspec.SetFileSpec(fspec);
-  return LLDB_RECORD_RESULT(sb_fspec);
+  return sb_fspec;
 }
 
 SBFileSpec SBHostOS::GetUserHomeDirectory() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
-                                    GetUserHomeDirectory);
+  LLDB_INSTRUMENT();
 
   FileSpec homedir;
   FileSystem::Instance().GetHomeDirectory(homedir);
@@ -98,15 +94,13 @@ SBFileSpec SBHostOS::GetUserHomeDirectory() {
   SBFileSpec sb_fspec;
   sb_fspec.SetFileSpec(homedir);
 
-  return LLDB_RECORD_RESULT(sb_fspec);
+  return sb_fspec;
 }
 
 lldb::thread_t SBHostOS::ThreadCreate(const char *name,
                                       lldb::thread_func_t thread_function,
                                       void *thread_arg, SBError *error_ptr) {
-  LLDB_RECORD_DUMMY(lldb::thread_t, SBHostOS, ThreadCreate,
-                    (lldb::thread_func_t, void *, SBError *), name,
-                    thread_function, thread_arg, error_ptr);
+  LLDB_INSTRUMENT_VA(name, thread_function, thread_arg, error_ptr);
   llvm::Expected<HostThread> thread =
       ThreadLauncher::LaunchThread(name, thread_function, thread_arg);
   if (!thread) {
@@ -120,15 +114,10 @@ lldb::thread_t SBHostOS::ThreadCreate(const char *name,
   return thread->Release();
 }
 
-void SBHostOS::ThreadCreated(const char *name) {
-  LLDB_RECORD_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *),
-                            name);
-}
+void SBHostOS::ThreadCreated(const char *name) { LLDB_INSTRUMENT_VA(name); }
 
 bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) {
-  LLDB_RECORD_DUMMY(bool, SBHostOS, ThreadCancel,
-                            (lldb::thread_t, lldb::SBError *), thread,
-                            error_ptr);
+  LLDB_INSTRUMENT_VA(thread, error_ptr);
 
   Status error;
   HostThread host_thread(thread);
@@ -140,9 +129,7 @@ bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) {
 }
 
 bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) {
-  LLDB_RECORD_DUMMY(bool, SBHostOS, ThreadDetach,
-                            (lldb::thread_t, lldb::SBError *), thread,
-                            error_ptr);
+  LLDB_INSTRUMENT_VA(thread, error_ptr);
 
   Status error;
 #if defined(_WIN32)
@@ -160,10 +147,7 @@ bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) {
 
 bool SBHostOS::ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result,
                           SBError *error_ptr) {
-  LLDB_RECORD_DUMMY(
-      bool, SBHostOS, ThreadJoin,
-      (lldb::thread_t, lldb::thread_result_t *, lldb::SBError *), thread,
-      result, error_ptr);
+  LLDB_INSTRUMENT_VA(thread, result, error_ptr);
 
   Status error;
   HostThread host_thread(thread);
@@ -173,22 +157,3 @@ bool SBHostOS::ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result,
   host_thread.Release();
   return error.Success();
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBHostOS>(Registry &R) {
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetProgramFileSpec,
-                              ());
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPythonPath,
-                              ());
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath,
-                              (lldb::PathType));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS,
-                              GetUserHomeDirectory, ());
-  LLDB_REGISTER_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *));
-}
-
-}
-}
diff --git a/lldb/source/API/SBInstruction.cpp b/lldb/source/API/SBInstruction.cpp
index 579ddf84cf45..6cb9e5dbc1af 100644
--- a/lldb/source/API/SBInstruction.cpp
+++ b/lldb/source/API/SBInstruction.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBInstruction.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFrame.h"
@@ -66,9 +66,7 @@ protected:
 using namespace lldb;
 using namespace lldb_private;
 
-SBInstruction::SBInstruction() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstruction);
-}
+SBInstruction::SBInstruction() { LLDB_INSTRUMENT_VA(this); }
 
 SBInstruction::SBInstruction(const lldb::DisassemblerSP &disasm_sp,
                              const lldb::InstructionSP &inst_sp)
@@ -76,44 +74,41 @@ SBInstruction::SBInstruction(const lldb::DisassemblerSP &disasm_sp,
 
 SBInstruction::SBInstruction(const SBInstruction &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBInstruction &,
-                     SBInstruction, operator=,(const lldb::SBInstruction &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBInstruction::~SBInstruction() = default;
 
 bool SBInstruction::IsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBInstruction::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstruction, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp && m_opaque_sp->IsValid();
 }
 
 SBAddress SBInstruction::GetAddress() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBInstruction, GetAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   SBAddress sb_addr;
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp && inst_sp->GetAddress().IsValid())
     sb_addr.SetAddress(inst_sp->GetAddress());
-  return LLDB_RECORD_RESULT(sb_addr);
+  return sb_addr;
 }
 
 const char *SBInstruction::GetMnemonic(SBTarget target) {
-  LLDB_RECORD_METHOD(const char *, SBInstruction, GetMnemonic, (lldb::SBTarget),
-                     target);
+  LLDB_INSTRUMENT_VA(this, target);
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
@@ -132,8 +127,7 @@ const char *SBInstruction::GetMnemonic(SBTarget target) {
 }
 
 const char *SBInstruction::GetOperands(SBTarget target) {
-  LLDB_RECORD_METHOD(const char *, SBInstruction, GetOperands, (lldb::SBTarget),
-                     target);
+  LLDB_INSTRUMENT_VA(this, target);
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
@@ -152,8 +146,7 @@ const char *SBInstruction::GetOperands(SBTarget target) {
 }
 
 const char *SBInstruction::GetComment(SBTarget target) {
-  LLDB_RECORD_METHOD(const char *, SBInstruction, GetComment, (lldb::SBTarget),
-                     target);
+  LLDB_INSTRUMENT_VA(this, target);
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
@@ -172,7 +165,7 @@ const char *SBInstruction::GetComment(SBTarget target) {
 }
 
 size_t SBInstruction::GetByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstruction, GetByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp)
@@ -181,8 +174,7 @@ size_t SBInstruction::GetByteSize() {
 }
 
 SBData SBInstruction::GetData(SBTarget target) {
-  LLDB_RECORD_METHOD(lldb::SBData, SBInstruction, GetData, (lldb::SBTarget),
-                     target);
+  LLDB_INSTRUMENT_VA(this, target);
 
   lldb::SBData sb_data;
   lldb::InstructionSP inst_sp(GetOpaque());
@@ -192,11 +184,11 @@ SBData SBInstruction::GetData(SBTarget target) {
       sb_data.SetOpaque(data_extractor_sp);
     }
   }
-  return LLDB_RECORD_RESULT(sb_data);
+  return sb_data;
 }
 
 bool SBInstruction::DoesBranch() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, DoesBranch);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp)
@@ -205,7 +197,7 @@ bool SBInstruction::DoesBranch() {
 }
 
 bool SBInstruction::HasDelaySlot() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, HasDelaySlot);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp)
@@ -214,7 +206,7 @@ bool SBInstruction::HasDelaySlot() {
 }
 
 bool SBInstruction::CanSetBreakpoint() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, CanSetBreakpoint);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp)
@@ -235,8 +227,7 @@ void SBInstruction::SetOpaque(const lldb::DisassemblerSP &disasm_sp,
 }
 
 bool SBInstruction::GetDescription(lldb::SBStream &s) {
-  LLDB_RECORD_METHOD(bool, SBInstruction, GetDescription, (lldb::SBStream &),
-                     s);
+  LLDB_INSTRUMENT_VA(this, s);
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
@@ -257,18 +248,18 @@ bool SBInstruction::GetDescription(lldb::SBStream &s) {
 }
 
 void SBInstruction::Print(FILE *outp) {
-  LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), outp);
+  LLDB_INSTRUMENT_VA(this, outp);
   FileSP out = std::make_shared<NativeFile>(outp, /*take_ownership=*/false);
   Print(out);
 }
 
 void SBInstruction::Print(SBFile out) {
-  LLDB_RECORD_METHOD(void, SBInstruction, Print, (SBFile), out);
+  LLDB_INSTRUMENT_VA(this, out);
   Print(out.m_opaque_sp);
 }
 
 void SBInstruction::Print(FileSP out_sp) {
-  LLDB_RECORD_METHOD(void, SBInstruction, Print, (FileSP), out_sp);
+  LLDB_INSTRUMENT_VA(this, out_sp);
 
   if (!out_sp || !out_sp->IsValid())
     return;
@@ -291,8 +282,7 @@ void SBInstruction::Print(FileSP out_sp) {
 
 bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame,
                                      uint32_t evaluate_options) {
-  LLDB_RECORD_METHOD(bool, SBInstruction, EmulateWithFrame,
-                     (lldb::SBFrame &, uint32_t), frame, evaluate_options);
+  LLDB_INSTRUMENT_VA(this, frame, evaluate_options);
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
@@ -316,8 +306,7 @@ bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame,
 }
 
 bool SBInstruction::DumpEmulation(const char *triple) {
-  LLDB_RECORD_METHOD(bool, SBInstruction, DumpEmulation, (const char *),
-                     triple);
+  LLDB_INSTRUMENT_VA(this, triple);
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp && triple) {
@@ -328,9 +317,7 @@ bool SBInstruction::DumpEmulation(const char *triple) {
 
 bool SBInstruction::TestEmulation(lldb::SBStream &output_stream,
                                   const char *test_file) {
-  LLDB_RECORD_METHOD(bool, SBInstruction, TestEmulation,
-                     (lldb::SBStream &, const char *), output_stream,
-                     test_file);
+  LLDB_INSTRUMENT_VA(this, output_stream, test_file);
 
   if (!m_opaque_sp)
     SetOpaque(lldb::DisassemblerSP(),
@@ -341,43 +328,3 @@ bool SBInstruction::TestEmulation(lldb::SBStream &output_stream,
     return inst_sp->TestEmulation(output_stream.get(), test_file);
   return false;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBInstruction>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBInstruction, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBInstruction &,
-      SBInstruction, operator=,(const lldb::SBInstruction &));
-  LLDB_REGISTER_METHOD(bool, SBInstruction, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBInstruction, operator bool, ());
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBInstruction, GetAddress, ());
-  LLDB_REGISTER_METHOD(const char *, SBInstruction, GetMnemonic,
-                       (lldb::SBTarget));
-  LLDB_REGISTER_METHOD(const char *, SBInstruction, GetOperands,
-                       (lldb::SBTarget));
-  LLDB_REGISTER_METHOD(const char *, SBInstruction, GetComment,
-                       (lldb::SBTarget));
-  LLDB_REGISTER_METHOD(size_t, SBInstruction, GetByteSize, ());
-  LLDB_REGISTER_METHOD(lldb::SBData, SBInstruction, GetData,
-                       (lldb::SBTarget));
-  LLDB_REGISTER_METHOD(bool, SBInstruction, DoesBranch, ());
-  LLDB_REGISTER_METHOD(bool, SBInstruction, HasDelaySlot, ());
-  LLDB_REGISTER_METHOD(bool, SBInstruction, CanSetBreakpoint, ());
-  LLDB_REGISTER_METHOD(bool, SBInstruction, GetDescription,
-                       (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(void, SBInstruction, Print, (FILE *));
-  LLDB_REGISTER_METHOD(void, SBInstruction, Print, (SBFile));
-  LLDB_REGISTER_METHOD(void, SBInstruction, Print, (FileSP));
-  LLDB_REGISTER_METHOD(bool, SBInstruction, EmulateWithFrame,
-                       (lldb::SBFrame &, uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBInstruction, DumpEmulation, (const char *));
-  LLDB_REGISTER_METHOD(bool, SBInstruction, TestEmulation,
-                       (lldb::SBStream &, const char *));
-}
-
-}
-}
diff --git a/lldb/source/API/SBInstructionList.cpp b/lldb/source/API/SBInstructionList.cpp
index a0c6fbe7e338..e289e8e9343d 100644
--- a/lldb/source/API/SBInstructionList.cpp
+++ b/lldb/source/API/SBInstructionList.cpp
@@ -7,55 +7,50 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBInstructionList.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
+#include "lldb/API/SBFile.h"
 #include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBStream.h"
-#include "lldb/API/SBFile.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBInstructionList::SBInstructionList() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstructionList);
-}
+SBInstructionList::SBInstructionList() { LLDB_INSTRUMENT_VA(this); }
 
 SBInstructionList::SBInstructionList(const SBInstructionList &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBInstructionList, (const lldb::SBInstructionList &),
-                          rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const SBInstructionList &SBInstructionList::
 operator=(const SBInstructionList &rhs) {
-  LLDB_RECORD_METHOD(
-      const lldb::SBInstructionList &,
-      SBInstructionList, operator=,(const lldb::SBInstructionList &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBInstructionList::~SBInstructionList() = default;
 
 bool SBInstructionList::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBInstructionList::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 size_t SBInstructionList::GetSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstructionList, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     return m_opaque_sp->GetInstructionList().GetSize();
@@ -63,23 +58,20 @@ size_t SBInstructionList::GetSize() {
 }
 
 SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBInstruction, SBInstructionList,
-                     GetInstructionAtIndex, (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBInstruction inst;
   if (m_opaque_sp && idx < m_opaque_sp->GetInstructionList().GetSize())
     inst.SetOpaque(
         m_opaque_sp,
         m_opaque_sp->GetInstructionList().GetInstructionAtIndex(idx));
-  return LLDB_RECORD_RESULT(inst);
+  return inst;
 }
 
 size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
                                                const SBAddress &end,
                                                bool canSetBreakpoint) {
-  LLDB_RECORD_METHOD(size_t, SBInstructionList, GetInstructionsCount,
-                     (const lldb::SBAddress &, const lldb::SBAddress &, bool),
-                     start, end, canSetBreakpoint);
+  LLDB_INSTRUMENT_VA(this, start, end, canSetBreakpoint);
 
   size_t num_instructions = GetSize();
   size_t i = 0;
@@ -104,14 +96,13 @@ size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
 }
 
 void SBInstructionList::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBInstructionList, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_sp.reset();
 }
 
 void SBInstructionList::AppendInstruction(SBInstruction insn) {
-  LLDB_RECORD_METHOD(void, SBInstructionList, AppendInstruction,
-                     (lldb::SBInstruction), insn);
+  LLDB_INSTRUMENT_VA(this, insn);
 }
 
 void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) {
@@ -119,7 +110,7 @@ void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) {
 }
 
 void SBInstructionList::Print(FILE *out) {
-  LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FILE *), out);
+  LLDB_INSTRUMENT_VA(this, out);
   if (out == nullptr)
     return;
   StreamFile stream(out, false);
@@ -127,7 +118,7 @@ void SBInstructionList::Print(FILE *out) {
 }
 
 void SBInstructionList::Print(SBFile out) {
-  LLDB_RECORD_METHOD(void, SBInstructionList, Print, (SBFile), out);
+  LLDB_INSTRUMENT_VA(this, out);
   if (!out.IsValid())
     return;
   StreamFile stream(out.m_opaque_sp);
@@ -135,7 +126,7 @@ void SBInstructionList::Print(SBFile out) {
 }
 
 void SBInstructionList::Print(FileSP out_sp) {
-  LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FileSP), out_sp);
+  LLDB_INSTRUMENT_VA(this, out_sp);
   if (!out_sp || !out_sp->IsValid())
     return;
   StreamFile stream(out_sp);
@@ -143,8 +134,7 @@ void SBInstructionList::Print(FileSP out_sp) {
 }
 
 bool SBInstructionList::GetDescription(lldb::SBStream &stream) {
-  LLDB_RECORD_METHOD(bool, SBInstructionList, GetDescription,
-                     (lldb::SBStream &), stream);
+  LLDB_INSTRUMENT_VA(this, stream);
   return GetDescription(stream.ref());
 }
 
@@ -186,8 +176,7 @@ bool SBInstructionList::GetDescription(Stream &sref) {
 }
 
 bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) {
-  LLDB_RECORD_METHOD(bool, SBInstructionList, DumpEmulationForAllInstructions,
-                     (const char *), triple);
+  LLDB_INSTRUMENT_VA(this, triple);
 
   if (m_opaque_sp) {
     size_t len = GetSize();
@@ -198,37 +187,3 @@ bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) {
   }
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBInstructionList>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBInstructionList, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBInstructionList,
-                            (const lldb::SBInstructionList &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBInstructionList &,
-      SBInstructionList, operator=,(const lldb::SBInstructionList &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, operator bool, ());
-  LLDB_REGISTER_METHOD(size_t, SBInstructionList, GetSize, ());
-  LLDB_REGISTER_METHOD(lldb::SBInstruction, SBInstructionList,
-                       GetInstructionAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(
-      size_t, SBInstructionList, GetInstructionsCount,
-      (const lldb::SBAddress &, const lldb::SBAddress &, bool));
-  LLDB_REGISTER_METHOD(void, SBInstructionList, Clear, ());
-  LLDB_REGISTER_METHOD(void, SBInstructionList, AppendInstruction,
-                       (lldb::SBInstruction));
-  LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FILE *));
-  LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (SBFile));
-  LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FileSP));
-  LLDB_REGISTER_METHOD(bool, SBInstructionList, GetDescription,
-                       (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(bool, SBInstructionList,
-                       DumpEmulationForAllInstructions, (const char *));
-}
-
-}
-}
diff --git a/lldb/source/API/SBLanguageRuntime.cpp b/lldb/source/API/SBLanguageRuntime.cpp
index e65b58270517..d571f282fce0 100644
--- a/lldb/source/API/SBLanguageRuntime.cpp
+++ b/lldb/source/API/SBLanguageRuntime.cpp
@@ -7,39 +7,22 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBLanguageRuntime.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/Target/Language.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 lldb::LanguageType
 SBLanguageRuntime::GetLanguageTypeFromString(const char *string) {
-  LLDB_RECORD_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
-                            GetLanguageTypeFromString, (const char *), string);
+  LLDB_INSTRUMENT_VA(string);
 
   return Language::GetLanguageTypeFromString(llvm::StringRef(string));
 }
 
 const char *
 SBLanguageRuntime::GetNameForLanguageType(lldb::LanguageType language) {
-  LLDB_RECORD_STATIC_METHOD(const char *, SBLanguageRuntime,
-                            GetNameForLanguageType, (lldb::LanguageType),
-                            language);
+  LLDB_INSTRUMENT_VA(language);
 
   return Language::GetNameForLanguageType(language);
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBLanguageRuntime>(Registry &R) {
-  LLDB_REGISTER_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
-                              GetLanguageTypeFromString, (const char *));
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBLanguageRuntime,
-                              GetNameForLanguageType, (lldb::LanguageType));
-}
-
-}
-}
diff --git a/lldb/source/API/SBLaunchInfo.cpp b/lldb/source/API/SBLaunchInfo.cpp
index 0735e62a16cf..5149feba5e0b 100644
--- a/lldb/source/API/SBLaunchInfo.cpp
+++ b/lldb/source/API/SBLaunchInfo.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBLaunchInfo.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBError.h"
@@ -23,8 +23,7 @@ using namespace lldb_private;
 
 class lldb_private::SBLaunchInfoImpl : public ProcessLaunchInfo {
 public:
-  SBLaunchInfoImpl()
-      : ProcessLaunchInfo(), m_envp(GetEnvironment().getEnvp()) {}
+  SBLaunchInfoImpl() : m_envp(GetEnvironment().getEnvp()) {}
 
   const char *const *GetEnvp() const { return m_envp; }
   void RegenerateEnvp() { m_envp = GetEnvironment().getEnvp(); }
@@ -41,7 +40,7 @@ private:
 
 SBLaunchInfo::SBLaunchInfo(const char **argv)
     : m_opaque_sp(new SBLaunchInfoImpl()) {
-  LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const char **), argv);
+  LLDB_INSTRUMENT_VA(this, argv);
 
   m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR);
   if (argv && argv[0])
@@ -49,17 +48,16 @@ SBLaunchInfo::SBLaunchInfo(const char **argv)
 }
 
 SBLaunchInfo::SBLaunchInfo(const SBLaunchInfo &rhs) {
-  LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const lldb::SBLaunchInfo &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_sp = rhs.m_opaque_sp;
 }
 
 SBLaunchInfo &SBLaunchInfo::operator=(const SBLaunchInfo &rhs) {
-  LLDB_RECORD_METHOD(SBLaunchInfo &,
-                     SBLaunchInfo, operator=,(const lldb::SBLaunchInfo &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_sp = rhs.m_opaque_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBLaunchInfo::~SBLaunchInfo() = default;
@@ -73,90 +71,86 @@ void SBLaunchInfo::set_ref(const ProcessLaunchInfo &info) {
 }
 
 lldb::pid_t SBLaunchInfo::GetProcessID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBLaunchInfo, GetProcessID);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetProcessID();
 }
 
 uint32_t SBLaunchInfo::GetUserID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetUserID();
 }
 
 uint32_t SBLaunchInfo::GetGroupID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetGroupID();
 }
 
 bool SBLaunchInfo::UserIDIsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->UserIDIsValid();
 }
 
 bool SBLaunchInfo::GroupIDIsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GroupIDIsValid();
 }
 
 void SBLaunchInfo::SetUserID(uint32_t uid) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid);
+  LLDB_INSTRUMENT_VA(this, uid);
 
   m_opaque_sp->SetUserID(uid);
 }
 
 void SBLaunchInfo::SetGroupID(uint32_t gid) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid);
+  LLDB_INSTRUMENT_VA(this, gid);
 
   m_opaque_sp->SetGroupID(gid);
 }
 
 SBFileSpec SBLaunchInfo::GetExecutableFile() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile);
+  LLDB_INSTRUMENT_VA(this);
 
-  return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_sp->GetExecutableFile()));
+  return SBFileSpec(m_opaque_sp->GetExecutableFile());
 }
 
 void SBLaunchInfo::SetExecutableFile(SBFileSpec exe_file,
                                      bool add_as_first_arg) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetExecutableFile,
-                     (lldb::SBFileSpec, bool), exe_file, add_as_first_arg);
+  LLDB_INSTRUMENT_VA(this, exe_file, add_as_first_arg);
 
   m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
 }
 
 SBListener SBLaunchInfo::GetListener() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBLaunchInfo, GetListener);
+  LLDB_INSTRUMENT_VA(this);
 
-  return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener()));
+  return SBListener(m_opaque_sp->GetListener());
 }
 
 void SBLaunchInfo::SetListener(SBListener &listener) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &),
-                     listener);
+  LLDB_INSTRUMENT_VA(this, listener);
 
   m_opaque_sp->SetListener(listener.GetSP());
 }
 
 uint32_t SBLaunchInfo::GetNumArguments() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumArguments);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetArguments().GetArgumentCount();
 }
 
 const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, (uint32_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
 }
 
 void SBLaunchInfo::SetArguments(const char **argv, bool append) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetArguments, (const char **, bool),
-                     argv, append);
+  LLDB_INSTRUMENT_VA(this, argv, append);
 
   if (append) {
     if (argv)
@@ -170,14 +164,13 @@ void SBLaunchInfo::SetArguments(const char **argv, bool append) {
 }
 
 uint32_t SBLaunchInfo::GetNumEnvironmentEntries() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetEnvironment().size();
 }
 
 const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
-                     (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   if (idx > GetNumEnvironmentEntries())
     return nullptr;
@@ -185,14 +178,12 @@ const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
 }
 
 void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
-                     (const char **, bool), envp, append);
+  LLDB_INSTRUMENT_VA(this, envp, append);
   SetEnvironment(SBEnvironment(Environment(envp)), append);
 }
 
 void SBLaunchInfo::SetEnvironment(const SBEnvironment &env, bool append) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironment,
-                     (const lldb::SBEnvironment &, bool), env, append);
+  LLDB_INSTRUMENT_VA(this, env, append);
   Environment &refEnv = env.ref();
   if (append) {
     for (auto &KV : refEnv)
@@ -203,58 +194,54 @@ void SBLaunchInfo::SetEnvironment(const SBEnvironment &env, bool append) {
 }
 
 SBEnvironment SBLaunchInfo::GetEnvironment() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBLaunchInfo, GetEnvironment);
-  return LLDB_RECORD_RESULT(
-      SBEnvironment(Environment(m_opaque_sp->GetEnvironment())));
+  LLDB_INSTRUMENT_VA(this);
+  return SBEnvironment(Environment(m_opaque_sp->GetEnvironment()));
 }
 
 void SBLaunchInfo::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBLaunchInfo, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_sp->Clear();
 }
 
 const char *SBLaunchInfo::GetWorkingDirectory() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
-                                   GetWorkingDirectory);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetWorkingDirectory().GetCString();
 }
 
 void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *),
-                     working_dir);
+  LLDB_INSTRUMENT_VA(this, working_dir);
 
   m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir));
 }
 
 uint32_t SBLaunchInfo::GetLaunchFlags() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetLaunchFlags);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetFlags().Get();
 }
 
 void SBLaunchInfo::SetLaunchFlags(uint32_t flags) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags);
+  LLDB_INSTRUMENT_VA(this, flags);
 
   m_opaque_sp->GetFlags().Reset(flags);
 }
 
 const char *SBLaunchInfo::GetProcessPluginName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetProcessPluginName);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetProcessPluginName();
 }
 
 void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetProcessPluginName, (const char *),
-                     plugin_name);
+  LLDB_INSTRUMENT_VA(this, plugin_name);
 
   return m_opaque_sp->SetProcessPluginName(plugin_name);
 }
 
 const char *SBLaunchInfo::GetShell() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetShell);
+  LLDB_INSTRUMENT_VA(this);
 
   // Constify this string so that it is saved in the string pool.  Otherwise it
   // would be freed when this function goes out of scope.
@@ -263,93 +250,86 @@ const char *SBLaunchInfo::GetShell() {
 }
 
 void SBLaunchInfo::SetShell(const char *path) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShell, (const char *), path);
+  LLDB_INSTRUMENT_VA(this, path);
 
   m_opaque_sp->SetShell(FileSpec(path));
 }
 
 bool SBLaunchInfo::GetShellExpandArguments() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GetShellExpandArguments);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetShellExpandArguments();
 }
 
 void SBLaunchInfo::SetShellExpandArguments(bool expand) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool),
-                     expand);
+  LLDB_INSTRUMENT_VA(this, expand);
 
   m_opaque_sp->SetShellExpandArguments(expand);
 }
 
 uint32_t SBLaunchInfo::GetResumeCount() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetResumeCount);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetResumeCount();
 }
 
 void SBLaunchInfo::SetResumeCount(uint32_t c) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t), c);
+  LLDB_INSTRUMENT_VA(this, c);
 
   m_opaque_sp->SetResumeCount(c);
 }
 
 bool SBLaunchInfo::AddCloseFileAction(int fd) {
-  LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int), fd);
+  LLDB_INSTRUMENT_VA(this, fd);
 
   return m_opaque_sp->AppendCloseFileAction(fd);
 }
 
 bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) {
-  LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, (int, int), fd,
-                     dup_fd);
+  LLDB_INSTRUMENT_VA(this, fd, dup_fd);
 
   return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
 }
 
 bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read,
                                      bool write) {
-  LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
-                     (int, const char *, bool, bool), fd, path, read, write);
+  LLDB_INSTRUMENT_VA(this, fd, path, read, write);
 
   return m_opaque_sp->AppendOpenFileAction(fd, FileSpec(path), read, write);
 }
 
 bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) {
-  LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
-                     (int, bool, bool), fd, read, write);
+  LLDB_INSTRUMENT_VA(this, fd, read, write);
 
   return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
 }
 
 void SBLaunchInfo::SetLaunchEventData(const char *data) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *),
-                     data);
+  LLDB_INSTRUMENT_VA(this, data);
 
   m_opaque_sp->SetLaunchEventData(data);
 }
 
 const char *SBLaunchInfo::GetLaunchEventData() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
-                                   GetLaunchEventData);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetLaunchEventData();
 }
 
 void SBLaunchInfo::SetDetachOnError(bool enable) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable);
+  LLDB_INSTRUMENT_VA(this, enable);
 
   m_opaque_sp->SetDetachOnError(enable);
 }
 
 bool SBLaunchInfo::GetDetachOnError() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLaunchInfo, GetDetachOnError);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetDetachOnError();
 }
 
 const char *SBLaunchInfo::GetScriptedProcessClassName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
-                                   GetScriptedProcessClassName);
+  LLDB_INSTRUMENT_VA(this);
 
   // Constify this string so that it is saved in the string pool.  Otherwise it
   // would be freed when this function goes out of scope.
@@ -358,15 +338,13 @@ const char *SBLaunchInfo::GetScriptedProcessClassName() const {
 }
 
 void SBLaunchInfo::SetScriptedProcessClassName(const char *class_name) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetScriptedProcessClassName,
-                     (const char *), class_name);
+  LLDB_INSTRUMENT_VA(this, class_name);
 
   m_opaque_sp->SetScriptedProcessClassName(class_name);
 }
 
 lldb::SBStructuredData SBLaunchInfo::GetScriptedProcessDictionary() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBStructuredData, SBLaunchInfo,
-                                   GetScriptedProcessDictionary);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb_private::StructuredData::DictionarySP dict_sp =
       m_opaque_sp->GetScriptedProcessDictionarySP();
@@ -374,12 +352,11 @@ lldb::SBStructuredData SBLaunchInfo::GetScriptedProcessDictionary() const {
   SBStructuredData data;
   data.m_impl_up->SetObjectSP(dict_sp);
 
-  return LLDB_RECORD_RESULT(data);
+  return data;
 }
 
 void SBLaunchInfo::SetScriptedProcessDictionary(lldb::SBStructuredData dict) {
-  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetScriptedProcessDictionary,
-                     (lldb::SBStructuredData), dict);
+  LLDB_INSTRUMENT_VA(this, dict);
   if (!dict.IsValid() || !dict.m_impl_up)
     return;
 
@@ -395,79 +372,3 @@ void SBLaunchInfo::SetScriptedProcessDictionary(lldb::SBStructuredData dict) {
 
   m_opaque_sp->SetScriptedProcessDictionarySP(dict_sp);
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBLaunchInfo>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const char **));
-  LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const lldb::SBLaunchInfo &));
-  LLDB_REGISTER_METHOD(SBLaunchInfo &,
-                       SBLaunchInfo, operator=,(const lldb::SBLaunchInfo &));
-  LLDB_REGISTER_METHOD(lldb::pid_t, SBLaunchInfo, GetProcessID, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetUserID, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetGroupID, ());
-  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, UserIDIsValid, ());
-  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GroupIDIsValid, ());
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile, ());
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetExecutableFile,
-                       (lldb::SBFileSpec, bool));
-  LLDB_REGISTER_METHOD(lldb::SBListener, SBLaunchInfo, GetListener, ());
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &));
-  LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumArguments, ());
-  LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetArguments,
-                       (const char **, bool));
-  LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries, ());
-  LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
-                       (const char **, bool));
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, Clear, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetWorkingDirectory,
-                             ());
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetWorkingDirectory,
-                       (const char *));
-  LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetLaunchFlags, ());
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t));
-  LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetProcessPluginName, ());
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetProcessPluginName,
-                       (const char *));
-  LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetShell, ());
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShell, (const char *));
-  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GetShellExpandArguments, ());
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool));
-  LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetResumeCount, ());
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int));
-  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction,
-                       (int, int));
-  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
-                       (int, const char *, bool, bool));
-  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
-                       (int, bool, bool));
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchEventData,
-                       (const char *));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetLaunchEventData,
-                             ());
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBLaunchInfo, GetDetachOnError, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo,
-                             GetScriptedProcessClassName, ());
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetScriptedProcessClassName,
-                       (const char *));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBLaunchInfo,
-                             GetScriptedProcessDictionary, ());
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetScriptedProcessDictionary,
-                       (lldb::SBStructuredData));
-  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironment,
-                       (const lldb::SBEnvironment &, bool));
-  LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBLaunchInfo, GetEnvironment, ());
-}
-
-}
-}
diff --git a/lldb/source/API/SBLineEntry.cpp b/lldb/source/API/SBLineEntry.cpp
index 29ffda9b0471..28d12e65fdaf 100644
--- a/lldb/source/API/SBLineEntry.cpp
+++ b/lldb/source/API/SBLineEntry.cpp
@@ -7,11 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBLineEntry.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Symbol/LineEntry.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/StreamString.h"
 
 #include <climits>
@@ -19,29 +19,25 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBLineEntry::SBLineEntry() : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBLineEntry);
-}
+SBLineEntry::SBLineEntry() { LLDB_INSTRUMENT_VA(this); }
 
-SBLineEntry::SBLineEntry(const SBLineEntry &rhs) : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &), rhs);
+SBLineEntry::SBLineEntry(const SBLineEntry &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
-SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr)
-    : m_opaque_up() {
+SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr) {
   if (lldb_object_ptr)
     m_opaque_up = std::make_unique<LineEntry>(*lldb_object_ptr);
 }
 
 const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBLineEntry &,
-                     SBLineEntry, operator=,(const lldb::SBLineEntry &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 void SBLineEntry::SetLineEntry(const lldb_private::LineEntry &lldb_object_ref) {
@@ -51,49 +47,48 @@ void SBLineEntry::SetLineEntry(const lldb_private::LineEntry &lldb_object_ref) {
 SBLineEntry::~SBLineEntry() = default;
 
 SBAddress SBLineEntry::GetStartAddress() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry,
-                                   GetStartAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   SBAddress sb_address;
   if (m_opaque_up)
     sb_address.SetAddress(m_opaque_up->range.GetBaseAddress());
 
-  return LLDB_RECORD_RESULT(sb_address);
+  return sb_address;
 }
 
 SBAddress SBLineEntry::GetEndAddress() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, GetEndAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   SBAddress sb_address;
   if (m_opaque_up) {
     sb_address.SetAddress(m_opaque_up->range.GetBaseAddress());
     sb_address.OffsetAddress(m_opaque_up->range.GetByteSize());
   }
-  return LLDB_RECORD_RESULT(sb_address);
+  return sb_address;
 }
 
 bool SBLineEntry::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBLineEntry::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up.get() && m_opaque_up->IsValid();
 }
 
 SBFileSpec SBLineEntry::GetFileSpec() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBLineEntry, GetFileSpec);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFileSpec sb_file_spec;
   if (m_opaque_up.get() && m_opaque_up->file)
     sb_file_spec.SetFileSpec(m_opaque_up->file);
 
-  return LLDB_RECORD_RESULT(sb_file_spec);
+  return sb_file_spec;
 }
 
 uint32_t SBLineEntry::GetLine() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetLine);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t line = 0;
   if (m_opaque_up)
@@ -103,7 +98,7 @@ uint32_t SBLineEntry::GetLine() const {
 }
 
 uint32_t SBLineEntry::GetColumn() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetColumn);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up)
     return m_opaque_up->column;
@@ -111,8 +106,7 @@ uint32_t SBLineEntry::GetColumn() const {
 }
 
 void SBLineEntry::SetFileSpec(lldb::SBFileSpec filespec) {
-  LLDB_RECORD_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec),
-                     filespec);
+  LLDB_INSTRUMENT_VA(this, filespec);
 
   if (filespec.IsValid())
     ref().file = filespec.ref();
@@ -120,20 +114,19 @@ void SBLineEntry::SetFileSpec(lldb::SBFileSpec filespec) {
     ref().file.Clear();
 }
 void SBLineEntry::SetLine(uint32_t line) {
-  LLDB_RECORD_METHOD(void, SBLineEntry, SetLine, (uint32_t), line);
+  LLDB_INSTRUMENT_VA(this, line);
 
   ref().line = line;
 }
 
 void SBLineEntry::SetColumn(uint32_t column) {
-  LLDB_RECORD_METHOD(void, SBLineEntry, SetColumn, (uint32_t), column);
+  LLDB_INSTRUMENT_VA(this, column);
 
   ref().line = column;
 }
 
 bool SBLineEntry::operator==(const SBLineEntry &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBLineEntry, operator==,(const lldb::SBLineEntry &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
   lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
@@ -145,8 +138,7 @@ bool SBLineEntry::operator==(const SBLineEntry &rhs) const {
 }
 
 bool SBLineEntry::operator!=(const SBLineEntry &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
   lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
@@ -170,8 +162,7 @@ lldb_private::LineEntry &SBLineEntry::ref() {
 const lldb_private::LineEntry &SBLineEntry::ref() const { return *m_opaque_up; }
 
 bool SBLineEntry::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -188,33 +179,3 @@ bool SBLineEntry::GetDescription(SBStream &description) {
 }
 
 lldb_private::LineEntry *SBLineEntry::get() { return m_opaque_up.get(); }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBLineEntry>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &));
-  LLDB_REGISTER_METHOD(const lldb::SBLineEntry &,
-                       SBLineEntry, operator=,(const lldb::SBLineEntry &));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetStartAddress,
-                             ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetEndAddress, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, operator bool, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBLineEntry, GetFileSpec, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetLine, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetColumn, ());
-  LLDB_REGISTER_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec));
-  LLDB_REGISTER_METHOD(void, SBLineEntry, SetLine, (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBLineEntry, SetColumn, (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBLineEntry, operator==,(const lldb::SBLineEntry &));
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &));
-  LLDB_REGISTER_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBListener.cpp b/lldb/source/API/SBListener.cpp
index 6e5e15de7b3d..2ce17a5f521d 100644
--- a/lldb/source/API/SBListener.cpp
+++ b/lldb/source/API/SBListener.cpp
@@ -7,42 +7,39 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBListener.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Utility/Broadcaster.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Listener.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBListener::SBListener() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBListener);
-}
+SBListener::SBListener() { LLDB_INSTRUMENT_VA(this); }
 
 SBListener::SBListener(const char *name)
     : m_opaque_sp(Listener::MakeListener(name)), m_unused_ptr(nullptr) {
-  LLDB_RECORD_CONSTRUCTOR(SBListener, (const char *), name);
+  LLDB_INSTRUMENT_VA(this, name);
 }
 
 SBListener::SBListener(const SBListener &rhs)
     : m_opaque_sp(rhs.m_opaque_sp), m_unused_ptr(nullptr) {
-  LLDB_RECORD_CONSTRUCTOR(SBListener, (const lldb::SBListener &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBListener &,
-                     SBListener, operator=,(const lldb::SBListener &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
     m_unused_ptr = nullptr;
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBListener::SBListener(const lldb::ListenerSP &listener_sp)
@@ -51,18 +48,17 @@ SBListener::SBListener(const lldb::ListenerSP &listener_sp)
 SBListener::~SBListener() = default;
 
 bool SBListener::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBListener::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp != nullptr;
 }
 
 void SBListener::AddEvent(const SBEvent &event) {
-  LLDB_RECORD_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &),
-                     event);
+  LLDB_INSTRUMENT_VA(this, event);
 
   EventSP &event_sp = event.GetSP();
   if (event_sp)
@@ -70,7 +66,7 @@ void SBListener::AddEvent(const SBEvent &event) {
 }
 
 void SBListener::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBListener, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     m_opaque_sp->Clear();
@@ -79,9 +75,7 @@ void SBListener::Clear() {
 uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger,
                                                  const char *broadcaster_class,
                                                  uint32_t event_mask) {
-  LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEventClass,
-                     (lldb::SBDebugger &, const char *, uint32_t), debugger,
-                     broadcaster_class, event_mask);
+  LLDB_INSTRUMENT_VA(this, debugger, broadcaster_class, event_mask);
 
   if (m_opaque_sp) {
     Debugger *lldb_debugger = debugger.get();
@@ -97,9 +91,7 @@ uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger,
 bool SBListener::StopListeningForEventClass(SBDebugger &debugger,
                                             const char *broadcaster_class,
                                             uint32_t event_mask) {
-  LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEventClass,
-                     (lldb::SBDebugger &, const char *, uint32_t), debugger,
-                     broadcaster_class, event_mask);
+  LLDB_INSTRUMENT_VA(this, debugger, broadcaster_class, event_mask);
 
   if (m_opaque_sp) {
     Debugger *lldb_debugger = debugger.get();
@@ -114,9 +106,7 @@ bool SBListener::StopListeningForEventClass(SBDebugger &debugger,
 
 uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster,
                                              uint32_t event_mask) {
-  LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEvents,
-                     (const lldb::SBBroadcaster &, uint32_t), broadcaster,
-                     event_mask);
+  LLDB_INSTRUMENT_VA(this, broadcaster, event_mask);
 
   uint32_t acquired_event_mask = 0;
   if (m_opaque_sp && broadcaster.IsValid()) {
@@ -129,9 +119,7 @@ uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster,
 
 bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
                                         uint32_t event_mask) {
-  LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEvents,
-                     (const lldb::SBBroadcaster &, uint32_t), broadcaster,
-                     event_mask);
+  LLDB_INSTRUMENT_VA(this, broadcaster, event_mask);
 
   if (m_opaque_sp && broadcaster.IsValid()) {
     return m_opaque_sp->StopListeningForEvents(broadcaster.get(), event_mask);
@@ -140,8 +128,7 @@ bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
 }
 
 bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
-  LLDB_RECORD_METHOD(bool, SBListener, WaitForEvent,
-                     (uint32_t, lldb::SBEvent &), timeout_secs, event);
+  LLDB_INSTRUMENT_VA(this, timeout_secs, event);
 
   bool success = false;
 
@@ -167,9 +154,7 @@ bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
 bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds,
                                             const SBBroadcaster &broadcaster,
                                             SBEvent &event) {
-  LLDB_RECORD_METHOD(bool, SBListener, WaitForEventForBroadcaster,
-                     (uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &),
-                     num_seconds, broadcaster, event);
+  LLDB_INSTRUMENT_VA(this, num_seconds, broadcaster, event);
 
   if (m_opaque_sp && broadcaster.IsValid()) {
     Timeout<std::micro> timeout(llvm::None);
@@ -189,10 +174,7 @@ bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds,
 bool SBListener::WaitForEventForBroadcasterWithType(
     uint32_t num_seconds, const SBBroadcaster &broadcaster,
     uint32_t event_type_mask, SBEvent &event) {
-  LLDB_RECORD_METHOD(
-      bool, SBListener, WaitForEventForBroadcasterWithType,
-      (uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &),
-      num_seconds, broadcaster, event_type_mask, event);
+  LLDB_INSTRUMENT_VA(this, num_seconds, broadcaster, event_type_mask, event);
 
   if (m_opaque_sp && broadcaster.IsValid()) {
     Timeout<std::micro> timeout(llvm::None);
@@ -210,8 +192,7 @@ bool SBListener::WaitForEventForBroadcasterWithType(
 }
 
 bool SBListener::PeekAtNextEvent(SBEvent &event) {
-  LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &),
-                     event);
+  LLDB_INSTRUMENT_VA(this, event);
 
   if (m_opaque_sp) {
     event.reset(m_opaque_sp->PeekAtNextEvent());
@@ -223,9 +204,7 @@ bool SBListener::PeekAtNextEvent(SBEvent &event) {
 
 bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
                                                SBEvent &event) {
-  LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
-                     (const lldb::SBBroadcaster &, lldb::SBEvent &),
-                     broadcaster, event);
+  LLDB_INSTRUMENT_VA(this, broadcaster, event);
 
   if (m_opaque_sp && broadcaster.IsValid()) {
     event.reset(m_opaque_sp->PeekAtNextEventForBroadcaster(broadcaster.get()));
@@ -238,9 +217,7 @@ bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
 bool SBListener::PeekAtNextEventForBroadcasterWithType(
     const SBBroadcaster &broadcaster, uint32_t event_type_mask,
     SBEvent &event) {
-  LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcasterWithType,
-                     (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &),
-                     broadcaster, event_type_mask, event);
+  LLDB_INSTRUMENT_VA(this, broadcaster, event_type_mask, event);
 
   if (m_opaque_sp && broadcaster.IsValid()) {
     event.reset(m_opaque_sp->PeekAtNextEventForBroadcasterWithType(
@@ -252,7 +229,7 @@ bool SBListener::PeekAtNextEventForBroadcasterWithType(
 }
 
 bool SBListener::GetNextEvent(SBEvent &event) {
-  LLDB_RECORD_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(this, event);
 
   if (m_opaque_sp) {
     EventSP event_sp;
@@ -267,9 +244,7 @@ bool SBListener::GetNextEvent(SBEvent &event) {
 
 bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
                                             SBEvent &event) {
-  LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcaster,
-                     (const lldb::SBBroadcaster &, lldb::SBEvent &),
-                     broadcaster, event);
+  LLDB_INSTRUMENT_VA(this, broadcaster, event);
 
   if (m_opaque_sp && broadcaster.IsValid()) {
     EventSP event_sp;
@@ -286,9 +261,7 @@ bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
 bool SBListener::GetNextEventForBroadcasterWithType(
     const SBBroadcaster &broadcaster, uint32_t event_type_mask,
     SBEvent &event) {
-  LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcasterWithType,
-                     (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &),
-                     broadcaster, event_type_mask, event);
+  LLDB_INSTRUMENT_VA(this, broadcaster, event_type_mask, event);
 
   if (m_opaque_sp && broadcaster.IsValid()) {
     EventSP event_sp;
@@ -304,8 +277,7 @@ bool SBListener::GetNextEventForBroadcasterWithType(
 }
 
 bool SBListener::HandleBroadcastEvent(const SBEvent &event) {
-  LLDB_RECORD_METHOD(bool, SBListener, HandleBroadcastEvent,
-                     (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(this, event);
 
   if (m_opaque_sp)
     return m_opaque_sp->HandleBroadcastEvent(event.GetSP());
@@ -322,52 +294,3 @@ void SBListener::reset(ListenerSP listener_sp) {
   m_opaque_sp = listener_sp;
   m_unused_ptr = nullptr;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBListener>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBListener, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBListener, (const char *));
-  LLDB_REGISTER_CONSTRUCTOR(SBListener, (const lldb::SBListener &));
-  LLDB_REGISTER_METHOD(const lldb::SBListener &,
-                       SBListener, operator=,(const lldb::SBListener &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBListener, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBListener, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(void, SBListener, Clear, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEventClass,
-                       (lldb::SBDebugger &, const char *, uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEventClass,
-                       (lldb::SBDebugger &, const char *, uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEvents,
-                       (const lldb::SBBroadcaster &, uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEvents,
-                       (const lldb::SBBroadcaster &, uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBListener, WaitForEvent,
-                       (uint32_t, lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(
-      bool, SBListener, WaitForEventForBroadcaster,
-      (uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(
-      bool, SBListener, WaitForEventForBroadcasterWithType,
-      (uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
-                       (const lldb::SBBroadcaster &, lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(
-      bool, SBListener, PeekAtNextEventForBroadcasterWithType,
-      (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(bool, SBListener, GetNextEventForBroadcaster,
-                       (const lldb::SBBroadcaster &, lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(
-      bool, SBListener, GetNextEventForBroadcasterWithType,
-      (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
-  LLDB_REGISTER_METHOD(bool, SBListener, HandleBroadcastEvent,
-                       (const lldb::SBEvent &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBMemoryRegionInfo.cpp b/lldb/source/API/SBMemoryRegionInfo.cpp
index 9cf7874b54a3..7d9db478dde1 100644
--- a/lldb/source/API/SBMemoryRegionInfo.cpp
+++ b/lldb/source/API/SBMemoryRegionInfo.cpp
@@ -7,29 +7,26 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBMemoryRegionInfo.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBMemoryRegionInfo::SBMemoryRegionInfo() : m_opaque_up(new MemoryRegionInfo()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfo);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBMemoryRegionInfo::SBMemoryRegionInfo(const char *name, lldb::addr_t begin,
                                        lldb::addr_t end, uint32_t permissions,
                                        bool mapped, bool stack_memory)
     : SBMemoryRegionInfo() {
-  LLDB_RECORD_CONSTRUCTOR(
-      SBMemoryRegionInfo,
-      (const char *, lldb::addr_t, lldb::addr_t, uint32_t, bool, bool), name,
-      begin, end, permissions, mapped, stack_memory);
+  LLDB_INSTRUMENT_VA(this, name, begin, end, permissions, mapped, stack_memory);
   m_opaque_up->SetName(name);
   m_opaque_up->GetRange().SetRangeBase(begin);
   m_opaque_up->GetRange().SetRangeEnd(end);
@@ -46,44 +43,36 @@ SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr)
     ref() = *lldb_object_ptr;
 }
 
-SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs)
-    : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfo,
-                          (const lldb::SBMemoryRegionInfo &), rhs);
+SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 const SBMemoryRegionInfo &SBMemoryRegionInfo::
 operator=(const SBMemoryRegionInfo &rhs) {
-  LLDB_RECORD_METHOD(
-      const lldb::SBMemoryRegionInfo &,
-      SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBMemoryRegionInfo::~SBMemoryRegionInfo() = default;
 
 void SBMemoryRegionInfo::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfo, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_up->Clear();
 }
 
 bool SBMemoryRegionInfo::operator==(const SBMemoryRegionInfo &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &),
-      rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return ref() == rhs.ref();
 }
 
 bool SBMemoryRegionInfo::operator!=(const SBMemoryRegionInfo &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &),
-      rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return ref() != rhs.ref();
 }
@@ -93,55 +82,55 @@ MemoryRegionInfo &SBMemoryRegionInfo::ref() { return *m_opaque_up; }
 const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; }
 
 lldb::addr_t SBMemoryRegionInfo::GetRegionBase() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetRange().GetRangeBase();
 }
 
 lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetRange().GetRangeEnd();
 }
 
 bool SBMemoryRegionInfo::IsReadable() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsReadable);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes;
 }
 
 bool SBMemoryRegionInfo::IsWritable() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsWritable);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes;
 }
 
 bool SBMemoryRegionInfo::IsExecutable() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsExecutable);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes;
 }
 
 bool SBMemoryRegionInfo::IsMapped() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsMapped);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes;
 }
 
 const char *SBMemoryRegionInfo::GetName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetName().AsCString();
 }
 
 bool SBMemoryRegionInfo::HasDirtyMemoryPageList() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, HasDirtyMemoryPageList);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetDirtyPageList().hasValue();
 }
 
 uint32_t SBMemoryRegionInfo::GetNumDirtyPages() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBMemoryRegionInfo, GetNumDirtyPages);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t num_dirty_pages = 0;
   llvm::Optional<std::vector<addr_t>> dirty_page_list =
@@ -153,8 +142,7 @@ uint32_t SBMemoryRegionInfo::GetNumDirtyPages() {
 }
 
 addr_t SBMemoryRegionInfo::GetDirtyPageAddressAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::addr_t, SBMemoryRegionInfo,
-                     GetDirtyPageAddressAtIndex, (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   addr_t dirty_page_addr = LLDB_INVALID_ADDRESS;
   const llvm::Optional<std::vector<addr_t>> &dirty_page_list =
@@ -166,14 +154,13 @@ addr_t SBMemoryRegionInfo::GetDirtyPageAddressAtIndex(uint32_t idx) {
 }
 
 int SBMemoryRegionInfo::GetPageSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(int, SBMemoryRegionInfo, GetPageSize);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetPageSize();
 }
 
 bool SBMemoryRegionInfo::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription,
-                     (lldb::SBStream &), description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
   const addr_t load_addr = m_opaque_up->GetRange().base;
@@ -187,42 +174,3 @@ bool SBMemoryRegionInfo::GetDescription(SBStream &description) {
 
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBMemoryRegionInfo>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo,
-                            (const lldb::SBMemoryRegionInfo &));
-  LLDB_REGISTER_CONSTRUCTOR(
-      SBMemoryRegionInfo,
-      (const char *, lldb::addr_t, lldb::addr_t, uint32_t, bool, bool));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBMemoryRegionInfo &,
-      SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &));
-  LLDB_REGISTER_METHOD(void, SBMemoryRegionInfo, Clear, ());
-  LLDB_REGISTER_METHOD_CONST(
-      bool,
-      SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &));
-  LLDB_REGISTER_METHOD_CONST(
-      bool,
-      SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &));
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase, ());
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd, ());
-  LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsReadable, ());
-  LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsWritable, ());
-  LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsExecutable, ());
-  LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsMapped, ());
-  LLDB_REGISTER_METHOD(const char *, SBMemoryRegionInfo, GetName, ());
-  LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, GetDescription,
-                       (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, HasDirtyMemoryPageList, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBMemoryRegionInfo, GetNumDirtyPages, ());
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetDirtyPageAddressAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(int, SBMemoryRegionInfo, GetPageSize, ());
-}
-
-}
-}
diff --git a/lldb/source/API/SBMemoryRegionInfoList.cpp b/lldb/source/API/SBMemoryRegionInfoList.cpp
index cd8fc00ffce0..39dee86dc300 100644
--- a/lldb/source/API/SBMemoryRegionInfoList.cpp
+++ b/lldb/source/API/SBMemoryRegionInfoList.cpp
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBMemoryRegionInfoList.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBMemoryRegionInfo.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include <vector>
 
@@ -83,70 +83,61 @@ const MemoryRegionInfos &SBMemoryRegionInfoList::ref() const {
 
 SBMemoryRegionInfoList::SBMemoryRegionInfoList()
     : m_opaque_up(new MemoryRegionInfoListImpl()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfoList);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBMemoryRegionInfoList::SBMemoryRegionInfoList(
     const SBMemoryRegionInfoList &rhs)
     : m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) {
-  LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfoList,
-                          (const lldb::SBMemoryRegionInfoList &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBMemoryRegionInfoList::~SBMemoryRegionInfoList() = default;
 
 const SBMemoryRegionInfoList &SBMemoryRegionInfoList::
 operator=(const SBMemoryRegionInfoList &rhs) {
-  LLDB_RECORD_METHOD(
-      const lldb::SBMemoryRegionInfoList &,
-      SBMemoryRegionInfoList, operator=,(const lldb::SBMemoryRegionInfoList &),
-      rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     *m_opaque_up = *rhs.m_opaque_up;
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 uint32_t SBMemoryRegionInfoList::GetSize() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetSize();
 }
 
 bool SBMemoryRegionInfoList::GetMemoryRegionContainingAddress(
     lldb::addr_t addr, SBMemoryRegionInfo &region_info) {
-  LLDB_RECORD_METHOD(
-      bool, SBMemoryRegionInfoList, GetMemoryRegionContainingAddress,
-      (lldb::addr_t, lldb::SBMemoryRegionInfo &), addr, region_info);
+  LLDB_INSTRUMENT_VA(this, addr, region_info);
 
   return m_opaque_up->GetMemoryRegionContainingAddress(addr, region_info.ref());
 }
 
 bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
     uint32_t idx, SBMemoryRegionInfo &region_info) {
-  LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
-                     (uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info);
+  LLDB_INSTRUMENT_VA(this, idx, region_info);
 
   return m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref());
 }
 
 void SBMemoryRegionInfoList::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfoList, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_up->Clear();
 }
 
 void SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region) {
-  LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,
-                     (lldb::SBMemoryRegionInfo &), sb_region);
+  LLDB_INSTRUMENT_VA(this, sb_region);
 
   m_opaque_up->Append(sb_region.ref());
 }
 
 void SBMemoryRegionInfoList::Append(SBMemoryRegionInfoList &sb_region_list) {
-  LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,
-                     (lldb::SBMemoryRegionInfoList &), sb_region_list);
+  LLDB_INSTRUMENT_VA(this, sb_region_list);
 
   m_opaque_up->Append(*sb_region_list);
 }
@@ -159,31 +150,3 @@ const MemoryRegionInfoListImpl &SBMemoryRegionInfoList::operator*() const {
   assert(m_opaque_up.get());
   return *m_opaque_up;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBMemoryRegionInfoList>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList,
-                            (const lldb::SBMemoryRegionInfoList &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBMemoryRegionInfoList &,
-      SBMemoryRegionInfoList, operator=,(
-                                  const lldb::SBMemoryRegionInfoList &));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBMemoryRegionInfoList, GetSize, ());
-  LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfoList,
-                       GetMemoryRegionContainingAddress,
-                       (lldb::addr_t, lldb::SBMemoryRegionInfo &));
-  LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
-                       (uint32_t, lldb::SBMemoryRegionInfo &));
-  LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Clear, ());
-  LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
-                       (lldb::SBMemoryRegionInfo &));
-  LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
-                       (lldb::SBMemoryRegionInfoList &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBModule.cpp b/lldb/source/API/SBModule.cpp
index 710ee8551bd6..1454012d3eb9 100644
--- a/lldb/source/API/SBModule.cpp
+++ b/lldb/source/API/SBModule.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBModule.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBModuleSpec.h"
@@ -24,19 +23,18 @@
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBModule::SBModule() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModule);
-}
+SBModule::SBModule() { LLDB_INSTRUMENT_VA(this); }
 
 SBModule::SBModule(const lldb::ModuleSP &module_sp) : m_opaque_sp(module_sp) {}
 
-SBModule::SBModule(const SBModuleSpec &module_spec) : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &), module_spec);
+SBModule::SBModule(const SBModuleSpec &module_spec) {
+  LLDB_INSTRUMENT_VA(this, module_spec);
 
   ModuleSP module_sp;
   Status error = ModuleList::GetSharedModule(
@@ -46,13 +44,11 @@ SBModule::SBModule(const SBModuleSpec &module_spec) : m_opaque_sp() {
 }
 
 SBModule::SBModule(const SBModule &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModule &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
-SBModule::SBModule(lldb::SBProcess &process, lldb::addr_t header_addr)
-    : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t), process,
-                          header_addr);
+SBModule::SBModule(lldb::SBProcess &process, lldb::addr_t header_addr) {
+  LLDB_INSTRUMENT_VA(this, process, header_addr);
 
   ProcessSP process_sp(process.GetSP());
   if (process_sp) {
@@ -67,58 +63,69 @@ SBModule::SBModule(lldb::SBProcess &process, lldb::addr_t header_addr)
 }
 
 const SBModule &SBModule::operator=(const SBModule &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBModule &, SBModule, operator=,
-                     (const lldb::SBModule &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBModule::~SBModule() = default;
 
 bool SBModule::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBModule::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 void SBModule::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_sp.reset();
 }
 
+bool SBModule::IsFileBacked() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  ModuleSP module_sp(GetSP());
+  if (!module_sp)
+    return false;
+
+  ObjectFile *obj_file = module_sp->GetObjectFile();
+  if (!obj_file)
+    return false;
+
+  return !obj_file->IsInMemory();
+}
+
 SBFileSpec SBModule::GetFileSpec() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetFileSpec);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFileSpec file_spec;
   ModuleSP module_sp(GetSP());
   if (module_sp)
     file_spec.SetFileSpec(module_sp->GetFileSpec());
 
-  return LLDB_RECORD_RESULT(file_spec);
+  return file_spec;
 }
 
 lldb::SBFileSpec SBModule::GetPlatformFileSpec() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
-                                   GetPlatformFileSpec);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFileSpec file_spec;
   ModuleSP module_sp(GetSP());
   if (module_sp)
     file_spec.SetFileSpec(module_sp->GetPlatformFileSpec());
 
-  return LLDB_RECORD_RESULT(file_spec);
+  return file_spec;
 }
 
 bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
-  LLDB_RECORD_METHOD(bool, SBModule, SetPlatformFileSpec,
-                     (const lldb::SBFileSpec &), platform_file);
+  LLDB_INSTRUMENT_VA(this, platform_file);
 
   bool result = false;
 
@@ -132,19 +139,17 @@ bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
 }
 
 lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModule,
-                             GetRemoteInstallFileSpec);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFileSpec sb_file_spec;
   ModuleSP module_sp(GetSP());
   if (module_sp)
     sb_file_spec.SetFileSpec(module_sp->GetRemoteInstallFileSpec());
-  return LLDB_RECORD_RESULT(sb_file_spec);
+  return sb_file_spec;
 }
 
 bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) {
-  LLDB_RECORD_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
-                     (lldb::SBFileSpec &), file);
+  LLDB_INSTRUMENT_VA(this, file);
 
   ModuleSP module_sp(GetSP());
   if (module_sp) {
@@ -155,7 +160,7 @@ bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) {
 }
 
 const uint8_t *SBModule::GetUUIDBytes() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const uint8_t *, SBModule, GetUUIDBytes);
+  LLDB_INSTRUMENT_VA(this);
 
   const uint8_t *uuid_bytes = nullptr;
   ModuleSP module_sp(GetSP());
@@ -166,7 +171,7 @@ const uint8_t *SBModule::GetUUIDBytes() const {
 }
 
 const char *SBModule::GetUUIDString() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *uuid_cstr = nullptr;
   ModuleSP module_sp(GetSP());
@@ -186,8 +191,7 @@ const char *SBModule::GetUUIDString() const {
 }
 
 bool SBModule::operator==(const SBModule &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBModule, operator==, (const lldb::SBModule &),
-                           rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (m_opaque_sp)
     return m_opaque_sp.get() == rhs.m_opaque_sp.get();
@@ -195,8 +199,7 @@ bool SBModule::operator==(const SBModule &rhs) const {
 }
 
 bool SBModule::operator!=(const SBModule &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBModule, operator!=, (const lldb::SBModule &),
-                           rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (m_opaque_sp)
     return m_opaque_sp.get() != rhs.m_opaque_sp.get();
@@ -208,8 +211,7 @@ ModuleSP SBModule::GetSP() const { return m_opaque_sp; }
 void SBModule::SetSP(const ModuleSP &module_sp) { m_opaque_sp = module_sp; }
 
 SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) {
-  LLDB_RECORD_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
-                     (lldb::addr_t), vm_addr);
+  LLDB_INSTRUMENT_VA(this, vm_addr);
 
   lldb::SBAddress sb_addr;
   ModuleSP module_sp(GetSP());
@@ -218,27 +220,24 @@ SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) {
     if (module_sp->ResolveFileAddress(vm_addr, addr))
       sb_addr.ref() = addr;
   }
-  return LLDB_RECORD_RESULT(sb_addr);
+  return sb_addr;
 }
 
 SBSymbolContext
 SBModule::ResolveSymbolContextForAddress(const SBAddress &addr,
                                          uint32_t resolve_scope) {
-  LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBModule,
-                     ResolveSymbolContextForAddress,
-                     (const lldb::SBAddress &, uint32_t), addr, resolve_scope);
+  LLDB_INSTRUMENT_VA(this, addr, resolve_scope);
 
   SBSymbolContext sb_sc;
   ModuleSP module_sp(GetSP());
   SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
   if (module_sp && addr.IsValid())
     module_sp->ResolveSymbolContextForAddress(addr.ref(), scope, *sb_sc);
-  return LLDB_RECORD_RESULT(sb_sc);
+  return sb_sc;
 }
 
 bool SBModule::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -252,7 +251,7 @@ bool SBModule::GetDescription(SBStream &description) {
 }
 
 uint32_t SBModule::GetNumCompileUnits() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits);
+  LLDB_INSTRUMENT_VA(this);
 
   ModuleSP module_sp(GetSP());
   if (module_sp) {
@@ -262,8 +261,7 @@ uint32_t SBModule::GetNumCompileUnits() {
 }
 
 SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
-                     (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   SBCompileUnit sb_cu;
   ModuleSP module_sp(GetSP());
@@ -271,19 +269,18 @@ SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) {
     CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(index);
     sb_cu.reset(cu_sp.get());
   }
-  return LLDB_RECORD_RESULT(sb_cu);
+  return sb_cu;
 }
 
 SBSymbolContextList SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) {
-  LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
-                     (const lldb::SBFileSpec &), sb_file_spec);
+  LLDB_INSTRUMENT_VA(this, sb_file_spec);
 
   SBSymbolContextList sb_sc_list;
   const ModuleSP module_sp(GetSP());
   if (sb_file_spec.IsValid() && module_sp) {
     module_sp->FindCompileUnits(*sb_file_spec, *sb_sc_list);
   }
-  return LLDB_RECORD_RESULT(sb_sc_list);
+  return sb_sc_list;
 }
 
 static Symtab *GetUnifiedSymbolTable(const lldb::ModuleSP &module_sp) {
@@ -293,7 +290,7 @@ static Symtab *GetUnifiedSymbolTable(const lldb::ModuleSP &module_sp) {
 }
 
 size_t SBModule::GetNumSymbols() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols);
+  LLDB_INSTRUMENT_VA(this);
 
   ModuleSP module_sp(GetSP());
   if (Symtab *symtab = GetUnifiedSymbolTable(module_sp))
@@ -302,20 +299,19 @@ size_t SBModule::GetNumSymbols() {
 }
 
 SBSymbol SBModule::GetSymbolAtIndex(size_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBSymbol sb_symbol;
   ModuleSP module_sp(GetSP());
   Symtab *symtab = GetUnifiedSymbolTable(module_sp);
   if (symtab)
     sb_symbol.SetSymbol(symtab->SymbolAtIndex(idx));
-  return LLDB_RECORD_RESULT(sb_symbol);
+  return sb_symbol;
 }
 
 lldb::SBSymbol SBModule::FindSymbol(const char *name,
                                     lldb::SymbolType symbol_type) {
-  LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, FindSymbol,
-                     (const char *, lldb::SymbolType), name, symbol_type);
+  LLDB_INSTRUMENT_VA(this, name, symbol_type);
 
   SBSymbol sb_symbol;
   if (name && name[0]) {
@@ -326,13 +322,12 @@ lldb::SBSymbol SBModule::FindSymbol(const char *name,
           ConstString(name), symbol_type, Symtab::eDebugAny,
           Symtab::eVisibilityAny));
   }
-  return LLDB_RECORD_RESULT(sb_symbol);
+  return sb_symbol;
 }
 
 lldb::SBSymbolContextList SBModule::FindSymbols(const char *name,
                                                 lldb::SymbolType symbol_type) {
-  LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
-                     (const char *, lldb::SymbolType), name, symbol_type);
+  LLDB_INSTRUMENT_VA(this, name, symbol_type);
 
   SBSymbolContextList sb_sc_list;
   if (name && name[0]) {
@@ -355,11 +350,11 @@ lldb::SBSymbolContextList SBModule::FindSymbols(const char *name,
       }
     }
   }
-  return LLDB_RECORD_RESULT(sb_sc_list);
+  return sb_sc_list;
 }
 
 size_t SBModule::GetNumSections() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSections);
+  LLDB_INSTRUMENT_VA(this);
 
   ModuleSP module_sp(GetSP());
   if (module_sp) {
@@ -373,8 +368,7 @@ size_t SBModule::GetNumSections() {
 }
 
 SBSection SBModule::GetSectionAtIndex(size_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBSection sb_section;
   ModuleSP module_sp(GetSP());
@@ -386,13 +380,12 @@ SBSection SBModule::GetSectionAtIndex(size_t idx) {
     if (section_list)
       sb_section.SetSP(section_list->GetSectionAtIndex(idx));
   }
-  return LLDB_RECORD_RESULT(sb_section);
+  return sb_section;
 }
 
 lldb::SBSymbolContextList SBModule::FindFunctions(const char *name,
                                                   uint32_t name_type_mask) {
-  LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
-                     (const char *, uint32_t), name, name_type_mask);
+  LLDB_INSTRUMENT_VA(this, name, name_type_mask);
 
   lldb::SBSymbolContextList sb_sc_list;
   ModuleSP module_sp(GetSP());
@@ -405,14 +398,12 @@ lldb::SBSymbolContextList SBModule::FindFunctions(const char *name,
     module_sp->FindFunctions(ConstString(name), CompilerDeclContext(), type,
                              function_options, *sb_sc_list);
   }
-  return LLDB_RECORD_RESULT(sb_sc_list);
+  return sb_sc_list;
 }
 
 SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
                                           uint32_t max_matches) {
-  LLDB_RECORD_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
-                     (lldb::SBTarget &, const char *, uint32_t), target, name,
-                     max_matches);
+  LLDB_INSTRUMENT_VA(this, target, name, max_matches);
 
   SBValueList sb_value_list;
   ModuleSP module_sp(GetSP());
@@ -429,23 +420,21 @@ SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_value_list);
+  return sb_value_list;
 }
 
 lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target,
                                                 const char *name) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
-                     (lldb::SBTarget &, const char *), target, name);
+  LLDB_INSTRUMENT_VA(this, target, name);
 
   SBValueList sb_value_list(FindGlobalVariables(target, name, 1));
   if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
-    return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0));
-  return LLDB_RECORD_RESULT(SBValue());
+    return sb_value_list.GetValueAtIndex(0);
+  return SBValue();
 }
 
 lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
-  LLDB_RECORD_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *),
-                     name_cstr);
+  LLDB_INSTRUMENT_VA(this, name_cstr);
 
   SBType sb_type;
   ModuleSP module_sp(GetSP());
@@ -461,17 +450,16 @@ lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
           module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
       if (auto err = type_system_or_err.takeError()) {
         llvm::consumeError(std::move(err));
-        return LLDB_RECORD_RESULT(SBType());
+        return SBType();
       }
       sb_type = SBType(type_system_or_err->GetBuiltinTypeByName(name));
     }
   }
-  return LLDB_RECORD_RESULT(sb_type);
+  return sb_type;
 }
 
 lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
-  LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType),
-                     type);
+  LLDB_INSTRUMENT_VA(this, type);
 
   ModuleSP module_sp(GetSP());
   if (module_sp) {
@@ -480,16 +468,14 @@ lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
     if (auto err = type_system_or_err.takeError()) {
       llvm::consumeError(std::move(err));
     } else {
-      return LLDB_RECORD_RESULT(
-          SBType(type_system_or_err->GetBasicTypeFromAST(type)));
+      return SBType(type_system_or_err->GetBasicTypeFromAST(type));
     }
   }
-  return LLDB_RECORD_RESULT(SBType());
+  return SBType();
 }
 
 lldb::SBTypeList SBModule::FindTypes(const char *type) {
-  LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *),
-                     type);
+  LLDB_INSTRUMENT_VA(this, type);
 
   SBTypeList retval;
 
@@ -521,47 +507,44 @@ lldb::SBTypeList SBModule::FindTypes(const char *type) {
       }
     }
   }
-  return LLDB_RECORD_RESULT(retval);
+  return retval;
 }
 
 lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) {
-  LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t),
-                     uid);
+  LLDB_INSTRUMENT_VA(this, uid);
 
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     if (SymbolFile *symfile = module_sp->GetSymbolFile()) {
       Type *type_ptr = symfile->ResolveTypeUID(uid);
       if (type_ptr)
-        return LLDB_RECORD_RESULT(SBType(type_ptr->shared_from_this()));
+        return SBType(type_ptr->shared_from_this());
     }
   }
-  return LLDB_RECORD_RESULT(SBType());
+  return SBType();
 }
 
 lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) {
-  LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t),
-                     type_mask);
+  LLDB_INSTRUMENT_VA(this, type_mask);
 
   SBTypeList sb_type_list;
 
   ModuleSP module_sp(GetSP());
   if (!module_sp)
-    return LLDB_RECORD_RESULT(sb_type_list);
+    return sb_type_list;
   SymbolFile *symfile = module_sp->GetSymbolFile();
   if (!symfile)
-    return LLDB_RECORD_RESULT(sb_type_list);
+    return sb_type_list;
 
   TypeClass type_class = static_cast<TypeClass>(type_mask);
   TypeList type_list;
   symfile->GetTypes(nullptr, type_class, type_list);
   sb_type_list.m_opaque_up->Append(type_list);
-  return LLDB_RECORD_RESULT(sb_type_list);
+  return sb_type_list;
 }
 
 SBSection SBModule::FindSection(const char *sect_name) {
-  LLDB_RECORD_METHOD(lldb::SBSection, SBModule, FindSection, (const char *),
-                     sect_name);
+  LLDB_INSTRUMENT_VA(this, sect_name);
 
   SBSection sb_section;
 
@@ -578,11 +561,11 @@ SBSection SBModule::FindSection(const char *sect_name) {
       }
     }
   }
-  return LLDB_RECORD_RESULT(sb_section);
+  return sb_section;
 }
 
 lldb::ByteOrder SBModule::GetByteOrder() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBModule, GetByteOrder);
+  LLDB_INSTRUMENT_VA(this);
 
   ModuleSP module_sp(GetSP());
   if (module_sp)
@@ -591,7 +574,7 @@ lldb::ByteOrder SBModule::GetByteOrder() {
 }
 
 const char *SBModule::GetTriple() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModule, GetTriple);
+  LLDB_INSTRUMENT_VA(this);
 
   ModuleSP module_sp(GetSP());
   if (module_sp) {
@@ -606,7 +589,7 @@ const char *SBModule::GetTriple() {
 }
 
 uint32_t SBModule::GetAddressByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetAddressByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   ModuleSP module_sp(GetSP());
   if (module_sp)
@@ -615,8 +598,7 @@ uint32_t SBModule::GetAddressByteSize() {
 }
 
 uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) {
-  LLDB_RECORD_METHOD(uint32_t, SBModule, GetVersion, (uint32_t *, uint32_t),
-                     versions, num_versions);
+  LLDB_INSTRUMENT_VA(this, versions, num_versions);
 
   llvm::VersionTuple version;
   if (ModuleSP module_sp = GetSP())
@@ -644,8 +626,7 @@ uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) {
 }
 
 lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
-                                   GetSymbolFileSpec);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBFileSpec sb_file_spec;
   ModuleSP module_sp(GetSP());
@@ -653,12 +634,11 @@ lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
     if (SymbolFile *symfile = module_sp->GetSymbolFile())
       sb_file_spec.SetFileSpec(symfile->GetObjectFile()->GetFileSpec());
   }
-  return LLDB_RECORD_RESULT(sb_file_spec);
+  return sb_file_spec;
 }
 
 lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
-                                   GetObjectFileHeaderAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBAddress sb_addr;
   ModuleSP module_sp(GetSP());
@@ -667,12 +647,11 @@ lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const {
     if (objfile_ptr)
       sb_addr.ref() = objfile_ptr->GetBaseAddress();
   }
-  return LLDB_RECORD_RESULT(sb_addr);
+  return sb_addr;
 }
 
 lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
-                                   GetObjectFileEntryPointAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBAddress sb_addr;
   ModuleSP module_sp(GetSP());
@@ -681,96 +660,18 @@ lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const {
     if (objfile_ptr)
       sb_addr.ref() = objfile_ptr->GetEntryPointAddress();
   }
-  return LLDB_RECORD_RESULT(sb_addr);
+  return sb_addr;
 }
 
 uint32_t SBModule::GetNumberAllocatedModules() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(uint32_t, SBModule,
-                                    GetNumberAllocatedModules);
+  LLDB_INSTRUMENT();
 
   return Module::GetNumberAllocatedModules();
 }
 
 void SBModule::GarbageCollectAllocatedModules() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBModule,
-                                    GarbageCollectAllocatedModules);
+  LLDB_INSTRUMENT();
 
   const bool mandatory = false;
   ModuleList::RemoveOrphanSharedModules(mandatory);
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <> void RegisterMethods<SBModule>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBModule, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &));
-  LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModule &));
-  LLDB_REGISTER_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t));
-  LLDB_REGISTER_METHOD(const lldb::SBModule &, SBModule, operator=,
-                       (const lldb::SBModule &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBModule, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBModule, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBModule, Clear, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetFileSpec, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetPlatformFileSpec,
-                             ());
-  LLDB_REGISTER_METHOD(bool, SBModule, SetPlatformFileSpec,
-                       (const lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModule, GetRemoteInstallFileSpec,
-                       ());
-  LLDB_REGISTER_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
-                       (lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBModule, GetUUIDString, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBModule, operator==,
-                             (const lldb::SBModule &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBModule, operator!=,
-                             (const lldb::SBModule &));
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
-                       (lldb::addr_t));
-  LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBModule,
-                       ResolveSymbolContextForAddress,
-                       (const lldb::SBAddress &, uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(uint32_t, SBModule, GetNumCompileUnits, ());
-  LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
-                       (const lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSymbols, ());
-  LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t));
-  LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, FindSymbol,
-                       (const char *, lldb::SymbolType));
-  LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
-                       (const char *, lldb::SymbolType));
-  LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSections, ());
-  LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t));
-  LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
-                       (const char *, uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
-                       (lldb::SBTarget &, const char *, uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
-                       (lldb::SBTarget &, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType));
-  LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t));
-  LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, FindSection, (const char *));
-  LLDB_REGISTER_METHOD(lldb::ByteOrder, SBModule, GetByteOrder, ());
-  LLDB_REGISTER_METHOD(const char *, SBModule, GetTriple, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBModule, GetAddressByteSize, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBModule, GetVersion, (uint32_t *, uint32_t));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetSymbolFileSpec, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
-                             GetObjectFileHeaderAddress, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
-                             GetObjectFileEntryPointAddress, ());
-  LLDB_REGISTER_STATIC_METHOD(uint32_t, SBModule, GetNumberAllocatedModules,
-                              ());
-  LLDB_REGISTER_STATIC_METHOD(void, SBModule, GarbageCollectAllocatedModules,
-                              ());
-}
-
-} // namespace repro
-} // namespace lldb_private
diff --git a/lldb/source/API/SBModuleSpec.cpp b/lldb/source/API/SBModuleSpec.cpp
index 5d88272a399b..7deba8e971f8 100644
--- a/lldb/source/API/SBModuleSpec.cpp
+++ b/lldb/source/API/SBModuleSpec.cpp
@@ -7,110 +7,105 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBModuleSpec.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpec);
+  LLDB_INSTRUMENT_VA(this);
 }
 
-SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &), rhs);
+SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBModuleSpec &,
-                     SBModuleSpec, operator=,(const lldb::SBModuleSpec &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBModuleSpec::~SBModuleSpec() = default;
 
 bool SBModuleSpec::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBModuleSpec::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->operator bool();
 }
 
 void SBModuleSpec::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBModuleSpec, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_up->Clear();
 }
 
 SBFileSpec SBModuleSpec::GetFileSpec() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetFileSpec);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFileSpec sb_spec(m_opaque_up->GetFileSpec());
-  return LLDB_RECORD_RESULT(sb_spec);
+  return sb_spec;
 }
 
 void SBModuleSpec::SetFileSpec(const lldb::SBFileSpec &sb_spec) {
-  LLDB_RECORD_METHOD(void, SBModuleSpec, SetFileSpec,
-                     (const lldb::SBFileSpec &), sb_spec);
+  LLDB_INSTRUMENT_VA(this, sb_spec);
 
   m_opaque_up->GetFileSpec() = *sb_spec;
 }
 
 lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec,
-                             GetPlatformFileSpec);
+  LLDB_INSTRUMENT_VA(this);
 
-  return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_up->GetPlatformFileSpec()));
+  return SBFileSpec(m_opaque_up->GetPlatformFileSpec());
 }
 
 void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) {
-  LLDB_RECORD_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
-                     (const lldb::SBFileSpec &), sb_spec);
+  LLDB_INSTRUMENT_VA(this, sb_spec);
 
   m_opaque_up->GetPlatformFileSpec() = *sb_spec;
 }
 
 lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec);
+  LLDB_INSTRUMENT_VA(this);
 
-  return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_up->GetSymbolFileSpec()));
+  return SBFileSpec(m_opaque_up->GetSymbolFileSpec());
 }
 
 void SBModuleSpec::SetSymbolFileSpec(const lldb::SBFileSpec &sb_spec) {
-  LLDB_RECORD_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
-                     (const lldb::SBFileSpec &), sb_spec);
+  LLDB_INSTRUMENT_VA(this, sb_spec);
 
   m_opaque_up->GetSymbolFileSpec() = *sb_spec;
 }
 
 const char *SBModuleSpec::GetObjectName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetObjectName);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetObjectName().GetCString();
 }
 
 void SBModuleSpec::SetObjectName(const char *name) {
-  LLDB_RECORD_METHOD(void, SBModuleSpec, SetObjectName, (const char *), name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   m_opaque_up->GetObjectName().SetCString(name);
 }
 
 const char *SBModuleSpec::GetTriple() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetTriple);
+  LLDB_INSTRUMENT_VA(this);
 
   std::string triple(m_opaque_up->GetArchitecture().GetTriple().str());
   // Unique the string so we don't run into ownership issues since the const
@@ -121,180 +116,114 @@ const char *SBModuleSpec::GetTriple() {
 }
 
 void SBModuleSpec::SetTriple(const char *triple) {
-  LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple);
+  LLDB_INSTRUMENT_VA(this, triple);
 
   m_opaque_up->GetArchitecture().SetTriple(triple);
 }
 
 const uint8_t *SBModuleSpec::GetUUIDBytes() {
+  LLDB_INSTRUMENT_VA(this)
   return m_opaque_up->GetUUID().GetBytes().data();
 }
 
 size_t SBModuleSpec::GetUUIDLength() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetUUID().GetBytes().size();
 }
 
 bool SBModuleSpec::SetUUIDBytes(const uint8_t *uuid, size_t uuid_len) {
+  LLDB_INSTRUMENT_VA(this, uuid, uuid_len)
   m_opaque_up->GetUUID() = UUID::fromOptionalData(uuid, uuid_len);
   return m_opaque_up->GetUUID().IsValid();
 }
 
 bool SBModuleSpec::GetDescription(lldb::SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   m_opaque_up->Dump(description.ref());
   return true;
 }
 
 SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpecList);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBModuleSpecList::SBModuleSpecList(const SBModuleSpecList &rhs)
     : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) {
-  LLDB_RECORD_CONSTRUCTOR(SBModuleSpecList, (const lldb::SBModuleSpecList &),
-                          rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) {
-  LLDB_RECORD_METHOD(
-      lldb::SBModuleSpecList &,
-      SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     *m_opaque_up = *rhs.m_opaque_up;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBModuleSpecList::~SBModuleSpecList() = default;
 
 SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
-                            GetModuleSpecifications, (const char *), path);
+  LLDB_INSTRUMENT_VA(path);
 
   SBModuleSpecList specs;
   FileSpec file_spec(path);
   FileSystem::Instance().Resolve(file_spec);
   Host::ResolveExecutableInBundle(file_spec);
   ObjectFile::GetModuleSpecifications(file_spec, 0, 0, *specs.m_opaque_up);
-  return LLDB_RECORD_RESULT(specs);
+  return specs;
 }
 
 void SBModuleSpecList::Append(const SBModuleSpec &spec) {
-  LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
-                     (const lldb::SBModuleSpec &), spec);
+  LLDB_INSTRUMENT_VA(this, spec);
 
   m_opaque_up->Append(*spec.m_opaque_up);
 }
 
 void SBModuleSpecList::Append(const SBModuleSpecList &spec_list) {
-  LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
-                     (const lldb::SBModuleSpecList &), spec_list);
+  LLDB_INSTRUMENT_VA(this, spec_list);
 
   m_opaque_up->Append(*spec_list.m_opaque_up);
 }
 
 size_t SBModuleSpecList::GetSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpecList, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetSize();
 }
 
 SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) {
-  LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
-                     (size_t), i);
+  LLDB_INSTRUMENT_VA(this, i);
 
   SBModuleSpec sb_module_spec;
   m_opaque_up->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_up);
-  return LLDB_RECORD_RESULT(sb_module_spec);
+  return sb_module_spec;
 }
 
 SBModuleSpec
 SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) {
-  LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
-                     FindFirstMatchingSpec, (const lldb::SBModuleSpec &),
-                     match_spec);
+  LLDB_INSTRUMENT_VA(this, match_spec);
 
   SBModuleSpec sb_module_spec;
   m_opaque_up->FindMatchingModuleSpec(*match_spec.m_opaque_up,
                                       *sb_module_spec.m_opaque_up);
-  return LLDB_RECORD_RESULT(sb_module_spec);
+  return sb_module_spec;
 }
 
 SBModuleSpecList
 SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) {
-  LLDB_RECORD_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
-                     FindMatchingSpecs, (const lldb::SBModuleSpec &),
-                     match_spec);
+  LLDB_INSTRUMENT_VA(this, match_spec);
 
   SBModuleSpecList specs;
   m_opaque_up->FindMatchingModuleSpecs(*match_spec.m_opaque_up,
                                        *specs.m_opaque_up);
-  return LLDB_RECORD_RESULT(specs);
+  return specs;
 }
 
 bool SBModuleSpecList::GetDescription(lldb::SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBModuleSpecList, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   m_opaque_up->Dump(description.ref());
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBModuleSpec>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &));
-  LLDB_REGISTER_METHOD(const lldb::SBModuleSpec &,
-                       SBModuleSpec, operator=,(const lldb::SBModuleSpec &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBModuleSpec, Clear, ());
-  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetFileSpec, ());
-  LLDB_REGISTER_METHOD(void, SBModuleSpec, SetFileSpec,
-                       (const lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetPlatformFileSpec,
-                       ());
-  LLDB_REGISTER_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
-                       (const lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec, ());
-  LLDB_REGISTER_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
-                       (const lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetObjectName, ());
-  LLDB_REGISTER_METHOD(void, SBModuleSpec, SetObjectName, (const char *));
-  LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetTriple, ());
-  LLDB_REGISTER_METHOD(void, SBModuleSpec, SetTriple, (const char *));
-  LLDB_REGISTER_METHOD(size_t, SBModuleSpec, GetUUIDLength, ());
-  LLDB_REGISTER_METHOD(bool, SBModuleSpec, GetDescription,
-                       (lldb::SBStream &));
-  LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList,
-                            (const lldb::SBModuleSpecList &));
-  LLDB_REGISTER_METHOD(
-      lldb::SBModuleSpecList &,
-      SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
-                              GetModuleSpecifications, (const char *));
-  LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
-                       (const lldb::SBModuleSpec &));
-  LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
-                       (const lldb::SBModuleSpecList &));
-  LLDB_REGISTER_METHOD(size_t, SBModuleSpecList, GetSize, ());
-  LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
-                       (size_t));
-  LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
-                       FindFirstMatchingSpec, (const lldb::SBModuleSpec &));
-  LLDB_REGISTER_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
-                       FindMatchingSpecs, (const lldb::SBModuleSpec &));
-  LLDB_REGISTER_METHOD(bool, SBModuleSpecList, GetDescription,
-                       (lldb::SBStream &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBPlatform.cpp b/lldb/source/API/SBPlatform.cpp
index d7a86f0ad1dd..d521a38b30e8 100644
--- a/lldb/source/API/SBPlatform.cpp
+++ b/lldb/source/API/SBPlatform.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBPlatform.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
@@ -19,6 +18,7 @@
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Status.h"
 
 #include "llvm/Support/FileSystem.h"
@@ -30,10 +30,7 @@ using namespace lldb_private;
 
 // PlatformConnectOptions
 struct PlatformConnectOptions {
-  PlatformConnectOptions(const char *url = nullptr)
-      : m_url(), m_rsync_options(), m_rsync_remote_path_prefix(),
-
-        m_local_cache_directory() {
+  PlatformConnectOptions(const char *url = nullptr) {
     if (url && url[0])
       m_url = url;
   }
@@ -52,7 +49,7 @@ struct PlatformConnectOptions {
 struct PlatformShellCommand {
   PlatformShellCommand(llvm::StringRef shell_interpreter,
                        llvm::StringRef shell_command)
-      : m_command(), m_working_dir(), m_status(0), m_signo(0) {
+      : m_status(0), m_signo(0) {
     if (!shell_interpreter.empty())
       m_shell = shell_interpreter.str();
 
@@ -60,8 +57,7 @@ struct PlatformShellCommand {
       m_command = shell_command.str();
   }
 
-  PlatformShellCommand(llvm::StringRef shell_command = llvm::StringRef())
-      : m_shell(), m_command(), m_working_dir() {
+  PlatformShellCommand(llvm::StringRef shell_command = llvm::StringRef()) {
     if (!shell_command.empty())
       m_command = shell_command.str();
   }
@@ -79,14 +75,13 @@ struct PlatformShellCommand {
 // SBPlatformConnectOptions
 SBPlatformConnectOptions::SBPlatformConnectOptions(const char *url)
     : m_opaque_ptr(new PlatformConnectOptions(url)) {
-  LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions, (const char *), url);
+  LLDB_INSTRUMENT_VA(this, url);
 }
 
 SBPlatformConnectOptions::SBPlatformConnectOptions(
     const SBPlatformConnectOptions &rhs)
     : m_opaque_ptr(new PlatformConnectOptions()) {
-  LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions,
-                          (const lldb::SBPlatformConnectOptions &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   *m_opaque_ptr = *rhs.m_opaque_ptr;
 }
@@ -95,18 +90,14 @@ SBPlatformConnectOptions::~SBPlatformConnectOptions() { delete m_opaque_ptr; }
 
 SBPlatformConnectOptions &
 SBPlatformConnectOptions::operator=(const SBPlatformConnectOptions &rhs) {
-  LLDB_RECORD_METHOD(
-      SBPlatformConnectOptions &,
-      SBPlatformConnectOptions, operator=,(
-                                    const lldb::SBPlatformConnectOptions &),
-      rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   *m_opaque_ptr = *rhs.m_opaque_ptr;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 const char *SBPlatformConnectOptions::GetURL() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, GetURL);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr->m_url.empty())
     return nullptr;
@@ -114,8 +105,7 @@ const char *SBPlatformConnectOptions::GetURL() {
 }
 
 void SBPlatformConnectOptions::SetURL(const char *url) {
-  LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *),
-                     url);
+  LLDB_INSTRUMENT_VA(this, url);
 
   if (url && url[0])
     m_opaque_ptr->m_url = url;
@@ -124,7 +114,7 @@ void SBPlatformConnectOptions::SetURL(const char *url) {
 }
 
 bool SBPlatformConnectOptions::GetRsyncEnabled() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatformConnectOptions, GetRsyncEnabled);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_ptr->m_rsync_enabled;
 }
@@ -132,9 +122,8 @@ bool SBPlatformConnectOptions::GetRsyncEnabled() {
 void SBPlatformConnectOptions::EnableRsync(
     const char *options, const char *remote_path_prefix,
     bool omit_hostname_from_remote_path) {
-  LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, EnableRsync,
-                     (const char *, const char *, bool), options,
-                     remote_path_prefix, omit_hostname_from_remote_path);
+  LLDB_INSTRUMENT_VA(this, options, remote_path_prefix,
+                     omit_hostname_from_remote_path);
 
   m_opaque_ptr->m_rsync_enabled = true;
   m_opaque_ptr->m_rsync_omit_hostname_from_remote_path =
@@ -151,21 +140,19 @@ void SBPlatformConnectOptions::EnableRsync(
 }
 
 void SBPlatformConnectOptions::DisableRsync() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformConnectOptions, DisableRsync);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_ptr->m_rsync_enabled = false;
 }
 
 const char *SBPlatformConnectOptions::GetLocalCacheDirectory() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions,
-                             GetLocalCacheDirectory);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_ptr->m_local_cache_directory.GetCString();
 }
 
 void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
-  LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
-                     (const char *), path);
+  LLDB_INSTRUMENT_VA(this, path);
 
   if (path && path[0])
     m_opaque_ptr->m_local_cache_directory.SetCString(path);
@@ -177,21 +164,18 @@ void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
 SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_interpreter,
                                                const char *shell_command)
     : m_opaque_ptr(new PlatformShellCommand(shell_interpreter, shell_command)) {
-  LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, (const char *, const char *),
-                          shell_interpreter, shell_command);
+  LLDB_INSTRUMENT_VA(this, shell_interpreter, shell_command);
 }
 
 SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_command)
     : m_opaque_ptr(new PlatformShellCommand(shell_command)) {
-  LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, (const char *),
-                          shell_command);
+  LLDB_INSTRUMENT_VA(this, shell_command);
 }
 
 SBPlatformShellCommand::SBPlatformShellCommand(
     const SBPlatformShellCommand &rhs)
     : m_opaque_ptr(new PlatformShellCommand()) {
-  LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand,
-                          (const lldb::SBPlatformShellCommand &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   *m_opaque_ptr = *rhs.m_opaque_ptr;
 }
@@ -199,19 +183,16 @@ SBPlatformShellCommand::SBPlatformShellCommand(
 SBPlatformShellCommand &
 SBPlatformShellCommand::operator=(const SBPlatformShellCommand &rhs) {
 
-  LLDB_RECORD_METHOD(
-      SBPlatformShellCommand &,
-      SBPlatformShellCommand, operator=,(const lldb::SBPlatformShellCommand &),
-      rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   *m_opaque_ptr = *rhs.m_opaque_ptr;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBPlatformShellCommand::~SBPlatformShellCommand() { delete m_opaque_ptr; }
 
 void SBPlatformShellCommand::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformShellCommand, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_ptr->m_output = std::string();
   m_opaque_ptr->m_status = 0;
@@ -219,7 +200,7 @@ void SBPlatformShellCommand::Clear() {
 }
 
 const char *SBPlatformShellCommand::GetShell() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetShell);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr->m_shell.empty())
     return nullptr;
@@ -227,8 +208,7 @@ const char *SBPlatformShellCommand::GetShell() {
 }
 
 void SBPlatformShellCommand::SetShell(const char *shell_interpreter) {
-  LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetShell, (const char *),
-                     shell_interpreter);
+  LLDB_INSTRUMENT_VA(this, shell_interpreter);
 
   if (shell_interpreter && shell_interpreter[0])
     m_opaque_ptr->m_shell = shell_interpreter;
@@ -237,7 +217,7 @@ void SBPlatformShellCommand::SetShell(const char *shell_interpreter) {
 }
 
 const char *SBPlatformShellCommand::GetCommand() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetCommand);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr->m_command.empty())
     return nullptr;
@@ -245,8 +225,7 @@ const char *SBPlatformShellCommand::GetCommand() {
 }
 
 void SBPlatformShellCommand::SetCommand(const char *shell_command) {
-  LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetCommand, (const char *),
-                     shell_command);
+  LLDB_INSTRUMENT_VA(this, shell_command);
 
   if (shell_command && shell_command[0])
     m_opaque_ptr->m_command = shell_command;
@@ -255,8 +234,7 @@ void SBPlatformShellCommand::SetCommand(const char *shell_command) {
 }
 
 const char *SBPlatformShellCommand::GetWorkingDirectory() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand,
-                             GetWorkingDirectory);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr->m_working_dir.empty())
     return nullptr;
@@ -264,8 +242,7 @@ const char *SBPlatformShellCommand::GetWorkingDirectory() {
 }
 
 void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
-  LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
-                     (const char *), path);
+  LLDB_INSTRUMENT_VA(this, path);
 
   if (path && path[0])
     m_opaque_ptr->m_working_dir = path;
@@ -274,8 +251,7 @@ void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
 }
 
 uint32_t SBPlatformShellCommand::GetTimeoutSeconds() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatformShellCommand,
-                             GetTimeoutSeconds);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr->m_timeout)
     return m_opaque_ptr->m_timeout->count();
@@ -283,8 +259,7 @@ uint32_t SBPlatformShellCommand::GetTimeoutSeconds() {
 }
 
 void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) {
-  LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
-                     (uint32_t), sec);
+  LLDB_INSTRUMENT_VA(this, sec);
 
   if (sec == UINT32_MAX)
     m_opaque_ptr->m_timeout = llvm::None;
@@ -293,19 +268,19 @@ void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) {
 }
 
 int SBPlatformShellCommand::GetSignal() {
-  LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetSignal);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_ptr->m_signo;
 }
 
 int SBPlatformShellCommand::GetStatus() {
-  LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_ptr->m_status;
 }
 
 const char *SBPlatformShellCommand::GetOutput() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetOutput);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr->m_output.empty())
     return nullptr;
@@ -313,12 +288,10 @@ const char *SBPlatformShellCommand::GetOutput() {
 }
 
 // SBPlatform
-SBPlatform::SBPlatform() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBPlatform);
-}
+SBPlatform::SBPlatform() { LLDB_INSTRUMENT_VA(this); }
 
-SBPlatform::SBPlatform(const char *platform_name) : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const char *), platform_name);
+SBPlatform::SBPlatform(const char *platform_name) {
+  LLDB_INSTRUMENT_VA(this, platform_name);
 
   Status error;
   if (platform_name && platform_name[0])
@@ -326,48 +299,46 @@ SBPlatform::SBPlatform(const char *platform_name) : m_opaque_sp() {
 }
 
 SBPlatform::SBPlatform(const SBPlatform &rhs) {
-  LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const lldb::SBPlatform &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_sp = rhs.m_opaque_sp;
 }
 
 SBPlatform &SBPlatform::operator=(const SBPlatform &rhs) {
-  LLDB_RECORD_METHOD(SBPlatform &,
-                     SBPlatform, operator=,(const lldb::SBPlatform &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_sp = rhs.m_opaque_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBPlatform::~SBPlatform() = default;
 
 SBPlatform SBPlatform::GetHostPlatform() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBPlatform, SBPlatform,
-                                    GetHostPlatform);
+  LLDB_INSTRUMENT();
 
   SBPlatform host_platform;
   host_platform.m_opaque_sp = Platform::GetHostPlatform();
-  return LLDB_RECORD_RESULT(host_platform);
+  return host_platform;
 }
 
 bool SBPlatform::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBPlatform::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 void SBPlatform::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_sp.reset();
 }
 
 const char *SBPlatform::GetName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
@@ -382,7 +353,7 @@ void SBPlatform::SetSP(const lldb::PlatformSP &platform_sp) {
 }
 
 const char *SBPlatform::GetWorkingDirectory() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetWorkingDirectory);
+  LLDB_INSTRUMENT_VA(this);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
@@ -391,8 +362,7 @@ const char *SBPlatform::GetWorkingDirectory() {
 }
 
 bool SBPlatform::SetWorkingDirectory(const char *path) {
-  LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *),
-                     path);
+  LLDB_INSTRUMENT_VA(this, path);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
@@ -406,8 +376,7 @@ bool SBPlatform::SetWorkingDirectory(const char *path) {
 }
 
 SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
-                     (lldb::SBPlatformConnectOptions &), connect_options);
+  LLDB_INSTRUMENT_VA(this, connect_options);
 
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
@@ -418,11 +387,11 @@ SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
   } else {
     sb_error.SetErrorString("invalid platform");
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 void SBPlatform::DisconnectRemote() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, DisconnectRemote);
+  LLDB_INSTRUMENT_VA(this);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
@@ -430,7 +399,7 @@ void SBPlatform::DisconnectRemote() {
 }
 
 bool SBPlatform::IsConnected() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatform, IsConnected);
+  LLDB_INSTRUMENT_VA(this);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
@@ -439,7 +408,7 @@ bool SBPlatform::IsConnected() {
 }
 
 const char *SBPlatform::GetTriple() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetTriple);
+  LLDB_INSTRUMENT_VA(this);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
@@ -454,7 +423,7 @@ const char *SBPlatform::GetTriple() {
 }
 
 const char *SBPlatform::GetOSBuild() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild);
+  LLDB_INSTRUMENT_VA(this);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
@@ -469,7 +438,7 @@ const char *SBPlatform::GetOSBuild() {
 }
 
 const char *SBPlatform::GetOSDescription() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription);
+  LLDB_INSTRUMENT_VA(this);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
@@ -484,7 +453,7 @@ const char *SBPlatform::GetOSDescription() {
 }
 
 const char *SBPlatform::GetHostname() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname);
+  LLDB_INSTRUMENT_VA(this);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
@@ -493,7 +462,7 @@ const char *SBPlatform::GetHostname() {
 }
 
 uint32_t SBPlatform::GetOSMajorVersion() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMajorVersion);
+  LLDB_INSTRUMENT_VA(this);
 
   llvm::VersionTuple version;
   if (PlatformSP platform_sp = GetSP())
@@ -502,7 +471,7 @@ uint32_t SBPlatform::GetOSMajorVersion() {
 }
 
 uint32_t SBPlatform::GetOSMinorVersion() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMinorVersion);
+  LLDB_INSTRUMENT_VA(this);
 
   llvm::VersionTuple version;
   if (PlatformSP platform_sp = GetSP())
@@ -511,7 +480,7 @@ uint32_t SBPlatform::GetOSMinorVersion() {
 }
 
 uint32_t SBPlatform::GetOSUpdateVersion() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSUpdateVersion);
+  LLDB_INSTRUMENT_VA(this);
 
   llvm::VersionTuple version;
   if (PlatformSP platform_sp = GetSP())
@@ -519,9 +488,14 @@ uint32_t SBPlatform::GetOSUpdateVersion() {
   return version.getSubminor().getValueOr(UINT32_MAX);
 }
 
+void SBPlatform::SetSDKRoot(const char *sysroot) {
+  LLDB_INSTRUMENT_VA(this, sysroot);
+  if (PlatformSP platform_sp = GetSP())
+    platform_sp->SetSDKRootDirectory(ConstString(sysroot));
+}
+
 SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Get,
-                     (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
+  LLDB_INSTRUMENT_VA(this, src, dst);
 
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
@@ -530,54 +504,48 @@ SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
   } else {
     sb_error.SetErrorString("invalid platform");
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Put,
-                     (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
-  return LLDB_RECORD_RESULT(
-      ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
-        if (src.Exists()) {
-          uint32_t permissions =
-              FileSystem::Instance().GetPermissions(src.ref());
-          if (permissions == 0) {
-            if (FileSystem::Instance().IsDirectory(src.ref()))
-              permissions = eFilePermissionsDirectoryDefault;
-            else
-              permissions = eFilePermissionsFileDefault;
-          }
+  LLDB_INSTRUMENT_VA(this, src, dst);
+  return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
+    if (src.Exists()) {
+      uint32_t permissions = FileSystem::Instance().GetPermissions(src.ref());
+      if (permissions == 0) {
+        if (FileSystem::Instance().IsDirectory(src.ref()))
+          permissions = eFilePermissionsDirectoryDefault;
+        else
+          permissions = eFilePermissionsFileDefault;
+      }
 
-          return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
-        }
+      return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
+    }
 
-        Status error;
-        error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
-                                       src.ref().GetPath().c_str());
-        return error;
-      }));
+    Status error;
+    error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
+                                   src.ref().GetPath().c_str());
+    return error;
+  });
 }
 
 SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Install,
-                     (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
-  return LLDB_RECORD_RESULT(
-      ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
-        if (src.Exists())
-          return platform_sp->Install(src.ref(), dst.ref());
+  LLDB_INSTRUMENT_VA(this, src, dst);
+  return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
+    if (src.Exists())
+      return platform_sp->Install(src.ref(), dst.ref());
 
-        Status error;
-        error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
-                                       src.ref().GetPath().c_str());
-        return error;
-      }));
+    Status error;
+    error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
+                                   src.ref().GetPath().c_str());
+    return error;
+  });
 }
 
 SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Run,
-                     (lldb::SBPlatformShellCommand &), shell_command);
-  return LLDB_RECORD_RESULT(
-      ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
+  LLDB_INSTRUMENT_VA(this, shell_command);
+  return ExecuteConnected(
+      [&](const lldb::PlatformSP &platform_sp) {
         const char *command = shell_command.GetCommand();
         if (!command)
           return Status("invalid shell command (empty)");
@@ -594,27 +562,24 @@ SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
             &shell_command.m_opaque_ptr->m_signo,
             &shell_command.m_opaque_ptr->m_output,
             shell_command.m_opaque_ptr->m_timeout);
-      }));
+      });
 }
 
 SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Launch, (lldb::SBLaunchInfo &),
-                     launch_info);
-  return LLDB_RECORD_RESULT(
-      ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
-        ProcessLaunchInfo info = launch_info.ref();
-        Status error = platform_sp->LaunchProcess(info);
-        launch_info.set_ref(info);
-        return error;
-      }));
+  LLDB_INSTRUMENT_VA(this, launch_info);
+  return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
+    ProcessLaunchInfo info = launch_info.ref();
+    Status error = platform_sp->LaunchProcess(info);
+    launch_info.set_ref(info);
+    return error;
+  });
 }
 
 SBError SBPlatform::Kill(const lldb::pid_t pid) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t), pid);
-  return LLDB_RECORD_RESULT(
-      ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
-        return platform_sp->KillProcess(pid);
-      }));
+  LLDB_INSTRUMENT_VA(this, pid);
+  return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
+    return platform_sp->KillProcess(pid);
+  });
 }
 
 SBError SBPlatform::ExecuteConnected(
@@ -633,8 +598,7 @@ SBError SBPlatform::ExecuteConnected(
 }
 
 SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
-                     (const char *, uint32_t), path, file_permissions);
+  LLDB_INSTRUMENT_VA(this, path, file_permissions);
 
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
@@ -644,12 +608,11 @@ SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) {
   } else {
     sb_error.SetErrorString("invalid platform");
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 uint32_t SBPlatform::GetFilePermissions(const char *path) {
-  LLDB_RECORD_METHOD(uint32_t, SBPlatform, GetFilePermissions, (const char *),
-                     path);
+  LLDB_INSTRUMENT_VA(this, path);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
@@ -662,8 +625,7 @@ uint32_t SBPlatform::GetFilePermissions(const char *path) {
 
 SBError SBPlatform::SetFilePermissions(const char *path,
                                        uint32_t file_permissions) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
-                     (const char *, uint32_t), path, file_permissions);
+  LLDB_INSTRUMENT_VA(this, path, file_permissions);
 
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
@@ -673,126 +635,25 @@ SBError SBPlatform::SetFilePermissions(const char *path,
   } else {
     sb_error.SetErrorString("invalid platform");
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBUnixSignals SBPlatform::GetUnixSignals() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform,
-                                   GetUnixSignals);
+  LLDB_INSTRUMENT_VA(this);
 
   if (auto platform_sp = GetSP())
-    return LLDB_RECORD_RESULT(SBUnixSignals{platform_sp});
+    return SBUnixSignals{platform_sp};
 
-  return LLDB_RECORD_RESULT(SBUnixSignals());
+  return SBUnixSignals();
 }
 
 SBEnvironment SBPlatform::GetEnvironment() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBPlatform, GetEnvironment);
+  LLDB_INSTRUMENT_VA(this);
   PlatformSP platform_sp(GetSP());
 
   if (platform_sp) {
-    return LLDB_RECORD_RESULT(SBEnvironment(platform_sp->GetEnvironment()));
+    return SBEnvironment(platform_sp->GetEnvironment());
   }
 
-  return LLDB_RECORD_RESULT(SBEnvironment());
+  return SBEnvironment();
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <> void RegisterMethods<SBPlatformConnectOptions>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, (const char *));
-  LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions,
-                            (const lldb::SBPlatformConnectOptions &));
-  LLDB_REGISTER_METHOD(
-      SBPlatformConnectOptions &,
-      SBPlatformConnectOptions, operator=,(
-                                    const lldb::SBPlatformConnectOptions &));
-  LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions, GetURL, ());
-  LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *));
-  LLDB_REGISTER_METHOD(bool, SBPlatformConnectOptions, GetRsyncEnabled, ());
-  LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, EnableRsync,
-                       (const char *, const char *, bool));
-  LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, DisableRsync, ());
-  LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions,
-                       GetLocalCacheDirectory, ());
-  LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
-                       (const char *));
-}
-
-template <> void RegisterMethods<SBPlatformShellCommand>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand, (const char *));
-  LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand,
-                            (const lldb::SBPlatformShellCommand &));
-  LLDB_REGISTER_METHOD(
-      SBPlatformShellCommand &,
-      SBPlatformShellCommand, operator=,(const lldb::SBPlatformShellCommand &));
-  LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, Clear, ());
-  LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetShell, ());
-  LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetShell, (const char *));
-  LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetCommand, ());
-  LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetCommand,
-                       (const char *));
-  LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand,
-                       GetWorkingDirectory, ());
-  LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
-                       (const char *));
-  LLDB_REGISTER_METHOD(uint32_t, SBPlatformShellCommand, GetTimeoutSeconds, ());
-  LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetSignal, ());
-  LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetStatus, ());
-  LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetOutput, ());
-}
-
-template <> void RegisterMethods<SBPlatform>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBPlatform, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const char *));
-  LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const lldb::SBPlatform &));
-  LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand,
-                            (const char *, const char *));
-  LLDB_REGISTER_METHOD(SBPlatform &,
-                       SBPlatform, operator=,(const lldb::SBPlatform &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, operator bool,());
-  LLDB_REGISTER_METHOD(void, SBPlatform, Clear, ());
-  LLDB_REGISTER_METHOD(const char *, SBPlatform, GetName, ());
-  LLDB_REGISTER_METHOD(const char *, SBPlatform, GetWorkingDirectory, ());
-  LLDB_REGISTER_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
-                       (lldb::SBPlatformConnectOptions &));
-  LLDB_REGISTER_METHOD(void, SBPlatform, DisconnectRemote, ());
-  LLDB_REGISTER_METHOD(bool, SBPlatform, IsConnected, ());
-  LLDB_REGISTER_METHOD(const char *, SBPlatform, GetTriple, ());
-  LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSBuild, ());
-  LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSDescription, ());
-  LLDB_REGISTER_METHOD(const char *, SBPlatform, GetHostname, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMajorVersion, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMinorVersion, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSUpdateVersion, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Get,
-                       (lldb::SBFileSpec &, lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Put,
-                       (lldb::SBFileSpec &, lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Install,
-                       (lldb::SBFileSpec &, lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Run,
-                       (lldb::SBPlatformShellCommand &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Launch,
-                       (lldb::SBLaunchInfo &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
-                       (const char *, uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetFilePermissions,
-                       (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
-                       (const char *, uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBPlatform, GetEnvironment, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBUnixSignals, SBPlatform, GetUnixSignals,
-                             ());
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBPlatform, SBPlatform, GetHostPlatform,
-                              ());
-}
-
-} // namespace repro
-} // namespace lldb_private
diff --git a/lldb/source/API/SBProcess.cpp b/lldb/source/API/SBProcess.cpp
index 797e19462800..2538013412b6 100644
--- a/lldb/source/API/SBProcess.cpp
+++ b/lldb/source/API/SBProcess.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBProcess.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include <cinttypes>
 
@@ -49,42 +49,38 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBProcess::SBProcess() : m_opaque_wp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcess);
-}
+SBProcess::SBProcess() { LLDB_INSTRUMENT_VA(this); }
 
 // SBProcess constructor
 
 SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
-  LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBProcess::SBProcess(const lldb::ProcessSP &process_sp)
     : m_opaque_wp(process_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp);
+  LLDB_INSTRUMENT_VA(this, process_sp);
 }
 
 const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBProcess &,
-                     SBProcess, operator=,(const lldb::SBProcess &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_wp = rhs.m_opaque_wp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 // Destructor
 SBProcess::~SBProcess() = default;
 
 const char *SBProcess::GetBroadcasterClassName() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
-                                    GetBroadcasterClassName);
+  LLDB_INSTRUMENT();
 
   return Process::GetStaticBroadcasterClass().AsCString();
 }
 
 const char *SBProcess::GetPluginName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName);
+  LLDB_INSTRUMENT_VA(this);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -94,7 +90,7 @@ const char *SBProcess::GetPluginName() {
 }
 
 const char *SBProcess::GetShortPluginName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName);
+  LLDB_INSTRUMENT_VA(this);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -108,17 +104,17 @@ lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); }
 void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
 
 void SBProcess::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_wp.reset();
 }
 
 bool SBProcess::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBProcess::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   ProcessSP process_sp(m_opaque_wp.lock());
   return ((bool)process_sp && process_sp->IsValid());
@@ -130,11 +126,7 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
                              const char *working_directory,
                              uint32_t launch_flags, bool stop_at_entry,
                              lldb::SBError &error) {
-  LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch,
-                     (const char **, const char **, const char *, const char *,
-                      const char *, const char *, uint32_t, bool,
-                      lldb::SBError &),
-                     argv, envp, stdin_path, stdout_path, stderr_path,
+  LLDB_INSTRUMENT_VA(this, argv, envp, stdin_path, stdout_path, stderr_path,
                      working_directory, launch_flags, stop_at_entry, error);
 
   ProcessSP process_sp(GetSP());
@@ -167,8 +159,7 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
 
 bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
                                             lldb::SBError &error) {
-  LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
-                     (lldb::pid_t, lldb::SBError &), pid, error);
+  LLDB_INSTRUMENT_VA(this, pid, error);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -190,7 +181,7 @@ bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
 }
 
 uint32_t SBProcess::GetNumThreads() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t num_threads = 0;
   ProcessSP process_sp(GetSP());
@@ -207,8 +198,7 @@ uint32_t SBProcess::GetNumThreads() {
 }
 
 SBThread SBProcess::GetSelectedThread() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess,
-                                   GetSelectedThread);
+  LLDB_INSTRUMENT_VA(this);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -220,13 +210,12 @@ SBThread SBProcess::GetSelectedThread() const {
     sb_thread.SetThread(thread_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
                                          lldb::addr_t context) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
-                     (lldb::tid_t, lldb::addr_t), tid, context);
+  LLDB_INSTRUMENT_VA(this, tid, context);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -238,11 +227,11 @@ SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
     sb_thread.SetThread(thread_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 SBTarget SBProcess::GetTarget() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget);
+  LLDB_INSTRUMENT_VA(this);
 
   SBTarget sb_target;
   TargetSP target_sp;
@@ -252,12 +241,11 @@ SBTarget SBProcess::GetTarget() const {
     sb_target.SetSP(target_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
-  LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src,
-                     src_len);
+  LLDB_INSTRUMENT_VA(this, src, src_len);
 
   size_t ret_val = 0;
   ProcessSP process_sp(GetSP());
@@ -270,8 +258,7 @@ size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
 }
 
 size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
-  LLDB_RECORD_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetSTDOUT,
-                                    (char *, size_t), dst, "", dst_len);
+  LLDB_INSTRUMENT_VA(this, dst, dst_len);
 
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
@@ -284,8 +271,7 @@ size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
 }
 
 size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
-  LLDB_RECORD_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetSTDERR,
-                                    (char *, size_t), dst, "", dst_len);
+  LLDB_INSTRUMENT_VA(this, dst, dst_len);
 
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
@@ -298,8 +284,7 @@ size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
 }
 
 size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
-  LLDB_RECORD_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
-                                    (char *, size_t), dst, "", dst_len);
+  LLDB_INSTRUMENT_VA(this, dst, dst_len);
 
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
@@ -312,23 +297,20 @@ size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
 }
 
 void SBProcess::ReportEventState(const SBEvent &event, SBFile out) const {
-  LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
-                           (const SBEvent &, SBFile), event, out);
+  LLDB_INSTRUMENT_VA(this, event, out);
 
   return ReportEventState(event, out.m_opaque_sp);
 }
 
 void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
-  LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
-                           (const lldb::SBEvent &, FILE *), event, out);
+  LLDB_INSTRUMENT_VA(this, event, out);
   FileSP outfile = std::make_shared<NativeFile>(out, false);
   return ReportEventState(event, outfile);
 }
 
 void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const {
 
-  LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
-                           (const SBEvent &, FileSP), event, out);
+  LLDB_INSTRUMENT_VA(this, event, out);
 
   if (!out || !out->IsValid())
     return;
@@ -344,9 +326,7 @@ void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const {
 
 void SBProcess::AppendEventStateReport(const SBEvent &event,
                                        SBCommandReturnObject &result) {
-  LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport,
-                     (const lldb::SBEvent &, lldb::SBCommandReturnObject &),
-                     event, result);
+  LLDB_INSTRUMENT_VA(this, event, result);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -360,8 +340,7 @@ void SBProcess::AppendEventStateReport(const SBEvent &event,
 }
 
 bool SBProcess::SetSelectedThread(const SBThread &thread) {
-  LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread,
-                     (const lldb::SBThread &), thread);
+  LLDB_INSTRUMENT_VA(this, thread);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -374,9 +353,7 @@ bool SBProcess::SetSelectedThread(const SBThread &thread) {
 }
 
 bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
-  LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t),
-                     tid);
-
+  LLDB_INSTRUMENT_VA(this, tid);
 
   bool ret_val = false;
   ProcessSP process_sp(GetSP());
@@ -390,8 +367,7 @@ bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
 }
 
 bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
-  LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t),
-                     index_id);
+  LLDB_INSTRUMENT_VA(this, index_id);
 
   bool ret_val = false;
   ProcessSP process_sp(GetSP());
@@ -406,8 +382,7 @@ bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
 }
 
 SBThread SBProcess::GetThreadAtIndex(size_t index) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t),
-                     index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -421,11 +396,11 @@ SBThread SBProcess::GetThreadAtIndex(size_t index) {
     sb_thread.SetThread(thread_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 uint32_t SBProcess::GetNumQueues() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t num_queues = 0;
   ProcessSP process_sp(GetSP());
@@ -442,8 +417,7 @@ uint32_t SBProcess::GetNumQueues() {
 }
 
 SBQueue SBProcess::GetQueueAtIndex(size_t index) {
-  LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t),
-                     index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   SBQueue sb_queue;
   QueueSP queue_sp;
@@ -458,12 +432,11 @@ SBQueue SBProcess::GetQueueAtIndex(size_t index) {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_queue);
+  return sb_queue;
 }
 
 uint32_t SBProcess::GetStopID(bool include_expression_stops) {
-  LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool),
-                     include_expression_stops);
+  LLDB_INSTRUMENT_VA(this, include_expression_stops);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -478,8 +451,7 @@ uint32_t SBProcess::GetStopID(bool include_expression_stops) {
 }
 
 SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
-  LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
-                     (uint32_t), stop_id);
+  LLDB_INSTRUMENT_VA(this, stop_id);
 
   SBEvent sb_event;
   EventSP event_sp;
@@ -491,11 +463,11 @@ SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
     sb_event.reset(event_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_event);
+  return sb_event;
 }
 
 StateType SBProcess::GetState() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState);
+  LLDB_INSTRUMENT_VA(this);
 
   StateType ret_val = eStateInvalid;
   ProcessSP process_sp(GetSP());
@@ -509,7 +481,7 @@ StateType SBProcess::GetState() {
 }
 
 int SBProcess::GetExitStatus() {
-  LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus);
+  LLDB_INSTRUMENT_VA(this);
 
   int exit_status = 0;
   ProcessSP process_sp(GetSP());
@@ -523,7 +495,7 @@ int SBProcess::GetExitStatus() {
 }
 
 const char *SBProcess::GetExitDescription() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *exit_desc = nullptr;
   ProcessSP process_sp(GetSP());
@@ -536,7 +508,7 @@ const char *SBProcess::GetExitDescription() {
 }
 
 lldb::pid_t SBProcess::GetProcessID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
   ProcessSP process_sp(GetSP());
@@ -547,7 +519,7 @@ lldb::pid_t SBProcess::GetProcessID() {
 }
 
 uint32_t SBProcess::GetUniqueID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t ret_val = 0;
   ProcessSP process_sp(GetSP());
@@ -557,7 +529,7 @@ uint32_t SBProcess::GetUniqueID() {
 }
 
 ByteOrder SBProcess::GetByteOrder() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder);
+  LLDB_INSTRUMENT_VA(this);
 
   ByteOrder byteOrder = eByteOrderInvalid;
   ProcessSP process_sp(GetSP());
@@ -569,7 +541,7 @@ ByteOrder SBProcess::GetByteOrder() const {
 }
 
 uint32_t SBProcess::GetAddressByteSize() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t size = 0;
   ProcessSP process_sp(GetSP());
@@ -581,7 +553,7 @@ uint32_t SBProcess::GetAddressByteSize() const {
 }
 
 SBError SBProcess::Continue() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -597,11 +569,11 @@ SBError SBProcess::Continue() {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBProcess::Destroy() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -612,11 +584,11 @@ SBError SBProcess::Destroy() {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBProcess::Stop() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -627,11 +599,11 @@ SBError SBProcess::Stop() {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBProcess::Kill() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -642,19 +614,19 @@ SBError SBProcess::Kill() {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBProcess::Detach() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach);
+  LLDB_INSTRUMENT_VA(this);
 
   // FIXME: This should come from a process default.
   bool keep_stopped = false;
-  return LLDB_RECORD_RESULT(Detach(keep_stopped));
+  return Detach(keep_stopped);
 }
 
 SBError SBProcess::Detach(bool keep_stopped) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped);
+  LLDB_INSTRUMENT_VA(this, keep_stopped);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -665,11 +637,11 @@ SBError SBProcess::Detach(bool keep_stopped) {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBProcess::Signal(int signo) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo);
+  LLDB_INSTRUMENT_VA(this, signo);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -680,20 +652,20 @@ SBError SBProcess::Signal(int signo) {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBUnixSignals SBProcess::GetUnixSignals() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals);
+  LLDB_INSTRUMENT_VA(this);
 
   if (auto process_sp = GetSP())
-    return LLDB_RECORD_RESULT(SBUnixSignals{process_sp});
+    return SBUnixSignals{process_sp};
 
-  return LLDB_RECORD_RESULT(SBUnixSignals{});
+  return SBUnixSignals{};
 }
 
 void SBProcess::SendAsyncInterrupt() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt);
+  LLDB_INSTRUMENT_VA(this);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -702,8 +674,7 @@ void SBProcess::SendAsyncInterrupt() {
 }
 
 SBThread SBProcess::GetThreadByID(tid_t tid) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t),
-                     tid);
+  LLDB_INSTRUMENT_VA(this, tid);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -717,12 +688,11 @@ SBThread SBProcess::GetThreadByID(tid_t tid) {
     sb_thread.SetThread(thread_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t),
-                     index_id);
+  LLDB_INSTRUMENT_VA(this, index_id);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -737,12 +707,11 @@ SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
     sb_thread.SetThread(thread_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get());
 
@@ -750,8 +719,7 @@ StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
 }
 
 bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get());
 
@@ -759,8 +727,7 @@ bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
 }
 
 size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   return Process::ProcessEventData::GetNumRestartedReasons(event.get());
 }
@@ -768,16 +735,13 @@ size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
 const char *
 SBProcess::GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event,
                                               size_t idx) {
-  LLDB_RECORD_STATIC_METHOD(const char *, SBProcess,
-                            GetRestartedReasonAtIndexFromEvent,
-                            (const lldb::SBEvent &, size_t), event, idx);
+  LLDB_INSTRUMENT_VA(event, idx);
 
   return Process::ProcessEventData::GetRestartedReasonAtIndex(event.get(), idx);
 }
 
 SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   ProcessSP process_sp =
       Process::ProcessEventData::GetProcessFromEvent(event.get());
@@ -786,36 +750,31 @@ SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
     process_sp = EventDataStructuredData::GetProcessFromEvent(event.get());
   }
 
-  return LLDB_RECORD_RESULT(SBProcess(process_sp));
+  return SBProcess(process_sp);
 }
 
 bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   return Process::ProcessEventData::GetInterruptedFromEvent(event.get());
 }
 
 lldb::SBStructuredData
 SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
-                            GetStructuredDataFromEvent, (const lldb::SBEvent &),
-                            event);
+  LLDB_INSTRUMENT_VA(event);
 
-  return LLDB_RECORD_RESULT(SBStructuredData(event.GetSP()));
+  return SBStructuredData(event.GetSP());
 }
 
 bool SBProcess::EventIsProcessEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) &&
          !EventIsStructuredDataEvent(event);
 }
 
 bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   EventSP event_sp = event.GetSP();
   EventData *event_data = event_sp ? event_sp->GetData() : nullptr;
@@ -824,30 +783,24 @@ bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
 }
 
 SBBroadcaster SBProcess::GetBroadcaster() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess,
-                                   GetBroadcaster);
-
+  LLDB_INSTRUMENT_VA(this);
 
   ProcessSP process_sp(GetSP());
 
   SBBroadcaster broadcaster(process_sp.get(), false);
 
-
-  return LLDB_RECORD_RESULT(broadcaster);
+  return broadcaster;
 }
 
 const char *SBProcess::GetBroadcasterClass() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
-                                    GetBroadcasterClass);
+  LLDB_INSTRUMENT();
 
   return Process::GetStaticBroadcasterClass().AsCString();
 }
 
 size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
                              SBError &sb_error) {
-  LLDB_RECORD_DUMMY(size_t, SBProcess, ReadMemory,
-                    (lldb::addr_t, void *, size_t, lldb::SBError &), addr, dst,
-                    dst_len, sb_error);
+  LLDB_INSTRUMENT_VA(this, addr, dst, dst_len, sb_error);
 
   size_t bytes_read = 0;
 
@@ -872,9 +825,7 @@ size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
 
 size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
                                         lldb::SBError &sb_error) {
-  LLDB_RECORD_DUMMY(size_t, SBProcess, ReadCStringFromMemory,
-                    (lldb::addr_t, void *, size_t, lldb::SBError &), addr, buf,
-                    size, sb_error);
+  LLDB_INSTRUMENT_VA(this, addr, buf, size, sb_error);
 
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
@@ -896,9 +847,7 @@ size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
 
 uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
                                            lldb::SBError &sb_error) {
-  LLDB_RECORD_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
-                     (lldb::addr_t, uint32_t, lldb::SBError &), addr, byte_size,
-                     sb_error);
+  LLDB_INSTRUMENT_VA(this, addr, byte_size, sb_error);
 
   uint64_t value = 0;
   ProcessSP process_sp(GetSP());
@@ -920,8 +869,7 @@ uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
 
 lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
                                               lldb::SBError &sb_error) {
-  LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
-                     (lldb::addr_t, lldb::SBError &), addr, sb_error);
+  LLDB_INSTRUMENT_VA(this, addr, sb_error);
 
   lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
   ProcessSP process_sp(GetSP());
@@ -942,9 +890,7 @@ lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
 
 size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
                               SBError &sb_error) {
-  LLDB_RECORD_DUMMY(size_t, SBProcess, WriteMemory,
-                    (lldb::addr_t, const void *, size_t, lldb::SBError &), addr,
-                    src, src_len, sb_error);
+  LLDB_INSTRUMENT_VA(this, addr, src, src_len, sb_error);
 
   size_t bytes_written = 0;
 
@@ -966,8 +912,7 @@ size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
 }
 
 bool SBProcess::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -991,34 +936,31 @@ bool SBProcess::GetDescription(SBStream &description) {
 }
 
 SBStructuredData SBProcess::GetExtendedCrashInformation() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBProcess,
-                             GetExtendedCrashInformation);
+  LLDB_INSTRUMENT_VA(this);
   SBStructuredData data;
   ProcessSP process_sp(GetSP());
   if (!process_sp)
-    return LLDB_RECORD_RESULT(data);
+    return data;
 
   PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
 
   if (!platform_sp)
-    return LLDB_RECORD_RESULT(data);
+    return data;
 
   auto expected_data =
       platform_sp->FetchExtendedCrashInformation(*process_sp.get());
 
   if (!expected_data)
-    return LLDB_RECORD_RESULT(data);
+    return data;
 
   StructuredData::ObjectSP fetched_data = *expected_data;
   data.m_impl_up->SetObjectSP(fetched_data);
-  return LLDB_RECORD_RESULT(data);
+  return data;
 }
 
 uint32_t
 SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
-  LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess,
-                           GetNumSupportedHardwareWatchpoints,
-                           (lldb::SBError &), sb_error);
+  LLDB_INSTRUMENT_VA(this, sb_error);
 
   uint32_t num = 0;
   ProcessSP process_sp(GetSP());
@@ -1034,9 +976,7 @@ SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
 
 uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
                               lldb::SBError &sb_error) {
-  LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImage,
-                     (lldb::SBFileSpec &, lldb::SBError &),
-                     sb_remote_image_spec, sb_error);
+  LLDB_INSTRUMENT_VA(this, sb_remote_image_spec, sb_error);
 
   return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error);
 }
@@ -1044,10 +984,7 @@ uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
 uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
                               const lldb::SBFileSpec &sb_remote_image_spec,
                               lldb::SBError &sb_error) {
-  LLDB_RECORD_METHOD(
-      uint32_t, SBProcess, LoadImage,
-      (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &),
-      sb_local_image_spec, sb_remote_image_spec, sb_error);
+  LLDB_INSTRUMENT_VA(this, sb_local_image_spec, sb_remote_image_spec, sb_error);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -1071,10 +1008,7 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
                                         SBStringList &paths,
                                         lldb::SBFileSpec &loaded_path,
                                         lldb::SBError &error) {
-  LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
-                     (const lldb::SBFileSpec &, lldb::SBStringList &,
-                      lldb::SBFileSpec &, lldb::SBError &),
-                     image_spec, paths, loaded_path, error);
+  LLDB_INSTRUMENT_VA(this, image_spec, paths, loaded_path, error);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -1106,8 +1040,7 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
 }
 
 lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t),
-                     image_token);
+  LLDB_INSTRUMENT_VA(this, image_token);
 
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -1124,12 +1057,11 @@ lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
     }
   } else
     sb_error.SetErrorString("invalid process");
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 lldb::SBError SBProcess::SendEventData(const char *event_data) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *),
-                     event_data);
+  LLDB_INSTRUMENT_VA(this, event_data);
 
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -1144,11 +1076,11 @@ lldb::SBError SBProcess::SendEventData(const char *event_data) {
     }
   } else
     sb_error.SetErrorString("invalid process");
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes);
+  LLDB_INSTRUMENT_VA(this);
 
   ProcessSP process_sp(GetSP());
   if (process_sp && process_sp->GetSystemRuntime()) {
@@ -1159,8 +1091,7 @@ uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
 }
 
 const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex,
-                     (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   ProcessSP process_sp(GetSP());
   if (process_sp && process_sp->GetSystemRuntime()) {
@@ -1175,21 +1106,19 @@ const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
 }
 
 SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
-  LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
-                     (lldb::addr_t), addr);
+  LLDB_INSTRUMENT_VA(this, addr);
 
   ProcessSP process_sp(GetSP());
   SBThreadCollection threads;
   if (process_sp) {
     threads = SBThreadCollection(process_sp->GetHistoryThreads(addr));
   }
-  return LLDB_RECORD_RESULT(threads);
+  return threads;
 }
 
 bool SBProcess::IsInstrumentationRuntimePresent(
     InstrumentationRuntimeType type) {
-  LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
-                     (lldb::InstrumentationRuntimeType), type);
+  LLDB_INSTRUMENT_VA(this, type);
 
   ProcessSP process_sp(GetSP());
   if (!process_sp)
@@ -1208,14 +1137,13 @@ bool SBProcess::IsInstrumentationRuntimePresent(
 }
 
 lldb::SBError SBProcess::SaveCore(const char *file_name) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *),
-                     file_name);
+  LLDB_INSTRUMENT_VA(this, file_name);
 
   lldb::SBError error;
   ProcessSP process_sp(GetSP());
   if (!process_sp) {
     error.SetErrorString("SBProcess is invalid");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
 
   std::lock_guard<std::recursive_mutex> guard(
@@ -1223,21 +1151,19 @@ lldb::SBError SBProcess::SaveCore(const char *file_name) {
 
   if (process_sp->GetState() != eStateStopped) {
     error.SetErrorString("the process is not stopped");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
 
   FileSpec core_file(file_name);
   SaveCoreStyle core_style = SaveCoreStyle::eSaveCoreFull;
   error.ref() = PluginManager::SaveCore(process_sp, core_file, core_style, "");
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 lldb::SBError
 SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                SBMemoryRegionInfo &sb_region_info) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
-                     (lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr,
-                     sb_region_info);
+  LLDB_INSTRUMENT_VA(this, load_addr, sb_region_info);
 
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -1255,12 +1181,11 @@ SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
   } else {
     sb_error.SetErrorString("SBProcess is invalid");
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess,
-                             GetMemoryRegions);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBMemoryRegionInfoList sb_region_list;
 
@@ -1273,11 +1198,11 @@ lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
     process_sp->GetMemoryRegions(sb_region_list.ref());
   }
 
-  return LLDB_RECORD_RESULT(sb_region_list);
+  return sb_region_list;
 }
 
 lldb::SBProcessInfo SBProcess::GetProcessInfo() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBProcessInfo sb_proc_info;
   ProcessSP process_sp(GetSP());
@@ -1285,14 +1210,12 @@ lldb::SBProcessInfo SBProcess::GetProcessInfo() {
   if (process_sp && process_sp->GetProcessInfo(proc_info)) {
     sb_proc_info.SetProcessInfo(proc_info);
   }
-  return LLDB_RECORD_RESULT(sb_proc_info);
+  return sb_proc_info;
 }
 
 lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
                                        lldb::SBError &sb_error) {
-  LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, AllocateMemory,
-                     (size_t, uint32_t, lldb::SBError &), size, permissions,
-                     sb_error);
+  LLDB_INSTRUMENT_VA(this, size, permissions, sb_error);
 
   lldb::addr_t addr = LLDB_INVALID_ADDRESS;
   ProcessSP process_sp(GetSP());
@@ -1312,8 +1235,7 @@ lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
 }
 
 lldb::SBError SBProcess::DeallocateMemory(lldb::addr_t ptr) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, DeallocateMemory, (lldb::addr_t),
-                     ptr);
+  LLDB_INSTRUMENT_VA(this, ptr);
 
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -1332,145 +1254,3 @@ lldb::SBError SBProcess::DeallocateMemory(lldb::addr_t ptr) {
   }
   return sb_error;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBProcess>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBProcess, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &));
-  LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &));
-  LLDB_REGISTER_METHOD(const lldb::SBProcess &,
-                       SBProcess, operator=,(const lldb::SBProcess &));
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
-                              GetBroadcasterClassName, ());
-  LLDB_REGISTER_METHOD(const char *, SBProcess, GetPluginName, ());
-  LLDB_REGISTER_METHOD(const char *, SBProcess, GetShortPluginName, ());
-  LLDB_REGISTER_METHOD(void, SBProcess, Clear, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBProcess, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBProcess, operator bool, ());
-  LLDB_REGISTER_METHOD(bool, SBProcess, RemoteLaunch,
-                       (const char **, const char **, const char *,
-                        const char *, const char *, const char *, uint32_t,
-                        bool, lldb::SBError &));
-  LLDB_REGISTER_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
-                       (lldb::pid_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumThreads, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBProcess, GetSelectedThread,
-                             ());
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
-                       (lldb::tid_t, lldb::addr_t));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBProcess, GetTarget, ());
-  LLDB_REGISTER_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t));
-  LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
-                             (const lldb::SBEvent &, FILE *));
-  LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
-                             (const lldb::SBEvent &, FileSP));
-  LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
-                             (const lldb::SBEvent &, SBFile));
-  LLDB_REGISTER_METHOD(
-      void, SBProcess, AppendEventStateReport,
-      (const lldb::SBEvent &, lldb::SBCommandReturnObject &));
-  LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThread,
-                       (const lldb::SBThread &));
-  LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t));
-  LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByIndexID,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumQueues, ());
-  LLDB_REGISTER_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetStopID, (bool));
-  LLDB_REGISTER_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::StateType, SBProcess, GetState, ());
-  LLDB_REGISTER_METHOD(int, SBProcess, GetExitStatus, ());
-  LLDB_REGISTER_METHOD(const char *, SBProcess, GetExitDescription, ());
-  LLDB_REGISTER_METHOD(lldb::pid_t, SBProcess, GetProcessID, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetUniqueID, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::ByteOrder, SBProcess, GetByteOrder, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, GetAddressByteSize, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Continue, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Destroy, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Stop, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Kill, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, (bool));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Signal, (int));
-  LLDB_REGISTER_METHOD(lldb::SBUnixSignals, SBProcess, GetUnixSignals, ());
-  LLDB_REGISTER_METHOD(void, SBProcess, SendAsyncInterrupt, ());
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByID,
-                       (lldb::tid_t));
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID,
-                       (uint32_t));
-  LLDB_REGISTER_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(size_t, SBProcess,
-                              GetNumRestartedReasonsFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
-                              GetRestartedReasonAtIndexFromEvent,
-                              (const lldb::SBEvent &, size_t));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
-                              GetStructuredDataFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBProcess, GetBroadcaster,
-                             ());
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, GetBroadcasterClass,
-                              ());
-  LLDB_REGISTER_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
-                       (lldb::addr_t, uint32_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
-                       (lldb::addr_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBProcess,
-                       GetExtendedCrashInformation, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess,
-                             GetNumSupportedHardwareWatchpoints,
-                             (lldb::SBError &));
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImage,
-                       (lldb::SBFileSpec &, lldb::SBError &));
-  LLDB_REGISTER_METHOD(
-      uint32_t, SBProcess, LoadImage,
-      (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &));
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
-                       (const lldb::SBFileSpec &, lldb::SBStringList &,
-                        lldb::SBFileSpec &, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SendEventData,
-                       (const char *));
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumExtendedBacktraceTypes, ());
-  LLDB_REGISTER_METHOD(const char *, SBProcess,
-                       GetExtendedBacktraceTypeAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
-                       (lldb::addr_t));
-  LLDB_REGISTER_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
-                       (lldb::InstrumentationRuntimeType));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
-                       (lldb::addr_t, lldb::SBMemoryRegionInfo &));
-  LLDB_REGISTER_METHOD(lldb::SBMemoryRegionInfoList, SBProcess,
-                       GetMemoryRegions, ());
-  LLDB_REGISTER_METHOD(lldb::SBProcessInfo, SBProcess, GetProcessInfo, ());
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, AllocateMemory,
-                       (size_t, uint32_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, DeallocateMemory,
-                       (lldb::addr_t));
-
-  LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetSTDOUT);
-  LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetSTDERR);
-  LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData);
-}
-
-}
-}
diff --git a/lldb/source/API/SBProcessInfo.cpp b/lldb/source/API/SBProcessInfo.cpp
index cba3bdc179f3..da3db75ff47e 100644
--- a/lldb/source/API/SBProcessInfo.cpp
+++ b/lldb/source/API/SBProcessInfo.cpp
@@ -7,20 +7,18 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBProcessInfo.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBFileSpec.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/ProcessInfo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBProcessInfo::SBProcessInfo() : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcessInfo);
-}
+SBProcessInfo::SBProcessInfo() { LLDB_INSTRUMENT_VA(this); }
 
-SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &), rhs);
+SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
@@ -28,13 +26,11 @@ SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_up() {
 SBProcessInfo::~SBProcessInfo() = default;
 
 SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBProcessInfo &,
-                     SBProcessInfo, operator=,(const lldb::SBProcessInfo &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 ProcessInstanceInfo &SBProcessInfo::ref() {
@@ -49,17 +45,17 @@ void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) {
 }
 
 bool SBProcessInfo::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBProcessInfo::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up != nullptr;
 }
 
 const char *SBProcessInfo::GetName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
   if (m_opaque_up) {
@@ -69,18 +65,17 @@ const char *SBProcessInfo::GetName() {
 }
 
 SBFileSpec SBProcessInfo::GetExecutableFile() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo,
-                             GetExecutableFile);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFileSpec file_spec;
   if (m_opaque_up) {
     file_spec.SetFileSpec(m_opaque_up->GetExecutableFile());
   }
-  return LLDB_RECORD_RESULT(file_spec);
+  return file_spec;
 }
 
 lldb::pid_t SBProcessInfo::GetProcessID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetProcessID);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
   if (m_opaque_up) {
@@ -90,7 +85,7 @@ lldb::pid_t SBProcessInfo::GetProcessID() {
 }
 
 uint32_t SBProcessInfo::GetUserID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t user_id = UINT32_MAX;
   if (m_opaque_up) {
@@ -100,7 +95,7 @@ uint32_t SBProcessInfo::GetUserID() {
 }
 
 uint32_t SBProcessInfo::GetGroupID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t group_id = UINT32_MAX;
   if (m_opaque_up) {
@@ -110,7 +105,7 @@ uint32_t SBProcessInfo::GetGroupID() {
 }
 
 bool SBProcessInfo::UserIDIsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid);
+  LLDB_INSTRUMENT_VA(this);
 
   bool is_valid = false;
   if (m_opaque_up) {
@@ -120,7 +115,7 @@ bool SBProcessInfo::UserIDIsValid() {
 }
 
 bool SBProcessInfo::GroupIDIsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid);
+  LLDB_INSTRUMENT_VA(this);
 
   bool is_valid = false;
   if (m_opaque_up) {
@@ -130,7 +125,7 @@ bool SBProcessInfo::GroupIDIsValid() {
 }
 
 uint32_t SBProcessInfo::GetEffectiveUserID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t user_id = UINT32_MAX;
   if (m_opaque_up) {
@@ -140,7 +135,7 @@ uint32_t SBProcessInfo::GetEffectiveUserID() {
 }
 
 uint32_t SBProcessInfo::GetEffectiveGroupID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t group_id = UINT32_MAX;
   if (m_opaque_up) {
@@ -150,7 +145,7 @@ uint32_t SBProcessInfo::GetEffectiveGroupID() {
 }
 
 bool SBProcessInfo::EffectiveUserIDIsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid);
+  LLDB_INSTRUMENT_VA(this);
 
   bool is_valid = false;
   if (m_opaque_up) {
@@ -160,7 +155,7 @@ bool SBProcessInfo::EffectiveUserIDIsValid() {
 }
 
 bool SBProcessInfo::EffectiveGroupIDIsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid);
+  LLDB_INSTRUMENT_VA(this);
 
   bool is_valid = false;
   if (m_opaque_up) {
@@ -170,7 +165,7 @@ bool SBProcessInfo::EffectiveGroupIDIsValid() {
 }
 
 lldb::pid_t SBProcessInfo::GetParentProcessID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetParentProcessID);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
   if (m_opaque_up) {
@@ -180,7 +175,7 @@ lldb::pid_t SBProcessInfo::GetParentProcessID() {
 }
 
 const char *SBProcessInfo::GetTriple() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetTriple);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *triple = nullptr;
   if (m_opaque_up) {
@@ -193,34 +188,3 @@ const char *SBProcessInfo::GetTriple() {
   }
   return triple;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBProcessInfo>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &));
-  LLDB_REGISTER_METHOD(
-      lldb::SBProcessInfo &,
-      SBProcessInfo, operator=,(const lldb::SBProcessInfo &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, operator bool, ());
-  LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetName, ());
-  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile,
-                       ());
-  LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetProcessID, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetUserID, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetGroupID, ());
-  LLDB_REGISTER_METHOD(bool, SBProcessInfo, UserIDIsValid, ());
-  LLDB_REGISTER_METHOD(bool, SBProcessInfo, GroupIDIsValid, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveUserID, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveGroupID, ());
-  LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveUserIDIsValid, ());
-  LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveGroupIDIsValid, ());
-  LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetParentProcessID, ());
-  LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetTriple, ());
-}
-
-}
-}
diff --git a/lldb/source/API/SBQueue.cpp b/lldb/source/API/SBQueue.cpp
index 746df9e79d61..b2c143f6357e 100644
--- a/lldb/source/API/SBQueue.cpp
+++ b/lldb/source/API/SBQueue.cpp
@@ -8,8 +8,8 @@
 
 #include <cinttypes>
 
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBQueue.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBQueueItem.h"
@@ -27,11 +27,10 @@ namespace lldb_private {
 
 class QueueImpl {
 public:
-  QueueImpl() : m_queue_wp(), m_threads(), m_pending_items() {}
+  QueueImpl() {}
 
   QueueImpl(const lldb::QueueSP &queue_sp)
-      : m_queue_wp(), m_threads(), m_thread_list_fetched(false),
-        m_pending_items(), m_pending_items_fetched(false) {
+      : m_thread_list_fetched(false), m_pending_items_fetched(false) {
     m_queue_wp = queue_sp;
   }
 
@@ -216,17 +215,15 @@ private:
 };
 }
 
-SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueue);
-}
+SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) { LLDB_INSTRUMENT_VA(this); }
 
 SBQueue::SBQueue(const QueueSP &queue_sp)
     : m_opaque_sp(new QueueImpl(queue_sp)) {
-  LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &), queue_sp);
+  LLDB_INSTRUMENT_VA(this, queue_sp);
 }
 
 SBQueue::SBQueue(const SBQueue &rhs) {
-  LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (&rhs == this)
     return;
@@ -235,27 +232,26 @@ SBQueue::SBQueue(const SBQueue &rhs) {
 }
 
 const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBQueue &,
-                     SBQueue, operator=,(const lldb::SBQueue &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_sp = rhs.m_opaque_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBQueue::~SBQueue() = default;
 
 bool SBQueue::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBQueue::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->IsValid();
 }
 
 void SBQueue::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBQueue, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_sp->Clear();
 }
@@ -265,94 +261,63 @@ void SBQueue::SetQueue(const QueueSP &queue_sp) {
 }
 
 lldb::queue_id_t SBQueue::GetQueueID() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBQueue, GetQueueID);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetQueueID();
 }
 
 uint32_t SBQueue::GetIndexID() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBQueue, GetIndexID);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t index_id = m_opaque_sp->GetIndexID();
   return index_id;
 }
 
 const char *SBQueue::GetName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBQueue, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetName();
 }
 
 uint32_t SBQueue::GetNumThreads() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumThreads);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetNumThreads();
 }
 
 SBThread SBQueue::GetThreadAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBThread th = m_opaque_sp->GetThreadAtIndex(idx);
-  return LLDB_RECORD_RESULT(th);
+  return th;
 }
 
 uint32_t SBQueue::GetNumPendingItems() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumPendingItems);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetNumPendingItems();
 }
 
 SBQueueItem SBQueue::GetPendingItemAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
-                     (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
-  return LLDB_RECORD_RESULT(m_opaque_sp->GetPendingItemAtIndex(idx));
+  return m_opaque_sp->GetPendingItemAtIndex(idx);
 }
 
 uint32_t SBQueue::GetNumRunningItems() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumRunningItems);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetNumRunningItems();
 }
 
 SBProcess SBQueue::GetProcess() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBQueue, GetProcess);
+  LLDB_INSTRUMENT_VA(this);
 
-  return LLDB_RECORD_RESULT(m_opaque_sp->GetProcess());
+  return m_opaque_sp->GetProcess();
 }
 
 lldb::QueueKind SBQueue::GetKind() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::QueueKind, SBQueue, GetKind);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetKind();
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBQueue>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBQueue, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &));
-  LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &));
-  LLDB_REGISTER_METHOD(const lldb::SBQueue &,
-                       SBQueue, operator=,(const lldb::SBQueue &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBQueue, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBQueue, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBQueue, Clear, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBQueue, GetQueueID, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBQueue, GetIndexID, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBQueue, GetName, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumThreads, ());
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumPendingItems, ());
-  LLDB_REGISTER_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumRunningItems, ());
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBQueue, GetProcess, ());
-  LLDB_REGISTER_METHOD(lldb::QueueKind, SBQueue, GetKind, ());
-}
-
-}
-}
diff --git a/lldb/source/API/SBQueueItem.cpp b/lldb/source/API/SBQueueItem.cpp
index 6cd9e4514caf..b2204452c0fa 100644
--- a/lldb/source/API/SBQueueItem.cpp
+++ b/lldb/source/API/SBQueueItem.cpp
@@ -8,7 +8,6 @@
 
 #include "lldb/lldb-forward.h"
 
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBQueueItem.h"
 #include "lldb/API/SBThread.h"
@@ -16,49 +15,46 @@
 #include "lldb/Target/Process.h"
 #include "lldb/Target/QueueItem.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // Constructors
-SBQueueItem::SBQueueItem() : m_queue_item_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueueItem);
-}
+SBQueueItem::SBQueueItem() { LLDB_INSTRUMENT_VA(this); }
 
 SBQueueItem::SBQueueItem(const QueueItemSP &queue_item_sp)
     : m_queue_item_sp(queue_item_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &),
-                          queue_item_sp);
+  LLDB_INSTRUMENT_VA(this, queue_item_sp);
 }
 
 // Destructor
 SBQueueItem::~SBQueueItem() { m_queue_item_sp.reset(); }
 
 bool SBQueueItem::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBQueueItem::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_queue_item_sp.get() != nullptr;
 }
 
 void SBQueueItem::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBQueueItem, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_queue_item_sp.reset();
 }
 
 void SBQueueItem::SetQueueItem(const QueueItemSP &queue_item_sp) {
-  LLDB_RECORD_METHOD(void, SBQueueItem, SetQueueItem,
-                     (const lldb::QueueItemSP &), queue_item_sp);
+  LLDB_INSTRUMENT_VA(this, queue_item_sp);
 
   m_queue_item_sp = queue_item_sp;
 }
 
 lldb::QueueItemKind SBQueueItem::GetKind() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::QueueItemKind, SBQueueItem, GetKind);
+  LLDB_INSTRUMENT_VA(this);
 
   QueueItemKind result = eQueueItemKindUnknown;
   if (m_queue_item_sp) {
@@ -68,7 +64,7 @@ lldb::QueueItemKind SBQueueItem::GetKind() const {
 }
 
 void SBQueueItem::SetKind(lldb::QueueItemKind kind) {
-  LLDB_RECORD_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind), kind);
+  LLDB_INSTRUMENT_VA(this, kind);
 
   if (m_queue_item_sp) {
     m_queue_item_sp->SetKind(kind);
@@ -76,17 +72,17 @@ void SBQueueItem::SetKind(lldb::QueueItemKind kind) {
 }
 
 SBAddress SBQueueItem::GetAddress() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBQueueItem, GetAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   SBAddress result;
   if (m_queue_item_sp) {
     result.SetAddress(m_queue_item_sp->GetAddress());
   }
-  return LLDB_RECORD_RESULT(result);
+  return result;
 }
 
 void SBQueueItem::SetAddress(SBAddress addr) {
-  LLDB_RECORD_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), addr);
+  LLDB_INSTRUMENT_VA(this, addr);
 
   if (m_queue_item_sp) {
     m_queue_item_sp->SetAddress(addr.ref());
@@ -94,8 +90,7 @@ void SBQueueItem::SetAddress(SBAddress addr) {
 }
 
 SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBQueueItem, GetExtendedBacktraceThread,
-                     (const char *), type);
+  LLDB_INSTRUMENT_VA(this, type);
 
   SBThread result;
   if (m_queue_item_sp) {
@@ -113,28 +108,5 @@ SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) {
       }
     }
   }
-  return LLDB_RECORD_RESULT(result);
-}
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBQueueItem>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBQueueItem, Clear, ());
-  LLDB_REGISTER_METHOD(void, SBQueueItem, SetQueueItem,
-                       (const lldb::QueueItemSP &));
-  LLDB_REGISTER_METHOD_CONST(lldb::QueueItemKind, SBQueueItem, GetKind, ());
-  LLDB_REGISTER_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBQueueItem, GetAddress, ());
-  LLDB_REGISTER_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress));
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBQueueItem,
-                       GetExtendedBacktraceThread, (const char *));
-}
-
-}
+  return result;
 }
diff --git a/lldb/source/API/SBReproducer.cpp b/lldb/source/API/SBReproducer.cpp
index c9c9a03c694a..d3d27cc57748 100644
--- a/lldb/source/API/SBReproducer.cpp
+++ b/lldb/source/API/SBReproducer.cpp
@@ -6,8 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "SBReproducerPrivate.h"
-
+#include "lldb/API/SBReproducer.h"
 #include "lldb/API/LLDB.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBAttachInfo.h"
@@ -21,8 +20,10 @@
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBHostOS.h"
-#include "lldb/API/SBReproducer.h"
 #include "lldb/Host/FileSystem.h"
+#include "lldb/Utility/Instrumentation.h"
+#include "lldb/Utility/Reproducer.h"
+#include "lldb/Utility/ReproducerProvider.h"
 #include "lldb/Version/Version.h"
 
 using namespace lldb;
@@ -38,117 +39,44 @@ SBReplayOptions::SBReplayOptions(const SBReplayOptions &rhs)
 SBReplayOptions::~SBReplayOptions() = default;
 
 SBReplayOptions &SBReplayOptions::operator=(const SBReplayOptions &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs)
   if (this == &rhs)
     return *this;
   *m_opaque_up = *rhs.m_opaque_up;
   return *this;
 }
 
-void SBReplayOptions::SetVerify(bool verify) { m_opaque_up->verify = verify; }
+void SBReplayOptions::SetVerify(bool verify) {
+  LLDB_INSTRUMENT_VA(this, verify) m_opaque_up->verify = verify;
+}
 
-bool SBReplayOptions::GetVerify() const { return m_opaque_up->verify; }
+bool SBReplayOptions::GetVerify() const {
+  LLDB_INSTRUMENT_VA(this) return m_opaque_up->verify;
+}
 
 void SBReplayOptions::SetCheckVersion(bool check) {
+  LLDB_INSTRUMENT_VA(this, check)
   m_opaque_up->check_version = check;
 }
 
 bool SBReplayOptions::GetCheckVersion() const {
+  LLDB_INSTRUMENT_VA(this)
   return m_opaque_up->check_version;
 }
 
-SBRegistry::SBRegistry() {
-  Registry &R = *this;
-
-  RegisterMethods<SBAddress>(R);
-  RegisterMethods<SBAttachInfo>(R);
-  RegisterMethods<SBBlock>(R);
-  RegisterMethods<SBBreakpoint>(R);
-  RegisterMethods<SBBreakpointList>(R);
-  RegisterMethods<SBBreakpointLocation>(R);
-  RegisterMethods<SBBreakpointName>(R);
-  RegisterMethods<SBBroadcaster>(R);
-  RegisterMethods<SBCommandInterpreter>(R);
-  RegisterMethods<SBCommandInterpreterRunOptions>(R);
-  RegisterMethods<SBCommandReturnObject>(R);
-  RegisterMethods<SBCommunication>(R);
-  RegisterMethods<SBCompileUnit>(R);
-  RegisterMethods<SBData>(R);
-  RegisterMethods<SBDebugger>(R);
-  RegisterMethods<SBDeclaration>(R);
-  RegisterMethods<SBEnvironment>(R);
-  RegisterMethods<SBError>(R);
-  RegisterMethods<SBEvent>(R);
-  RegisterMethods<SBExecutionContext>(R);
-  RegisterMethods<SBExpressionOptions>(R);
-  RegisterMethods<SBFile>(R);
-  RegisterMethods<SBFileSpec>(R);
-  RegisterMethods<SBFileSpecList>(R);
-  RegisterMethods<SBFrame>(R);
-  RegisterMethods<SBFunction>(R);
-  RegisterMethods<SBHostOS>(R);
-  RegisterMethods<SBInputReader>(R);
-  RegisterMethods<SBInstruction>(R);
-  RegisterMethods<SBInstructionList>(R);
-  RegisterMethods<SBLanguageRuntime>(R);
-  RegisterMethods<SBLaunchInfo>(R);
-  RegisterMethods<SBLineEntry>(R);
-  RegisterMethods<SBListener>(R);
-  RegisterMethods<SBMemoryRegionInfo>(R);
-  RegisterMethods<SBMemoryRegionInfoList>(R);
-  RegisterMethods<SBModule>(R);
-  RegisterMethods<SBModuleSpec>(R);
-  RegisterMethods<SBPlatform>(R);
-  RegisterMethods<SBPlatformConnectOptions>(R);
-  RegisterMethods<SBPlatformShellCommand>(R);
-  RegisterMethods<SBProcess>(R);
-  RegisterMethods<SBProcessInfo>(R);
-  RegisterMethods<SBQueue>(R);
-  RegisterMethods<SBQueueItem>(R);
-  RegisterMethods<SBSection>(R);
-  RegisterMethods<SBSourceManager>(R);
-  RegisterMethods<SBStream>(R);
-  RegisterMethods<SBStringList>(R);
-  RegisterMethods<SBStructuredData>(R);
-  RegisterMethods<SBSymbol>(R);
-  RegisterMethods<SBSymbolContext>(R);
-  RegisterMethods<SBSymbolContextList>(R);
-  RegisterMethods<SBTarget>(R);
-  RegisterMethods<SBThread>(R);
-  RegisterMethods<SBThreadCollection>(R);
-  RegisterMethods<SBThreadPlan>(R);
-  RegisterMethods<SBTrace>(R);
-  RegisterMethods<SBType>(R);
-  RegisterMethods<SBTypeCategory>(R);
-  RegisterMethods<SBTypeEnumMember>(R);
-  RegisterMethods<SBTypeFilter>(R);
-  RegisterMethods<SBTypeFormat>(R);
-  RegisterMethods<SBTypeNameSpecifier>(R);
-  RegisterMethods<SBTypeSummary>(R);
-  RegisterMethods<SBTypeSummaryOptions>(R);
-  RegisterMethods<SBTypeSynthetic>(R);
-  RegisterMethods<SBUnixSignals>(R);
-  RegisterMethods<SBValue>(R);
-  RegisterMethods<SBValueList>(R);
-  RegisterMethods<SBVariablesOptions>(R);
-  RegisterMethods<SBWatchpoint>(R);
-}
-
 const char *SBReproducer::Capture() {
+  LLDB_INSTRUMENT()
   static std::string error;
   if (auto e = Reproducer::Initialize(ReproducerMode::Capture, llvm::None)) {
     error = llvm::toString(std::move(e));
     return error.c_str();
   }
 
-  if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
-    auto &p = g->GetOrCreate<SBProvider>();
-    InstrumentationData::Initialize(p.GetSerializer(), p.GetRegistry());
-  }
-
   return nullptr;
 }
 
 const char *SBReproducer::Capture(const char *path) {
+  LLDB_INSTRUMENT_VA(path)
   static std::string error;
   if (auto e =
           Reproducer::Initialize(ReproducerMode::Capture, FileSpec(path))) {
@@ -156,32 +84,32 @@ const char *SBReproducer::Capture(const char *path) {
     return error.c_str();
   }
 
-  if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
-    auto &p = g->GetOrCreate<SBProvider>();
-    InstrumentationData::Initialize(p.GetSerializer(), p.GetRegistry());
-  }
-
   return nullptr;
 }
 
 const char *SBReproducer::PassiveReplay(const char *path) {
+  LLDB_INSTRUMENT_VA(path)
   return "Reproducer replay has been removed";
 }
 
 const char *SBReproducer::Replay(const char *path) {
+  LLDB_INSTRUMENT_VA(path)
   return "Reproducer replay has been removed";
 }
 
 const char *SBReproducer::Replay(const char *path, bool skip_version_check) {
+  LLDB_INSTRUMENT_VA(path, skip_version_check)
   return Replay(path);
 }
 
 const char *SBReproducer::Replay(const char *path,
                                  const SBReplayOptions &options) {
+  LLDB_INSTRUMENT_VA(path, options)
   return Replay(path);
 }
 
 const char *SBReproducer::Finalize(const char *path) {
+  LLDB_INSTRUMENT_VA(path)
   static std::string error;
 
   repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
@@ -199,6 +127,7 @@ const char *SBReproducer::Finalize(const char *path) {
 }
 
 bool SBReproducer::Generate() {
+  LLDB_INSTRUMENT()
   auto &r = Reproducer::Instance();
   if (auto generator = r.GetGenerator()) {
     generator->Keep();
@@ -208,6 +137,7 @@ bool SBReproducer::Generate() {
 }
 
 bool SBReproducer::SetAutoGenerate(bool b) {
+  LLDB_INSTRUMENT_VA(b)
   auto &r = Reproducer::Instance();
   if (auto generator = r.GetGenerator()) {
     generator->SetAutoGenerate(b);
@@ -217,6 +147,7 @@ bool SBReproducer::SetAutoGenerate(bool b) {
 }
 
 const char *SBReproducer::GetPath() {
+  LLDB_INSTRUMENT()
   ConstString path;
   auto &r = Reproducer::Instance();
   if (FileSpec reproducer_path = Reproducer::Instance().GetReproducerPath())
@@ -225,6 +156,7 @@ const char *SBReproducer::GetPath() {
 }
 
 void SBReproducer::SetWorkingDirectory(const char *path) {
+  LLDB_INSTRUMENT_VA(path)
   if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
     auto &wp = g->GetOrCreate<repro::WorkingDirectoryProvider>();
     wp.SetDirectory(path);
@@ -232,7 +164,3 @@ void SBReproducer::SetWorkingDirectory(const char *path) {
     fp.RecordInterestingDirectory(wp.GetDirectory());
   }
 }
-
-char lldb_private::repro::SBProvider::ID = 0;
-const char *SBProvider::Info::name = "sbapi";
-const char *SBProvider::Info::file = "sbapi.bin";
diff --git a/lldb/source/API/SBReproducerPrivate.h b/lldb/source/API/SBReproducerPrivate.h
deleted file mode 100644
index 02ac31c2ad89..000000000000
--- a/lldb/source/API/SBReproducerPrivate.h
+++ /dev/null
@@ -1,78 +0,0 @@
-//===-- SBReproducerPrivate.h -----------------------------------*- C++ -*-===//
-//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLDB_SOURCE_API_SBREPRODUCERPRIVATE_H
-#define LLDB_SOURCE_API_SBREPRODUCERPRIVATE_H
-
-#include "lldb/API/SBReproducer.h"
-
-#include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/Log.h"
-#include "lldb/Utility/Reproducer.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
-#include "lldb/Utility/ReproducerProvider.h"
-
-#include "llvm/ADT/DenseMap.h"
-
-#define LLDB_GET_INSTRUMENTATION_DATA()                                        \
-  lldb_private::repro::InstrumentationData::Instance()
-
-namespace lldb_private {
-namespace repro {
-
-class SBRegistry : public Registry {
-public:
-  SBRegistry();
-};
-
-class SBProvider : public Provider<SBProvider> {
-public:
-  struct Info {
-    static const char *name;
-    static const char *file;
-  };
-
-  SBProvider(const FileSpec &directory)
-      : Provider(directory),
-        m_stream(directory.CopyByAppendingPathComponent("sbapi.bin").GetPath(),
-                 m_ec, llvm::sys::fs::OpenFlags::OF_None),
-        m_serializer(m_stream) {}
-
-  Serializer &GetSerializer() { return m_serializer; }
-  Registry &GetRegistry() { return m_registry; }
-
-  static char ID;
-
-private:
-  std::error_code m_ec;
-  llvm::raw_fd_ostream m_stream;
-  Serializer m_serializer;
-  SBRegistry m_registry;
-};
-
-class ReplayData {
-public:
-  ReplayData(std::unique_ptr<llvm::MemoryBuffer> memory_buffer)
-      : m_memory_buffer(std::move(memory_buffer)), m_registry(),
-        m_deserializer(m_memory_buffer->getBuffer()) {}
-  Deserializer &GetDeserializer() { return m_deserializer; }
-  Registry &GetRegistry() { return m_registry; }
-
-private:
-  std::unique_ptr<llvm::MemoryBuffer> m_memory_buffer;
-  SBRegistry m_registry;
-  Deserializer m_deserializer;
-};
-
-template <typename T> void RegisterMethods(Registry &R);
-
-} // namespace repro
-} // namespace lldb_private
-
-#endif
diff --git a/lldb/source/API/SBSection.cpp b/lldb/source/API/SBSection.cpp
index bb56fa18d9ca..733e0db0b5ba 100644
--- a/lldb/source/API/SBSection.cpp
+++ b/lldb/source/API/SBSection.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSection.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/Core/Module.h"
@@ -15,50 +14,47 @@
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBSection::SBSection() : m_opaque_wp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSection);
-}
+SBSection::SBSection() { LLDB_INSTRUMENT_VA(this); }
 
 SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
-  LLDB_RECORD_CONSTRUCTOR(SBSection, (const lldb::SBSection &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
-SBSection::SBSection(const lldb::SectionSP &section_sp)
-    : m_opaque_wp() // Don't init with section_sp otherwise this will throw if
-                    // section_sp doesn't contain a valid Section *
-{
+SBSection::SBSection(const lldb::SectionSP &section_sp) {
+  // Don't init with section_sp otherwise this will throw if
+  // section_sp doesn't contain a valid Section *
   if (section_sp)
     m_opaque_wp = section_sp;
 }
 
 const SBSection &SBSection::operator=(const SBSection &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBSection &,
-                     SBSection, operator=,(const lldb::SBSection &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_wp = rhs.m_opaque_wp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBSection::~SBSection() = default;
 
 bool SBSection::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBSection::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   SectionSP section_sp(GetSP());
   return section_sp && section_sp->GetModule().get() != nullptr;
 }
 
 const char *SBSection::GetName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBSection, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   SectionSP section_sp(GetSP());
   if (section_sp)
@@ -67,7 +63,7 @@ const char *SBSection::GetName() {
 }
 
 lldb::SBSection SBSection::GetParent() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBSection sb_section;
   SectionSP section_sp(GetSP());
@@ -76,12 +72,11 @@ lldb::SBSection SBSection::GetParent() {
     if (parent_section_sp)
       sb_section.SetSP(parent_section_sp);
   }
-  return LLDB_RECORD_RESULT(sb_section);
+  return sb_section;
 }
 
 lldb::SBSection SBSection::FindSubSection(const char *sect_name) {
-  LLDB_RECORD_METHOD(lldb::SBSection, SBSection, FindSubSection, (const char *),
-                     sect_name);
+  LLDB_INSTRUMENT_VA(this, sect_name);
 
   lldb::SBSection sb_section;
   if (sect_name) {
@@ -92,11 +87,11 @@ lldb::SBSection SBSection::FindSubSection(const char *sect_name) {
           section_sp->GetChildren().FindSectionByName(const_sect_name));
     }
   }
-  return LLDB_RECORD_RESULT(sb_section);
+  return sb_section;
 }
 
 size_t SBSection::GetNumSubSections() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBSection, GetNumSubSections);
+  LLDB_INSTRUMENT_VA(this);
 
   SectionSP section_sp(GetSP());
   if (section_sp)
@@ -105,14 +100,13 @@ size_t SBSection::GetNumSubSections() {
 }
 
 lldb::SBSection SBSection::GetSubSectionAtIndex(size_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, (size_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   lldb::SBSection sb_section;
   SectionSP section_sp(GetSP());
   if (section_sp)
     sb_section.SetSP(section_sp->GetChildren().GetSectionAtIndex(idx));
-  return LLDB_RECORD_RESULT(sb_section);
+  return sb_section;
 }
 
 lldb::SectionSP SBSection::GetSP() const { return m_opaque_wp.lock(); }
@@ -122,7 +116,7 @@ void SBSection::SetSP(const lldb::SectionSP &section_sp) {
 }
 
 lldb::addr_t SBSection::GetFileAddress() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetFileAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::addr_t file_addr = LLDB_INVALID_ADDRESS;
   SectionSP section_sp(GetSP());
@@ -132,8 +126,7 @@ lldb::addr_t SBSection::GetFileAddress() {
 }
 
 lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
-  LLDB_RECORD_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
-                     (lldb::SBTarget &), sb_target);
+  LLDB_INSTRUMENT_VA(this, sb_target);
 
   TargetSP target_sp(sb_target.GetSP());
   if (target_sp) {
@@ -145,7 +138,7 @@ lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
 }
 
 lldb::addr_t SBSection::GetByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   SectionSP section_sp(GetSP());
   if (section_sp)
@@ -154,7 +147,7 @@ lldb::addr_t SBSection::GetByteSize() {
 }
 
 uint64_t SBSection::GetFileOffset() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileOffset);
+  LLDB_INSTRUMENT_VA(this);
 
   SectionSP section_sp(GetSP());
   if (section_sp) {
@@ -169,7 +162,7 @@ uint64_t SBSection::GetFileOffset() {
 }
 
 uint64_t SBSection::GetFileByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   SectionSP section_sp(GetSP());
   if (section_sp)
@@ -178,14 +171,13 @@ uint64_t SBSection::GetFileByteSize() {
 }
 
 SBData SBSection::GetSectionData() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBSection, GetSectionData);
+  LLDB_INSTRUMENT_VA(this);
 
-  return LLDB_RECORD_RESULT(GetSectionData(0, UINT64_MAX));
+  return GetSectionData(0, UINT64_MAX);
 }
 
 SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) {
-  LLDB_RECORD_METHOD(lldb::SBData, SBSection, GetSectionData,
-                     (uint64_t, uint64_t), offset, size);
+  LLDB_INSTRUMENT_VA(this, offset, size);
 
   SBData sb_data;
   SectionSP section_sp(GetSP());
@@ -220,11 +212,11 @@ SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) {
       }
     }
   }
-  return LLDB_RECORD_RESULT(sb_data);
+  return sb_data;
 }
 
 SectionType SBSection::GetSectionType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SectionType, SBSection, GetSectionType);
+  LLDB_INSTRUMENT_VA(this);
 
   SectionSP section_sp(GetSP());
   if (section_sp.get())
@@ -233,7 +225,7 @@ SectionType SBSection::GetSectionType() {
 }
 
 uint32_t SBSection::GetPermissions() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSection, GetPermissions);
+  LLDB_INSTRUMENT_VA(this);
 
   SectionSP section_sp(GetSP());
   if (section_sp)
@@ -242,7 +234,7 @@ uint32_t SBSection::GetPermissions() const {
 }
 
 uint32_t SBSection::GetTargetByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSection, GetTargetByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   SectionSP section_sp(GetSP());
   if (section_sp.get())
@@ -251,8 +243,7 @@ uint32_t SBSection::GetTargetByteSize() {
 }
 
 bool SBSection::operator==(const SBSection &rhs) {
-  LLDB_RECORD_METHOD(bool, SBSection, operator==,(const lldb::SBSection &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   SectionSP lhs_section_sp(GetSP());
   SectionSP rhs_section_sp(rhs.GetSP());
@@ -262,8 +253,7 @@ bool SBSection::operator==(const SBSection &rhs) {
 }
 
 bool SBSection::operator!=(const SBSection &rhs) {
-  LLDB_RECORD_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   SectionSP lhs_section_sp(GetSP());
   SectionSP rhs_section_sp(rhs.GetSP());
@@ -271,8 +261,7 @@ bool SBSection::operator!=(const SBSection &rhs) {
 }
 
 bool SBSection::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -288,41 +277,3 @@ bool SBSection::GetDescription(SBStream &description) {
 
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBSection>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBSection, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBSection, (const lldb::SBSection &));
-  LLDB_REGISTER_METHOD(const lldb::SBSection &,
-                       SBSection, operator=,(const lldb::SBSection &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBSection, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBSection, operator bool, ());
-  LLDB_REGISTER_METHOD(const char *, SBSection, GetName, ());
-  LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetParent, ());
-  LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, FindSubSection,
-                       (const char *));
-  LLDB_REGISTER_METHOD(size_t, SBSection, GetNumSubSections, ());
-  LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex,
-                       (size_t));
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetFileAddress, ());
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
-                       (lldb::SBTarget &));
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetByteSize, ());
-  LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileOffset, ());
-  LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileByteSize, ());
-  LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData, ());
-  LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData,
-                       (uint64_t, uint64_t));
-  LLDB_REGISTER_METHOD(lldb::SectionType, SBSection, GetSectionType, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBSection, GetPermissions, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBSection, GetTargetByteSize, ());
-  LLDB_REGISTER_METHOD(bool, SBSection, operator==,(const lldb::SBSection &));
-  LLDB_REGISTER_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &));
-  LLDB_REGISTER_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBSourceManager.cpp b/lldb/source/API/SBSourceManager.cpp
index 43c3443672f7..7729f5d9d69f 100644
--- a/lldb/source/API/SBSourceManager.cpp
+++ b/lldb/source/API/SBSourceManager.cpp
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSourceManager.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/Core/Debugger.h"
@@ -24,10 +24,9 @@ namespace lldb_private {
 class SourceManagerImpl {
 public:
   SourceManagerImpl(const lldb::DebuggerSP &debugger_sp)
-      : m_debugger_wp(debugger_sp), m_target_wp() {}
+      : m_debugger_wp(debugger_sp) {}
 
-  SourceManagerImpl(const lldb::TargetSP &target_sp)
-      : m_debugger_wp(), m_target_wp(target_sp) {}
+  SourceManagerImpl(const lldb::TargetSP &target_sp) : m_target_wp(target_sp) {}
 
   SourceManagerImpl(const SourceManagerImpl &rhs) {
     if (&rhs == this)
@@ -72,21 +71,19 @@ using namespace lldb;
 using namespace lldb_private;
 
 SBSourceManager::SBSourceManager(const SBDebugger &debugger) {
-  LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &),
-                          debugger);
+  LLDB_INSTRUMENT_VA(this, debugger);
 
   m_opaque_up = std::make_unique<SourceManagerImpl>(debugger.get_sp());
 }
 
 SBSourceManager::SBSourceManager(const SBTarget &target) {
-  LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &), target);
+  LLDB_INSTRUMENT_VA(this, target);
 
   m_opaque_up = std::make_unique<SourceManagerImpl>(target.GetSP());
 }
 
 SBSourceManager::SBSourceManager(const SBSourceManager &rhs) {
-  LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &),
-                          rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (&rhs == this)
     return;
@@ -96,12 +93,10 @@ SBSourceManager::SBSourceManager(const SBSourceManager &rhs) {
 
 const lldb::SBSourceManager &SBSourceManager::
 operator=(const lldb::SBSourceManager &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBSourceManager &,
-                     SBSourceManager, operator=,(const lldb::SBSourceManager &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = std::make_unique<SourceManagerImpl>(*(rhs.m_opaque_up.get()));
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBSourceManager::~SBSourceManager() = default;
@@ -109,10 +104,7 @@ SBSourceManager::~SBSourceManager() = default;
 size_t SBSourceManager::DisplaySourceLinesWithLineNumbers(
     const SBFileSpec &file, uint32_t line, uint32_t context_before,
     uint32_t context_after, const char *current_line_cstr, SBStream &s) {
-  LLDB_RECORD_METHOD(size_t, SBSourceManager, DisplaySourceLinesWithLineNumbers,
-                     (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t,
-                      const char *, lldb::SBStream &),
-                     file, line, context_before, context_after,
+  LLDB_INSTRUMENT_VA(this, file, line, context_before, context_after,
                      current_line_cstr, s);
 
   const uint32_t column = 0;
@@ -125,11 +117,8 @@ size_t SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn(
     const SBFileSpec &file, uint32_t line, uint32_t column,
     uint32_t context_before, uint32_t context_after,
     const char *current_line_cstr, SBStream &s) {
-  LLDB_RECORD_METHOD(
-      size_t, SBSourceManager, DisplaySourceLinesWithLineNumbersAndColumn,
-      (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, uint32_t,
-       const char *, lldb::SBStream &),
-      file, line, column, context_before, context_after, current_line_cstr, s);
+  LLDB_INSTRUMENT_VA(this, file, line, column, context_before, context_after,
+                     current_line_cstr, s);
 
   if (m_opaque_up == nullptr)
     return 0;
@@ -138,27 +127,3 @@ size_t SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn(
       file.ref(), line, column, context_before, context_after,
       current_line_cstr, s.get());
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBSourceManager>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &));
-  LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &));
-  LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBSourceManager &,
-      SBSourceManager, operator=,(const lldb::SBSourceManager &));
-  LLDB_REGISTER_METHOD(size_t, SBSourceManager,
-                       DisplaySourceLinesWithLineNumbers,
-                       (const lldb::SBFileSpec &, uint32_t, uint32_t,
-                        uint32_t, const char *, lldb::SBStream &));
-  LLDB_REGISTER_METHOD(size_t, SBSourceManager,
-                       DisplaySourceLinesWithLineNumbersAndColumn,
-                       (const lldb::SBFileSpec &, uint32_t, uint32_t,
-                        uint32_t, uint32_t, const char *, lldb::SBStream &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBStream.cpp b/lldb/source/API/SBStream.cpp
index 190abd18df33..9ceef3466f93 100644
--- a/lldb/source/API/SBStream.cpp
+++ b/lldb/source/API/SBStream.cpp
@@ -8,10 +8,10 @@
 
 #include "lldb/API/SBStream.h"
 
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBFile.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/FileSystem.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
@@ -20,7 +20,7 @@ using namespace lldb;
 using namespace lldb_private;
 
 SBStream::SBStream() : m_opaque_up(new StreamString()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStream);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBStream::SBStream(SBStream &&rhs)
@@ -29,11 +29,11 @@ SBStream::SBStream(SBStream &&rhs)
 SBStream::~SBStream() = default;
 
 bool SBStream::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBStream::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_up != nullptr);
 }
@@ -41,7 +41,7 @@ SBStream::operator bool() const {
 // If this stream is not redirected to a file, it will maintain a local cache
 // for the stream data which can be accessed using this accessor.
 const char *SBStream::GetData() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBStream, GetData);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_is_file || m_opaque_up == nullptr)
     return nullptr;
@@ -52,7 +52,7 @@ const char *SBStream::GetData() {
 // If this stream is not redirected to a file, it will maintain a local cache
 // for the stream output whose length can be accessed using this accessor.
 size_t SBStream::GetSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBStream, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_is_file || m_opaque_up == nullptr)
     return 0;
@@ -61,7 +61,7 @@ size_t SBStream::GetSize() {
 }
 
 void SBStream::Print(const char *str) {
-  LLDB_RECORD_METHOD(void, SBStream, Print, (const char *), str);
+  LLDB_INSTRUMENT_VA(this, str);
 
   Printf("%s", str);
 }
@@ -76,8 +76,7 @@ void SBStream::Printf(const char *format, ...) {
 }
 
 void SBStream::RedirectToFile(const char *path, bool append) {
-  LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path,
-                     append);
+  LLDB_INSTRUMENT_VA(this, path, append);
 
   if (path == nullptr)
     return;
@@ -114,19 +113,18 @@ void SBStream::RedirectToFile(const char *path, bool append) {
 }
 
 void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) {
-  LLDB_RECORD_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), fh,
-                     transfer_fh_ownership);
+  LLDB_INSTRUMENT_VA(this, fh, transfer_fh_ownership);
   FileSP file = std::make_unique<NativeFile>(fh, transfer_fh_ownership);
   return RedirectToFile(file);
 }
 
 void SBStream::RedirectToFile(SBFile file) {
-  LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (SBFile), file)
+  LLDB_INSTRUMENT_VA(this, file)
   RedirectToFile(file.GetFile());
 }
 
 void SBStream::RedirectToFile(FileSP file_sp) {
-  LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (FileSP), file_sp);
+  LLDB_INSTRUMENT_VA(this, file_sp);
 
   if (!file_sp || !file_sp->IsValid())
     return;
@@ -150,8 +148,7 @@ void SBStream::RedirectToFile(FileSP file_sp) {
 }
 
 void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) {
-  LLDB_RECORD_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool), fd,
-                     transfer_fh_ownership);
+  LLDB_INSTRUMENT_VA(this, fd, transfer_fh_ownership);
 
   std::string local_data;
   if (m_opaque_up) {
@@ -182,7 +179,7 @@ lldb_private::Stream &SBStream::ref() {
 }
 
 void SBStream::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBStream, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up) {
     // See if we have any locally backed data. If so, copy it so we can then
@@ -193,25 +190,3 @@ void SBStream::Clear() {
       static_cast<StreamString *>(m_opaque_up.get())->Clear();
   }
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBStream>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBStream, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBStream, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBStream, operator bool, ());
-  LLDB_REGISTER_METHOD(const char *, SBStream, GetData, ());
-  LLDB_REGISTER_METHOD(size_t, SBStream, GetSize, ());
-  LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (const char *, bool));
-  LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (FileSP));
-  LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (SBFile));
-  LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool));
-  LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool));
-  LLDB_REGISTER_METHOD(void, SBStream, Clear, ());
-  LLDB_REGISTER_METHOD(void, SBStream, Print, (const char *));
-}
-
-}
-}
diff --git a/lldb/source/API/SBStringList.cpp b/lldb/source/API/SBStringList.cpp
index d9b03692ec0e..dfb77b1ab32f 100644
--- a/lldb/source/API/SBStringList.cpp
+++ b/lldb/source/API/SBStringList.cpp
@@ -7,36 +7,32 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBStringList.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/StringList.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBStringList::SBStringList() : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStringList);
-}
+SBStringList::SBStringList() { LLDB_INSTRUMENT_VA(this); }
 
-SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr)
-    : m_opaque_up() {
+SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr) {
   if (lldb_strings_ptr)
     m_opaque_up = std::make_unique<StringList>(*lldb_strings_ptr);
 }
 
-SBStringList::SBStringList(const SBStringList &rhs) : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &), rhs);
+SBStringList::SBStringList(const SBStringList &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 const SBStringList &SBStringList::operator=(const SBStringList &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBStringList &,
-                     SBStringList, operator=,(const lldb::SBStringList &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBStringList::~SBStringList() = default;
@@ -50,17 +46,17 @@ const lldb_private::StringList &SBStringList::operator*() const {
 }
 
 bool SBStringList::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBStringList::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_up != nullptr);
 }
 
 void SBStringList::AppendString(const char *str) {
-  LLDB_RECORD_METHOD(void, SBStringList, AppendString, (const char *), str);
+  LLDB_INSTRUMENT_VA(this, str);
 
   if (str != nullptr) {
     if (IsValid())
@@ -71,8 +67,7 @@ void SBStringList::AppendString(const char *str) {
 }
 
 void SBStringList::AppendList(const char **strv, int strc) {
-  LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const char **, int), strv,
-                     strc);
+  LLDB_INSTRUMENT_VA(this, strv, strc);
 
   if ((strv != nullptr) && (strc > 0)) {
     if (IsValid())
@@ -83,8 +78,7 @@ void SBStringList::AppendList(const char **strv, int strc) {
 }
 
 void SBStringList::AppendList(const SBStringList &strings) {
-  LLDB_RECORD_METHOD(void, SBStringList, AppendList,
-                     (const lldb::SBStringList &), strings);
+  LLDB_INSTRUMENT_VA(this, strings);
 
   if (strings.IsValid()) {
     if (!IsValid())
@@ -100,7 +94,7 @@ void SBStringList::AppendList(const StringList &strings) {
 }
 
 uint32_t SBStringList::GetSize() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid()) {
     return m_opaque_up->GetSize();
@@ -109,8 +103,7 @@ uint32_t SBStringList::GetSize() const {
 }
 
 const char *SBStringList::GetStringAtIndex(size_t idx) {
-  LLDB_RECORD_METHOD(const char *, SBStringList, GetStringAtIndex, (size_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   if (IsValid()) {
     return m_opaque_up->GetStringAtIndex(idx);
@@ -119,8 +112,7 @@ const char *SBStringList::GetStringAtIndex(size_t idx) {
 }
 
 const char *SBStringList::GetStringAtIndex(size_t idx) const {
-  LLDB_RECORD_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
-                           (size_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   if (IsValid()) {
     return m_opaque_up->GetStringAtIndex(idx);
@@ -129,35 +121,9 @@ const char *SBStringList::GetStringAtIndex(size_t idx) const {
 }
 
 void SBStringList::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBStringList, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid()) {
     m_opaque_up->Clear();
   }
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBStringList>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBStringList, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &));
-  LLDB_REGISTER_METHOD(const lldb::SBStringList &,
-                       SBStringList, operator=,(const lldb::SBStringList &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBStringList, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBStringList, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBStringList, AppendString, (const char *));
-  LLDB_REGISTER_METHOD(void, SBStringList, AppendList, (const char **, int));
-  LLDB_REGISTER_METHOD(void, SBStringList, AppendList,
-                       (const lldb::SBStringList &));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBStringList, GetSize, ());
-  LLDB_REGISTER_METHOD(const char *, SBStringList, GetStringAtIndex,
-                       (size_t));
-  LLDB_REGISTER_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
-                             (size_t));
-  LLDB_REGISTER_METHOD(void, SBStringList, Clear, ());
-}
-
-}
-}
diff --git a/lldb/source/API/SBStructuredData.cpp b/lldb/source/API/SBStructuredData.cpp
index e99c6194c516..498bcdd39e44 100644
--- a/lldb/source/API/SBStructuredData.cpp
+++ b/lldb/source/API/SBStructuredData.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBStructuredData.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
@@ -25,41 +25,36 @@ using namespace lldb_private;
 #pragma mark SBStructuredData
 
 SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStructuredData);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs)
     : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up)) {
-  LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &),
-                          rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp)
     : m_impl_up(new StructuredDataImpl(event_sp)) {
-  LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &), event_sp);
+  LLDB_INSTRUMENT_VA(this, event_sp);
 }
 
 SBStructuredData::SBStructuredData(const lldb_private::StructuredDataImpl &impl)
     : m_impl_up(new StructuredDataImpl(impl)) {
-  LLDB_RECORD_CONSTRUCTOR(SBStructuredData,
-                          (const lldb_private::StructuredDataImpl &), impl);
+  LLDB_INSTRUMENT_VA(this, impl);
 }
 
 SBStructuredData::~SBStructuredData() = default;
 
 SBStructuredData &SBStructuredData::
 operator=(const lldb::SBStructuredData &rhs) {
-  LLDB_RECORD_METHOD(
-      lldb::SBStructuredData &,
-      SBStructuredData, operator=,(const lldb::SBStructuredData &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   *m_impl_up = *rhs.m_impl_up;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
-                     (lldb::SBStream &), stream);
+  LLDB_INSTRUMENT_VA(this, stream);
 
   lldb::SBError error;
   std::string json_str(stream.GetData());
@@ -69,69 +64,64 @@ lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
 
   if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary)
     error.SetErrorString("Invalid Syntax");
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 lldb::SBError SBStructuredData::SetFromJSON(const char *json) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
-                     (const char *), json);
+  LLDB_INSTRUMENT_VA(this, json);
   lldb::SBStream s;
   s.Print(json);
-  return LLDB_RECORD_RESULT(SetFromJSON(s));
+  return SetFromJSON(s);
 }
 
 bool SBStructuredData::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 
 SBStructuredData::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_impl_up->IsValid();
 }
 
 void SBStructuredData::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBStructuredData, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_impl_up->Clear();
 }
 
 SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
-                           (lldb::SBStream &), stream);
+  LLDB_INSTRUMENT_VA(this, stream);
 
   SBError error;
   error.SetError(m_impl_up->GetAsJSON(stream.ref()));
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
-                           (lldb::SBStream &), stream);
+  LLDB_INSTRUMENT_VA(this, stream);
 
   Status error = m_impl_up->GetDescription(stream.ref());
   SBError sb_error;
   sb_error.SetError(error);
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 StructuredDataType SBStructuredData::GetType() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::StructuredDataType, SBStructuredData,
-                                   GetType);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_impl_up->GetType();
 }
 
 size_t SBStructuredData::GetSize() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBStructuredData, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_impl_up->GetSize();
 }
 
 bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetKeys,
-                           (lldb::SBStringList &), keys);
+  LLDB_INSTRUMENT_VA(this, keys);
 
   if (GetType() != eStructuredDataTypeDictionary)
     return false;
@@ -157,89 +147,41 @@ bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
 }
 
 lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
-                           GetValueForKey, (const char *), key);
+  LLDB_INSTRUMENT_VA(this, key);
 
   SBStructuredData result;
   result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key));
-  return LLDB_RECORD_RESULT(result);
+  return result;
 }
 
 lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
-                           GetItemAtIndex, (size_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBStructuredData result;
   result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx));
-  return LLDB_RECORD_RESULT(result);
+  return result;
 }
 
 uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const {
-  LLDB_RECORD_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
-                           (uint64_t), fail_value);
+  LLDB_INSTRUMENT_VA(this, fail_value);
 
   return m_impl_up->GetIntegerValue(fail_value);
 }
 
 double SBStructuredData::GetFloatValue(double fail_value) const {
-  LLDB_RECORD_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double),
-                           fail_value);
+  LLDB_INSTRUMENT_VA(this, fail_value);
 
   return m_impl_up->GetFloatValue(fail_value);
 }
 
 bool SBStructuredData::GetBooleanValue(bool fail_value) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool),
-                           fail_value);
+  LLDB_INSTRUMENT_VA(this, fail_value);
 
   return m_impl_up->GetBooleanValue(fail_value);
 }
 
 size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const {
-  LLDB_RECORD_CHAR_PTR_METHOD_CONST(size_t, SBStructuredData, GetStringValue,
-                                    (char *, size_t), dst, "", dst_len);
+  LLDB_INSTRUMENT_VA(this, dst, dst_len);
 
   return m_impl_up->GetStringValue(dst, dst_len);
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <> void RegisterMethods<SBStructuredData>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &));
-  LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &));
-  LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
-                            (const lldb_private::StructuredDataImpl &));
-  LLDB_REGISTER_METHOD(
-      lldb::SBStructuredData &,
-      SBStructuredData, operator=,(const lldb::SBStructuredData &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
-                       (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
-                       (const char *));
-  LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBStructuredData, Clear, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
-                             (lldb::SBStream &));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
-                             (lldb::SBStream &));
-  LLDB_REGISTER_METHOD_CONST(lldb::StructuredDataType, SBStructuredData,
-                             GetType, ());
-  LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetSize, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetKeys,
-                             (lldb::SBStringList &));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
-                             GetValueForKey, (const char *));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
-                             GetItemAtIndex, (size_t));
-  LLDB_REGISTER_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
-                             (uint64_t));
-  LLDB_REGISTER_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double));
-  LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool));
-  LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBStructuredData, GetStringValue);
-}
-
-} // namespace repro
-} // namespace lldb_private
diff --git a/lldb/source/API/SBSymbol.cpp b/lldb/source/API/SBSymbol.cpp
index d3abc13675f5..b671f987dc99 100644
--- a/lldb/source/API/SBSymbol.cpp
+++ b/lldb/source/API/SBSymbol.cpp
@@ -7,32 +7,31 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSymbol.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBSymbol::SBSymbol() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbol); }
+SBSymbol::SBSymbol() { LLDB_INSTRUMENT_VA(this); }
 
 SBSymbol::SBSymbol(lldb_private::Symbol *lldb_object_ptr)
     : m_opaque_ptr(lldb_object_ptr) {}
 
 SBSymbol::SBSymbol(const lldb::SBSymbol &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
-  LLDB_RECORD_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const SBSymbol &SBSymbol::operator=(const SBSymbol &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBSymbol &,
-                     SBSymbol, operator=,(const lldb::SBSymbol &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_ptr = rhs.m_opaque_ptr;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBSymbol::~SBSymbol() { m_opaque_ptr = nullptr; }
@@ -42,17 +41,17 @@ void SBSymbol::SetSymbol(lldb_private::Symbol *lldb_object_ptr) {
 }
 
 bool SBSymbol::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBSymbol::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_ptr != nullptr;
 }
 
 const char *SBSymbol::GetName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
   if (m_opaque_ptr)
@@ -62,7 +61,7 @@ const char *SBSymbol::GetName() const {
 }
 
 const char *SBSymbol::GetDisplayName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
   if (m_opaque_ptr)
@@ -72,7 +71,7 @@ const char *SBSymbol::GetDisplayName() const {
 }
 
 const char *SBSymbol::GetMangledName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
   if (m_opaque_ptr)
@@ -81,22 +80,19 @@ const char *SBSymbol::GetMangledName() const {
 }
 
 bool SBSymbol::operator==(const SBSymbol &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator==,(const lldb::SBSymbol &),
-                           rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_ptr == rhs.m_opaque_ptr;
 }
 
 bool SBSymbol::operator!=(const SBSymbol &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator!=,(const lldb::SBSymbol &),
-                           rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_ptr != rhs.m_opaque_ptr;
 }
 
 bool SBSymbol::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -109,16 +105,14 @@ bool SBSymbol::GetDescription(SBStream &description) {
 }
 
 SBInstructionList SBSymbol::GetInstructions(SBTarget target) {
-  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
-                     (lldb::SBTarget), target);
+  LLDB_INSTRUMENT_VA(this, target);
 
-  return LLDB_RECORD_RESULT(GetInstructions(target, nullptr));
+  return GetInstructions(target, nullptr);
 }
 
 SBInstructionList SBSymbol::GetInstructions(SBTarget target,
                                             const char *flavor_string) {
-  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
-                     (lldb::SBTarget, const char *), target, flavor_string);
+  LLDB_INSTRUMENT_VA(this, target, flavor_string);
 
   SBInstructionList sb_instructions;
   if (m_opaque_ptr) {
@@ -137,7 +131,7 @@ SBInstructionList SBSymbol::GetInstructions(SBTarget target,
       }
     }
   }
-  return LLDB_RECORD_RESULT(sb_instructions);
+  return sb_instructions;
 }
 
 lldb_private::Symbol *SBSymbol::get() { return m_opaque_ptr; }
@@ -145,17 +139,17 @@ lldb_private::Symbol *SBSymbol::get() { return m_opaque_ptr; }
 void SBSymbol::reset(lldb_private::Symbol *symbol) { m_opaque_ptr = symbol; }
 
 SBAddress SBSymbol::GetStartAddress() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetStartAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   SBAddress addr;
   if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
     addr.SetAddress(m_opaque_ptr->GetAddressRef());
   }
-  return LLDB_RECORD_RESULT(addr);
+  return addr;
 }
 
 SBAddress SBSymbol::GetEndAddress() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetEndAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   SBAddress addr;
   if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
@@ -165,11 +159,11 @@ SBAddress SBSymbol::GetEndAddress() {
       addr->Slide(m_opaque_ptr->GetByteSize());
     }
   }
-  return LLDB_RECORD_RESULT(addr);
+  return addr;
 }
 
 uint32_t SBSymbol::GetPrologueByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSymbol, GetPrologueByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->GetPrologueByteSize();
@@ -177,7 +171,7 @@ uint32_t SBSymbol::GetPrologueByteSize() {
 }
 
 SymbolType SBSymbol::GetType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SymbolType, SBSymbol, GetType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->GetType();
@@ -185,7 +179,7 @@ SymbolType SBSymbol::GetType() {
 }
 
 bool SBSymbol::IsExternal() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsExternal);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->IsExternal();
@@ -193,43 +187,9 @@ bool SBSymbol::IsExternal() {
 }
 
 bool SBSymbol::IsSynthetic() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsSynthetic);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_ptr)
     return m_opaque_ptr->IsSynthetic();
   return false;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBSymbol>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBSymbol, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &));
-  LLDB_REGISTER_METHOD(const lldb::SBSymbol &,
-                       SBSymbol, operator=,(const lldb::SBSymbol &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, operator bool, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetName, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetDisplayName, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetMangledName, ());
-  LLDB_REGISTER_METHOD_CONST(bool,
-                             SBSymbol, operator==,(const lldb::SBSymbol &));
-  LLDB_REGISTER_METHOD_CONST(bool,
-                             SBSymbol, operator!=,(const lldb::SBSymbol &));
-  LLDB_REGISTER_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
-                       (lldb::SBTarget));
-  LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
-                       (lldb::SBTarget, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetStartAddress, ());
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetEndAddress, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBSymbol, GetPrologueByteSize, ());
-  LLDB_REGISTER_METHOD(lldb::SymbolType, SBSymbol, GetType, ());
-  LLDB_REGISTER_METHOD(bool, SBSymbol, IsExternal, ());
-  LLDB_REGISTER_METHOD(bool, SBSymbol, IsSynthetic, ());
-}
-
-}
-}
diff --git a/lldb/source/API/SBSymbolContext.cpp b/lldb/source/API/SBSymbolContext.cpp
index 89fe051658ff..484399c89590 100644
--- a/lldb/source/API/SBSymbolContext.cpp
+++ b/lldb/source/API/SBSymbolContext.cpp
@@ -7,30 +7,26 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSymbolContext.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBSymbolContext::SBSymbolContext() : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext);
-}
+SBSymbolContext::SBSymbolContext() { LLDB_INSTRUMENT_VA(this); }
 
 SBSymbolContext::SBSymbolContext(const SymbolContext &sc)
     : m_opaque_up(std::make_unique<SymbolContext>(sc)) {
-  LLDB_RECORD_CONSTRUCTOR(SBSymbolContext,
-                          (const lldb_private::SymbolContext &), sc);
+  LLDB_INSTRUMENT_VA(this, sc);
 }
 
-SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &),
-                          rhs);
+SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
@@ -38,27 +34,25 @@ SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() {
 SBSymbolContext::~SBSymbolContext() = default;
 
 const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBSymbolContext &,
-                     SBSymbolContext, operator=,(const lldb::SBSymbolContext &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBSymbolContext::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBSymbolContext::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up != nullptr;
 }
 
 SBModule SBSymbolContext::GetModule() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule);
+  LLDB_INSTRUMENT_VA(this);
 
   SBModule sb_module;
   ModuleSP module_sp;
@@ -67,19 +61,17 @@ SBModule SBSymbolContext::GetModule() {
     sb_module.SetSP(module_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_module);
+  return sb_module;
 }
 
 SBCompileUnit SBSymbolContext::GetCompileUnit() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext,
-                             GetCompileUnit);
+  LLDB_INSTRUMENT_VA(this);
 
-  return LLDB_RECORD_RESULT(
-      SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : nullptr));
+  return SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : nullptr);
 }
 
 SBFunction SBSymbolContext::GetFunction() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction);
+  LLDB_INSTRUMENT_VA(this);
 
   Function *function = nullptr;
 
@@ -88,28 +80,27 @@ SBFunction SBSymbolContext::GetFunction() {
 
   SBFunction sb_function(function);
 
-  return LLDB_RECORD_RESULT(sb_function);
+  return sb_function;
 }
 
 SBBlock SBSymbolContext::GetBlock() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock);
+  LLDB_INSTRUMENT_VA(this);
 
-  return LLDB_RECORD_RESULT(
-      SBBlock(m_opaque_up ? m_opaque_up->block : nullptr));
+  return SBBlock(m_opaque_up ? m_opaque_up->block : nullptr);
 }
 
 SBLineEntry SBSymbolContext::GetLineEntry() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry);
+  LLDB_INSTRUMENT_VA(this);
 
   SBLineEntry sb_line_entry;
   if (m_opaque_up)
     sb_line_entry.SetLineEntry(m_opaque_up->line_entry);
 
-  return LLDB_RECORD_RESULT(sb_line_entry);
+  return sb_line_entry;
 }
 
 SBSymbol SBSymbolContext::GetSymbol() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol);
+  LLDB_INSTRUMENT_VA(this);
 
   Symbol *symbol = nullptr;
 
@@ -118,39 +109,35 @@ SBSymbol SBSymbolContext::GetSymbol() {
 
   SBSymbol sb_symbol(symbol);
 
-  return LLDB_RECORD_RESULT(sb_symbol);
+  return sb_symbol;
 }
 
 void SBSymbolContext::SetModule(lldb::SBModule module) {
-  LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
-                     module);
+  LLDB_INSTRUMENT_VA(this, module);
 
   ref().module_sp = module.GetSP();
 }
 
 void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) {
-  LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit,
-                     (lldb::SBCompileUnit), compile_unit);
+  LLDB_INSTRUMENT_VA(this, compile_unit);
 
   ref().comp_unit = compile_unit.get();
 }
 
 void SBSymbolContext::SetFunction(lldb::SBFunction function) {
-  LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
-                     function);
+  LLDB_INSTRUMENT_VA(this, function);
 
   ref().function = function.get();
 }
 
 void SBSymbolContext::SetBlock(lldb::SBBlock block) {
-  LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block);
+  LLDB_INSTRUMENT_VA(this, block);
 
   ref().block = block.GetPtr();
 }
 
 void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
-  LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry),
-                     line_entry);
+  LLDB_INSTRUMENT_VA(this, line_entry);
 
   if (line_entry.IsValid())
     ref().line_entry = line_entry.ref();
@@ -159,8 +146,7 @@ void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
 }
 
 void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
-  LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
-                     symbol);
+  LLDB_INSTRUMENT_VA(this, symbol);
 
   ref().symbol = symbol.get();
 }
@@ -191,8 +177,7 @@ lldb_private::SymbolContext *SBSymbolContext::get() const {
 }
 
 bool SBSymbolContext::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -207,56 +192,13 @@ bool SBSymbolContext::GetDescription(SBStream &description) {
 SBSymbolContext
 SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc,
                                          SBAddress &parent_frame_addr) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
-                           GetParentOfInlinedScope,
-                           (const lldb::SBAddress &, lldb::SBAddress &),
-                           curr_frame_pc, parent_frame_addr);
+  LLDB_INSTRUMENT_VA(this, curr_frame_pc, parent_frame_addr);
 
   SBSymbolContext sb_sc;
   if (m_opaque_up.get() && curr_frame_pc.IsValid()) {
     if (m_opaque_up->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(),
                                              parent_frame_addr.ref()))
-      return LLDB_RECORD_RESULT(sb_sc);
+      return sb_sc;
   }
-  return LLDB_RECORD_RESULT(SBSymbolContext());
-}
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBSymbolContext>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext,
-                            (const lldb_private::SymbolContext &));
-  LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBSymbolContext &,
-      SBSymbolContext, operator=,(const lldb::SBSymbolContext &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, operator bool, ());
-  LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ());
-  LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit,
-                       ());
-  LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ());
-  LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ());
-  LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ());
-  LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ());
-  LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule));
-  LLDB_REGISTER_METHOD(void, SBSymbolContext, SetCompileUnit,
-                       (lldb::SBCompileUnit));
-  LLDB_REGISTER_METHOD(void, SBSymbolContext, SetFunction,
-                       (lldb::SBFunction));
-  LLDB_REGISTER_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock));
-  LLDB_REGISTER_METHOD(void, SBSymbolContext, SetLineEntry,
-                       (lldb::SBLineEntry));
-  LLDB_REGISTER_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol));
-  LLDB_REGISTER_METHOD(bool, SBSymbolContext, GetDescription,
-                       (lldb::SBStream &));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
-                             GetParentOfInlinedScope,
-                             (const lldb::SBAddress &, lldb::SBAddress &));
-}
-
-}
+  return SBSymbolContext();
 }
diff --git a/lldb/source/API/SBSymbolContextList.cpp b/lldb/source/API/SBSymbolContextList.cpp
index 70a8bbe6694c..baa558caebbc 100644
--- a/lldb/source/API/SBSymbolContextList.cpp
+++ b/lldb/source/API/SBSymbolContextList.cpp
@@ -7,23 +7,21 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSymbolContextList.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBSymbolContextList::SBSymbolContextList()
     : m_opaque_up(new SymbolContextList()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContextList);
+  LLDB_INSTRUMENT_VA(this);
 }
 
-SBSymbolContextList::SBSymbolContextList(const SBSymbolContextList &rhs)
-    : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBSymbolContextList,
-                          (const lldb::SBSymbolContextList &), rhs);
+SBSymbolContextList::SBSymbolContextList(const SBSymbolContextList &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
@@ -32,17 +30,15 @@ SBSymbolContextList::~SBSymbolContextList() = default;
 
 const SBSymbolContextList &SBSymbolContextList::
 operator=(const SBSymbolContextList &rhs) {
-  LLDB_RECORD_METHOD(
-      const lldb::SBSymbolContextList &,
-      SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 uint32_t SBSymbolContextList::GetSize() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSymbolContextList, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up)
     return m_opaque_up->GetSize();
@@ -50,8 +46,7 @@ uint32_t SBSymbolContextList::GetSize() const {
 }
 
 SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
-                     GetContextAtIndex, (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBSymbolContext sb_sc;
   if (m_opaque_up) {
@@ -59,38 +54,36 @@ SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) {
     if (m_opaque_up->GetContextAtIndex(idx, sc))
       sb_sc = sc;
   }
-  return LLDB_RECORD_RESULT(sb_sc);
+  return sb_sc;
 }
 
 void SBSymbolContextList::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBSymbolContextList, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up)
     m_opaque_up->Clear();
 }
 
 void SBSymbolContextList::Append(SBSymbolContext &sc) {
-  LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
-                     (lldb::SBSymbolContext &), sc);
+  LLDB_INSTRUMENT_VA(this, sc);
 
   if (sc.IsValid() && m_opaque_up.get())
     m_opaque_up->Append(*sc);
 }
 
 void SBSymbolContextList::Append(SBSymbolContextList &sc_list) {
-  LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
-                     (lldb::SBSymbolContextList &), sc_list);
+  LLDB_INSTRUMENT_VA(this, sc_list);
 
   if (sc_list.IsValid() && m_opaque_up.get())
     m_opaque_up->Append(*sc_list);
 }
 
 bool SBSymbolContextList::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBSymbolContextList::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up != nullptr;
 }
@@ -105,39 +98,10 @@ lldb_private::SymbolContextList &SBSymbolContextList::operator*() const {
 }
 
 bool SBSymbolContextList::GetDescription(lldb::SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBSymbolContextList, GetDescription,
-                     (lldb::SBStream &), description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
   if (m_opaque_up)
     m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, nullptr);
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBSymbolContextList>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList,
-                            (const lldb::SBSymbolContextList &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBSymbolContextList &,
-      SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBSymbolContextList, GetSize, ());
-  LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
-                       GetContextAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBSymbolContextList, Clear, ());
-  LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
-                       (lldb::SBSymbolContext &));
-  LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
-                       (lldb::SBSymbolContextList &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, operator bool, ());
-  LLDB_REGISTER_METHOD(bool, SBSymbolContextList, GetDescription,
-                       (lldb::SBStream &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp
index dc79c77fee9e..75534b2343d4 100644
--- a/lldb/source/API/SBTarget.cpp
+++ b/lldb/source/API/SBTarget.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTarget.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/lldb-public.h"
 
@@ -93,48 +93,41 @@ static Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) {
 }
 
 // SBTarget constructor
-SBTarget::SBTarget() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTarget);
-}
+SBTarget::SBTarget() { LLDB_INSTRUMENT_VA(this); }
 
 SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &), target_sp);
+  LLDB_INSTRUMENT_VA(this, target_sp);
 }
 
 const SBTarget &SBTarget::operator=(const SBTarget &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBTarget &,
-                     SBTarget, operator=,(const lldb::SBTarget &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 // Destructor
 SBTarget::~SBTarget() = default;
 
 bool SBTarget::EventIsTargetEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   return Target::TargetEventData::GetEventDataFromEvent(event.get()) != nullptr;
 }
 
 SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
-  return LLDB_RECORD_RESULT(
-      Target::TargetEventData::GetTargetFromEvent(event.get()));
+  return Target::TargetEventData::GetTargetFromEvent(event.get());
 }
 
 uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   const ModuleList module_list =
       Target::TargetEventData::GetModuleListFromEvent(event.get());
@@ -143,34 +136,31 @@ uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) {
 
 SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx,
                                              const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndexFromEvent,
-                            (const uint32_t, const lldb::SBEvent &), idx,
-                            event);
+  LLDB_INSTRUMENT_VA(idx, event);
 
   const ModuleList module_list =
       Target::TargetEventData::GetModuleListFromEvent(event.get());
-  return LLDB_RECORD_RESULT(SBModule(module_list.GetModuleAtIndex(idx)));
+  return SBModule(module_list.GetModuleAtIndex(idx));
 }
 
 const char *SBTarget::GetBroadcasterClassName() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBTarget,
-                                    GetBroadcasterClassName);
+  LLDB_INSTRUMENT();
 
   return Target::GetStaticBroadcasterClass().AsCString();
 }
 
 bool SBTarget::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTarget::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid();
 }
 
 SBProcess SBTarget::GetProcess() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess);
+  LLDB_INSTRUMENT_VA(this);
 
   SBProcess sb_process;
   ProcessSP process_sp;
@@ -180,49 +170,49 @@ SBProcess SBTarget::GetProcess() {
     sb_process.SetSP(process_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_process);
+  return sb_process;
 }
 
 SBPlatform SBTarget::GetPlatform() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
-    return LLDB_RECORD_RESULT(SBPlatform());
+    return SBPlatform();
 
   SBPlatform platform;
   platform.m_opaque_sp = target_sp->GetPlatform();
 
-  return LLDB_RECORD_RESULT(platform);
+  return platform;
 }
 
 SBDebugger SBTarget::GetDebugger() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger);
+  LLDB_INSTRUMENT_VA(this);
 
   SBDebugger debugger;
   TargetSP target_sp(GetSP());
   if (target_sp)
     debugger.reset(target_sp->GetDebugger().shared_from_this());
-  return LLDB_RECORD_RESULT(debugger);
+  return debugger;
 }
 
 SBStructuredData SBTarget::GetStatistics() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics);
+  LLDB_INSTRUMENT_VA(this);
 
   SBStructuredData data;
   TargetSP target_sp(GetSP());
   if (!target_sp)
-    return LLDB_RECORD_RESULT(data);
+    return data;
   std::string json_str =
       llvm::formatv("{0:2}",
           DebuggerStats::ReportStatistics(target_sp->GetDebugger(),
                                           target_sp.get())).str();
   data.m_impl_up->SetObjectSP(StructuredData::ParseJSON(json_str));
-  return LLDB_RECORD_RESULT(data);
+  return data;
 }
 
 void SBTarget::SetCollectingStats(bool v) {
-  LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v);
+  LLDB_INSTRUMENT_VA(this, v);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
@@ -231,7 +221,7 @@ void SBTarget::SetCollectingStats(bool v) {
 }
 
 bool SBTarget::GetCollectingStats() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
@@ -240,16 +230,14 @@ bool SBTarget::GetCollectingStats() {
 }
 
 SBProcess SBTarget::LoadCore(const char *core_file) {
-  LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *),
-                     core_file);
+  LLDB_INSTRUMENT_VA(this, core_file);
 
   lldb::SBError error; // Ignored
-  return LLDB_RECORD_RESULT(LoadCore(core_file, error));
+  return LoadCore(core_file, error);
 }
 
 SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore,
-                     (const char *, lldb::SBError &), core_file, error);
+  LLDB_INSTRUMENT_VA(this, core_file, error);
 
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
@@ -268,18 +256,16 @@ SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) {
   } else {
     error.SetErrorString("SBTarget is invalid");
   }
-  return LLDB_RECORD_RESULT(sb_process);
+  return sb_process;
 }
 
 SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp,
                                  const char *working_directory) {
-  LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
-                     (const char **, const char **, const char *), argv, envp,
-                     working_directory);
+  LLDB_INSTRUMENT_VA(this, argv, envp, working_directory);
 
   TargetSP target_sp = GetSP();
   if (!target_sp)
-    return LLDB_RECORD_RESULT(SBProcess());
+    return SBProcess();
 
   SBLaunchInfo launch_info = GetLaunchInfo();
 
@@ -294,11 +280,11 @@ SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp,
     launch_info.SetWorkingDirectory(working_directory);
 
   SBError error;
-  return LLDB_RECORD_RESULT(Launch(launch_info, error));
+  return Launch(launch_info, error);
 }
 
 SBError SBTarget::Install() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError sb_error;
   TargetSP target_sp(GetSP());
@@ -306,7 +292,7 @@ SBError SBTarget::Install() {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     sb_error.ref() = target_sp->Install(nullptr);
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
@@ -315,12 +301,9 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
                            const char *working_directory,
                            uint32_t launch_flags, // See LaunchFlags
                            bool stop_at_entry, lldb::SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
-                     (lldb::SBListener &, const char **, const char **,
-                      const char *, const char *, const char *, const char *,
-                      uint32_t, bool, lldb::SBError &),
-                     listener, argv, envp, stdin_path, stdout_path, stderr_path,
-                     working_directory, launch_flags, stop_at_entry, error);
+  LLDB_INSTRUMENT_VA(this, listener, argv, envp, stdin_path, stdout_path,
+                     stderr_path, working_directory, launch_flags,
+                     stop_at_entry, error);
 
   SBProcess sb_process;
   ProcessSP process_sp;
@@ -345,7 +328,7 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
           error.SetErrorString("process attach is in progress");
         else
           error.SetErrorString("a process is already being debugged");
-        return LLDB_RECORD_RESULT(sb_process);
+        return sb_process;
       }
     }
 
@@ -356,7 +339,7 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
       if (listener.IsValid()) {
         error.SetErrorString("process is connected and already has a listener, "
                              "pass empty listener");
-        return LLDB_RECORD_RESULT(sb_process);
+        return sb_process;
       }
     }
 
@@ -394,14 +377,11 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
     error.SetErrorString("SBTarget is invalid");
   }
 
-  return LLDB_RECORD_RESULT(sb_process);
+  return sb_process;
 }
 
 SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
-                     (lldb::SBLaunchInfo &, lldb::SBError &), sb_launch_info,
-                     error);
-
+  LLDB_INSTRUMENT_VA(this, sb_launch_info, error);
 
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
@@ -419,7 +399,7 @@ SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) {
             error.SetErrorString("process attach is in progress");
           else
             error.SetErrorString("a process is already being debugged");
-          return LLDB_RECORD_RESULT(sb_process);
+          return sb_process;
         }
       }
     }
@@ -443,13 +423,11 @@ SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) {
     error.SetErrorString("SBTarget is invalid");
   }
 
-  return LLDB_RECORD_RESULT(sb_process);
+  return sb_process;
 }
 
 lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Attach,
-                     (lldb::SBAttachInfo &, lldb::SBError &), sb_attach_info,
-                     error);
+  LLDB_INSTRUMENT_VA(this, sb_attach_info, error);
 
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
@@ -467,7 +445,7 @@ lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) {
         } else {
           error.ref().SetErrorStringWithFormat(
               "no process found with process ID %" PRIu64, attach_pid);
-          return LLDB_RECORD_RESULT(sb_process);
+          return sb_process;
         }
       }
     }
@@ -478,7 +456,7 @@ lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) {
     error.SetErrorString("SBTarget is invalid");
   }
 
-  return LLDB_RECORD_RESULT(sb_process);
+  return sb_process;
 }
 
 lldb::SBProcess SBTarget::AttachToProcessWithID(
@@ -486,9 +464,7 @@ lldb::SBProcess SBTarget::AttachToProcessWithID(
     lldb::pid_t pid, // The process ID to attach to
     SBError &error   // An error explaining what went wrong if attach fails
 ) {
-  LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
-                     (lldb::SBListener &, lldb::pid_t, lldb::SBError &),
-                     listener, pid, error);
+  LLDB_INSTRUMENT_VA(this, listener, pid, error);
 
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
@@ -509,7 +485,7 @@ lldb::SBProcess SBTarget::AttachToProcessWithID(
   } else
     error.SetErrorString("SBTarget is invalid");
 
-  return LLDB_RECORD_RESULT(sb_process);
+  return sb_process;
 }
 
 lldb::SBProcess SBTarget::AttachToProcessWithName(
@@ -518,9 +494,7 @@ lldb::SBProcess SBTarget::AttachToProcessWithName(
     bool wait_for, // if true wait for a new instance of "name" to be launched
     SBError &error // An error explaining what went wrong if attach fails
 ) {
-  LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithName,
-                     (lldb::SBListener &, const char *, bool, lldb::SBError &),
-                     listener, name, wait_for, error);
+  LLDB_INSTRUMENT_VA(this, listener, name, wait_for, error);
 
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
@@ -538,16 +512,13 @@ lldb::SBProcess SBTarget::AttachToProcessWithName(
   } else
     error.SetErrorString("SBTarget is invalid");
 
-  return LLDB_RECORD_RESULT(sb_process);
+  return sb_process;
 }
 
 lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url,
                                         const char *plugin_name,
                                         SBError &error) {
-  LLDB_RECORD_METHOD(
-      lldb::SBProcess, SBTarget, ConnectRemote,
-      (lldb::SBListener &, const char *, const char *, lldb::SBError &),
-      listener, url, plugin_name, error);
+  LLDB_INSTRUMENT_VA(this, listener, url, plugin_name, error);
 
   SBProcess sb_process;
   ProcessSP process_sp;
@@ -573,11 +544,11 @@ lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url,
     error.SetErrorString("SBTarget is invalid");
   }
 
-  return LLDB_RECORD_RESULT(sb_process);
+  return sb_process;
 }
 
 SBFileSpec SBTarget::GetExecutable() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFileSpec exe_file_spec;
   TargetSP target_sp(GetSP());
@@ -587,19 +558,17 @@ SBFileSpec SBTarget::GetExecutable() {
       exe_file_spec.SetFileSpec(exe_module->GetFileSpec());
   }
 
-  return LLDB_RECORD_RESULT(exe_file_spec);
+  return exe_file_spec;
 }
 
 bool SBTarget::operator==(const SBTarget &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &),
-                           rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_sp.get() == rhs.m_opaque_sp.get();
 }
 
 bool SBTarget::operator!=(const SBTarget &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator!=,(const lldb::SBTarget &),
-                           rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_sp.get() != rhs.m_opaque_sp.get();
 }
@@ -611,8 +580,7 @@ void SBTarget::SetSP(const lldb::TargetSP &target_sp) {
 }
 
 lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) {
-  LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
-                     (lldb::addr_t), vm_addr);
+  LLDB_INSTRUMENT_VA(this, vm_addr);
 
   lldb::SBAddress sb_addr;
   Address &addr = sb_addr.ref();
@@ -620,18 +588,17 @@ lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) {
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     if (target_sp->ResolveLoadAddress(vm_addr, addr))
-      return LLDB_RECORD_RESULT(sb_addr);
+      return sb_addr;
   }
 
   // We have a load address that isn't in a section, just return an address
   // with the offset filled in (the address) and the section set to NULL
   addr.SetRawAddress(vm_addr);
-  return LLDB_RECORD_RESULT(sb_addr);
+  return sb_addr;
 }
 
 lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) {
-  LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
-                     (lldb::addr_t), file_addr);
+  LLDB_INSTRUMENT_VA(this, file_addr);
 
   lldb::SBAddress sb_addr;
   Address &addr = sb_addr.ref();
@@ -639,17 +606,16 @@ lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) {
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     if (target_sp->ResolveFileAddress(file_addr, addr))
-      return LLDB_RECORD_RESULT(sb_addr);
+      return sb_addr;
   }
 
   addr.SetRawAddress(file_addr);
-  return LLDB_RECORD_RESULT(sb_addr);
+  return sb_addr;
 }
 
 lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id,
                                                  lldb::addr_t vm_addr) {
-  LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
-                     (uint32_t, lldb::addr_t), stop_id, vm_addr);
+  LLDB_INSTRUMENT_VA(this, stop_id, vm_addr);
 
   lldb::SBAddress sb_addr;
   Address &addr = sb_addr.ref();
@@ -657,21 +623,19 @@ lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id,
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     if (target_sp->ResolveLoadAddress(vm_addr, addr))
-      return LLDB_RECORD_RESULT(sb_addr);
+      return sb_addr;
   }
 
   // We have a load address that isn't in a section, just return an address
   // with the offset filled in (the address) and the section set to NULL
   addr.SetRawAddress(vm_addr);
-  return LLDB_RECORD_RESULT(sb_addr);
+  return sb_addr;
 }
 
 SBSymbolContext
 SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr,
                                          uint32_t resolve_scope) {
-  LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBTarget,
-                     ResolveSymbolContextForAddress,
-                     (const lldb::SBAddress &, uint32_t), addr, resolve_scope);
+  LLDB_INSTRUMENT_VA(this, addr, resolve_scope);
 
   SBSymbolContext sc;
   SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
@@ -681,14 +645,12 @@ SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr,
       target_sp->GetImages().ResolveSymbolContextForAddress(addr.ref(), scope,
                                                             sc.ref());
   }
-  return LLDB_RECORD_RESULT(sc);
+  return sc;
 }
 
 size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size,
                             lldb::SBError &error) {
-  LLDB_RECORD_METHOD(size_t, SBTarget, ReadMemory,
-                     (const lldb::SBAddress, void *, size_t, lldb::SBError &),
-                     addr, buf, size, error);
+  LLDB_INSTRUMENT_VA(this, addr, buf, size, error);
 
   SBError sb_error;
   size_t bytes_read = 0;
@@ -706,54 +668,43 @@ size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size,
 
 SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file,
                                                   uint32_t line) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
-                     (const char *, uint32_t), file, line);
+  LLDB_INSTRUMENT_VA(this, file, line);
 
-  return LLDB_RECORD_RESULT(
-      SBBreakpoint(BreakpointCreateByLocation(SBFileSpec(file, false), line)));
+  return SBBreakpoint(
+      BreakpointCreateByLocation(SBFileSpec(file, false), line));
 }
 
 SBBreakpoint
 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
                                      uint32_t line) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
-                     (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line);
+  LLDB_INSTRUMENT_VA(this, sb_file_spec, line);
 
-  return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0));
+  return BreakpointCreateByLocation(sb_file_spec, line, 0);
 }
 
 SBBreakpoint
 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
                                      uint32_t line, lldb::addr_t offset) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
-                     (const lldb::SBFileSpec &, uint32_t, lldb::addr_t),
-                     sb_file_spec, line, offset);
+  LLDB_INSTRUMENT_VA(this, sb_file_spec, line, offset);
 
   SBFileSpecList empty_list;
-  return LLDB_RECORD_RESULT(
-      BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list));
+  return BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list);
 }
 
 SBBreakpoint
 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
                                      uint32_t line, lldb::addr_t offset,
                                      SBFileSpecList &sb_module_list) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
-                     (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
-                      lldb::SBFileSpecList &),
-                     sb_file_spec, line, offset, sb_module_list);
+  LLDB_INSTRUMENT_VA(this, sb_file_spec, line, offset, sb_module_list);
 
-  return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0,
-                                                       offset, sb_module_list));
+  return BreakpointCreateByLocation(sb_file_spec, line, 0, offset,
+                                    sb_module_list);
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByLocation(
     const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
     lldb::addr_t offset, SBFileSpecList &sb_module_list) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
-                     (const lldb::SBFileSpec &, uint32_t, uint32_t,
-                      lldb::addr_t, lldb::SBFileSpecList &),
-                     sb_file_spec, line, column, offset, sb_module_list);
+  LLDB_INSTRUMENT_VA(this, sb_file_spec, line, column, offset, sb_module_list);
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
@@ -774,17 +725,14 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation(
         skip_prologue, internal, hardware, move_to_nearest_code);
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
+  return sb_bp;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByLocation(
     const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
     lldb::addr_t offset, SBFileSpecList &sb_module_list,
     bool move_to_nearest_code) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
-                     (const lldb::SBFileSpec &, uint32_t, uint32_t,
-                      lldb::addr_t, lldb::SBFileSpecList &, bool),
-                     sb_file_spec, line, column, offset, sb_module_list,
+  LLDB_INSTRUMENT_VA(this, sb_file_spec, line, column, offset, sb_module_list,
                      move_to_nearest_code);
 
   SBBreakpoint sb_bp;
@@ -806,13 +754,12 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation(
         move_to_nearest_code ? eLazyBoolYes : eLazyBoolNo);
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
+  return sb_bp;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name,
                                               const char *module_name) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
-                     (const char *, const char *), symbol_name, module_name);
+  LLDB_INSTRUMENT_VA(this, symbol_name, module_name);
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
@@ -836,47 +783,38 @@ SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name,
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
+  return sb_bp;
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateByName(const char *symbol_name,
                                  const SBFileSpecList &module_list,
                                  const SBFileSpecList &comp_unit_list) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
-                     (const char *, const lldb::SBFileSpecList &,
-                      const lldb::SBFileSpecList &),
-                     symbol_name, module_list, comp_unit_list);
+  LLDB_INSTRUMENT_VA(this, symbol_name, module_list, comp_unit_list);
 
   lldb::FunctionNameType name_type_mask = eFunctionNameTypeAuto;
-  return LLDB_RECORD_RESULT(
-      BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown,
-                             module_list, comp_unit_list));
+  return BreakpointCreateByName(symbol_name, name_type_mask,
+                                eLanguageTypeUnknown, module_list,
+                                comp_unit_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
     const char *symbol_name, uint32_t name_type_mask,
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
-                     (const char *, uint32_t, const lldb::SBFileSpecList &,
-                      const lldb::SBFileSpecList &),
-                     symbol_name, name_type_mask, module_list, comp_unit_list);
+  LLDB_INSTRUMENT_VA(this, symbol_name, name_type_mask, module_list,
+                     comp_unit_list);
 
-  return LLDB_RECORD_RESULT(
-      BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown,
-                             module_list, comp_unit_list));
+  return BreakpointCreateByName(symbol_name, name_type_mask,
+                                eLanguageTypeUnknown, module_list,
+                                comp_unit_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
     const char *symbol_name, uint32_t name_type_mask,
     LanguageType symbol_language, const SBFileSpecList &module_list,
     const SBFileSpecList &comp_unit_list) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
-                     (const char *, uint32_t, lldb::LanguageType,
-                      const lldb::SBFileSpecList &,
-                      const lldb::SBFileSpecList &),
-                     symbol_name, name_type_mask, symbol_language, module_list,
-                     comp_unit_list);
+  LLDB_INSTRUMENT_VA(this, symbol_name, name_type_mask, symbol_language,
+                     module_list, comp_unit_list);
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
@@ -891,49 +829,38 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
                                         skip_prologue, internal, hardware);
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
+  return sb_bp;
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
     const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
-  LLDB_RECORD_METHOD(
-      lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
-      (const char **, uint32_t, uint32_t, const lldb::SBFileSpecList &,
-       const lldb::SBFileSpecList &),
-      symbol_names, num_names, name_type_mask, module_list, comp_unit_list);
+  LLDB_INSTRUMENT_VA(this, symbol_names, num_names, name_type_mask, module_list,
+                     comp_unit_list);
 
-  return LLDB_RECORD_RESULT(BreakpointCreateByNames(
-      symbol_names, num_names, name_type_mask, eLanguageTypeUnknown,
-      module_list, comp_unit_list));
+  return BreakpointCreateByNames(symbol_names, num_names, name_type_mask,
+                                 eLanguageTypeUnknown, module_list,
+                                 comp_unit_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
     const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
     LanguageType symbol_language, const SBFileSpecList &module_list,
     const SBFileSpecList &comp_unit_list) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
-                     (const char **, uint32_t, uint32_t, lldb::LanguageType,
-                      const lldb::SBFileSpecList &,
-                      const lldb::SBFileSpecList &),
-                     symbol_names, num_names, name_type_mask, symbol_language,
-                     module_list, comp_unit_list);
+  LLDB_INSTRUMENT_VA(this, symbol_names, num_names, name_type_mask,
+                     symbol_language, module_list, comp_unit_list);
 
-  return LLDB_RECORD_RESULT(BreakpointCreateByNames(
-      symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, 0,
-      module_list, comp_unit_list));
+  return BreakpointCreateByNames(symbol_names, num_names, name_type_mask,
+                                 eLanguageTypeUnknown, 0, module_list,
+                                 comp_unit_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
     const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
     LanguageType symbol_language, lldb::addr_t offset,
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
-                     (const char **, uint32_t, uint32_t, lldb::LanguageType,
-                      lldb::addr_t, const lldb::SBFileSpecList &,
-                      const lldb::SBFileSpecList &),
-                     symbol_names, num_names, name_type_mask, symbol_language,
-                     offset, module_list, comp_unit_list);
+  LLDB_INSTRUMENT_VA(this, symbol_names, num_names, name_type_mask,
+                     symbol_language, offset, module_list, comp_unit_list);
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
@@ -948,47 +875,37 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
         symbol_language, offset, skip_prologue, internal, hardware);
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
+  return sb_bp;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
                                                const char *module_name) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
-                     (const char *, const char *), symbol_name_regex,
-                     module_name);
+  LLDB_INSTRUMENT_VA(this, symbol_name_regex, module_name);
 
   SBFileSpecList module_spec_list;
   SBFileSpecList comp_unit_list;
   if (module_name && module_name[0]) {
     module_spec_list.Append(FileSpec(module_name));
   }
-  return LLDB_RECORD_RESULT(
-      BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown,
-                              module_spec_list, comp_unit_list));
+  return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown,
+                                 module_spec_list, comp_unit_list);
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
                                   const SBFileSpecList &module_list,
                                   const SBFileSpecList &comp_unit_list) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
-                     (const char *, const lldb::SBFileSpecList &,
-                      const lldb::SBFileSpecList &),
-                     symbol_name_regex, module_list, comp_unit_list);
+  LLDB_INSTRUMENT_VA(this, symbol_name_regex, module_list, comp_unit_list);
 
-  return LLDB_RECORD_RESULT(BreakpointCreateByRegex(
-      symbol_name_regex, eLanguageTypeUnknown, module_list, comp_unit_list));
+  return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown,
+                                 module_list, comp_unit_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(
     const char *symbol_name_regex, LanguageType symbol_language,
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
-  LLDB_RECORD_METHOD(
-      lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
-      (const char *, lldb::LanguageType, const lldb::SBFileSpecList &,
-       const lldb::SBFileSpecList &),
-      symbol_name_regex, symbol_language, module_list, comp_unit_list);
-
+  LLDB_INSTRUMENT_VA(this, symbol_name_regex, symbol_language, module_list,
+                     comp_unit_list);
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
@@ -1004,12 +921,11 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(
         symbol_language, skip_prologue, internal, hardware);
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
+  return sb_bp;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress,
-                     (lldb::addr_t), address);
+  LLDB_INSTRUMENT_VA(this, address);
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
@@ -1019,17 +935,16 @@ SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) {
     sb_bp = target_sp->CreateBreakpoint(address, false, hardware);
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
+  return sb_bp;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress,
-                     (lldb::SBAddress &), sb_address);
+  LLDB_INSTRUMENT_VA(this, sb_address);
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (!sb_address.IsValid()) {
-    return LLDB_RECORD_RESULT(sb_bp);
+    return sb_bp;
   }
 
   if (target_sp) {
@@ -1038,17 +953,14 @@ SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) {
     sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware);
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
+  return sb_bp;
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateBySourceRegex(const char *source_regex,
                                         const lldb::SBFileSpec &source_file,
                                         const char *module_name) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
-                     BreakpointCreateBySourceRegex,
-                     (const char *, const lldb::SBFileSpec &, const char *),
-                     source_regex, source_file, module_name);
+  LLDB_INSTRUMENT_VA(this, source_regex, source_file, module_name);
 
   SBFileSpecList module_spec_list;
 
@@ -1061,32 +973,25 @@ SBTarget::BreakpointCreateBySourceRegex(const char *source_regex,
     source_file_list.Append(source_file);
   }
 
-  return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex(
-      source_regex, module_spec_list, source_file_list));
+  return BreakpointCreateBySourceRegex(source_regex, module_spec_list,
+                                       source_file_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
     const char *source_regex, const SBFileSpecList &module_list,
     const lldb::SBFileSpecList &source_file_list) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
-                     BreakpointCreateBySourceRegex,
-                     (const char *, const lldb::SBFileSpecList &,
-                      const lldb::SBFileSpecList &),
-                     source_regex, module_list, source_file_list);
+  LLDB_INSTRUMENT_VA(this, source_regex, module_list, source_file_list);
 
-  return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex(
-      source_regex, module_list, source_file_list, SBStringList()));
+  return BreakpointCreateBySourceRegex(source_regex, module_list,
+                                       source_file_list, SBStringList());
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
     const char *source_regex, const SBFileSpecList &module_list,
     const lldb::SBFileSpecList &source_file_list,
     const SBStringList &func_names) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
-                     BreakpointCreateBySourceRegex,
-                     (const char *, const lldb::SBFileSpecList &,
-                      const lldb::SBFileSpecList &, const lldb::SBStringList &),
-                     source_regex, module_list, source_file_list, func_names);
+  LLDB_INSTRUMENT_VA(this, source_regex, module_list, source_file_list,
+                     func_names);
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
@@ -1105,15 +1010,13 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
         std::move(regexp), false, hardware, move_to_nearest_code);
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
+  return sb_bp;
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateForException(lldb::LanguageType language,
                                        bool catch_bp, bool throw_bp) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateForException,
-                     (lldb::LanguageType, bool, bool), language, catch_bp,
-                     throw_bp);
+  LLDB_INSTRUMENT_VA(this, language, catch_bp, throw_bp);
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
@@ -1124,18 +1027,15 @@ SBTarget::BreakpointCreateForException(lldb::LanguageType language,
                                                   hardware);
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
+  return sb_bp;
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript(
     const char *class_name, SBStructuredData &extra_args,
     const SBFileSpecList &module_list, const SBFileSpecList &file_list,
     bool request_hardware) {
-  LLDB_RECORD_METHOD(
-      lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript,
-      (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
-       const lldb::SBFileSpecList &, bool),
-      class_name, extra_args, module_list, file_list, request_hardware);
+  LLDB_INSTRUMENT_VA(this, class_name, extra_args, module_list, file_list,
+                     request_hardware);
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
@@ -1154,11 +1054,11 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript(
                                             &error);
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
+  return sb_bp;
 }
 
 uint32_t SBTarget::GetNumBreakpoints() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1169,8 +1069,7 @@ uint32_t SBTarget::GetNumBreakpoints() const {
 }
 
 SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBBreakpoint, SBTarget, GetBreakpointAtIndex,
-                           (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBBreakpoint sb_breakpoint;
   TargetSP target_sp(GetSP());
@@ -1178,12 +1077,11 @@ SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const {
     // The breakpoint list is thread safe, no need to lock
     sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx);
   }
-  return LLDB_RECORD_RESULT(sb_breakpoint);
+  return sb_breakpoint;
 }
 
 bool SBTarget::BreakpointDelete(break_id_t bp_id) {
-  LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t),
-                     bp_id);
+  LLDB_INSTRUMENT_VA(this, bp_id);
 
   bool result = false;
   TargetSP target_sp(GetSP());
@@ -1196,8 +1094,7 @@ bool SBTarget::BreakpointDelete(break_id_t bp_id) {
 }
 
 SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
-                     (lldb::break_id_t), bp_id);
+  LLDB_INSTRUMENT_VA(this, bp_id);
 
   SBBreakpoint sb_breakpoint;
   TargetSP target_sp(GetSP());
@@ -1206,13 +1103,12 @@ SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) {
     sb_breakpoint = target_sp->GetBreakpointByID(bp_id);
   }
 
-  return LLDB_RECORD_RESULT(sb_breakpoint);
+  return sb_breakpoint;
 }
 
 bool SBTarget::FindBreakpointsByName(const char *name,
                                      SBBreakpointList &bkpts) {
-  LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName,
-                     (const char *, lldb::SBBreakpointList &), name, bkpts);
+  LLDB_INSTRUMENT_VA(this, name, bkpts);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1233,8 +1129,7 @@ bool SBTarget::FindBreakpointsByName(const char *name,
 }
 
 void SBTarget::GetBreakpointNames(SBStringList &names) {
-  LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &),
-                     names);
+  LLDB_INSTRUMENT_VA(this, names);
 
   names.Clear();
 
@@ -1250,8 +1145,7 @@ void SBTarget::GetBreakpointNames(SBStringList &names) {
 }
 
 void SBTarget::DeleteBreakpointName(const char *name) {
-  LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *),
-                     name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1261,7 +1155,7 @@ void SBTarget::DeleteBreakpointName(const char *name) {
 }
 
 bool SBTarget::EnableAllBreakpoints() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1273,7 +1167,7 @@ bool SBTarget::EnableAllBreakpoints() {
 }
 
 bool SBTarget::DisableAllBreakpoints() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1285,7 +1179,7 @@ bool SBTarget::DisableAllBreakpoints() {
 }
 
 bool SBTarget::DeleteAllBreakpoints() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1298,29 +1192,23 @@ bool SBTarget::DeleteAllBreakpoints() {
 
 lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
                                                   SBBreakpointList &new_bps) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
-                     (lldb::SBFileSpec &, lldb::SBBreakpointList &),
-                     source_file, new_bps);
+  LLDB_INSTRUMENT_VA(this, source_file, new_bps);
 
   SBStringList empty_name_list;
-  return LLDB_RECORD_RESULT(
-      BreakpointsCreateFromFile(source_file, empty_name_list, new_bps));
+  return BreakpointsCreateFromFile(source_file, empty_name_list, new_bps);
 }
 
 lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
                                                   SBStringList &matching_names,
                                                   SBBreakpointList &new_bps) {
-  LLDB_RECORD_METHOD(
-      lldb::SBError, SBTarget, BreakpointsCreateFromFile,
-      (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &),
-      source_file, matching_names, new_bps);
+  LLDB_INSTRUMENT_VA(this, source_file, matching_names, new_bps);
 
   SBError sberr;
   TargetSP target_sp(GetSP());
   if (!target_sp) {
     sberr.SetErrorString(
         "BreakpointCreateFromFile called with invalid target.");
-    return LLDB_RECORD_RESULT(sberr);
+    return sberr;
   }
   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
@@ -1334,42 +1222,39 @@ lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
   sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(),
                                                      name_vector, bp_ids);
   if (sberr.Fail())
-    return LLDB_RECORD_RESULT(sberr);
+    return sberr;
 
   size_t num_bkpts = bp_ids.GetSize();
   for (size_t i = 0; i < num_bkpts; i++) {
     BreakpointID bp_id = bp_ids.GetBreakpointIDAtIndex(i);
     new_bps.AppendByID(bp_id.GetBreakpointID());
   }
-  return LLDB_RECORD_RESULT(sberr);
+  return sberr;
 }
 
 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
-                     (lldb::SBFileSpec &), dest_file);
+  LLDB_INSTRUMENT_VA(this, dest_file);
 
   SBError sberr;
   TargetSP target_sp(GetSP());
   if (!target_sp) {
     sberr.SetErrorString("BreakpointWriteToFile called with invalid target.");
-    return LLDB_RECORD_RESULT(sberr);
+    return sberr;
   }
   SBBreakpointList bkpt_list(*this);
-  return LLDB_RECORD_RESULT(BreakpointsWriteToFile(dest_file, bkpt_list));
+  return BreakpointsWriteToFile(dest_file, bkpt_list);
 }
 
 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file,
                                                SBBreakpointList &bkpt_list,
                                                bool append) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
-                     (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool),
-                     dest_file, bkpt_list, append);
+  LLDB_INSTRUMENT_VA(this, dest_file, bkpt_list, append);
 
   SBError sberr;
   TargetSP target_sp(GetSP());
   if (!target_sp) {
     sberr.SetErrorString("BreakpointWriteToFile called with invalid target.");
-    return LLDB_RECORD_RESULT(sberr);
+    return sberr;
   }
 
   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
@@ -1377,11 +1262,11 @@ lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file,
   bkpt_list.CopyToBreakpointIDList(bp_id_list);
   sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(),
                                                       bp_id_list, append);
-  return LLDB_RECORD_RESULT(sberr);
+  return sberr;
 }
 
 uint32_t SBTarget::GetNumWatchpoints() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1392,8 +1277,7 @@ uint32_t SBTarget::GetNumWatchpoints() const {
 }
 
 SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBWatchpoint, SBTarget, GetWatchpointAtIndex,
-                           (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBWatchpoint sb_watchpoint;
   TargetSP target_sp(GetSP());
@@ -1401,13 +1285,11 @@ SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const {
     // The watchpoint list is thread safe, no need to lock
     sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx));
   }
-  return LLDB_RECORD_RESULT(sb_watchpoint);
+  return sb_watchpoint;
 }
 
 bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) {
-  LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t),
-                     wp_id);
-
+  LLDB_INSTRUMENT_VA(this, wp_id);
 
   bool result = false;
   TargetSP target_sp(GetSP());
@@ -1422,9 +1304,7 @@ bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) {
 }
 
 SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) {
-  LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
-                     (lldb::watch_id_t), wp_id);
-
+  LLDB_INSTRUMENT_VA(this, wp_id);
 
   SBWatchpoint sb_watchpoint;
   lldb::WatchpointSP watchpoint_sp;
@@ -1437,15 +1317,13 @@ SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) {
     sb_watchpoint.SetSP(watchpoint_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_watchpoint);
+  return sb_watchpoint;
 }
 
 lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size,
                                           bool read, bool write,
                                           SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
-                     (lldb::addr_t, size_t, bool, bool, lldb::SBError &), addr,
-                     size, read, write, error);
+  LLDB_INSTRUMENT_VA(this, addr, size, read, write, error);
 
   SBWatchpoint sb_watchpoint;
   lldb::WatchpointSP watchpoint_sp;
@@ -1461,7 +1339,7 @@ lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size,
     if (watch_type == 0) {
       error.SetErrorString(
           "Can't create a watchpoint that is neither read nor write.");
-      return LLDB_RECORD_RESULT(sb_watchpoint);
+      return sb_watchpoint;
     }
 
     // Target::CreateWatchpoint() is thread safe.
@@ -1474,11 +1352,11 @@ lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size,
     sb_watchpoint.SetSP(watchpoint_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_watchpoint);
+  return sb_watchpoint;
 }
 
 bool SBTarget::EnableAllWatchpoints() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1492,7 +1370,7 @@ bool SBTarget::EnableAllWatchpoints() {
 }
 
 bool SBTarget::DisableAllWatchpoints() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1507,9 +1385,7 @@ bool SBTarget::DisableAllWatchpoints() {
 
 SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr,
                                          SBType type) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
-                     (const char *, lldb::SBAddress, lldb::SBType), name, addr,
-                     type);
+  LLDB_INSTRUMENT_VA(this, name, addr, type);
 
   SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
@@ -1522,14 +1398,12 @@ SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr,
                                                              exe_ctx, ast_type);
   }
   sb_value.SetSP(new_value_sp);
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data,
                                             lldb::SBType type) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
-                     (const char *, lldb::SBData, lldb::SBType), name, data,
-                     type);
+  LLDB_INSTRUMENT_VA(this, name, data, type);
 
   SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
@@ -1542,13 +1416,12 @@ lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data,
                                                           exe_ctx, ast_type);
   }
   sb_value.SetSP(new_value_sp);
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 lldb::SBValue SBTarget::CreateValueFromExpression(const char *name,
                                                   const char *expr) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
-                     (const char *, const char *), name, expr);
+  LLDB_INSTRUMENT_VA(this, name, expr);
 
   SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
@@ -1559,11 +1432,11 @@ lldb::SBValue SBTarget::CreateValueFromExpression(const char *name,
         ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx);
   }
   sb_value.SetSP(new_value_sp);
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 bool SBTarget::DeleteAllWatchpoints() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1578,9 +1451,7 @@ bool SBTarget::DeleteAllWatchpoints() {
 
 void SBTarget::AppendImageSearchPath(const char *from, const char *to,
                                      lldb::SBError &error) {
-  LLDB_RECORD_METHOD(void, SBTarget, AppendImageSearchPath,
-                     (const char *, const char *, lldb::SBError &), from, to,
-                     error);
+  LLDB_INSTRUMENT_VA(this, from, to, error);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
@@ -1597,18 +1468,14 @@ void SBTarget::AppendImageSearchPath(const char *from, const char *to,
 
 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
                                    const char *uuid_cstr) {
-  LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
-                     (const char *, const char *, const char *), path, triple,
-                     uuid_cstr);
+  LLDB_INSTRUMENT_VA(this, path, triple, uuid_cstr);
 
-  return LLDB_RECORD_RESULT(AddModule(path, triple, uuid_cstr, nullptr));
+  return AddModule(path, triple, uuid_cstr, nullptr);
 }
 
 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
                                    const char *uuid_cstr, const char *symfile) {
-  LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
-                     (const char *, const char *, const char *, const char *),
-                     path, triple, uuid_cstr, symfile);
+  LLDB_INSTRUMENT_VA(this, path, triple, uuid_cstr, symfile);
 
   lldb::SBModule sb_module;
   TargetSP target_sp(GetSP());
@@ -1631,23 +1498,22 @@ lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
 
     sb_module.SetSP(target_sp->GetOrCreateModule(module_spec, true /* notify */));
   }
-  return LLDB_RECORD_RESULT(sb_module);
+  return sb_module;
 }
 
 lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) {
-  LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
-                     (const lldb::SBModuleSpec &), module_spec);
+  LLDB_INSTRUMENT_VA(this, module_spec);
 
   lldb::SBModule sb_module;
   TargetSP target_sp(GetSP());
   if (target_sp)
     sb_module.SetSP(target_sp->GetOrCreateModule(*module_spec.m_opaque_up,
                                                  true /* notify */));
-  return LLDB_RECORD_RESULT(sb_module);
+  return sb_module;
 }
 
 bool SBTarget::AddModule(lldb::SBModule &module) {
-  LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module);
+  LLDB_INSTRUMENT_VA(this, module);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1658,7 +1524,7 @@ bool SBTarget::AddModule(lldb::SBModule &module) {
 }
 
 uint32_t SBTarget::GetNumModules() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t num = 0;
   TargetSP target_sp(GetSP());
@@ -1671,14 +1537,13 @@ uint32_t SBTarget::GetNumModules() const {
 }
 
 void SBTarget::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_sp.reset();
 }
 
 SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) {
-  LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule,
-                     (const lldb::SBFileSpec &), sb_file_spec);
+  LLDB_INSTRUMENT_VA(this, sb_file_spec);
 
   SBModule sb_module;
   TargetSP target_sp(GetSP());
@@ -1687,22 +1552,21 @@ SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) {
     // The module list is thread safe, no need to lock
     sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec));
   }
-  return LLDB_RECORD_RESULT(sb_module);
+  return sb_module;
 }
 
 SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) {
-  LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
-                     (const lldb::SBFileSpec &), sb_file_spec);
+  LLDB_INSTRUMENT_VA(this, sb_file_spec);
 
   SBSymbolContextList sb_sc_list;
   const TargetSP target_sp(GetSP());
   if (target_sp && sb_file_spec.IsValid())
     target_sp->GetImages().FindCompileUnits(*sb_file_spec, *sb_sc_list);
-  return LLDB_RECORD_RESULT(sb_sc_list);
+  return sb_sc_list;
 }
 
 lldb::ByteOrder SBTarget::GetByteOrder() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp)
@@ -1711,7 +1575,7 @@ lldb::ByteOrder SBTarget::GetByteOrder() {
 }
 
 const char *SBTarget::GetTriple() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTarget, GetTriple);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1726,7 +1590,7 @@ const char *SBTarget::GetTriple() {
 }
 
 uint32_t SBTarget::GetDataByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1736,7 +1600,7 @@ uint32_t SBTarget::GetDataByteSize() {
 }
 
 uint32_t SBTarget::GetCodeByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -1746,7 +1610,7 @@ uint32_t SBTarget::GetCodeByteSize() {
 }
 
 uint32_t SBTarget::GetMaximumNumberOfChildrenToDisplay() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetMaximumNumberOfChildrenToDisplay);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if(target_sp){
@@ -1756,7 +1620,7 @@ uint32_t SBTarget::GetMaximumNumberOfChildrenToDisplay() const {
 }
 
 uint32_t SBTarget::GetAddressByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp)
@@ -1765,8 +1629,7 @@ uint32_t SBTarget::GetAddressByteSize() {
 }
 
 SBModule SBTarget::GetModuleAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBModule sb_module;
   ModuleSP module_sp;
@@ -1777,11 +1640,11 @@ SBModule SBTarget::GetModuleAtIndex(uint32_t idx) {
     sb_module.SetSP(module_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_module);
+  return sb_module;
 }
 
 bool SBTarget::RemoveModule(lldb::SBModule module) {
-  LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module);
+  LLDB_INSTRUMENT_VA(this, module);
 
   TargetSP target_sp(GetSP());
   if (target_sp)
@@ -1790,22 +1653,17 @@ bool SBTarget::RemoveModule(lldb::SBModule module) {
 }
 
 SBBroadcaster SBTarget::GetBroadcaster() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBTarget,
-                                   GetBroadcaster);
-
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   SBBroadcaster broadcaster(target_sp.get(), false);
 
-
-  return LLDB_RECORD_RESULT(broadcaster);
+  return broadcaster;
 }
 
 bool SBTarget::GetDescription(SBStream &description,
                               lldb::DescriptionLevel description_level) {
-  LLDB_RECORD_METHOD(bool, SBTarget, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     description_level);
+  LLDB_INSTRUMENT_VA(this, description, description_level);
 
   Stream &strm = description.ref();
 
@@ -1820,16 +1678,15 @@ bool SBTarget::GetDescription(SBStream &description,
 
 lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name,
                                                   uint32_t name_type_mask) {
-  LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions,
-                     (const char *, uint32_t), name, name_type_mask);
+  LLDB_INSTRUMENT_VA(this, name, name_type_mask);
 
   lldb::SBSymbolContextList sb_sc_list;
   if (!name || !name[0])
-    return LLDB_RECORD_RESULT(sb_sc_list);
+    return sb_sc_list;
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
-    return LLDB_RECORD_RESULT(sb_sc_list);
+    return sb_sc_list;
 
   ModuleFunctionSearchOptions function_options;
   function_options.include_symbols = true;
@@ -1838,15 +1695,13 @@ lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name,
   FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
   target_sp->GetImages().FindFunctions(ConstString(name), mask,
                                        function_options, *sb_sc_list);
-  return LLDB_RECORD_RESULT(sb_sc_list);
+  return sb_sc_list;
 }
 
 lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name,
                                                         uint32_t max_matches,
                                                         MatchType matchtype) {
-  LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindGlobalFunctions,
-                     (const char *, uint32_t, lldb::MatchType), name,
-                     max_matches, matchtype);
+  LLDB_INSTRUMENT_VA(this, name, max_matches, matchtype);
 
   lldb::SBSymbolContextList sb_sc_list;
   if (name && name[0]) {
@@ -1876,12 +1731,11 @@ lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name,
       }
     }
   }
-  return LLDB_RECORD_RESULT(sb_sc_list);
+  return sb_sc_list;
 }
 
 lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
-  LLDB_RECORD_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *),
-                     typename_cstr);
+  LLDB_INSTRUMENT_VA(this, typename_cstr);
 
   TargetSP target_sp(GetSP());
   if (typename_cstr && typename_cstr[0] && target_sp) {
@@ -1897,7 +1751,7 @@ lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
         TypeSP type_sp(
             module_sp->FindFirstType(sc, const_typename, exact_match));
         if (type_sp)
-          return LLDB_RECORD_RESULT(SBType(type_sp));
+          return SBType(type_sp);
       }
     }
 
@@ -1907,7 +1761,7 @@ lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
         if (auto vendor = runtime->GetDeclVendor()) {
           auto types = vendor->FindTypes(const_typename, /*max_matches*/ 1);
           if (!types.empty())
-            return LLDB_RECORD_RESULT(SBType(types.front()));
+            return SBType(types.front());
         }
       }
     }
@@ -1915,28 +1769,26 @@ lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
     // No matches, search for basic typename matches
     for (auto *type_system : target_sp->GetScratchTypeSystems())
       if (auto type = type_system->GetBuiltinTypeByName(const_typename))
-        return LLDB_RECORD_RESULT(SBType(type));
+        return SBType(type);
   }
 
-  return LLDB_RECORD_RESULT(SBType());
+  return SBType();
 }
 
 SBType SBTarget::GetBasicType(lldb::BasicType type) {
-  LLDB_RECORD_METHOD(lldb::SBType, SBTarget, GetBasicType, (lldb::BasicType),
-                     type);
+  LLDB_INSTRUMENT_VA(this, type);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
     for (auto *type_system : target_sp->GetScratchTypeSystems())
       if (auto compiler_type = type_system->GetBasicTypeFromAST(type))
-        return LLDB_RECORD_RESULT(SBType(compiler_type));
+        return SBType(compiler_type);
   }
-  return LLDB_RECORD_RESULT(SBType());
+  return SBType();
 }
 
 lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) {
-  LLDB_RECORD_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *),
-                     typename_cstr);
+  LLDB_INSTRUMENT_VA(this, typename_cstr);
 
   SBTypeList sb_type_list;
   TargetSP target_sp(GetSP());
@@ -1975,13 +1827,12 @@ lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) {
           sb_type_list.Append(SBType(compiler_type));
     }
   }
-  return LLDB_RECORD_RESULT(sb_type_list);
+  return sb_type_list;
 }
 
 SBValueList SBTarget::FindGlobalVariables(const char *name,
                                           uint32_t max_matches) {
-  LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
-                     (const char *, uint32_t), name, max_matches);
+  LLDB_INSTRUMENT_VA(this, name, max_matches);
 
   SBValueList sb_value_list;
 
@@ -2003,15 +1854,13 @@ SBValueList SBTarget::FindGlobalVariables(const char *name,
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_value_list);
+  return sb_value_list;
 }
 
 SBValueList SBTarget::FindGlobalVariables(const char *name,
                                           uint32_t max_matches,
                                           MatchType matchtype) {
-  LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
-                     (const char *, uint32_t, lldb::MatchType), name,
-                     max_matches, matchtype);
+  LLDB_INSTRUMENT_VA(this, name, max_matches, matchtype);
 
   SBValueList sb_value_list;
 
@@ -2049,40 +1898,36 @@ SBValueList SBTarget::FindGlobalVariables(const char *name,
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_value_list);
+  return sb_value_list;
 }
 
 lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
-                     (const char *), name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   SBValueList sb_value_list(FindGlobalVariables(name, 1));
   if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
-    return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0));
-  return LLDB_RECORD_RESULT(SBValue());
+    return sb_value_list.GetValueAtIndex(0);
+  return SBValue();
 }
 
 SBSourceManager SBTarget::GetSourceManager() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, GetSourceManager);
+  LLDB_INSTRUMENT_VA(this);
 
   SBSourceManager source_manager(*this);
-  return LLDB_RECORD_RESULT(source_manager);
+  return source_manager;
 }
 
 lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
                                                    uint32_t count) {
-  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
-                     (lldb::SBAddress, uint32_t), base_addr, count);
+  LLDB_INSTRUMENT_VA(this, base_addr, count);
 
-  return LLDB_RECORD_RESULT(ReadInstructions(base_addr, count, nullptr));
+  return ReadInstructions(base_addr, count, nullptr);
 }
 
 lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
                                                    uint32_t count,
                                                    const char *flavor_string) {
-  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
-                     (lldb::SBAddress, uint32_t, const char *), base_addr,
-                     count, flavor_string);
+  LLDB_INSTRUMENT_VA(this, base_addr, count, flavor_string);
 
   SBInstructionList sb_instructions;
 
@@ -2106,28 +1951,22 @@ lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_instructions);
+  return sb_instructions;
 }
 
 lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr,
                                                   const void *buf,
                                                   size_t size) {
-  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
-                     (lldb::SBAddress, const void *, size_t), base_addr, buf,
-                     size);
+  LLDB_INSTRUMENT_VA(this, base_addr, buf, size);
 
-  return LLDB_RECORD_RESULT(
-      GetInstructionsWithFlavor(base_addr, nullptr, buf, size));
+  return GetInstructionsWithFlavor(base_addr, nullptr, buf, size);
 }
 
 lldb::SBInstructionList
 SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr,
                                     const char *flavor_string, const void *buf,
                                     size_t size) {
-  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget,
-                     GetInstructionsWithFlavor,
-                     (lldb::SBAddress, const char *, const void *, size_t),
-                     base_addr, flavor_string, buf, size);
+  LLDB_INSTRUMENT_VA(this, base_addr, flavor_string, buf, size);
 
   SBInstructionList sb_instructions;
 
@@ -2145,38 +1984,31 @@ SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr,
         UINT32_MAX, data_from_file));
   }
 
-  return LLDB_RECORD_RESULT(sb_instructions);
+  return sb_instructions;
 }
 
 lldb::SBInstructionList SBTarget::GetInstructions(lldb::addr_t base_addr,
                                                   const void *buf,
                                                   size_t size) {
-  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
-                     (lldb::addr_t, const void *, size_t), base_addr, buf,
-                     size);
+  LLDB_INSTRUMENT_VA(this, base_addr, buf, size);
 
-  return LLDB_RECORD_RESULT(GetInstructionsWithFlavor(
-      ResolveLoadAddress(base_addr), nullptr, buf, size));
+  return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), nullptr, buf,
+                                   size);
 }
 
 lldb::SBInstructionList
 SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr,
                                     const char *flavor_string, const void *buf,
                                     size_t size) {
-  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget,
-                     GetInstructionsWithFlavor,
-                     (lldb::addr_t, const char *, const void *, size_t),
-                     base_addr, flavor_string, buf, size);
+  LLDB_INSTRUMENT_VA(this, base_addr, flavor_string, buf, size);
 
-  return LLDB_RECORD_RESULT(GetInstructionsWithFlavor(
-      ResolveLoadAddress(base_addr), flavor_string, buf, size));
+  return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), flavor_string,
+                                   buf, size);
 }
 
 SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section,
                                         lldb::addr_t section_base_addr) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
-                     (lldb::SBSection, lldb::addr_t), section,
-                     section_base_addr);
+  LLDB_INSTRUMENT_VA(this, section, section_base_addr);
 
   SBError sb_error;
   TargetSP target_sp(GetSP());
@@ -2208,12 +2040,11 @@ SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section,
   } else {
     sb_error.SetErrorString("invalid target");
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
-                     (lldb::SBSection), section);
+  LLDB_INSTRUMENT_VA(this, section);
 
   SBError sb_error;
 
@@ -2243,13 +2074,12 @@ SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) {
   } else {
     sb_error.SetErrorStringWithFormat("invalid target");
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module,
                                        int64_t slide_offset) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
-                     (lldb::SBModule, int64_t), module, slide_offset);
+  LLDB_INSTRUMENT_VA(this, module, slide_offset);
 
   SBError sb_error;
 
@@ -2278,12 +2108,11 @@ SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module,
   } else {
     sb_error.SetErrorStringWithFormat("invalid target");
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
-                     (lldb::SBModule), module);
+  LLDB_INSTRUMENT_VA(this, module);
 
   SBError sb_error;
 
@@ -2330,13 +2159,12 @@ SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) {
   } else {
     sb_error.SetErrorStringWithFormat("invalid target");
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name,
                                                 lldb::SymbolType symbol_type) {
-  LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
-                     (const char *, lldb::SymbolType), name, symbol_type);
+  LLDB_INSTRUMENT_VA(this, name, symbol_type);
 
   SBSymbolContextList sb_sc_list;
   if (name && name[0]) {
@@ -2345,30 +2173,27 @@ lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name,
       target_sp->GetImages().FindSymbolsWithNameAndType(
           ConstString(name), symbol_type, *sb_sc_list);
   }
-  return LLDB_RECORD_RESULT(sb_sc_list);
+  return sb_sc_list;
 }
 
 lldb::SBValue SBTarget::EvaluateExpression(const char *expr) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
-                     (const char *), expr);
+  LLDB_INSTRUMENT_VA(this, expr);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
-    return LLDB_RECORD_RESULT(SBValue());
+    return SBValue();
 
   SBExpressionOptions options;
   lldb::DynamicValueType fetch_dynamic_value =
       target_sp->GetPreferDynamicValue();
   options.SetFetchDynamicValue(fetch_dynamic_value);
   options.SetUnwindOnError(true);
-  return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
+  return EvaluateExpression(expr, options);
 }
 
 lldb::SBValue SBTarget::EvaluateExpression(const char *expr,
                                            const SBExpressionOptions &options) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
-                     (const char *, const lldb::SBExpressionOptions &), expr,
-                     options);
+  LLDB_INSTRUMENT_VA(this, expr, options);
 
   Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
   SBValue expr_result;
@@ -2377,7 +2202,7 @@ lldb::SBValue SBTarget::EvaluateExpression(const char *expr,
   StackFrame *frame = nullptr;
   if (target_sp) {
     if (expr == nullptr || expr[0] == '\0') {
-      return LLDB_RECORD_RESULT(expr_result);
+      return expr_result;
     }
 
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
@@ -2397,11 +2222,11 @@ lldb::SBValue SBTarget::EvaluateExpression(const char *expr,
             "** [SBTarget::EvaluateExpression] Expression result is "
             "%s, summary %s **",
             expr_result.GetValue(), expr_result.GetSummary());
-  return LLDB_RECORD_RESULT(expr_result);
+  return expr_result;
 }
 
 lldb::addr_t SBTarget::GetStackRedZoneSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize);
+  LLDB_INSTRUMENT_VA(this);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
@@ -2418,8 +2243,7 @@ lldb::addr_t SBTarget::GetStackRedZoneSize() {
 }
 
 bool SBTarget::IsLoaded(const SBModule &module) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBTarget, IsLoaded, (const lldb::SBModule &),
-                           module);
+  LLDB_INSTRUMENT_VA(this, module);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
@@ -2433,18 +2257,17 @@ bool SBTarget::IsLoaded(const SBModule &module) const {
 }
 
 lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBLaunchInfo launch_info(nullptr);
   TargetSP target_sp(GetSP());
   if (target_sp)
     launch_info.set_ref(m_opaque_sp->GetProcessLaunchInfo());
-  return LLDB_RECORD_RESULT(launch_info);
+  return launch_info;
 }
 
 void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) {
-  LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo,
-                     (const lldb::SBLaunchInfo &), launch_info);
+  LLDB_INSTRUMENT_VA(this, launch_info);
 
   TargetSP target_sp(GetSP());
   if (target_sp)
@@ -2452,309 +2275,39 @@ void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) {
 }
 
 SBEnvironment SBTarget::GetEnvironment() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBTarget, GetEnvironment);
+  LLDB_INSTRUMENT_VA(this);
   TargetSP target_sp(GetSP());
 
   if (target_sp) {
-    return LLDB_RECORD_RESULT(SBEnvironment(target_sp->GetEnvironment()));
+    return SBEnvironment(target_sp->GetEnvironment());
   }
 
-  return LLDB_RECORD_RESULT(SBEnvironment());
+  return SBEnvironment();
 }
 
 lldb::SBTrace SBTarget::GetTrace() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTrace, SBTarget, GetTrace);
+  LLDB_INSTRUMENT_VA(this);
   TargetSP target_sp(GetSP());
 
   if (target_sp)
-    return LLDB_RECORD_RESULT(SBTrace(target_sp->GetTrace()));
+    return SBTrace(target_sp->GetTrace());
 
-  return LLDB_RECORD_RESULT(SBTrace());
+  return SBTrace();
 }
 
 lldb::SBTrace SBTarget::CreateTrace(lldb::SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBTrace, SBTarget, CreateTrace, (lldb::SBError &),
-                     error);
+  LLDB_INSTRUMENT_VA(this, error);
   TargetSP target_sp(GetSP());
   error.Clear();
 
   if (target_sp) {
     if (llvm::Expected<lldb::TraceSP> trace_sp = target_sp->CreateTrace()) {
-      return LLDB_RECORD_RESULT(SBTrace(*trace_sp));
+      return SBTrace(*trace_sp);
     } else {
       error.SetErrorString(llvm::toString(trace_sp.takeError()).c_str());
     }
   } else {
     error.SetErrorString("missing target");
   }
-  return LLDB_RECORD_RESULT(SBTrace());
-}
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBTarget>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBTarget, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &));
-  LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &));
-  LLDB_REGISTER_METHOD(const lldb::SBTarget &,
-                       SBTarget, operator=,(const lldb::SBTarget &));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget,
-                              GetModuleAtIndexFromEvent,
-                              (const uint32_t, const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName,
-                              ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTarget, operator bool, ());
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ());
-  LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ());
-  LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ());
-  LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool));
-  LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ());
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore,
-                       (const char *, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
-                       (const char **, const char **, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, Install, ());
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
-                       (lldb::SBListener &, const char **, const char **,
-                        const char *, const char *, const char *,
-                        const char *, uint32_t, bool, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
-                       (lldb::SBLaunchInfo &, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Attach,
-                       (lldb::SBAttachInfo &, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
-                       (lldb::SBListener &, lldb::pid_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(
-      lldb::SBProcess, SBTarget, AttachToProcessWithName,
-      (lldb::SBListener &, const char *, bool, lldb::SBError &));
-  LLDB_REGISTER_METHOD(
-      lldb::SBProcess, SBTarget, ConnectRemote,
-      (lldb::SBListener &, const char *, const char *, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBTarget, GetExecutable, ());
-  LLDB_REGISTER_METHOD_CONST(bool,
-                             SBTarget, operator==,(const lldb::SBTarget &));
-  LLDB_REGISTER_METHOD_CONST(bool,
-                             SBTarget, operator!=,(const lldb::SBTarget &));
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
-                       (lldb::addr_t));
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
-                       (lldb::addr_t));
-  LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
-                       (uint32_t, lldb::addr_t));
-  LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBTarget,
-                       ResolveSymbolContextForAddress,
-                       (const lldb::SBAddress &, uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
-                       BreakpointCreateByLocation, (const char *, uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
-                       BreakpointCreateByLocation,
-                       (const lldb::SBFileSpec &, uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
-                       BreakpointCreateByLocation,
-                       (const lldb::SBFileSpec &, uint32_t, lldb::addr_t));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
-                       BreakpointCreateByLocation,
-                       (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
-                        lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
-                       BreakpointCreateByLocation,
-                       (const lldb::SBFileSpec &, uint32_t, uint32_t,
-                        lldb::addr_t, lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
-                       (const lldb::SBFileSpec &, uint32_t, uint32_t,
-                        lldb::addr_t, lldb::SBFileSpecList &, bool));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
-                       (const char *, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
-                       (const char *, const lldb::SBFileSpecList &,
-                        const lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
-                       (const char *, uint32_t, const lldb::SBFileSpecList &,
-                        const lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
-                       (const char *, uint32_t, lldb::LanguageType,
-                        const lldb::SBFileSpecList &,
-                        const lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
-                       (const char **, uint32_t, uint32_t,
-                        const lldb::SBFileSpecList &,
-                        const lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
-                       (const char **, uint32_t, uint32_t, lldb::LanguageType,
-                        const lldb::SBFileSpecList &,
-                        const lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
-                       (const char **, uint32_t, uint32_t, lldb::LanguageType,
-                        lldb::addr_t, const lldb::SBFileSpecList &,
-                        const lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
-                       (const char *, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
-                       (const char *, const lldb::SBFileSpecList &,
-                        const lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
-                       (const char *, lldb::LanguageType,
-                        const lldb::SBFileSpecList &,
-                        const lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
-                       BreakpointCreateByAddress, (lldb::addr_t));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
-                       BreakpointCreateBySBAddress, (lldb::SBAddress &));
-  LLDB_REGISTER_METHOD(
-      lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
-      (const char *, const lldb::SBFileSpec &, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
-                       BreakpointCreateBySourceRegex,
-                       (const char *, const lldb::SBFileSpecList &,
-                        const lldb::SBFileSpecList &));
-  LLDB_REGISTER_METHOD(
-      lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
-      (const char *, const lldb::SBFileSpecList &,
-       const lldb::SBFileSpecList &, const lldb::SBStringList &));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
-                       BreakpointCreateForException,
-                       (lldb::LanguageType, bool, bool));
-  LLDB_REGISTER_METHOD(
-      lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript,
-      (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
-       const lldb::SBFileSpecList &, bool));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumBreakpoints, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBBreakpoint, SBTarget,
-                             GetBreakpointAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t));
-  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
-                       (lldb::break_id_t));
-  LLDB_REGISTER_METHOD(bool, SBTarget, FindBreakpointsByName,
-                       (const char *, lldb::SBBreakpointList &));
-  LLDB_REGISTER_METHOD(void, SBTarget, GetBreakpointNames,
-                       (lldb::SBStringList &));
-  LLDB_REGISTER_METHOD(void, SBTarget, DeleteBreakpointName, (const char *));
-  LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllBreakpoints, ());
-  LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllBreakpoints, ());
-  LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllBreakpoints, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
-                       (lldb::SBFileSpec &, lldb::SBBreakpointList &));
-  LLDB_REGISTER_METHOD(
-      lldb::SBError, SBTarget, BreakpointsCreateFromFile,
-      (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
-                       (lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
-                       (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumWatchpoints, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBWatchpoint, SBTarget,
-                             GetWatchpointAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t));
-  LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
-                       (lldb::watch_id_t));
-  LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
-                       (lldb::addr_t, size_t, bool, bool, lldb::SBError &));
-  LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllWatchpoints, ());
-  LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllWatchpoints, ());
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
-                       (const char *, lldb::SBAddress, lldb::SBType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
-                       (const char *, lldb::SBData, lldb::SBType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
-                       (const char *, const char *));
-  LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ());
-  LLDB_REGISTER_METHOD(void, SBTarget, AppendImageSearchPath,
-                       (const char *, const char *, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
-                       (const char *, const char *, const char *));
-  LLDB_REGISTER_METHOD(
-      lldb::SBModule, SBTarget, AddModule,
-      (const char *, const char *, const char *, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
-                       (const lldb::SBModuleSpec &));
-  LLDB_REGISTER_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &));
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumModules, ());
-  LLDB_REGISTER_METHOD(void, SBTarget, Clear, ());
-  LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, FindModule,
-                       (const lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
-                       (const lldb::SBFileSpec &));
-  LLDB_REGISTER_METHOD(lldb::ByteOrder, SBTarget, GetByteOrder, ());
-  LLDB_REGISTER_METHOD(const char *, SBTarget, GetTriple, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetDataByteSize, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetCodeByteSize, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetMaximumNumberOfChildrenToDisplay,());
-  LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ());
-  LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBTarget, GetBroadcaster,
-                             ());
-  LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-  LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions,
-                       (const char *, uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget,
-                       FindGlobalFunctions,
-                       (const char *, uint32_t, lldb::MatchType));
-  LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, GetBasicType,
-                       (lldb::BasicType));
-  LLDB_REGISTER_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
-                       (const char *, uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
-                       (const char *, uint32_t, lldb::MatchType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
-                       (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBTarget, GetSourceManager, ());
-  LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
-                       (lldb::SBAddress, uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
-                       (lldb::SBAddress, uint32_t, const char *));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
-                       (lldb::SBSection, lldb::addr_t));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
-                       (lldb::SBSection));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
-                       (lldb::SBModule, int64_t));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
-                       (lldb::SBModule));
-  LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
-                       (const char *, lldb::SymbolType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
-                       (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
-                       (const char *, const lldb::SBExpressionOptions &));
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsLoaded,
-                             (const lldb::SBModule &));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ());
-  LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo,
-                       (const lldb::SBLaunchInfo &));
-  LLDB_REGISTER_METHOD(
-      size_t, SBTarget, ReadMemory,
-      (const lldb::SBAddress, void *, size_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
-                       (lldb::SBAddress, const void *, size_t));
-  LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget,
-                       GetInstructionsWithFlavor,
-                       (lldb::SBAddress, const char *, const void *, size_t));
-  LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
-                       (lldb::addr_t, const void *, size_t));
-  LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget,
-                       GetInstructionsWithFlavor,
-                       (lldb::addr_t, const char *, const void *, size_t));
-  LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBTarget, GetEnvironment, ());
-  LLDB_REGISTER_METHOD(lldb::SBTrace, SBTarget, GetTrace, ());
-  LLDB_REGISTER_METHOD(lldb::SBTrace, SBTarget, CreateTrace, (lldb::SBError &));
-}
-
-}
+  return SBTrace();
 }
diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp
index 8d5b6f2a5423..dcc2a6ed3d18 100644
--- a/lldb/source/API/SBThread.cpp
+++ b/lldb/source/API/SBThread.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBThread.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
@@ -40,6 +39,7 @@
 #include "lldb/Target/ThreadPlanStepInstruction.h"
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Target/ThreadPlanStepRange.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StructuredData.h"
@@ -51,24 +51,23 @@ using namespace lldb;
 using namespace lldb_private;
 
 const char *SBThread::GetBroadcasterClassName() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBThread,
-                                    GetBroadcasterClassName);
+  LLDB_INSTRUMENT();
 
   return Thread::GetStaticBroadcasterClass().AsCString();
 }
 
 // Constructors
 SBThread::SBThread() : m_opaque_sp(new ExecutionContextRef()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThread);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBThread::SBThread(const ThreadSP &lldb_object_sp)
     : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
-  LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &), lldb_object_sp);
+  LLDB_INSTRUMENT_VA(this, lldb_object_sp);
 }
 
-SBThread::SBThread(const SBThread &rhs) : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::SBThread &), rhs);
+SBThread::SBThread(const SBThread &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_sp = clone(rhs.m_opaque_sp);
 }
@@ -76,19 +75,18 @@ SBThread::SBThread(const SBThread &rhs) : m_opaque_sp() {
 // Assignment operator
 
 const lldb::SBThread &SBThread::operator=(const SBThread &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBThread &,
-                     SBThread, operator=,(const lldb::SBThread &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_sp = clone(rhs.m_opaque_sp);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 // Destructor
 SBThread::~SBThread() = default;
 
 lldb::SBQueue SBThread::GetQueue() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBQueue, SBThread, GetQueue);
+  LLDB_INSTRUMENT_VA(this);
 
   SBQueue sb_queue;
   QueueSP queue_sp;
@@ -105,15 +103,15 @@ lldb::SBQueue SBThread::GetQueue() const {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_queue);
+  return sb_queue;
 }
 
 bool SBThread::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBThread::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -130,13 +128,13 @@ SBThread::operator bool() const {
 }
 
 void SBThread::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_sp->Clear();
 }
 
 StopReason SBThread::GetStopReason() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThread, GetStopReason);
+  LLDB_INSTRUMENT_VA(this);
 
   StopReason reason = eStopReasonInvalid;
   std::unique_lock<std::recursive_mutex> lock;
@@ -153,7 +151,7 @@ StopReason SBThread::GetStopReason() {
 }
 
 size_t SBThread::GetStopReasonDataCount() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThread, GetStopReasonDataCount);
+  LLDB_INSTRUMENT_VA(this);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -210,8 +208,7 @@ size_t SBThread::GetStopReasonDataCount() {
 }
 
 uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, (uint32_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -280,8 +277,7 @@ uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
 }
 
 bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
-  LLDB_RECORD_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
-                     (lldb::SBStream &), stream);
+  LLDB_INSTRUMENT_VA(this, stream);
 
   Stream &strm = stream.ref();
 
@@ -303,9 +299,7 @@ bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
 
 SBThreadCollection
 SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
-  LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread,
-                     GetStopReasonExtendedBacktraces,
-                     (lldb::InstrumentationRuntimeType), type);
+  LLDB_INSTRUMENT_VA(this, type);
 
   SBThreadCollection threads;
 
@@ -313,23 +307,22 @@ SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope())
-    return LLDB_RECORD_RESULT(SBThreadCollection());
+    return SBThreadCollection();
 
   ProcessSP process_sp = exe_ctx.GetProcessSP();
 
   StopInfoSP stop_info = exe_ctx.GetThreadPtr()->GetStopInfo();
   StructuredData::ObjectSP info = stop_info->GetExtendedInfo();
   if (!info)
-    return LLDB_RECORD_RESULT(threads);
+    return threads;
 
   threads = process_sp->GetInstrumentationRuntime(type)
                 ->GetBacktracesFromExtendedStopInfo(info);
-  return LLDB_RECORD_RESULT(threads);
+  return threads;
 }
 
 size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
-  LLDB_RECORD_CHAR_PTR_METHOD(size_t, SBThread, GetStopDescription,
-                              (char *, size_t), dst, "", dst_len);
+  LLDB_INSTRUMENT_VA(this, dst, dst_len);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -357,7 +350,7 @@ size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
 }
 
 SBValue SBThread::GetStopReturnValue() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetStopReturnValue);
+  LLDB_INSTRUMENT_VA(this);
 
   ValueObjectSP return_valobj_sp;
   std::unique_lock<std::recursive_mutex> lock;
@@ -373,7 +366,7 @@ SBValue SBThread::GetStopReturnValue() {
     }
   }
 
-  return LLDB_RECORD_RESULT(SBValue(return_valobj_sp));
+  return SBValue(return_valobj_sp);
 }
 
 void SBThread::SetThread(const ThreadSP &lldb_object_sp) {
@@ -381,7 +374,7 @@ void SBThread::SetThread(const ThreadSP &lldb_object_sp) {
 }
 
 lldb::tid_t SBThread::GetThreadID() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::tid_t, SBThread, GetThreadID);
+  LLDB_INSTRUMENT_VA(this);
 
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
@@ -390,7 +383,7 @@ lldb::tid_t SBThread::GetThreadID() const {
 }
 
 uint32_t SBThread::GetIndexID() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBThread, GetIndexID);
+  LLDB_INSTRUMENT_VA(this);
 
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
@@ -399,7 +392,7 @@ uint32_t SBThread::GetIndexID() const {
 }
 
 const char *SBThread::GetName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
   std::unique_lock<std::recursive_mutex> lock;
@@ -416,7 +409,7 @@ const char *SBThread::GetName() const {
 }
 
 const char *SBThread::GetQueueName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetQueueName);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *name = nullptr;
   std::unique_lock<std::recursive_mutex> lock;
@@ -433,7 +426,7 @@ const char *SBThread::GetQueueName() const {
 }
 
 lldb::queue_id_t SBThread::GetQueueID() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBThread, GetQueueID);
+  LLDB_INSTRUMENT_VA(this);
 
   queue_id_t id = LLDB_INVALID_QUEUE_ID;
   std::unique_lock<std::recursive_mutex> lock;
@@ -450,8 +443,7 @@ lldb::queue_id_t SBThread::GetQueueID() const {
 }
 
 bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) {
-  LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString,
-                     (const char *, lldb::SBStream &), path, strm);
+  LLDB_INSTRUMENT_VA(this, path, strm);
 
   bool success = false;
   std::unique_lock<std::recursive_mutex> lock;
@@ -532,16 +524,14 @@ SBError SBThread::ResumeNewPlan(ExecutionContext &exe_ctx,
 }
 
 void SBThread::StepOver(lldb::RunMode stop_other_threads) {
-  LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode),
-                     stop_other_threads);
+  LLDB_INSTRUMENT_VA(this, stop_other_threads);
 
   SBError error; // Ignored
   StepOver(stop_other_threads, error);
 }
 
 void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) {
-  LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode, lldb::SBError &),
-                     stop_other_threads, error);
+  LLDB_INSTRUMENT_VA(this, stop_other_threads, error);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -573,16 +563,14 @@ void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) {
 }
 
 void SBThread::StepInto(lldb::RunMode stop_other_threads) {
-  LLDB_RECORD_METHOD(void, SBThread, StepInto, (lldb::RunMode),
-                     stop_other_threads);
+  LLDB_INSTRUMENT_VA(this, stop_other_threads);
 
   StepInto(nullptr, stop_other_threads);
 }
 
 void SBThread::StepInto(const char *target_name,
                         lldb::RunMode stop_other_threads) {
-  LLDB_RECORD_METHOD(void, SBThread, StepInto, (const char *, lldb::RunMode),
-                     target_name, stop_other_threads);
+  LLDB_INSTRUMENT_VA(this, target_name, stop_other_threads);
 
   SBError error; // Ignored
   StepInto(target_name, LLDB_INVALID_LINE_NUMBER, error, stop_other_threads);
@@ -590,10 +578,7 @@ void SBThread::StepInto(const char *target_name,
 
 void SBThread::StepInto(const char *target_name, uint32_t end_line,
                         SBError &error, lldb::RunMode stop_other_threads) {
-  LLDB_RECORD_METHOD(void, SBThread, StepInto,
-                     (const char *, uint32_t, lldb::SBError &, lldb::RunMode),
-                     target_name, end_line, error, stop_other_threads);
-
+  LLDB_INSTRUMENT_VA(this, target_name, end_line, error, stop_other_threads);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -640,14 +625,14 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line,
 }
 
 void SBThread::StepOut() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, StepOut);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError error; // Ignored
   StepOut(error);
 }
 
 void SBThread::StepOut(SBError &error) {
-  LLDB_RECORD_METHOD(void, SBThread, StepOut, (lldb::SBError &), error);
+  LLDB_INSTRUMENT_VA(this, error);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -675,17 +660,14 @@ void SBThread::StepOut(SBError &error) {
 }
 
 void SBThread::StepOutOfFrame(SBFrame &sb_frame) {
-  LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &),
-                     sb_frame);
+  LLDB_INSTRUMENT_VA(this, sb_frame);
 
   SBError error; // Ignored
   StepOutOfFrame(sb_frame, error);
 }
 
 void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
-  LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame,
-                     (lldb::SBFrame &, lldb::SBError &), sb_frame, error);
-
+  LLDB_INSTRUMENT_VA(this, sb_frame, error);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -722,15 +704,14 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
 }
 
 void SBThread::StepInstruction(bool step_over) {
-  LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool), step_over);
+  LLDB_INSTRUMENT_VA(this, step_over);
 
   SBError error; // Ignored
   StepInstruction(step_over, error);
 }
 
 void SBThread::StepInstruction(bool step_over, SBError &error) {
-  LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool, lldb::SBError &),
-                     step_over, error);
+  LLDB_INSTRUMENT_VA(this, step_over, error);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -752,15 +733,14 @@ void SBThread::StepInstruction(bool step_over, SBError &error) {
 }
 
 void SBThread::RunToAddress(lldb::addr_t addr) {
-  LLDB_RECORD_METHOD(void, SBThread, RunToAddress, (lldb::addr_t), addr);
+  LLDB_INSTRUMENT_VA(this, addr);
 
   SBError error; // Ignored
   RunToAddress(addr, error);
 }
 
 void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
-  LLDB_RECORD_METHOD(void, SBThread, RunToAddress,
-                     (lldb::addr_t, lldb::SBError &), addr, error);
+  LLDB_INSTRUMENT_VA(this, addr, error);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -789,9 +769,7 @@ void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
 
 SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
                                 lldb::SBFileSpec &sb_file_spec, uint32_t line) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepOverUntil,
-                     (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t), sb_frame,
-                     sb_file_spec, line);
+  LLDB_INSTRUMENT_VA(this, sb_frame, sb_file_spec, line);
 
   SBError sb_error;
   char path[PATH_MAX];
@@ -807,7 +785,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
 
     if (line == 0) {
       sb_error.SetErrorString("invalid line argument");
-      return LLDB_RECORD_RESULT(sb_error);
+      return sb_error;
     }
 
     if (!frame_sp) {
@@ -819,7 +797,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
     SymbolContext frame_sc;
     if (!frame_sp) {
       sb_error.SetErrorString("no valid frames in thread to step");
-      return LLDB_RECORD_RESULT(sb_error);
+      return sb_error;
     }
 
     // If we have a frame, get its line
@@ -830,7 +808,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
     if (frame_sc.comp_unit == nullptr) {
       sb_error.SetErrorStringWithFormat(
           "frame %u doesn't have debug information", frame_sp->GetFrameIndex());
-      return LLDB_RECORD_RESULT(sb_error);
+      return sb_error;
     }
 
     FileSpec step_file_spec;
@@ -842,7 +820,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
         step_file_spec = frame_sc.line_entry.file;
       else {
         sb_error.SetErrorString("invalid file argument or no file for frame");
-        return LLDB_RECORD_RESULT(sb_error);
+        return sb_error;
       }
     }
 
@@ -904,34 +882,28 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
   } else {
     sb_error.SetErrorString("this SBThread object is invalid");
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
-                     (const char *), script_class_name);
+  LLDB_INSTRUMENT_VA(this, script_class_name);
 
-  return LLDB_RECORD_RESULT(
-      StepUsingScriptedThreadPlan(script_class_name, true));
+  return StepUsingScriptedThreadPlan(script_class_name, true);
 }
 
 SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
                                             bool resume_immediately) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
-                     (const char *, bool), script_class_name,
-                     resume_immediately);
+  LLDB_INSTRUMENT_VA(this, script_class_name, resume_immediately);
 
   lldb::SBStructuredData no_data;
-  return LLDB_RECORD_RESULT(StepUsingScriptedThreadPlan(
-      script_class_name, no_data, resume_immediately));
+  return StepUsingScriptedThreadPlan(script_class_name, no_data,
+                                     resume_immediately);
 }
 
 SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
                                               SBStructuredData &args_data,
                                               bool resume_immediately) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
-                     (const char *, lldb::SBStructuredData &, bool),
-                     script_class_name, args_data, resume_immediately);
+  LLDB_INSTRUMENT_VA(this, script_class_name, args_data, resume_immediately);
 
   SBError error;
 
@@ -940,7 +912,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
 
   if (!exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
@@ -952,23 +924,22 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
 
   if (new_plan_status.Fail()) {
     error.SetErrorString(new_plan_status.AsCString());
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
 
   if (!resume_immediately)
-    return LLDB_RECORD_RESULT(error);
+    return error;
 
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
     error.SetErrorString(new_plan_status.AsCString());
 
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBThread, JumpToLine,
-                     (lldb::SBFileSpec &, uint32_t), file_spec, line);
+  LLDB_INSTRUMENT_VA(this, file_spec, line);
 
   SBError sb_error;
 
@@ -977,19 +948,18 @@ SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) {
 
   if (!exe_ctx.HasThreadScope()) {
     sb_error.SetErrorString("this SBThread object is invalid");
-    return LLDB_RECORD_RESULT(sb_error);
+    return sb_error;
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
 
   Status err = thread->JumpToLine(file_spec.ref(), line, true);
   sb_error.SetError(err);
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
-                     (lldb::SBFrame &, lldb::SBValue &), frame, return_value);
+  LLDB_INSTRUMENT_VA(this, frame, return_value);
 
   SBError sb_error;
 
@@ -1002,12 +972,11 @@ SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) {
         thread->ReturnFromFrame(frame.GetFrameSP(), return_value.GetSP()));
   }
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBThread::UnwindInnermostExpression() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBThread,
-                             UnwindInnermostExpression);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError sb_error;
 
@@ -1021,18 +990,18 @@ SBError SBThread::UnwindInnermostExpression() {
       thread->SetSelectedFrameByIndex(0, false);
   }
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 bool SBThread::Suspend() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Suspend);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError error; // Ignored
   return Suspend(error);
 }
 
 bool SBThread::Suspend(SBError &error) {
-  LLDB_RECORD_METHOD(bool, SBThread, Suspend, (lldb::SBError &), error);
+  LLDB_INSTRUMENT_VA(this, error);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1052,14 +1021,14 @@ bool SBThread::Suspend(SBError &error) {
 }
 
 bool SBThread::Resume() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Resume);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError error; // Ignored
   return Resume(error);
 }
 
 bool SBThread::Resume(SBError &error) {
-  LLDB_RECORD_METHOD(bool, SBThread, Resume, (lldb::SBError &), error);
+  LLDB_INSTRUMENT_VA(this, error);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1080,7 +1049,7 @@ bool SBThread::Resume(SBError &error) {
 }
 
 bool SBThread::IsSuspended() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsSuspended);
+  LLDB_INSTRUMENT_VA(this);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1091,7 +1060,7 @@ bool SBThread::IsSuspended() {
 }
 
 bool SBThread::IsStopped() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsStopped);
+  LLDB_INSTRUMENT_VA(this);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1102,7 +1071,7 @@ bool SBThread::IsStopped() {
 }
 
 SBProcess SBThread::GetProcess() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBThread, GetProcess);
+  LLDB_INSTRUMENT_VA(this);
 
   SBProcess sb_process;
   std::unique_lock<std::recursive_mutex> lock;
@@ -1114,11 +1083,11 @@ SBProcess SBThread::GetProcess() {
     sb_process.SetSP(exe_ctx.GetProcessSP());
   }
 
-  return LLDB_RECORD_RESULT(sb_process);
+  return sb_process;
 }
 
 uint32_t SBThread::GetNumFrames() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, GetNumFrames);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t num_frames = 0;
   std::unique_lock<std::recursive_mutex> lock;
@@ -1135,7 +1104,7 @@ uint32_t SBThread::GetNumFrames() {
 }
 
 SBFrame SBThread::GetFrameAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBFrame sb_frame;
   StackFrameSP frame_sp;
@@ -1150,11 +1119,11 @@ SBFrame SBThread::GetFrameAtIndex(uint32_t idx) {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_frame);
+  return sb_frame;
 }
 
 lldb::SBFrame SBThread::GetSelectedFrame() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBThread, GetSelectedFrame);
+  LLDB_INSTRUMENT_VA(this);
 
   SBFrame sb_frame;
   StackFrameSP frame_sp;
@@ -1169,12 +1138,11 @@ lldb::SBFrame SBThread::GetSelectedFrame() {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_frame);
+  return sb_frame;
 }
 
 lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBFrame sb_frame;
   StackFrameSP frame_sp;
@@ -1193,51 +1161,43 @@ lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_frame);
+  return sb_frame;
 }
 
 bool SBThread::EventIsThreadEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBThread, EventIsThreadEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   return Thread::ThreadEventData::GetEventDataFromEvent(event.get()) != nullptr;
 }
 
 SBFrame SBThread::GetStackFrameFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
-  return LLDB_RECORD_RESULT(
-      Thread::ThreadEventData::GetStackFrameFromEvent(event.get()));
+  return Thread::ThreadEventData::GetStackFrameFromEvent(event.get());
 }
 
 SBThread SBThread::GetThreadFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
-  return LLDB_RECORD_RESULT(
-      Thread::ThreadEventData::GetThreadFromEvent(event.get()));
+  return Thread::ThreadEventData::GetThreadFromEvent(event.get());
 }
 
 bool SBThread::operator==(const SBThread &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBThread, operator==,(const lldb::SBThread &),
-                           rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_sp->GetThreadSP().get() ==
          rhs.m_opaque_sp->GetThreadSP().get();
 }
 
 bool SBThread::operator!=(const SBThread &rhs) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBThread, operator!=,(const lldb::SBThread &),
-                           rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return m_opaque_sp->GetThreadSP().get() !=
          rhs.m_opaque_sp->GetThreadSP().get();
 }
 
 bool SBThread::GetStatus(SBStream &status) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &),
-                           status);
+  LLDB_INSTRUMENT_VA(this, status);
 
   Stream &strm = status.ref();
 
@@ -1253,15 +1213,13 @@ bool SBThread::GetStatus(SBStream &status) const {
 }
 
 bool SBThread::GetDescription(SBStream &description) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, (lldb::SBStream &),
-                           description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   return GetDescription(description, false);
 }
 
 bool SBThread::GetDescription(SBStream &description, bool stop_format) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription,
-                           (lldb::SBStream &, bool), description, stop_format);
+  LLDB_INSTRUMENT_VA(this, description, stop_format);
 
   Stream &strm = description.ref();
 
@@ -1281,8 +1239,7 @@ bool SBThread::GetDescription(SBStream &description, bool stop_format) const {
 }
 
 SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
-                     (const char *), type);
+  LLDB_INSTRUMENT_VA(this, type);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1312,12 +1269,11 @@ SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_origin_thread);
+  return sb_origin_thread;
 }
 
 uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread,
-                             GetExtendedBacktraceOriginatingIndexID);
+  LLDB_INSTRUMENT_VA(this);
 
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
@@ -1326,29 +1282,27 @@ uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
 }
 
 SBValue SBThread::GetCurrentException() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetCurrentException);
+  LLDB_INSTRUMENT_VA(this);
 
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (!thread_sp)
-    return LLDB_RECORD_RESULT(SBValue());
+    return SBValue();
 
-  return LLDB_RECORD_RESULT(SBValue(thread_sp->GetCurrentException()));
+  return SBValue(thread_sp->GetCurrentException());
 }
 
 SBThread SBThread::GetCurrentExceptionBacktrace() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBThread,
-                             GetCurrentExceptionBacktrace);
+  LLDB_INSTRUMENT_VA(this);
 
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (!thread_sp)
-    return LLDB_RECORD_RESULT(SBThread());
+    return SBThread();
 
-  return LLDB_RECORD_RESULT(
-      SBThread(thread_sp->GetCurrentExceptionBacktrace()));
+  return SBThread(thread_sp->GetCurrentExceptionBacktrace());
 }
 
 bool SBThread::SafeToCallFunctions() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, SafeToCallFunctions);
+  LLDB_INSTRUMENT_VA(this);
 
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
@@ -1364,109 +1318,49 @@ lldb_private::Thread *SBThread::get() {
   return m_opaque_sp->GetThreadSP().get();
 }
 
-namespace lldb_private {
-namespace repro {
+SBValue SBThread::GetSiginfo(SBError &error) {
+  LLDB_INSTRUMENT_VA(this, error);
 
-template <>
-void RegisterMethods<SBThread>(Registry &R) {
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBThread, GetBroadcasterClassName,
-                              ());
-  LLDB_REGISTER_CONSTRUCTOR(SBThread, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &));
-  LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::SBThread &));
-  LLDB_REGISTER_METHOD(const lldb::SBThread &,
-                       SBThread, operator=,(const lldb::SBThread &));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBQueue, SBThread, GetQueue, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBThread, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBThread, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBThread, Clear, ());
-  LLDB_REGISTER_METHOD(lldb::StopReason, SBThread, GetStopReason, ());
-  LLDB_REGISTER_METHOD(size_t, SBThread, GetStopReasonDataCount, ());
-  LLDB_REGISTER_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
-                       (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBThread,
-                       GetStopReasonExtendedBacktraces,
-                       (lldb::InstrumentationRuntimeType));
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetStopReturnValue, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::tid_t, SBThread, GetThreadID, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBThread, GetIndexID, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetName, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetQueueName, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBThread, GetQueueID, ());
-  LLDB_REGISTER_METHOD(bool, SBThread, GetInfoItemByPathAsString,
-                       (const char *, lldb::SBStream &));
-  LLDB_REGISTER_METHOD(void, SBThread, StepOver, (lldb::RunMode));
-  LLDB_REGISTER_METHOD(void, SBThread, StepOver,
-                       (lldb::RunMode, lldb::SBError &));
-  LLDB_REGISTER_METHOD(void, SBThread, StepInto, (lldb::RunMode));
-  LLDB_REGISTER_METHOD(void, SBThread, StepInto,
-                       (const char *, lldb::RunMode));
-  LLDB_REGISTER_METHOD(
-      void, SBThread, StepInto,
-      (const char *, uint32_t, lldb::SBError &, lldb::RunMode));
-  LLDB_REGISTER_METHOD(void, SBThread, StepOut, ());
-  LLDB_REGISTER_METHOD(void, SBThread, StepOut, (lldb::SBError &));
-  LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &));
-  LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame,
-                       (lldb::SBFrame &, lldb::SBError &));
-  LLDB_REGISTER_METHOD(void, SBThread, StepInstruction, (bool));
-  LLDB_REGISTER_METHOD(void, SBThread, StepInstruction,
-                       (bool, lldb::SBError &));
-  LLDB_REGISTER_METHOD(void, SBThread, RunToAddress, (lldb::addr_t));
-  LLDB_REGISTER_METHOD(void, SBThread, RunToAddress,
-                       (lldb::addr_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepOverUntil,
-                       (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
-                       (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
-                       (const char *, bool));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
-                       (const char *, SBStructuredData &, bool));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBThread, JumpToLine,
-                       (lldb::SBFileSpec &, uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
-                       (lldb::SBFrame &, lldb::SBValue &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBThread, UnwindInnermostExpression,
-                       ());
-  LLDB_REGISTER_METHOD(bool, SBThread, Suspend, ());
-  LLDB_REGISTER_METHOD(bool, SBThread, Suspend, (lldb::SBError &));
-  LLDB_REGISTER_METHOD(bool, SBThread, Resume, ());
-  LLDB_REGISTER_METHOD(bool, SBThread, Resume, (lldb::SBError &));
-  LLDB_REGISTER_METHOD(bool, SBThread, IsSuspended, ());
-  LLDB_REGISTER_METHOD(bool, SBThread, IsStopped, ());
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBThread, GetProcess, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBThread, GetNumFrames, ());
-  LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetSelectedFrame, ());
-  LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBThread, EventIsThreadEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_METHOD_CONST(bool,
-                             SBThread, operator==,(const lldb::SBThread &));
-  LLDB_REGISTER_METHOD_CONST(bool,
-                             SBThread, operator!=,(const lldb::SBThread &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription,
-                             (lldb::SBStream &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription,
-                             (lldb::SBStream &, bool));
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
-                       (const char *));
-  LLDB_REGISTER_METHOD(uint32_t, SBThread,
-                       GetExtendedBacktraceOriginatingIndexID, ());
-  LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetCurrentException, ());
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetCurrentExceptionBacktrace,
-                       ());
-  LLDB_REGISTER_METHOD(bool, SBThread, SafeToCallFunctions, ());
-  LLDB_REGISTER_CHAR_PTR_METHOD(size_t, SBThread, GetStopDescription);
-}
+  SBValue value;
+  SBProcess process = GetProcess();
+  if (!process.IsValid()) {
+    error.SetErrorString("no process");
+    return value;
+  }
+  SBTarget target = process.GetTarget();
+  if (!target.IsValid()) {
+    error.SetErrorString("unable to get target");
+    return value;
+  }
+  SBPlatform platform = target.GetPlatform();
+  if (!platform.IsValid()) {
+    error.SetErrorString("unable to get platform");
+    return value;
+  }
+  CompilerType type = platform.GetSP()->GetSiginfoType(
+      target.GetSP()->GetArchitecture().GetTriple());
+  if (!type.IsValid()) {
+    error.SetErrorString("no siginfo_t for the platform");
+    return value;
+  }
+  llvm::Optional<uint64_t> type_size = type.GetByteSize(nullptr);
+  assert(type_size);
+  ThreadSP thread_sp = m_opaque_sp->GetThreadSP();
+  if (!thread_sp) {
+    error.SetErrorString("unable to get thread");
+    return value;
+  }
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> data =
+      thread_sp->GetSiginfo(type_size.getValue());
+  if (!data) {
+    error.SetErrorString(llvm::toString(data.takeError()).c_str());
+    return value;
+  }
+  SBData sb_data;
+  sb_data.SetData(error, data.get()->getBufferStart(),
+                  data.get()->getBufferSize(), process.GetByteOrder(), 0);
+  if (!sb_data.IsValid())
+    return value;
 
-}
+  return target.CreateValueFromData("siginfo", sb_data, type);
 }
diff --git a/lldb/source/API/SBThreadCollection.cpp b/lldb/source/API/SBThreadCollection.cpp
index bfca864d6bcd..9d688e012239 100644
--- a/lldb/source/API/SBThreadCollection.cpp
+++ b/lldb/source/API/SBThreadCollection.cpp
@@ -7,32 +7,27 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBThreadCollection.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/Target/ThreadList.h"
+#include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBThreadCollection::SBThreadCollection() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadCollection);
-}
+SBThreadCollection::SBThreadCollection() { LLDB_INSTRUMENT_VA(this); }
 
 SBThreadCollection::SBThreadCollection(const SBThreadCollection &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBThreadCollection,
-                          (const lldb::SBThreadCollection &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const SBThreadCollection &SBThreadCollection::
 operator=(const SBThreadCollection &rhs) {
-  LLDB_RECORD_METHOD(
-      const lldb::SBThreadCollection &,
-      SBThreadCollection, operator=,(const lldb::SBThreadCollection &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBThreadCollection::SBThreadCollection(const ThreadCollectionSP &threads)
@@ -61,17 +56,17 @@ const lldb::ThreadCollectionSP &SBThreadCollection::operator*() const {
 }
 
 bool SBThreadCollection::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBThreadCollection::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 size_t SBThreadCollection::GetSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadCollection, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     return m_opaque_sp->GetSize();
@@ -79,32 +74,10 @@ size_t SBThreadCollection::GetSize() {
 }
 
 SBThread SBThreadCollection::GetThreadAtIndex(size_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
-                     (size_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBThread thread;
   if (m_opaque_sp && idx < m_opaque_sp->GetSize())
     thread = m_opaque_sp->GetThreadAtIndex(idx);
-  return LLDB_RECORD_RESULT(thread);
-}
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBThreadCollection>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection,
-                            (const lldb::SBThreadCollection &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBThreadCollection &,
-      SBThreadCollection, operator=,(const lldb::SBThreadCollection &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, operator bool, ());
-  LLDB_REGISTER_METHOD(size_t, SBThreadCollection, GetSize, ());
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
-                       (size_t));
-}
-
-}
+  return thread;
 }
diff --git a/lldb/source/API/SBThreadPlan.cpp b/lldb/source/API/SBThreadPlan.cpp
index 99ecb321595f..2e66ac120839 100644
--- a/lldb/source/API/SBThreadPlan.cpp
+++ b/lldb/source/API/SBThreadPlan.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBThread.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
@@ -50,22 +50,20 @@ using namespace lldb;
 using namespace lldb_private;
 
 // Constructors
-SBThreadPlan::SBThreadPlan() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadPlan); }
+SBThreadPlan::SBThreadPlan() { LLDB_INSTRUMENT_VA(this); }
 
 SBThreadPlan::SBThreadPlan(const ThreadPlanSP &lldb_object_sp)
     : m_opaque_wp(lldb_object_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &),
-                          lldb_object_sp);
+  LLDB_INSTRUMENT_VA(this, lldb_object_sp);
 }
 
 SBThreadPlan::SBThreadPlan(const SBThreadPlan &rhs)
     : m_opaque_wp(rhs.m_opaque_wp) {
-  LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) {
-  LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *),
-                          sb_thread, class_name);
+  LLDB_INSTRUMENT_VA(this, sb_thread, class_name);
 
   Thread *thread = sb_thread.get();
   if (thread)
@@ -75,9 +73,7 @@ SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) {
 
 SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name,
                            lldb::SBStructuredData &args_data) {
-  LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *,
-                                         SBStructuredData &),
-                          sb_thread, class_name, args_data);
+  LLDB_INSTRUMENT_VA(this, sb_thread, class_name, args_data);
 
   Thread *thread = sb_thread.get();
   if (thread)
@@ -88,65 +84,61 @@ SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name,
 // Assignment operator
 
 const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBThreadPlan &,
-                     SBThreadPlan, operator=,(const lldb::SBThreadPlan &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_wp = rhs.m_opaque_wp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 // Destructor
 SBThreadPlan::~SBThreadPlan() = default;
 
 bool SBThreadPlan::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBThreadPlan::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return static_cast<bool>(GetSP());
 }
 
 void SBThreadPlan::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_wp.reset();
 }
 
 lldb::StopReason SBThreadPlan::GetStopReason() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThreadPlan, GetStopReason);
+  LLDB_INSTRUMENT_VA(this);
 
   return eStopReasonNone;
 }
 
 size_t SBThreadPlan::GetStopReasonDataCount() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadPlan, GetStopReasonDataCount);
+  LLDB_INSTRUMENT_VA(this);
 
   return 0;
 }
 
 uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
-                     (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   return 0;
 }
 
 SBThread SBThreadPlan::GetThread() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBThreadPlan, GetThread);
+  LLDB_INSTRUMENT_VA(this);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp) {
-    return LLDB_RECORD_RESULT(
-        SBThread(thread_plan_sp->GetThread().shared_from_this()));
+    return SBThread(thread_plan_sp->GetThread().shared_from_this());
   } else
-    return LLDB_RECORD_RESULT(SBThread());
+    return SBThread();
 }
 
 bool SBThreadPlan::GetDescription(lldb::SBStream &description) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBThreadPlan, GetDescription,
-                           (lldb::SBStream &), description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp) {
@@ -162,7 +154,7 @@ void SBThreadPlan::SetThreadPlan(const ThreadPlanSP &lldb_object_wp) {
 }
 
 void SBThreadPlan::SetPlanComplete(bool success) {
-  LLDB_RECORD_METHOD(void, SBThreadPlan, SetPlanComplete, (bool), success);
+  LLDB_INSTRUMENT_VA(this, success);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp)
@@ -170,7 +162,7 @@ void SBThreadPlan::SetPlanComplete(bool success) {
 }
 
 bool SBThreadPlan::IsPlanComplete() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanComplete);
+  LLDB_INSTRUMENT_VA(this);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp)
@@ -179,7 +171,7 @@ bool SBThreadPlan::IsPlanComplete() {
 }
 
 bool SBThreadPlan::IsPlanStale() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale);
+  LLDB_INSTRUMENT_VA(this);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp)
@@ -188,7 +180,7 @@ bool SBThreadPlan::IsPlanStale() {
 }
 
 bool SBThreadPlan::IsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid);
+  LLDB_INSTRUMENT_VA(this);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp)
@@ -197,7 +189,7 @@ bool SBThreadPlan::IsValid() {
 }
 
 bool SBThreadPlan::GetStopOthers() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, GetStopOthers);
+  LLDB_INSTRUMENT_VA(this);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp)
@@ -206,7 +198,7 @@ bool SBThreadPlan::GetStopOthers() {
 }
 
 void SBThreadPlan::SetStopOthers(bool stop_others) {
-  LLDB_RECORD_METHOD(void, SBThreadPlan, SetStopOthers, (bool), stop_others);
+  LLDB_INSTRUMENT_VA(this, stop_others);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp)
@@ -222,27 +214,21 @@ void SBThreadPlan::SetStopOthers(bool stop_others) {
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepOverRange(SBAddress &sb_start_address,
                                               lldb::addr_t size) {
-  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                     QueueThreadPlanForStepOverRange,
-                     (lldb::SBAddress &, lldb::addr_t), sb_start_address, size);
+  LLDB_INSTRUMENT_VA(this, sb_start_address, size);
 
   SBError error;
-  return LLDB_RECORD_RESULT(
-      QueueThreadPlanForStepOverRange(sb_start_address, size, error));
+  return QueueThreadPlanForStepOverRange(sb_start_address, size, error);
 }
 
 SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange(
     SBAddress &sb_start_address, lldb::addr_t size, SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                     QueueThreadPlanForStepOverRange,
-                     (lldb::SBAddress &, lldb::addr_t, lldb::SBError &),
-                     sb_start_address, size, error);
+  LLDB_INSTRUMENT_VA(this, sb_start_address, size, error);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp) {
     Address *start_address = sb_start_address.get();
     if (!start_address) {
-      return LLDB_RECORD_RESULT(SBThreadPlan());
+      return SBThreadPlan();
     }
 
     AddressRange range(*start_address, size);
@@ -259,36 +245,30 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange(
     else
       plan.GetSP()->SetPrivate(true);
 
-    return LLDB_RECORD_RESULT(plan);
+    return plan;
   }
-  return LLDB_RECORD_RESULT(SBThreadPlan());
+  return SBThreadPlan();
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
                                             lldb::addr_t size) {
-  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                     QueueThreadPlanForStepInRange,
-                     (lldb::SBAddress &, lldb::addr_t), sb_start_address, size);
+  LLDB_INSTRUMENT_VA(this, sb_start_address, size);
 
   SBError error;
-  return LLDB_RECORD_RESULT(
-      QueueThreadPlanForStepInRange(sb_start_address, size, error));
+  return QueueThreadPlanForStepInRange(sb_start_address, size, error);
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
                                             lldb::addr_t size, SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                     QueueThreadPlanForStepInRange,
-                     (lldb::SBAddress &, lldb::addr_t, lldb::SBError &),
-                     sb_start_address, size, error);
+  LLDB_INSTRUMENT_VA(this, sb_start_address, size, error);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp) {
     Address *start_address = sb_start_address.get();
     if (!start_address) {
-      return LLDB_RECORD_RESULT(SBThreadPlan());
+      return SBThreadPlan();
     }
 
     AddressRange range(*start_address, size);
@@ -305,30 +285,24 @@ SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
     else
       plan.GetSP()->SetPrivate(true);
 
-    return LLDB_RECORD_RESULT(plan);
+    return plan;
   }
-  return LLDB_RECORD_RESULT(SBThreadPlan());
+  return SBThreadPlan();
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
                                         bool first_insn) {
-  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                     QueueThreadPlanForStepOut, (uint32_t, bool),
-                     frame_idx_to_step_to, first_insn);
+  LLDB_INSTRUMENT_VA(this, frame_idx_to_step_to, first_insn);
 
   SBError error;
-  return LLDB_RECORD_RESULT(
-      QueueThreadPlanForStepOut(frame_idx_to_step_to, first_insn, error));
+  return QueueThreadPlanForStepOut(frame_idx_to_step_to, first_insn, error);
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
                                         bool first_insn, SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                     QueueThreadPlanForStepOut,
-                     (uint32_t, bool, lldb::SBError &), frame_idx_to_step_to,
-                     first_insn, error);
+  LLDB_INSTRUMENT_VA(this, frame_idx_to_step_to, first_insn, error);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp) {
@@ -347,32 +321,28 @@ SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
     else
       plan.GetSP()->SetPrivate(true);
 
-    return LLDB_RECORD_RESULT(plan);
+    return plan;
   }
-  return LLDB_RECORD_RESULT(SBThreadPlan());
+  return SBThreadPlan();
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) {
-  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                     QueueThreadPlanForRunToAddress, (lldb::SBAddress),
-                     sb_address);
+  LLDB_INSTRUMENT_VA(this, sb_address);
 
   SBError error;
-  return LLDB_RECORD_RESULT(QueueThreadPlanForRunToAddress(sb_address, error));
+  return QueueThreadPlanForRunToAddress(sb_address, error);
 }
 
 SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address,
                                                           SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                     QueueThreadPlanForRunToAddress,
-                     (lldb::SBAddress, lldb::SBError &), sb_address, error);
+  LLDB_INSTRUMENT_VA(this, sb_address, error);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp) {
     Address *address = sb_address.get();
     if (!address)
-      return LLDB_RECORD_RESULT(SBThreadPlan());
+      return SBThreadPlan();
 
     Status plan_status;
     SBThreadPlan plan =
@@ -384,28 +354,23 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address,
     else
       plan.GetSP()->SetPrivate(true);
 
-    return LLDB_RECORD_RESULT(plan);
+    return plan;
   }
-  return LLDB_RECORD_RESULT(SBThreadPlan());
+  return SBThreadPlan();
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) {
-  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                     QueueThreadPlanForStepScripted, (const char *),
-                     script_class_name);
+  LLDB_INSTRUMENT_VA(this, script_class_name);
 
   SBError error;
-  return LLDB_RECORD_RESULT(
-      QueueThreadPlanForStepScripted(script_class_name, error));
+  return QueueThreadPlanForStepScripted(script_class_name, error);
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
                                              SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                     QueueThreadPlanForStepScripted,
-                     (const char *, lldb::SBError &), script_class_name, error);
+  LLDB_INSTRUMENT_VA(this, script_class_name, error);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp) {
@@ -420,19 +385,16 @@ SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
     else
       plan.GetSP()->SetPrivate(true);
 
-    return LLDB_RECORD_RESULT(plan);
+    return plan;
   }
-  return LLDB_RECORD_RESULT(SBThreadPlan());
+  return SBThreadPlan();
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
                                              lldb::SBStructuredData &args_data,
                                              SBError &error) {
-  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                     QueueThreadPlanForStepScripted,
-                     (const char *, lldb::SBStructuredData &, lldb::SBError &), 
-                     script_class_name, args_data, error);
+  LLDB_INSTRUMENT_VA(this, script_class_name, args_data, error);
 
   ThreadPlanSP thread_plan_sp(GetSP());
   if (thread_plan_sp) {
@@ -447,73 +409,8 @@ SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
     else
       plan.GetSP()->SetPrivate(true);
 
-    return LLDB_RECORD_RESULT(plan);
+    return plan;
   } else {
-    return LLDB_RECORD_RESULT(SBThreadPlan());
+    return SBThreadPlan();
   }
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBThreadPlan>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &));
-  LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &));
-  LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *));
-  LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *,
-                       lldb::SBStructuredData &));
-  LLDB_REGISTER_METHOD(const lldb::SBThreadPlan &,
-                       SBThreadPlan, operator=,(const lldb::SBThreadPlan &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBThreadPlan, Clear, ());
-  LLDB_REGISTER_METHOD(lldb::StopReason, SBThreadPlan, GetStopReason, ());
-  LLDB_REGISTER_METHOD(size_t, SBThreadPlan, GetStopReasonDataCount, ());
-  LLDB_REGISTER_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBThreadPlan, GetThread, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, GetDescription,
-                             (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(void, SBThreadPlan, SetPlanComplete, (bool));
-  LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanComplete, ());
-  LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanStale, ());
-  LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsValid, ());
-  LLDB_REGISTER_METHOD(void, SBThreadPlan, SetStopOthers, (bool));
-  LLDB_REGISTER_METHOD(bool, SBThreadPlan, GetStopOthers, ());
-  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                       QueueThreadPlanForStepOverRange,
-                       (lldb::SBAddress &, lldb::addr_t));
-  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                       QueueThreadPlanForStepOverRange,
-                       (lldb::SBAddress &, lldb::addr_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                       QueueThreadPlanForStepInRange,
-                       (lldb::SBAddress &, lldb::addr_t));
-  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                       QueueThreadPlanForStepInRange,
-                       (lldb::SBAddress &, lldb::addr_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                       QueueThreadPlanForStepOut, (uint32_t, bool));
-  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                       QueueThreadPlanForStepOut,
-                       (uint32_t, bool, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                       QueueThreadPlanForRunToAddress, (lldb::SBAddress));
-  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                       QueueThreadPlanForRunToAddress,
-                       (lldb::SBAddress, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                       QueueThreadPlanForStepScripted, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                       QueueThreadPlanForStepScripted,
-                       (const char *, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
-                       QueueThreadPlanForStepScripted,
-                       (const char *, lldb::SBStructuredData &,
-                       lldb::SBError &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBTrace.cpp b/lldb/source/API/SBTrace.cpp
index 079c33a562c0..64a675e2e16c 100644
--- a/lldb/source/API/SBTrace.cpp
+++ b/lldb/source/API/SBTrace.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "SBReproducerPrivate.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBThread.h"
@@ -20,35 +20,31 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBTrace::SBTrace() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTrace); }
+SBTrace::SBTrace() { LLDB_INSTRUMENT_VA(this); }
 
 SBTrace::SBTrace(const lldb::TraceSP &trace_sp) : m_opaque_sp(trace_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBTrace, (const lldb::TraceSP &), trace_sp);
+  LLDB_INSTRUMENT_VA(this, trace_sp);
 }
 
 const char *SBTrace::GetStartConfigurationHelp() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTrace, GetStartConfigurationHelp);
-  return LLDB_RECORD_RESULT(
-      m_opaque_sp ? m_opaque_sp->GetStartConfigurationHelp() : nullptr);
+  LLDB_INSTRUMENT_VA(this);
+  return m_opaque_sp ? m_opaque_sp->GetStartConfigurationHelp() : nullptr;
 }
 
 SBError SBTrace::Start(const SBStructuredData &configuration) {
-  LLDB_RECORD_METHOD(SBError, SBTrace, Start, (const SBStructuredData &),
-                     configuration);
+  LLDB_INSTRUMENT_VA(this, configuration);
   SBError error;
   if (!m_opaque_sp)
     error.SetErrorString("error: invalid trace");
   else if (llvm::Error err =
                m_opaque_sp->Start(configuration.m_impl_up->GetObjectSP()))
     error.SetErrorString(llvm::toString(std::move(err)).c_str());
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 SBError SBTrace::Start(const SBThread &thread,
                        const SBStructuredData &configuration) {
-  LLDB_RECORD_METHOD(SBError, SBTrace, Start,
-                     (const SBThread &, const SBStructuredData &), thread,
-                     configuration);
+  LLDB_INSTRUMENT_VA(this, thread, configuration);
 
   SBError error;
   if (!m_opaque_sp)
@@ -60,55 +56,35 @@ SBError SBTrace::Start(const SBThread &thread,
       error.SetErrorString(llvm::toString(std::move(err)).c_str());
   }
 
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 SBError SBTrace::Stop() {
-  LLDB_RECORD_METHOD_NO_ARGS(SBError, SBTrace, Stop);
+  LLDB_INSTRUMENT_VA(this);
   SBError error;
   if (!m_opaque_sp)
     error.SetErrorString("error: invalid trace");
   else if (llvm::Error err = m_opaque_sp->Stop())
     error.SetErrorString(llvm::toString(std::move(err)).c_str());
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 SBError SBTrace::Stop(const SBThread &thread) {
-  LLDB_RECORD_METHOD(SBError, SBTrace, Stop, (const SBThread &), thread);
+  LLDB_INSTRUMENT_VA(this, thread);
   SBError error;
   if (!m_opaque_sp)
     error.SetErrorString("error: invalid trace");
   else if (llvm::Error err = m_opaque_sp->Stop({thread.GetThreadID()}))
     error.SetErrorString(llvm::toString(std::move(err)).c_str());
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 bool SBTrace::IsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTrace, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 
 SBTrace::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTrace, operator bool);
+  LLDB_INSTRUMENT_VA(this);
   return (bool)m_opaque_sp;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBTrace>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBTrace, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTrace, (const lldb::TraceSP &));
-  LLDB_REGISTER_METHOD(SBError, SBTrace, Start, (const SBStructuredData &));
-  LLDB_REGISTER_METHOD(SBError, SBTrace, Start,
-                       (const SBThread &, const SBStructuredData &));
-  LLDB_REGISTER_METHOD(SBError, SBTrace, Stop, (const SBThread &));
-  LLDB_REGISTER_METHOD(SBError, SBTrace, Stop, ());
-  LLDB_REGISTER_METHOD(bool, SBTrace, IsValid, ());
-  LLDB_REGISTER_METHOD(const char *, SBTrace, GetStartConfigurationHelp, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTrace, operator bool, ());
-}
-
-}
-}
diff --git a/lldb/source/API/SBType.cpp b/lldb/source/API/SBType.cpp
index 550c4b065914..da9202bf9386 100644
--- a/lldb/source/API/SBType.cpp
+++ b/lldb/source/API/SBType.cpp
@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBType.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBStream.h"
@@ -17,6 +16,7 @@
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/APSInt.h"
@@ -26,7 +26,7 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBType::SBType() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBType); }
+SBType::SBType() { LLDB_INSTRUMENT_VA(this); }
 
 SBType::SBType(const CompilerType &type)
     : m_opaque_sp(new TypeImpl(
@@ -38,8 +38,8 @@ SBType::SBType(const lldb::TypeSP &type_sp)
 SBType::SBType(const lldb::TypeImplSP &type_impl_sp)
     : m_opaque_sp(type_impl_sp) {}
 
-SBType::SBType(const SBType &rhs) : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR(SBType, (const lldb::SBType &), rhs);
+SBType::SBType(const SBType &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
@@ -51,7 +51,7 @@ SBType::SBType(const SBType &rhs) : m_opaque_sp() {
 //{}
 //
 bool SBType::operator==(SBType &rhs) {
-  LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -63,7 +63,7 @@ bool SBType::operator==(SBType &rhs) {
 }
 
 bool SBType::operator!=(SBType &rhs) {
-  LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return rhs.IsValid();
@@ -81,13 +81,12 @@ void SBType::SetSP(const lldb::TypeImplSP &type_impl_sp) {
 }
 
 SBType &SBType::operator=(const SBType &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBType::~SBType() = default;
@@ -107,11 +106,11 @@ const TypeImpl &SBType::ref() const {
 }
 
 bool SBType::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBType::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp.get() == nullptr)
     return false;
@@ -120,7 +119,7 @@ SBType::operator bool() const {
 }
 
 uint64_t SBType::GetByteSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBType, GetByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     if (llvm::Optional<uint64_t> size =
@@ -130,7 +129,7 @@ uint64_t SBType::GetByteSize() {
 }
 
 bool SBType::IsPointerType() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPointerType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -138,7 +137,7 @@ bool SBType::IsPointerType() {
 }
 
 bool SBType::IsArrayType() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsArrayType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -147,7 +146,7 @@ bool SBType::IsArrayType() {
 }
 
 bool SBType::IsVectorType() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsVectorType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -155,7 +154,7 @@ bool SBType::IsVectorType() {
 }
 
 bool SBType::IsReferenceType() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsReferenceType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -163,71 +162,66 @@ bool SBType::IsReferenceType() {
 }
 
 SBType SBType::GetPointerType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBType());
+    return SBType();
 
-  return LLDB_RECORD_RESULT(
-      SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType()))));
+  return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType())));
 }
 
 SBType SBType::GetPointeeType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointeeType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBType());
-  return LLDB_RECORD_RESULT(
-      SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType()))));
+    return SBType();
+  return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType())));
 }
 
 SBType SBType::GetReferenceType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetReferenceType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBType());
-  return LLDB_RECORD_RESULT(
-      SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType()))));
+    return SBType();
+  return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType())));
 }
 
 SBType SBType::GetTypedefedType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetTypedefedType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBType());
-  return LLDB_RECORD_RESULT(
-      SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType()))));
+    return SBType();
+  return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType())));
 }
 
 SBType SBType::GetDereferencedType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetDereferencedType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBType());
-  return LLDB_RECORD_RESULT(
-      SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType()))));
+    return SBType();
+  return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType())));
 }
 
 SBType SBType::GetArrayElementType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetArrayElementType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBType());
-  return LLDB_RECORD_RESULT(SBType(TypeImplSP(new TypeImpl(
-      m_opaque_sp->GetCompilerType(true).GetArrayElementType(nullptr)))));
+    return SBType();
+  return SBType(TypeImplSP(new TypeImpl(
+      m_opaque_sp->GetCompilerType(true).GetArrayElementType(nullptr))));
 }
 
 SBType SBType::GetArrayType(uint64_t size) {
-  LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size);
+  LLDB_INSTRUMENT_VA(this, size);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBType());
-  return LLDB_RECORD_RESULT(SBType(TypeImplSP(
-      new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size)))));
+    return SBType();
+  return SBType(TypeImplSP(
+      new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size))));
 }
 
 SBType SBType::GetVectorElementType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType);
+  LLDB_INSTRUMENT_VA(this);
 
   SBType type_sb;
   if (IsValid()) {
@@ -236,11 +230,11 @@ SBType SBType::GetVectorElementType() {
                                                         nullptr))
       type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type)));
   }
-  return LLDB_RECORD_RESULT(type_sb);
+  return type_sb;
 }
 
 bool SBType::IsFunctionType() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsFunctionType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -248,7 +242,7 @@ bool SBType::IsFunctionType() {
 }
 
 bool SBType::IsPolymorphicClass() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPolymorphicClass);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -256,7 +250,7 @@ bool SBType::IsPolymorphicClass() {
 }
 
 bool SBType::IsTypedefType() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypedefType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -264,7 +258,7 @@ bool SBType::IsTypedefType() {
 }
 
 bool SBType::IsAnonymousType() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsAnonymousType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -272,7 +266,7 @@ bool SBType::IsAnonymousType() {
 }
 
 bool SBType::IsScopedEnumerationType() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsScopedEnumerationType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -280,20 +274,19 @@ bool SBType::IsScopedEnumerationType() {
 }
 
 lldb::SBType SBType::GetFunctionReturnType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid()) {
     CompilerType return_type(
         m_opaque_sp->GetCompilerType(true).GetFunctionReturnType());
     if (return_type.IsValid())
-      return LLDB_RECORD_RESULT(SBType(return_type));
+      return SBType(return_type);
   }
-  return LLDB_RECORD_RESULT(lldb::SBType());
+  return lldb::SBType();
 }
 
 lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeList, SBType,
-                             GetFunctionArgumentTypes);
+  LLDB_INSTRUMENT_VA(this);
 
   SBTypeList sb_type_list;
   if (IsValid()) {
@@ -303,11 +296,11 @@ lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
       sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i)));
     }
   }
-  return LLDB_RECORD_RESULT(sb_type_list);
+  return sb_type_list;
 }
 
 uint32_t SBType::GetNumberOfMemberFunctions() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfMemberFunctions);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid()) {
     return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions();
@@ -316,46 +309,43 @@ uint32_t SBType::GetNumberOfMemberFunctions() {
 }
 
 lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction, SBType,
-                     GetMemberFunctionAtIndex, (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBTypeMemberFunction sb_func_type;
   if (IsValid())
     sb_func_type.reset(new TypeMemberFunctionImpl(
         m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx)));
-  return LLDB_RECORD_RESULT(sb_func_type);
+  return sb_func_type;
 }
 
 lldb::SBType SBType::GetUnqualifiedType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBType());
-  return LLDB_RECORD_RESULT(
-      SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType()))));
+    return SBType();
+  return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType())));
 }
 
 lldb::SBType SBType::GetCanonicalType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
-    return LLDB_RECORD_RESULT(
-        SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType()))));
-  return LLDB_RECORD_RESULT(SBType());
+    return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType())));
+  return SBType();
 }
 
 SBType SBType::GetEnumerationIntegerType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetEnumerationIntegerType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid()) {
-    return LLDB_RECORD_RESULT(
-        SBType(m_opaque_sp->GetCompilerType(true).GetEnumerationIntegerType()));
+    return SBType(
+        m_opaque_sp->GetCompilerType(true).GetEnumerationIntegerType());
   }
-  return LLDB_RECORD_RESULT(SBType());
+  return SBType();
 }
 
 lldb::BasicType SBType::GetBasicType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration();
@@ -363,17 +353,16 @@ lldb::BasicType SBType::GetBasicType() {
 }
 
 SBType SBType::GetBasicType(lldb::BasicType basic_type) {
-  LLDB_RECORD_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType),
-                     basic_type);
+  LLDB_INSTRUMENT_VA(this, basic_type);
 
   if (IsValid() && m_opaque_sp->IsValid())
-    return LLDB_RECORD_RESULT(SBType(
-        m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type)));
-  return LLDB_RECORD_RESULT(SBType());
+    return SBType(
+        m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type));
+  return SBType();
 }
 
 uint32_t SBType::GetNumberOfDirectBaseClasses() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfDirectBaseClasses);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses();
@@ -381,7 +370,7 @@ uint32_t SBType::GetNumberOfDirectBaseClasses() {
 }
 
 uint32_t SBType::GetNumberOfVirtualBaseClasses() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfVirtualBaseClasses);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses();
@@ -389,7 +378,7 @@ uint32_t SBType::GetNumberOfVirtualBaseClasses() {
 }
 
 uint32_t SBType::GetNumberOfFields() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     return m_opaque_sp->GetCompilerType(true).GetNumFields();
@@ -398,9 +387,7 @@ uint32_t SBType::GetNumberOfFields() {
 
 bool SBType::GetDescription(SBStream &description,
                             lldb::DescriptionLevel description_level) {
-  LLDB_RECORD_METHOD(bool, SBType, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     description_level);
+  LLDB_INSTRUMENT_VA(this, description, description_level);
 
   Stream &strm = description.ref();
 
@@ -413,8 +400,7 @@ bool SBType::GetDescription(SBStream &description,
 }
 
 SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
-                     (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBTypeMember sb_type_member;
   if (IsValid()) {
@@ -426,12 +412,11 @@ SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
       sb_type_member.reset(new TypeMemberImpl(
           TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
   }
-  return LLDB_RECORD_RESULT(sb_type_member);
+  return sb_type_member;
 }
 
 SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
-                     (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBTypeMember sb_type_member;
   if (IsValid()) {
@@ -443,12 +428,11 @@ SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
       sb_type_member.reset(new TypeMemberImpl(
           TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
   }
-  return LLDB_RECORD_RESULT(sb_type_member);
+  return sb_type_member;
 }
 
 SBTypeEnumMemberList SBType::GetEnumMembers() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType,
-                             GetEnumMembers);
+  LLDB_INSTRUMENT_VA(this);
 
   SBTypeEnumMemberList sb_enum_member_list;
   if (IsValid()) {
@@ -466,12 +450,11 @@ SBTypeEnumMemberList SBType::GetEnumMembers() {
       });
     }
   }
-  return LLDB_RECORD_RESULT(sb_enum_member_list);
+  return sb_enum_member_list;
 }
 
 SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, (uint32_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBTypeMember sb_type_member;
   if (IsValid()) {
@@ -493,11 +476,11 @@ SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
       }
     }
   }
-  return LLDB_RECORD_RESULT(sb_type_member);
+  return sb_type_member;
 }
 
 bool SBType::IsTypeComplete() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypeComplete);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -505,7 +488,7 @@ bool SBType::IsTypeComplete() {
 }
 
 uint32_t SBType::GetTypeFlags() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetTypeFlags);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return 0;
@@ -513,18 +496,18 @@ uint32_t SBType::GetTypeFlags() {
 }
 
 lldb::SBModule SBType::GetModule() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBType, GetModule);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBModule sb_module;
   if (!IsValid())
-    return LLDB_RECORD_RESULT(sb_module);
+    return sb_module;
 
   sb_module.SetSP(m_opaque_sp->GetModule());
-  return LLDB_RECORD_RESULT(sb_module);
+  return sb_module;
 }
 
 const char *SBType::GetName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return "";
@@ -532,7 +515,7 @@ const char *SBType::GetName() {
 }
 
 const char *SBType::GetDisplayTypeName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetDisplayTypeName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return "";
@@ -540,7 +523,7 @@ const char *SBType::GetDisplayTypeName() {
 }
 
 lldb::TypeClass SBType::GetTypeClass() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeClass, SBType, GetTypeClass);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     return m_opaque_sp->GetCompilerType(true).GetTypeClass();
@@ -548,7 +531,7 @@ lldb::TypeClass SBType::GetTypeClass() {
 }
 
 uint32_t SBType::GetNumberOfTemplateArguments() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfTemplateArguments);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments();
@@ -556,11 +539,10 @@ uint32_t SBType::GetNumberOfTemplateArguments() {
 }
 
 lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, (uint32_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBType());
+    return SBType();
 
   CompilerType type;
   switch(GetTemplateArgumentKind(idx)) {
@@ -576,13 +558,12 @@ lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
       break;
   }
   if (type.IsValid())
-    return LLDB_RECORD_RESULT(SBType(type));
-  return LLDB_RECORD_RESULT(SBType());
+    return SBType(type);
+  return SBType();
 }
 
 lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::TemplateArgumentKind, SBType,
-                     GetTemplateArgumentKind, (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   if (IsValid())
     return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx);
@@ -590,12 +571,12 @@ lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
 }
 
 SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeList);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBTypeList::SBTypeList(const SBTypeList &rhs)
     : m_opaque_up(new TypeListImpl()) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
        i < rhs_size; i++)
@@ -603,18 +584,17 @@ SBTypeList::SBTypeList(const SBTypeList &rhs)
 }
 
 bool SBTypeList::IsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeList, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTypeList::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeList, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_up != nullptr);
 }
 
 SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBTypeList &,
-                     SBTypeList, operator=,(const lldb::SBTypeList &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_up = std::make_unique<TypeListImpl>();
@@ -622,41 +602,38 @@ SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
          i < rhs_size; i++)
       Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 void SBTypeList::Append(SBType type) {
-  LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), type);
+  LLDB_INSTRUMENT_VA(this, type);
 
   if (type.IsValid())
     m_opaque_up->Append(type.m_opaque_sp);
 }
 
 SBType SBTypeList::GetTypeAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t),
-                     index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (m_opaque_up)
-    return LLDB_RECORD_RESULT(SBType(m_opaque_up->GetTypeAtIndex(index)));
-  return LLDB_RECORD_RESULT(SBType());
+    return SBType(m_opaque_up->GetTypeAtIndex(index));
+  return SBType();
 }
 
 uint32_t SBTypeList::GetSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetSize();
 }
 
 SBTypeList::~SBTypeList() = default;
 
-SBTypeMember::SBTypeMember() : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMember);
-}
+SBTypeMember::SBTypeMember() { LLDB_INSTRUMENT_VA(this); }
 
 SBTypeMember::~SBTypeMember() = default;
 
-SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &), rhs);
+SBTypeMember::SBTypeMember(const SBTypeMember &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     if (rhs.IsValid())
@@ -665,28 +642,27 @@ SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_up() {
 }
 
 lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBTypeMember &,
-                     SBTypeMember, operator=,(const lldb::SBTypeMember &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_up = std::make_unique<TypeMemberImpl>(rhs.ref());
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBTypeMember::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTypeMember::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up.get();
 }
 
 const char *SBTypeMember::GetName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMember, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up)
     return m_opaque_up->GetName().GetCString();
@@ -694,17 +670,17 @@ const char *SBTypeMember::GetName() {
 }
 
 SBType SBTypeMember::GetType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMember, GetType);
+  LLDB_INSTRUMENT_VA(this);
 
   SBType sb_type;
   if (m_opaque_up) {
     sb_type.SetSP(m_opaque_up->GetTypeImpl());
   }
-  return LLDB_RECORD_RESULT(sb_type);
+  return sb_type;
 }
 
 uint64_t SBTypeMember::GetOffsetInBytes() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up)
     return m_opaque_up->GetBitOffset() / 8u;
@@ -712,7 +688,7 @@ uint64_t SBTypeMember::GetOffsetInBytes() {
 }
 
 uint64_t SBTypeMember::GetOffsetInBits() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up)
     return m_opaque_up->GetBitOffset();
@@ -720,7 +696,7 @@ uint64_t SBTypeMember::GetOffsetInBits() {
 }
 
 bool SBTypeMember::IsBitfield() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up)
     return m_opaque_up->GetIsBitfield();
@@ -728,7 +704,7 @@ bool SBTypeMember::IsBitfield() {
 }
 
 uint32_t SBTypeMember::GetBitfieldSizeInBits() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_up)
     return m_opaque_up->GetBitfieldBitSize();
@@ -737,9 +713,7 @@ uint32_t SBTypeMember::GetBitfieldSizeInBits() {
 
 bool SBTypeMember::GetDescription(lldb::SBStream &description,
                                   lldb::DescriptionLevel description_level) {
-  LLDB_RECORD_METHOD(bool, SBTypeMember, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     description_level);
+  LLDB_INSTRUMENT_VA(this, description, description_level);
 
   Stream &strm = description.ref();
 
@@ -780,42 +754,36 @@ TypeMemberImpl &SBTypeMember::ref() {
 
 const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; }
 
-SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMemberFunction);
-}
+SBTypeMemberFunction::SBTypeMemberFunction() { LLDB_INSTRUMENT_VA(this); }
 
 SBTypeMemberFunction::~SBTypeMemberFunction() = default;
 
 SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeMemberFunction,
-                          (const lldb::SBTypeMemberFunction &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 lldb::SBTypeMemberFunction &SBTypeMemberFunction::
 operator=(const lldb::SBTypeMemberFunction &rhs) {
-  LLDB_RECORD_METHOD(
-      lldb::SBTypeMemberFunction &,
-      SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &),
-      rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBTypeMemberFunction::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTypeMemberFunction::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get();
 }
 
 const char *SBTypeMemberFunction::GetName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     return m_opaque_sp->GetName().GetCString();
@@ -823,8 +791,7 @@ const char *SBTypeMemberFunction::GetName() {
 }
 
 const char *SBTypeMemberFunction::GetDemangledName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
-                             GetDemangledName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp) {
     ConstString mangled_str = m_opaque_sp->GetMangledName();
@@ -837,8 +804,7 @@ const char *SBTypeMemberFunction::GetDemangledName() {
 }
 
 const char *SBTypeMemberFunction::GetMangledName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
-                             GetMangledName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     return m_opaque_sp->GetMangledName().GetCString();
@@ -846,28 +812,27 @@ const char *SBTypeMemberFunction::GetMangledName() {
 }
 
 SBType SBTypeMemberFunction::GetType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetType);
+  LLDB_INSTRUMENT_VA(this);
 
   SBType sb_type;
   if (m_opaque_sp) {
     sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType())));
   }
-  return LLDB_RECORD_RESULT(sb_type);
+  return sb_type;
 }
 
 lldb::SBType SBTypeMemberFunction::GetReturnType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetReturnType);
+  LLDB_INSTRUMENT_VA(this);
 
   SBType sb_type;
   if (m_opaque_sp) {
     sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType())));
   }
-  return LLDB_RECORD_RESULT(sb_type);
+  return sb_type;
 }
 
 uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMemberFunction,
-                             GetNumberOfArguments);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     return m_opaque_sp->GetNumArguments();
@@ -875,20 +840,18 @@ uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
 }
 
 lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
-  LLDB_RECORD_METHOD(lldb::SBType, SBTypeMemberFunction, GetArgumentTypeAtIndex,
-                     (uint32_t), i);
+  LLDB_INSTRUMENT_VA(this, i);
 
   SBType sb_type;
   if (m_opaque_sp) {
     sb_type.SetSP(
         lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i))));
   }
-  return LLDB_RECORD_RESULT(sb_type);
+  return sb_type;
 }
 
 lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction,
-                             GetKind);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp)
     return m_opaque_sp->GetKind();
@@ -897,9 +860,7 @@ lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
 
 bool SBTypeMemberFunction::GetDescription(
     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
-  LLDB_RECORD_METHOD(bool, SBTypeMemberFunction, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     description_level);
+  LLDB_INSTRUMENT_VA(this, description, description_level);
 
   Stream &strm = description.ref();
 
@@ -922,120 +883,3 @@ TypeMemberFunctionImpl &SBTypeMemberFunction::ref() {
 const TypeMemberFunctionImpl &SBTypeMemberFunction::ref() const {
   return *m_opaque_sp.get();
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBType>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBType, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBType, (const lldb::SBType &));
-  LLDB_REGISTER_METHOD(bool, SBType, operator==,(lldb::SBType &));
-  LLDB_REGISTER_METHOD(bool, SBType, operator!=,(lldb::SBType &));
-  LLDB_REGISTER_METHOD(lldb::SBType &,
-                       SBType, operator=,(const lldb::SBType &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBType, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBType, operator bool, ());
-  LLDB_REGISTER_METHOD(uint64_t, SBType, GetByteSize, ());
-  LLDB_REGISTER_METHOD(bool, SBType, IsPointerType, ());
-  LLDB_REGISTER_METHOD(bool, SBType, IsArrayType, ());
-  LLDB_REGISTER_METHOD(bool, SBType, IsVectorType, ());
-  LLDB_REGISTER_METHOD(bool, SBType, IsReferenceType, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointerType, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointeeType, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetReferenceType, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTypedefedType, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetDereferencedType, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayElementType, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t));
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetVectorElementType, ());
-  LLDB_REGISTER_METHOD(bool, SBType, IsFunctionType, ());
-  LLDB_REGISTER_METHOD(bool, SBType, IsPolymorphicClass, ());
-  LLDB_REGISTER_METHOD(bool, SBType, IsTypedefType, ());
-  LLDB_REGISTER_METHOD(bool, SBType, IsAnonymousType, ());
-  LLDB_REGISTER_METHOD(bool, SBType, IsScopedEnumerationType, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetFunctionReturnType, ());
-  LLDB_REGISTER_METHOD(lldb::SBTypeList, SBType, GetFunctionArgumentTypes,
-                       ());
-  LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfMemberFunctions, ());
-  LLDB_REGISTER_METHOD(lldb::SBTypeMemberFunction, SBType,
-                       GetMemberFunctionAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetUnqualifiedType, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetCanonicalType, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetEnumerationIntegerType, ());
-  LLDB_REGISTER_METHOD(lldb::BasicType, SBType, GetBasicType, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType));
-  LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfDirectBaseClasses, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfVirtualBaseClasses, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfFields, ());
-  LLDB_REGISTER_METHOD(bool, SBType, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-  LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBTypeEnumMemberList, SBType, GetEnumMembers,
-                       ());
-  LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBType, IsTypeComplete, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBType, GetTypeFlags, ());
-  LLDB_REGISTER_METHOD(lldb::SBModule, SBType, GetModule, ());
-  LLDB_REGISTER_METHOD(const char *, SBType, GetName, ());
-  LLDB_REGISTER_METHOD(const char *, SBType, GetDisplayTypeName, ());
-  LLDB_REGISTER_METHOD(lldb::TypeClass, SBType, GetTypeClass, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfTemplateArguments, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTemplateArgumentType,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::TemplateArgumentKind, SBType,
-                       GetTemplateArgumentKind, (uint32_t));
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeList, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &));
-  LLDB_REGISTER_METHOD(bool, SBTypeList, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeList, operator bool, ());
-  LLDB_REGISTER_METHOD(lldb::SBTypeList &,
-                       SBTypeList, operator=,(const lldb::SBTypeList &));
-  LLDB_REGISTER_METHOD(void, SBTypeList, Append, (lldb::SBType));
-  LLDB_REGISTER_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeList, GetSize, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &));
-  LLDB_REGISTER_METHOD(lldb::SBTypeMember &,
-                       SBTypeMember, operator=,(const lldb::SBTypeMember &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, operator bool, ());
-  LLDB_REGISTER_METHOD(const char *, SBTypeMember, GetName, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMember, GetType, ());
-  LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBytes, ());
-  LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBits, ());
-  LLDB_REGISTER_METHOD(bool, SBTypeMember, IsBitfield, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeMember, GetBitfieldSizeInBits, ());
-  LLDB_REGISTER_METHOD(bool, SBTypeMember, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction,
-                            (const lldb::SBTypeMemberFunction &));
-  LLDB_REGISTER_METHOD(
-      lldb::SBTypeMemberFunction &,
-      SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, operator bool, ());
-  LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetName, ());
-  LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetDemangledName,
-                       ());
-  LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetMangledName,
-                       ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetType, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetReturnType, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeMemberFunction, GetNumberOfArguments,
-                       ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction,
-                       GetArgumentTypeAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::MemberFunctionKind, SBTypeMemberFunction,
-                       GetKind, ());
-  LLDB_REGISTER_METHOD(bool, SBTypeMemberFunction, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-}
-
-}
-}
diff --git a/lldb/source/API/SBTypeCategory.cpp b/lldb/source/API/SBTypeCategory.cpp
index e7432959b260..7d929fe49795 100644
--- a/lldb/source/API/SBTypeCategory.cpp
+++ b/lldb/source/API/SBTypeCategory.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeCategory.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTypeFilter.h"
@@ -26,33 +26,31 @@ using namespace lldb_private;
 
 typedef std::pair<lldb::TypeCategoryImplSP, user_id_t> ImplType;
 
-SBTypeCategory::SBTypeCategory() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeCategory);
-}
+SBTypeCategory::SBTypeCategory() { LLDB_INSTRUMENT_VA(this); }
 
-SBTypeCategory::SBTypeCategory(const char *name) : m_opaque_sp() {
+SBTypeCategory::SBTypeCategory(const char *name) {
   DataVisualization::Categories::GetCategory(ConstString(name), m_opaque_sp);
 }
 
 SBTypeCategory::SBTypeCategory(const lldb::SBTypeCategory &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBTypeCategory::~SBTypeCategory() = default;
 
 bool SBTypeCategory::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTypeCategory::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_sp.get() != nullptr);
 }
 
 bool SBTypeCategory::GetEnabled() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeCategory, GetEnabled);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -60,7 +58,7 @@ bool SBTypeCategory::GetEnabled() {
 }
 
 void SBTypeCategory::SetEnabled(bool enabled) {
-  LLDB_RECORD_METHOD(void, SBTypeCategory, SetEnabled, (bool), enabled);
+  LLDB_INSTRUMENT_VA(this, enabled);
 
   if (!IsValid())
     return;
@@ -71,7 +69,7 @@ void SBTypeCategory::SetEnabled(bool enabled) {
 }
 
 const char *SBTypeCategory::GetName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeCategory, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return nullptr;
@@ -79,8 +77,7 @@ const char *SBTypeCategory::GetName() {
 }
 
 lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
-                     (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   if (IsValid())
     return m_opaque_sp->GetLanguageAtIndex(idx);
@@ -88,7 +85,7 @@ lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
 }
 
 uint32_t SBTypeCategory::GetNumLanguages() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumLanguages);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     return m_opaque_sp->GetNumLanguages();
@@ -96,15 +93,14 @@ uint32_t SBTypeCategory::GetNumLanguages() {
 }
 
 void SBTypeCategory::AddLanguage(lldb::LanguageType language) {
-  LLDB_RECORD_METHOD(void, SBTypeCategory, AddLanguage, (lldb::LanguageType),
-                     language);
+  LLDB_INSTRUMENT_VA(this, language);
 
   if (IsValid())
     m_opaque_sp->AddLanguage(language);
 }
 
 uint32_t SBTypeCategory::GetNumFormats() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFormats);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return 0;
@@ -114,7 +110,7 @@ uint32_t SBTypeCategory::GetNumFormats() {
 }
 
 uint32_t SBTypeCategory::GetNumSummaries() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return 0;
@@ -123,7 +119,7 @@ uint32_t SBTypeCategory::GetNumSummaries() {
 }
 
 uint32_t SBTypeCategory::GetNumFilters() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return 0;
@@ -132,7 +128,7 @@ uint32_t SBTypeCategory::GetNumFilters() {
 }
 
 uint32_t SBTypeCategory::GetNumSynthetics() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSynthetics);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return 0;
@@ -142,58 +138,52 @@ uint32_t SBTypeCategory::GetNumSynthetics() {
 
 lldb::SBTypeNameSpecifier
 SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
-                     GetTypeNameSpecifierForFilterAtIndex, (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
-  return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
-      m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index)));
+    return SBTypeNameSpecifier();
+  return SBTypeNameSpecifier(
+      m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index));
 }
 
 lldb::SBTypeNameSpecifier
 SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
-                     GetTypeNameSpecifierForFormatAtIndex, (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
-  return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
-      m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index)));
+    return SBTypeNameSpecifier();
+  return SBTypeNameSpecifier(
+      m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index));
 }
 
 lldb::SBTypeNameSpecifier
 SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
-                     GetTypeNameSpecifierForSummaryAtIndex, (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
-  return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
-      m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index)));
+    return SBTypeNameSpecifier();
+  return SBTypeNameSpecifier(
+      m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index));
 }
 
 lldb::SBTypeNameSpecifier
 SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
-                     GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t),
-                     index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
-  return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
-      m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index)));
+    return SBTypeNameSpecifier();
+  return SBTypeNameSpecifier(
+      m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index));
 }
 
 SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
-  LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
-                     (lldb::SBTypeNameSpecifier), spec);
+  LLDB_INSTRUMENT_VA(this, spec);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBTypeFilter());
+    return SBTypeFilter();
 
   if (!spec.IsValid())
-    return LLDB_RECORD_RESULT(SBTypeFilter());
+    return SBTypeFilter();
 
   lldb::TypeFilterImplSP children_sp;
 
@@ -205,22 +195,21 @@ SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
         ConstString(spec.GetName()), children_sp);
 
   if (!children_sp)
-    return LLDB_RECORD_RESULT(lldb::SBTypeFilter());
+    return lldb::SBTypeFilter();
 
   TypeFilterImplSP filter_sp =
       std::static_pointer_cast<TypeFilterImpl>(children_sp);
 
-  return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp));
+  return lldb::SBTypeFilter(filter_sp);
 }
 SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
-  LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
-                     (lldb::SBTypeNameSpecifier), spec);
+  LLDB_INSTRUMENT_VA(this, spec);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBTypeFormat());
+    return SBTypeFormat();
 
   if (!spec.IsValid())
-    return LLDB_RECORD_RESULT(SBTypeFormat());
+    return SBTypeFormat();
 
   lldb::TypeFormatImplSP format_sp;
 
@@ -232,20 +221,19 @@ SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
         ConstString(spec.GetName()), format_sp);
 
   if (!format_sp)
-    return LLDB_RECORD_RESULT(lldb::SBTypeFormat());
+    return lldb::SBTypeFormat();
 
-  return LLDB_RECORD_RESULT(lldb::SBTypeFormat(format_sp));
+  return lldb::SBTypeFormat(format_sp);
 }
 
 SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
-  LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
-                     (lldb::SBTypeNameSpecifier), spec);
+  LLDB_INSTRUMENT_VA(this, spec);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBTypeSummary());
+    return SBTypeSummary();
 
   if (!spec.IsValid())
-    return LLDB_RECORD_RESULT(SBTypeSummary());
+    return SBTypeSummary();
 
   lldb::TypeSummaryImplSP summary_sp;
 
@@ -257,20 +245,19 @@ SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
         ConstString(spec.GetName()), summary_sp);
 
   if (!summary_sp)
-    return LLDB_RECORD_RESULT(lldb::SBTypeSummary());
+    return lldb::SBTypeSummary();
 
-  return LLDB_RECORD_RESULT(lldb::SBTypeSummary(summary_sp));
+  return lldb::SBTypeSummary(summary_sp);
 }
 
 SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
-  LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType,
-                     (lldb::SBTypeNameSpecifier), spec);
+  LLDB_INSTRUMENT_VA(this, spec);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBTypeSynthetic());
+    return SBTypeSynthetic();
 
   if (!spec.IsValid())
-    return LLDB_RECORD_RESULT(SBTypeSynthetic());
+    return SBTypeSynthetic();
 
   lldb::SyntheticChildrenSP children_sp;
 
@@ -282,75 +269,67 @@ SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
         ConstString(spec.GetName()), children_sp);
 
   if (!children_sp)
-    return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic());
+    return lldb::SBTypeSynthetic();
 
   ScriptedSyntheticChildrenSP synth_sp =
       std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
 
-  return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp));
+  return lldb::SBTypeSynthetic(synth_sp);
 }
 
 SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
-                     (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBTypeFilter());
+    return SBTypeFilter();
   lldb::SyntheticChildrenSP children_sp =
       m_opaque_sp->GetSyntheticAtIndex((index));
 
   if (!children_sp.get())
-    return LLDB_RECORD_RESULT(lldb::SBTypeFilter());
+    return lldb::SBTypeFilter();
 
   TypeFilterImplSP filter_sp =
       std::static_pointer_cast<TypeFilterImpl>(children_sp);
 
-  return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp));
+  return lldb::SBTypeFilter(filter_sp);
 }
 
 SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
-                     (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBTypeFormat());
-  return LLDB_RECORD_RESULT(
-      SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index))));
+    return SBTypeFormat();
+  return SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index)));
 }
 
 SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
-                     (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBTypeSummary());
-  return LLDB_RECORD_RESULT(
-      SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index))));
+    return SBTypeSummary();
+  return SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index)));
 }
 
 SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticAtIndex,
-                     (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBTypeSynthetic());
+    return SBTypeSynthetic();
   lldb::SyntheticChildrenSP children_sp =
       m_opaque_sp->GetSyntheticAtIndex((index));
 
   if (!children_sp.get())
-    return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic());
+    return lldb::SBTypeSynthetic();
 
   ScriptedSyntheticChildrenSP synth_sp =
       std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
 
-  return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp));
+  return lldb::SBTypeSynthetic(synth_sp);
 }
 
 bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
                                    SBTypeFormat format) {
-  LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFormat,
-                     (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat), type_name,
-                     format);
+  LLDB_INSTRUMENT_VA(this, type_name, format);
 
   if (!IsValid())
     return false;
@@ -372,8 +351,7 @@ bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
 }
 
 bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
-  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
-                     (lldb::SBTypeNameSpecifier), type_name);
+  LLDB_INSTRUMENT_VA(this, type_name);
 
   if (!IsValid())
     return false;
@@ -391,9 +369,7 @@ bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
 
 bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
                                     SBTypeSummary summary) {
-  LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSummary,
-                     (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary),
-                     type_name, summary);
+  LLDB_INSTRUMENT_VA(this, type_name, summary);
 
   if (!IsValid())
     return false;
@@ -449,8 +425,7 @@ bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
 }
 
 bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
-  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
-                     (lldb::SBTypeNameSpecifier), type_name);
+  LLDB_INSTRUMENT_VA(this, type_name);
 
   if (!IsValid())
     return false;
@@ -468,9 +443,7 @@ bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
 
 bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
                                    SBTypeFilter filter) {
-  LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter,
-                     (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name,
-                     filter);
+  LLDB_INSTRUMENT_VA(this, type_name, filter);
 
   if (!IsValid())
     return false;
@@ -492,8 +465,7 @@ bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
 }
 
 bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
-  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
-                     (lldb::SBTypeNameSpecifier), type_name);
+  LLDB_INSTRUMENT_VA(this, type_name);
 
   if (!IsValid())
     return false;
@@ -511,9 +483,7 @@ bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
 
 bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
                                       SBTypeSynthetic synth) {
-  LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
-                     (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic),
-                     type_name, synth);
+  LLDB_INSTRUMENT_VA(this, type_name, synth);
 
   if (!IsValid())
     return false;
@@ -569,8 +539,7 @@ bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
 }
 
 bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
-  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
-                     (lldb::SBTypeNameSpecifier), type_name);
+  LLDB_INSTRUMENT_VA(this, type_name);
 
   if (!IsValid())
     return false;
@@ -588,9 +557,7 @@ bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
 
 bool SBTypeCategory::GetDescription(lldb::SBStream &description,
                                     lldb::DescriptionLevel description_level) {
-  LLDB_RECORD_METHOD(bool, SBTypeCategory, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     description_level);
+  LLDB_INSTRUMENT_VA(this, description, description_level);
 
   if (!IsValid())
     return false;
@@ -600,19 +567,16 @@ bool SBTypeCategory::GetDescription(lldb::SBStream &description,
 
 lldb::SBTypeCategory &SBTypeCategory::
 operator=(const lldb::SBTypeCategory &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBTypeCategory &,
-                     SBTypeCategory, operator=,(const lldb::SBTypeCategory &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -621,8 +585,7 @@ bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
 }
 
 bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return rhs.IsValid();
@@ -651,78 +614,3 @@ bool SBTypeCategory::IsDefaultCategory() {
 
   return (strcmp(m_opaque_sp->GetName(), "default") == 0);
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBTypeCategory>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, operator bool, ());
-  LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetEnabled, ());
-  LLDB_REGISTER_METHOD(void, SBTypeCategory, SetEnabled, (bool));
-  LLDB_REGISTER_METHOD(const char *, SBTypeCategory, GetName, ());
-  LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumLanguages, ());
-  LLDB_REGISTER_METHOD(void, SBTypeCategory, AddLanguage,
-                       (lldb::LanguageType));
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFormats, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSummaries, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFilters, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSynthetics, ());
-  LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
-                       GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
-                       (lldb::SBTypeNameSpecifier));
-  LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
-                       GetSyntheticForType, (lldb::SBTypeNameSpecifier));
-  LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
-                       GetSyntheticAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSummary,
-                       (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary));
-  LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
-                       (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic));
-  LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
-                       (lldb::SBTypeNameSpecifier));
-  LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
-                       GetTypeNameSpecifierForFilterAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
-                       GetTypeNameSpecifierForFormatAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
-                       GetTypeNameSpecifierForSummaryAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
-                       (lldb::SBTypeNameSpecifier));
-  LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
-                       (lldb::SBTypeNameSpecifier));
-  LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFormat,
-                       (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat));
-  LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
-                       (lldb::SBTypeNameSpecifier));
-  LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
-                       (lldb::SBTypeNameSpecifier));
-  LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFilter,
-                       (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter));
-  LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
-                       (lldb::SBTypeNameSpecifier));
-  LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-  LLDB_REGISTER_METHOD(
-      lldb::SBTypeCategory &,
-      SBTypeCategory, operator=,(const lldb::SBTypeCategory &));
-  LLDB_REGISTER_METHOD(bool,
-                       SBTypeCategory, operator==,(lldb::SBTypeCategory &));
-  LLDB_REGISTER_METHOD(bool,
-                       SBTypeCategory, operator!=,(lldb::SBTypeCategory &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBTypeEnumMember.cpp b/lldb/source/API/SBTypeEnumMember.cpp
index 43a4891b54b1..a3d99bd57e31 100644
--- a/lldb/source/API/SBTypeEnumMember.cpp
+++ b/lldb/source/API/SBTypeEnumMember.cpp
@@ -7,13 +7,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeEnumMember.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBType.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Stream.h"
 
 #include <memory>
@@ -21,9 +21,7 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMember);
-}
+SBTypeEnumMember::SBTypeEnumMember() { LLDB_INSTRUMENT_VA(this); }
 
 SBTypeEnumMember::~SBTypeEnumMember() = default;
 
@@ -31,36 +29,32 @@ SBTypeEnumMember::SBTypeEnumMember(
     const lldb::TypeEnumMemberImplSP &enum_member_sp)
     : m_opaque_sp(enum_member_sp) {}
 
-SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs)
-    : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &),
-                          rhs);
+SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_sp = clone(rhs.m_opaque_sp);
 }
 
 SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
-  LLDB_RECORD_METHOD(
-      SBTypeEnumMember &,
-      SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_sp = clone(rhs.m_opaque_sp);
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBTypeEnumMember::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTypeEnumMember::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get();
 }
 
 const char *SBTypeEnumMember::GetName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp.get())
     return m_opaque_sp->GetName().GetCString();
@@ -68,7 +62,7 @@ const char *SBTypeEnumMember::GetName() {
 }
 
 int64_t SBTypeEnumMember::GetValueAsSigned() {
-  LLDB_RECORD_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp.get())
     return m_opaque_sp->GetValueAsSigned();
@@ -76,7 +70,7 @@ int64_t SBTypeEnumMember::GetValueAsSigned() {
 }
 
 uint64_t SBTypeEnumMember::GetValueAsUnsigned() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, GetValueAsUnsigned);
+  LLDB_INSTRUMENT_VA(this);
 
   if (m_opaque_sp.get())
     return m_opaque_sp->GetValueAsUnsigned();
@@ -84,13 +78,13 @@ uint64_t SBTypeEnumMember::GetValueAsUnsigned() {
 }
 
 SBType SBTypeEnumMember::GetType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType);
+  LLDB_INSTRUMENT_VA(this);
 
   SBType sb_type;
   if (m_opaque_sp.get()) {
     sb_type.SetSP(m_opaque_sp->GetIntegerType());
   }
-  return LLDB_RECORD_RESULT(sb_type);
+  return sb_type;
 }
 
 void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) {
@@ -109,13 +103,12 @@ const TypeEnumMemberImpl &SBTypeEnumMember::ref() const {
 
 SBTypeEnumMemberList::SBTypeEnumMemberList()
     : m_opaque_up(new TypeEnumMemberListImpl()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs)
     : m_opaque_up(new TypeEnumMemberListImpl()) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMemberList,
-                          (const lldb::SBTypeEnumMemberList &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   for (uint32_t i = 0,
                 rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
@@ -124,21 +117,18 @@ SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs)
 }
 
 bool SBTypeEnumMemberList::IsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTypeEnumMemberList::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMemberList, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_up != nullptr);
 }
 
 SBTypeEnumMemberList &SBTypeEnumMemberList::
 operator=(const SBTypeEnumMemberList &rhs) {
-  LLDB_RECORD_METHOD(
-      lldb::SBTypeEnumMemberList &,
-      SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &),
-      rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_up = std::make_unique<TypeEnumMemberListImpl>();
@@ -148,12 +138,11 @@ operator=(const SBTypeEnumMemberList &rhs) {
       Append(
           const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i));
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
-  LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append,
-                     (lldb::SBTypeEnumMember), enum_member);
+  LLDB_INSTRUMENT_VA(this, enum_member);
 
   if (enum_member.IsValid())
     m_opaque_up->Append(enum_member.m_opaque_sp);
@@ -161,17 +150,15 @@ void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
 
 SBTypeEnumMember
 SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) {
-  LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
-                     GetTypeEnumMemberAtIndex, (uint32_t), index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (m_opaque_up)
-    return LLDB_RECORD_RESULT(
-        SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index)));
-  return LLDB_RECORD_RESULT(SBTypeEnumMember());
+    return SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index));
+  return SBTypeEnumMember();
 }
 
 uint32_t SBTypeEnumMemberList::GetSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetSize();
 }
@@ -180,9 +167,7 @@ SBTypeEnumMemberList::~SBTypeEnumMemberList() = default;
 
 bool SBTypeEnumMember::GetDescription(
     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
-  LLDB_RECORD_METHOD(bool, SBTypeEnumMember, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     description_level);
+  LLDB_INSTRUMENT_VA(this, description, description_level);
 
   Stream &strm = description.ref();
 
@@ -196,40 +181,3 @@ bool SBTypeEnumMember::GetDescription(
   }
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBTypeEnumMember>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember,
-                            (const lldb::SBTypeEnumMember &));
-  LLDB_REGISTER_METHOD(
-      lldb::SBTypeEnumMember &,
-      SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, operator bool, ());
-  LLDB_REGISTER_METHOD(const char *, SBTypeEnumMember, GetName, ());
-  LLDB_REGISTER_METHOD(int64_t, SBTypeEnumMember, GetValueAsSigned, ());
-  LLDB_REGISTER_METHOD(uint64_t, SBTypeEnumMember, GetValueAsUnsigned, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBTypeEnumMember, GetType, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList,
-                            (const lldb::SBTypeEnumMemberList &));
-  LLDB_REGISTER_METHOD(bool, SBTypeEnumMemberList, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMemberList, operator bool, ());
-  LLDB_REGISTER_METHOD(
-      lldb::SBTypeEnumMemberList &,
-      SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &));
-  LLDB_REGISTER_METHOD(void, SBTypeEnumMemberList, Append,
-                       (lldb::SBTypeEnumMember));
-  LLDB_REGISTER_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
-                       GetTypeEnumMemberAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeEnumMemberList, GetSize, ());
-  LLDB_REGISTER_METHOD(bool, SBTypeEnumMember, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-}
-
-}
-}
diff --git a/lldb/source/API/SBTypeFilter.cpp b/lldb/source/API/SBTypeFilter.cpp
index 5f91a194f16b..94f222b254b2 100644
--- a/lldb/source/API/SBTypeFilter.cpp
+++ b/lldb/source/API/SBTypeFilter.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeFilter.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBStream.h"
 
@@ -16,34 +16,32 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBTypeFilter::SBTypeFilter() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFilter);
-}
+SBTypeFilter::SBTypeFilter() { LLDB_INSTRUMENT_VA(this); }
 
 SBTypeFilter::SBTypeFilter(uint32_t options)
     : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (uint32_t), options);
+  LLDB_INSTRUMENT_VA(this, options);
 }
 
 SBTypeFilter::SBTypeFilter(const lldb::SBTypeFilter &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBTypeFilter::~SBTypeFilter() = default;
 
 bool SBTypeFilter::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTypeFilter::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 uint32_t SBTypeFilter::GetOptions() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     return m_opaque_sp->GetOptions();
@@ -51,7 +49,7 @@ uint32_t SBTypeFilter::GetOptions() {
 }
 
 void SBTypeFilter::SetOptions(uint32_t value) {
-  LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value);
+  LLDB_INSTRUMENT_VA(this, value);
 
   if (CopyOnWrite_Impl())
     m_opaque_sp->SetOptions(value);
@@ -59,9 +57,7 @@ void SBTypeFilter::SetOptions(uint32_t value) {
 
 bool SBTypeFilter::GetDescription(lldb::SBStream &description,
                                   lldb::DescriptionLevel description_level) {
-  LLDB_RECORD_METHOD(bool, SBTypeFilter, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     description_level);
+  LLDB_INSTRUMENT_VA(this, description, description_level);
 
   if (!IsValid())
     return false;
@@ -72,15 +68,14 @@ bool SBTypeFilter::GetDescription(lldb::SBStream &description,
 }
 
 void SBTypeFilter::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBTypeFilter, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   if (CopyOnWrite_Impl())
     m_opaque_sp->Clear();
 }
 
 uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter,
-                             GetNumberOfExpressionPaths);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     return m_opaque_sp->GetCount();
@@ -88,8 +83,7 @@ uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
 }
 
 const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
-  LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
-                     (uint32_t), i);
+  LLDB_INSTRUMENT_VA(this, i);
 
   if (IsValid()) {
     const char *item = m_opaque_sp->GetExpressionPathAtIndex(i);
@@ -101,8 +95,7 @@ const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
 }
 
 bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
-  LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
-                     (uint32_t, const char *), i, item);
+  LLDB_INSTRUMENT_VA(this, i, item);
 
   if (CopyOnWrite_Impl())
     return m_opaque_sp->SetExpressionPathAtIndex(i, item);
@@ -111,26 +104,23 @@ bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
 }
 
 void SBTypeFilter::AppendExpressionPath(const char *item) {
-  LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *),
-                     item);
+  LLDB_INSTRUMENT_VA(this, item);
 
   if (CopyOnWrite_Impl())
     m_opaque_sp->AddExpressionPath(item);
 }
 
 lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBTypeFilter &,
-                     SBTypeFilter, operator=,(const lldb::SBTypeFilter &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -139,8 +129,7 @@ bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
 }
 
 bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -157,8 +146,7 @@ bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
 }
 
 bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -190,36 +178,3 @@ bool SBTypeFilter::CopyOnWrite_Impl() {
 
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBTypeFilter>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (uint32_t));
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, operator bool, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetOptions, ());
-  LLDB_REGISTER_METHOD(void, SBTypeFilter, SetOptions, (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBTypeFilter, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-  LLDB_REGISTER_METHOD(void, SBTypeFilter, Clear, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths,
-                       ());
-  LLDB_REGISTER_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
-                       (uint32_t, const char *));
-  LLDB_REGISTER_METHOD(void, SBTypeFilter, AppendExpressionPath,
-                       (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBTypeFilter &,
-                       SBTypeFilter, operator=,(const lldb::SBTypeFilter &));
-  LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &));
-  LLDB_REGISTER_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &));
-  LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBTypeFormat.cpp b/lldb/source/API/SBTypeFormat.cpp
index 70289bef8db5..86e11e8b8fde 100644
--- a/lldb/source/API/SBTypeFormat.cpp
+++ b/lldb/source/API/SBTypeFormat.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeFormat.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBStream.h"
 
@@ -16,43 +16,39 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBTypeFormat::SBTypeFormat() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFormat);
-}
+SBTypeFormat::SBTypeFormat() { LLDB_INSTRUMENT_VA(this); }
 
 SBTypeFormat::SBTypeFormat(lldb::Format format, uint32_t options)
     : m_opaque_sp(
           TypeFormatImplSP(new TypeFormatImpl_Format(format, options))) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t), format,
-                          options);
+  LLDB_INSTRUMENT_VA(this, format, options);
 }
 
 SBTypeFormat::SBTypeFormat(const char *type, uint32_t options)
     : m_opaque_sp(TypeFormatImplSP(new TypeFormatImpl_EnumType(
           ConstString(type ? type : ""), options))) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t), type,
-                          options);
+  LLDB_INSTRUMENT_VA(this, type, options);
 }
 
 SBTypeFormat::SBTypeFormat(const lldb::SBTypeFormat &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBTypeFormat::~SBTypeFormat() = default;
 
 bool SBTypeFormat::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTypeFormat::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 lldb::Format SBTypeFormat::GetFormat() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBTypeFormat, GetFormat);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)
     return ((TypeFormatImpl_Format *)m_opaque_sp.get())->GetFormat();
@@ -60,7 +56,7 @@ lldb::Format SBTypeFormat::GetFormat() {
 }
 
 const char *SBTypeFormat::GetTypeName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeFormat, GetTypeName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum)
     return ((TypeFormatImpl_EnumType *)m_opaque_sp.get())
@@ -70,7 +66,7 @@ const char *SBTypeFormat::GetTypeName() {
 }
 
 uint32_t SBTypeFormat::GetOptions() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFormat, GetOptions);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     return m_opaque_sp->GetOptions();
@@ -78,14 +74,14 @@ uint32_t SBTypeFormat::GetOptions() {
 }
 
 void SBTypeFormat::SetFormat(lldb::Format fmt) {
-  LLDB_RECORD_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format), fmt);
+  LLDB_INSTRUMENT_VA(this, fmt);
 
   if (CopyOnWrite_Impl(Type::eTypeFormat))
     ((TypeFormatImpl_Format *)m_opaque_sp.get())->SetFormat(fmt);
 }
 
 void SBTypeFormat::SetTypeName(const char *type) {
-  LLDB_RECORD_METHOD(void, SBTypeFormat, SetTypeName, (const char *), type);
+  LLDB_INSTRUMENT_VA(this, type);
 
   if (CopyOnWrite_Impl(Type::eTypeEnum))
     ((TypeFormatImpl_EnumType *)m_opaque_sp.get())
@@ -93,7 +89,7 @@ void SBTypeFormat::SetTypeName(const char *type) {
 }
 
 void SBTypeFormat::SetOptions(uint32_t value) {
-  LLDB_RECORD_METHOD(void, SBTypeFormat, SetOptions, (uint32_t), value);
+  LLDB_INSTRUMENT_VA(this, value);
 
   if (CopyOnWrite_Impl(Type::eTypeKeepSame))
     m_opaque_sp->SetOptions(value);
@@ -101,9 +97,7 @@ void SBTypeFormat::SetOptions(uint32_t value) {
 
 bool SBTypeFormat::GetDescription(lldb::SBStream &description,
                                   lldb::DescriptionLevel description_level) {
-  LLDB_RECORD_METHOD(bool, SBTypeFormat, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     description_level);
+  LLDB_INSTRUMENT_VA(this, description, description_level);
 
   if (!IsValid())
     return false;
@@ -114,18 +108,16 @@ bool SBTypeFormat::GetDescription(lldb::SBStream &description,
 }
 
 lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBTypeFormat &,
-                     SBTypeFormat, operator=,(const lldb::SBTypeFormat &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -133,8 +125,7 @@ bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) {
 }
 
 bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -146,8 +137,7 @@ bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
 }
 
 bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -191,32 +181,3 @@ bool SBTypeFormat::CopyOnWrite_Impl(Type type) {
 
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBTypeFormat>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t));
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t));
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, operator bool, ());
-  LLDB_REGISTER_METHOD(lldb::Format, SBTypeFormat, GetFormat, ());
-  LLDB_REGISTER_METHOD(const char *, SBTypeFormat, GetTypeName, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeFormat, GetOptions, ());
-  LLDB_REGISTER_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format));
-  LLDB_REGISTER_METHOD(void, SBTypeFormat, SetTypeName, (const char *));
-  LLDB_REGISTER_METHOD(void, SBTypeFormat, SetOptions, (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBTypeFormat, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-  LLDB_REGISTER_METHOD(lldb::SBTypeFormat &,
-                       SBTypeFormat, operator=,(const lldb::SBTypeFormat &));
-  LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &));
-  LLDB_REGISTER_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &));
-  LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBTypeNameSpecifier.cpp b/lldb/source/API/SBTypeNameSpecifier.cpp
index 3673a5024530..bc83a1d664d0 100644
--- a/lldb/source/API/SBTypeNameSpecifier.cpp
+++ b/lldb/source/API/SBTypeNameSpecifier.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeNameSpecifier.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBType.h"
@@ -17,21 +17,18 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBTypeNameSpecifier::SBTypeNameSpecifier() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeNameSpecifier);
-}
+SBTypeNameSpecifier::SBTypeNameSpecifier() { LLDB_INSTRUMENT_VA(this); }
 
 SBTypeNameSpecifier::SBTypeNameSpecifier(const char *name, bool is_regex)
     : m_opaque_sp(new TypeNameSpecifierImpl(name, is_regex)) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool), name,
-                          is_regex);
+  LLDB_INSTRUMENT_VA(this, name, is_regex);
 
   if (name == nullptr || (*name) == 0)
     m_opaque_sp.reset();
 }
 
-SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType), type);
+SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) {
+  LLDB_INSTRUMENT_VA(this, type);
 
   if (type.IsValid())
     m_opaque_sp = TypeNameSpecifierImplSP(
@@ -40,24 +37,23 @@ SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) : m_opaque_sp() {
 
 SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier,
-                          (const lldb::SBTypeNameSpecifier &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBTypeNameSpecifier::~SBTypeNameSpecifier() = default;
 
 bool SBTypeNameSpecifier::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTypeNameSpecifier::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 const char *SBTypeNameSpecifier::GetName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return nullptr;
@@ -66,18 +62,18 @@ const char *SBTypeNameSpecifier::GetName() {
 }
 
 SBType SBTypeNameSpecifier::GetType() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
-    return LLDB_RECORD_RESULT(SBType());
+    return SBType();
   lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType();
   if (c_type.IsValid())
-    return LLDB_RECORD_RESULT(SBType(c_type));
-  return LLDB_RECORD_RESULT(SBType());
+    return SBType(c_type);
+  return SBType();
 }
 
 bool SBTypeNameSpecifier::IsRegex() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -87,9 +83,7 @@ bool SBTypeNameSpecifier::IsRegex() {
 
 bool SBTypeNameSpecifier::GetDescription(
     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
-  LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     description_level);
+  LLDB_INSTRUMENT_VA(this, description, description_level);
 
   if (!IsValid())
     return false;
@@ -100,19 +94,16 @@ bool SBTypeNameSpecifier::GetDescription(
 
 lldb::SBTypeNameSpecifier &SBTypeNameSpecifier::
 operator=(const lldb::SBTypeNameSpecifier &rhs) {
-  LLDB_RECORD_METHOD(
-      lldb::SBTypeNameSpecifier &,
-      SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
-  LLDB_RECORD_METHOD(
-      bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -120,8 +111,7 @@ bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
 }
 
 bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
-                     (lldb::SBTypeNameSpecifier &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -135,8 +125,7 @@ bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
 }
 
 bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) {
-  LLDB_RECORD_METHOD(
-      bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -155,34 +144,3 @@ void SBTypeNameSpecifier::SetSP(
 SBTypeNameSpecifier::SBTypeNameSpecifier(
     const lldb::TypeNameSpecifierImplSP &type_namespec_sp)
     : m_opaque_sp(type_namespec_sp) {}
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBTypeNameSpecifier>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool));
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType));
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier,
-                            (const lldb::SBTypeNameSpecifier &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, operator bool, ());
-  LLDB_REGISTER_METHOD(const char *, SBTypeNameSpecifier, GetName, ());
-  LLDB_REGISTER_METHOD(lldb::SBType, SBTypeNameSpecifier, GetType, ());
-  LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsRegex, ());
-  LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-  LLDB_REGISTER_METHOD(
-      lldb::SBTypeNameSpecifier &,
-      SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &));
-  LLDB_REGISTER_METHOD(
-      bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &));
-  LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
-                       (lldb::SBTypeNameSpecifier &));
-  LLDB_REGISTER_METHOD(
-      bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBTypeSummary.cpp b/lldb/source/API/SBTypeSummary.cpp
index 2d7f8ef340c9..a65dfc987ad2 100644
--- a/lldb/source/API/SBTypeSummary.cpp
+++ b/lldb/source/API/SBTypeSummary.cpp
@@ -7,11 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeSummary.h"
-#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/DataFormatters/DataVisualization.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "llvm/Support/Casting.h"
 
@@ -19,15 +19,14 @@ using namespace lldb;
 using namespace lldb_private;
 
 SBTypeSummaryOptions::SBTypeSummaryOptions() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummaryOptions);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_up = std::make_unique<TypeSummaryOptions>();
 }
 
 SBTypeSummaryOptions::SBTypeSummaryOptions(
     const lldb::SBTypeSummaryOptions &rhs) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions,
-                          (const lldb::SBTypeSummaryOptions &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
@@ -35,18 +34,17 @@ SBTypeSummaryOptions::SBTypeSummaryOptions(
 SBTypeSummaryOptions::~SBTypeSummaryOptions() = default;
 
 bool SBTypeSummaryOptions::IsValid() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummaryOptions, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTypeSummaryOptions::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummaryOptions, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up.get();
 }
 
 lldb::LanguageType SBTypeSummaryOptions::GetLanguage() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBTypeSummaryOptions,
-                             GetLanguage);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     return m_opaque_up->GetLanguage();
@@ -54,8 +52,7 @@ lldb::LanguageType SBTypeSummaryOptions::GetLanguage() {
 }
 
 lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
-                             GetCapping);
+  LLDB_INSTRUMENT_VA(this);
 
   if (IsValid())
     return m_opaque_up->GetCapping();
@@ -63,16 +60,14 @@ lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() {
 }
 
 void SBTypeSummaryOptions::SetLanguage(lldb::LanguageType l) {
-  LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetLanguage,
-                     (lldb::LanguageType), l);
+  LLDB_INSTRUMENT_VA(this, l);
 
   if (IsValid())
     m_opaque_up->SetLanguage(l);
 }
 
 void SBTypeSummaryOptions::SetCapping(lldb::TypeSummaryCapping c) {
-  LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetCapping,
-                     (lldb::TypeSummaryCapping), c);
+  LLDB_INSTRUMENT_VA(this, c);
 
   if (IsValid())
     m_opaque_up->SetCapping(c);
@@ -102,61 +97,48 @@ const lldb_private::TypeSummaryOptions &SBTypeSummaryOptions::ref() const {
 SBTypeSummaryOptions::SBTypeSummaryOptions(
     const lldb_private::TypeSummaryOptions &lldb_object)
     : m_opaque_up(std::make_unique<TypeSummaryOptions>(lldb_object)) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions,
-                          (const lldb_private::TypeSummaryOptions &),
-                          lldb_object);
+  LLDB_INSTRUMENT_VA(this, lldb_object);
 }
 
-SBTypeSummary::SBTypeSummary() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummary);
-}
+SBTypeSummary::SBTypeSummary() { LLDB_INSTRUMENT_VA(this); }
 
 SBTypeSummary SBTypeSummary::CreateWithSummaryString(const char *data,
                                                      uint32_t options) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
-                            CreateWithSummaryString, (const char *, uint32_t),
-                            data, options);
+  LLDB_INSTRUMENT_VA(data, options);
 
   if (!data || data[0] == 0)
-    return LLDB_RECORD_RESULT(SBTypeSummary());
+    return SBTypeSummary();
 
-  return LLDB_RECORD_RESULT(
-      SBTypeSummary(TypeSummaryImplSP(new StringSummaryFormat(options, data))));
+  return SBTypeSummary(
+      TypeSummaryImplSP(new StringSummaryFormat(options, data)));
 }
 
 SBTypeSummary SBTypeSummary::CreateWithFunctionName(const char *data,
                                                     uint32_t options) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
-                            CreateWithFunctionName, (const char *, uint32_t),
-                            data, options);
+  LLDB_INSTRUMENT_VA(data, options);
 
   if (!data || data[0] == 0)
-    return LLDB_RECORD_RESULT(SBTypeSummary());
+    return SBTypeSummary();
 
-  return LLDB_RECORD_RESULT(
-      SBTypeSummary(TypeSummaryImplSP(new ScriptSummaryFormat(options, data))));
+  return SBTypeSummary(
+      TypeSummaryImplSP(new ScriptSummaryFormat(options, data)));
 }
 
 SBTypeSummary SBTypeSummary::CreateWithScriptCode(const char *data,
                                                   uint32_t options) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
-                            CreateWithScriptCode, (const char *, uint32_t),
-                            data, options);
+  LLDB_INSTRUMENT_VA(data, options);
 
   if (!data || data[0] == 0)
-    return LLDB_RECORD_RESULT(SBTypeSummary());
+    return SBTypeSummary();
 
-  return LLDB_RECORD_RESULT(SBTypeSummary(
-      TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data))));
+  return SBTypeSummary(
+      TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data)));
 }
 
 SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
                                                 uint32_t options,
                                                 const char *description) {
-  LLDB_RECORD_DUMMY(
-      lldb::SBTypeSummary, SBTypeSummary, CreateWithCallback,
-      (lldb::SBTypeSummary::FormatCallback, uint32_t, const char *), cb,
-      options, description);
+  LLDB_INSTRUMENT_VA(cb, options, description);
 
   SBTypeSummary retval;
   if (cb) {
@@ -180,23 +162,23 @@ SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
 
 SBTypeSummary::SBTypeSummary(const lldb::SBTypeSummary &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBTypeSummary::~SBTypeSummary() = default;
 
 bool SBTypeSummary::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTypeSummary::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 bool SBTypeSummary::IsFunctionCode() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionCode);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -209,7 +191,7 @@ bool SBTypeSummary::IsFunctionCode() {
 }
 
 bool SBTypeSummary::IsFunctionName() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -222,7 +204,7 @@ bool SBTypeSummary::IsFunctionName() {
 }
 
 bool SBTypeSummary::IsSummaryString() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -231,7 +213,7 @@ bool SBTypeSummary::IsSummaryString() {
 }
 
 const char *SBTypeSummary::GetData() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return nullptr;
@@ -249,7 +231,7 @@ const char *SBTypeSummary::GetData() {
 }
 
 uint32_t SBTypeSummary::GetOptions() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSummary, GetOptions);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return lldb::eTypeOptionNone;
@@ -257,7 +239,7 @@ uint32_t SBTypeSummary::GetOptions() {
 }
 
 void SBTypeSummary::SetOptions(uint32_t value) {
-  LLDB_RECORD_METHOD(void, SBTypeSummary, SetOptions, (uint32_t), value);
+  LLDB_INSTRUMENT_VA(this, value);
 
   if (!CopyOnWrite_Impl())
     return;
@@ -265,8 +247,7 @@ void SBTypeSummary::SetOptions(uint32_t value) {
 }
 
 void SBTypeSummary::SetSummaryString(const char *data) {
-  LLDB_RECORD_METHOD(void, SBTypeSummary, SetSummaryString, (const char *),
-                     data);
+  LLDB_INSTRUMENT_VA(this, data);
 
   if (!IsValid())
     return;
@@ -278,8 +259,7 @@ void SBTypeSummary::SetSummaryString(const char *data) {
 }
 
 void SBTypeSummary::SetFunctionName(const char *data) {
-  LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionName, (const char *),
-                     data);
+  LLDB_INSTRUMENT_VA(this, data);
 
   if (!IsValid())
     return;
@@ -291,8 +271,7 @@ void SBTypeSummary::SetFunctionName(const char *data) {
 }
 
 void SBTypeSummary::SetFunctionCode(const char *data) {
-  LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *),
-                     data);
+  LLDB_INSTRUMENT_VA(this, data);
 
   if (!IsValid())
     return;
@@ -305,9 +284,7 @@ void SBTypeSummary::SetFunctionCode(const char *data) {
 
 bool SBTypeSummary::GetDescription(lldb::SBStream &description,
                                    lldb::DescriptionLevel description_level) {
-  LLDB_RECORD_METHOD(bool, SBTypeSummary, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     description_level);
+  LLDB_INSTRUMENT_VA(this, description, description_level);
 
   if (!CopyOnWrite_Impl())
     return false;
@@ -318,8 +295,7 @@ bool SBTypeSummary::GetDescription(lldb::SBStream &description,
 }
 
 bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) {
-  LLDB_RECORD_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue),
-                     value);
+  LLDB_INSTRUMENT_VA(this, value);
 
   if (!IsValid())
     return false;
@@ -328,19 +304,16 @@ bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) {
 }
 
 lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBTypeSummary &,
-                     SBTypeSummary, operator=,(const lldb::SBTypeSummary &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeSummary, operator==,(lldb::SBTypeSummary &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -348,8 +321,7 @@ bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) {
 }
 
 bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeSummary, IsEqualTo, (lldb::SBTypeSummary &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (IsValid()) {
     // valid and invalid are different
@@ -389,8 +361,7 @@ bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) {
 }
 
 bool SBTypeSummary::operator!=(lldb::SBTypeSummary &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeSummary, operator!=,(lldb::SBTypeSummary &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -463,65 +434,3 @@ bool SBTypeSummary::ChangeSummaryType(bool want_script) {
 
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBTypeSummaryOptions>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
-                            (const lldb::SBTypeSummaryOptions &));
-  LLDB_REGISTER_METHOD(bool, SBTypeSummaryOptions, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummaryOptions, operator bool, ());
-  LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeSummaryOptions, GetLanguage,
-                       ());
-  LLDB_REGISTER_METHOD(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
-                       GetCapping, ());
-  LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetLanguage,
-                       (lldb::LanguageType));
-  LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetCapping,
-                       (lldb::TypeSummaryCapping));
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
-                            (const lldb_private::TypeSummaryOptions &));
-}
-
-template <>
-void RegisterMethods<SBTypeSummary>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, ());
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
-                              CreateWithSummaryString,
-                              (const char *, uint32_t));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
-                              CreateWithFunctionName,
-                              (const char *, uint32_t));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
-                              CreateWithScriptCode, (const char *, uint32_t));
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, operator bool, ());
-  LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionCode, ());
-  LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionName, ());
-  LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsSummaryString, ());
-  LLDB_REGISTER_METHOD(const char *, SBTypeSummary, GetData, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeSummary, GetOptions, ());
-  LLDB_REGISTER_METHOD(void, SBTypeSummary, SetOptions, (uint32_t));
-  LLDB_REGISTER_METHOD(void, SBTypeSummary, SetSummaryString, (const char *));
-  LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionName, (const char *));
-  LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *));
-  LLDB_REGISTER_METHOD(bool, SBTypeSummary, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-  LLDB_REGISTER_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue));
-  LLDB_REGISTER_METHOD(
-      lldb::SBTypeSummary &,
-      SBTypeSummary, operator=,(const lldb::SBTypeSummary &));
-  LLDB_REGISTER_METHOD(bool,
-                       SBTypeSummary, operator==,(lldb::SBTypeSummary &));
-  LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsEqualTo,
-                       (lldb::SBTypeSummary &));
-  LLDB_REGISTER_METHOD(bool,
-                       SBTypeSummary, operator!=,(lldb::SBTypeSummary &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBTypeSynthetic.cpp b/lldb/source/API/SBTypeSynthetic.cpp
index af5e167b9c24..7258ff04745d 100644
--- a/lldb/source/API/SBTypeSynthetic.cpp
+++ b/lldb/source/API/SBTypeSynthetic.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeSynthetic.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBStream.h"
 
@@ -16,54 +16,47 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBTypeSynthetic::SBTypeSynthetic() : m_opaque_sp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSynthetic);
-}
+SBTypeSynthetic::SBTypeSynthetic() { LLDB_INSTRUMENT_VA(this); }
 
 SBTypeSynthetic SBTypeSynthetic::CreateWithClassName(const char *data,
                                                      uint32_t options) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
-                            CreateWithClassName, (const char *, uint32_t), data,
-                            options);
+  LLDB_INSTRUMENT_VA(data, options);
 
   if (!data || data[0] == 0)
-    return LLDB_RECORD_RESULT(SBTypeSynthetic());
-  return LLDB_RECORD_RESULT(SBTypeSynthetic(ScriptedSyntheticChildrenSP(
-      new ScriptedSyntheticChildren(options, data, ""))));
+    return SBTypeSynthetic();
+  return SBTypeSynthetic(ScriptedSyntheticChildrenSP(
+      new ScriptedSyntheticChildren(options, data, "")));
 }
 
 SBTypeSynthetic SBTypeSynthetic::CreateWithScriptCode(const char *data,
                                                       uint32_t options) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
-                            CreateWithScriptCode, (const char *, uint32_t),
-                            data, options);
+  LLDB_INSTRUMENT_VA(data, options);
 
   if (!data || data[0] == 0)
-    return LLDB_RECORD_RESULT(SBTypeSynthetic());
-  return LLDB_RECORD_RESULT(SBTypeSynthetic(ScriptedSyntheticChildrenSP(
-      new ScriptedSyntheticChildren(options, "", data))));
+    return SBTypeSynthetic();
+  return SBTypeSynthetic(ScriptedSyntheticChildrenSP(
+      new ScriptedSyntheticChildren(options, "", data)));
 }
 
 SBTypeSynthetic::SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &),
-                          rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBTypeSynthetic::~SBTypeSynthetic() = default;
 
 bool SBTypeSynthetic::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBTypeSynthetic::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 bool SBTypeSynthetic::IsClassCode() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassCode);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -72,7 +65,7 @@ bool SBTypeSynthetic::IsClassCode() {
 }
 
 bool SBTypeSynthetic::IsClassName() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassName);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return false;
@@ -80,7 +73,7 @@ bool SBTypeSynthetic::IsClassName() {
 }
 
 const char *SBTypeSynthetic::GetData() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSynthetic, GetData);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return nullptr;
@@ -91,21 +84,21 @@ const char *SBTypeSynthetic::GetData() {
 }
 
 void SBTypeSynthetic::SetClassName(const char *data) {
-  LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), data);
+  LLDB_INSTRUMENT_VA(this, data);
 
   if (IsValid() && data && *data)
     m_opaque_sp->SetPythonClassName(data);
 }
 
 void SBTypeSynthetic::SetClassCode(const char *data) {
-  LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *), data);
+  LLDB_INSTRUMENT_VA(this, data);
 
   if (IsValid() && data && *data)
     m_opaque_sp->SetPythonCode(data);
 }
 
 uint32_t SBTypeSynthetic::GetOptions() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSynthetic, GetOptions);
+  LLDB_INSTRUMENT_VA(this);
 
   if (!IsValid())
     return lldb::eTypeOptionNone;
@@ -113,7 +106,7 @@ uint32_t SBTypeSynthetic::GetOptions() {
 }
 
 void SBTypeSynthetic::SetOptions(uint32_t value) {
-  LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value);
+  LLDB_INSTRUMENT_VA(this, value);
 
   if (!CopyOnWrite_Impl())
     return;
@@ -122,9 +115,7 @@ void SBTypeSynthetic::SetOptions(uint32_t value) {
 
 bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
                                      lldb::DescriptionLevel description_level) {
-  LLDB_RECORD_METHOD(bool, SBTypeSynthetic, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     description_level);
+  LLDB_INSTRUMENT_VA(this, description, description_level);
 
   if (m_opaque_sp) {
     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
@@ -135,19 +126,16 @@ bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
 
 lldb::SBTypeSynthetic &SBTypeSynthetic::
 operator=(const lldb::SBTypeSynthetic &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &,
-                     SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
-  LLDB_RECORD_METHOD(
-      bool, SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -155,8 +143,7 @@ bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
 }
 
 bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
-  LLDB_RECORD_METHOD(bool, SBTypeSynthetic, IsEqualTo,
-                     (lldb::SBTypeSynthetic &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -174,8 +161,7 @@ bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
 }
 
 bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) {
-  LLDB_RECORD_METHOD(
-      bool, SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (!IsValid())
     return !rhs.IsValid();
@@ -209,39 +195,3 @@ bool SBTypeSynthetic::CopyOnWrite_Impl() {
 
   return true;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBTypeSynthetic>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, ());
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
-                              CreateWithClassName, (const char *, uint32_t));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
-                              CreateWithScriptCode, (const char *, uint32_t));
-  LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, operator bool, ());
-  LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassCode, ());
-  LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassName, ());
-  LLDB_REGISTER_METHOD(const char *, SBTypeSynthetic, GetData, ());
-  LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassName, (const char *));
-  LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *));
-  LLDB_REGISTER_METHOD(uint32_t, SBTypeSynthetic, GetOptions, ());
-  LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t));
-  LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-  LLDB_REGISTER_METHOD(
-      lldb::SBTypeSynthetic &,
-      SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &));
-  LLDB_REGISTER_METHOD(bool,
-                       SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &));
-  LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsEqualTo,
-                       (lldb::SBTypeSynthetic &));
-  LLDB_REGISTER_METHOD(bool,
-                       SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &));
-}
-
-}
-}
diff --git a/lldb/source/API/SBUnixSignals.cpp b/lldb/source/API/SBUnixSignals.cpp
index a933f6d22333..dc7a68255d13 100644
--- a/lldb/source/API/SBUnixSignals.cpp
+++ b/lldb/source/API/SBUnixSignals.cpp
@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "SBReproducerPrivate.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/UnixSignals.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/lldb-defines.h"
 
 #include "lldb/API/SBUnixSignals.h"
@@ -17,13 +17,11 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBUnixSignals::SBUnixSignals() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBUnixSignals);
-}
+SBUnixSignals::SBUnixSignals() { LLDB_INSTRUMENT_VA(this); }
 
 SBUnixSignals::SBUnixSignals(const SBUnixSignals &rhs)
     : m_opaque_wp(rhs.m_opaque_wp) {
-  LLDB_RECORD_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBUnixSignals::SBUnixSignals(ProcessSP &process_sp)
@@ -33,13 +31,11 @@ SBUnixSignals::SBUnixSignals(PlatformSP &platform_sp)
     : m_opaque_wp(platform_sp ? platform_sp->GetUnixSignals() : nullptr) {}
 
 const SBUnixSignals &SBUnixSignals::operator=(const SBUnixSignals &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBUnixSignals &,
-                     SBUnixSignals, operator=,(const lldb::SBUnixSignals &),
-                     rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_wp = rhs.m_opaque_wp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBUnixSignals::~SBUnixSignals() = default;
@@ -51,24 +47,23 @@ void SBUnixSignals::SetSP(const UnixSignalsSP &signals_sp) {
 }
 
 void SBUnixSignals::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBUnixSignals, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_wp.reset();
 }
 
 bool SBUnixSignals::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBUnixSignals::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return static_cast<bool>(GetSP());
 }
 
 const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
-  LLDB_RECORD_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
-                           (int32_t), signo);
+  LLDB_INSTRUMENT_VA(this, signo);
 
   if (auto signals_sp = GetSP())
     return signals_sp->GetSignalAsCString(signo);
@@ -77,8 +72,7 @@ const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
 }
 
 int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
-  LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
-                           (const char *), name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   if (auto signals_sp = GetSP())
     return signals_sp->GetSignalNumberFromName(name);
@@ -87,8 +81,7 @@ int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
 }
 
 bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, (int32_t),
-                           signo);
+  LLDB_INSTRUMENT_VA(this, signo);
 
   if (auto signals_sp = GetSP())
     return signals_sp->GetShouldSuppress(signo);
@@ -97,8 +90,7 @@ bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
 }
 
 bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
-  LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool),
-                     signo, value);
+  LLDB_INSTRUMENT_VA(this, signo, value);
 
   auto signals_sp = GetSP();
 
@@ -109,8 +101,7 @@ bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
 }
 
 bool SBUnixSignals::GetShouldStop(int32_t signo) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t),
-                           signo);
+  LLDB_INSTRUMENT_VA(this, signo);
 
   if (auto signals_sp = GetSP())
     return signals_sp->GetShouldStop(signo);
@@ -119,8 +110,7 @@ bool SBUnixSignals::GetShouldStop(int32_t signo) const {
 }
 
 bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
-  LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo,
-                     value);
+  LLDB_INSTRUMENT_VA(this, signo, value);
 
   auto signals_sp = GetSP();
 
@@ -131,8 +121,7 @@ bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
 }
 
 bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t),
-                           signo);
+  LLDB_INSTRUMENT_VA(this, signo);
 
   if (auto signals_sp = GetSP())
     return signals_sp->GetShouldNotify(signo);
@@ -141,8 +130,7 @@ bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
 }
 
 bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
-  LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool),
-                     signo, value);
+  LLDB_INSTRUMENT_VA(this, signo, value);
 
   auto signals_sp = GetSP();
 
@@ -153,7 +141,7 @@ bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
 }
 
 int32_t SBUnixSignals::GetNumSignals() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals);
+  LLDB_INSTRUMENT_VA(this);
 
   if (auto signals_sp = GetSP())
     return signals_sp->GetNumSignals();
@@ -162,44 +150,10 @@ int32_t SBUnixSignals::GetNumSignals() const {
 }
 
 int32_t SBUnixSignals::GetSignalAtIndex(int32_t index) const {
-  LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, (int32_t),
-                           index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   if (auto signals_sp = GetSP())
     return signals_sp->GetSignalAtIndex(index);
 
   return LLDB_INVALID_SIGNAL_NUMBER;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBUnixSignals>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &));
-  LLDB_REGISTER_METHOD(
-      const lldb::SBUnixSignals &,
-      SBUnixSignals, operator=,(const lldb::SBUnixSignals &));
-  LLDB_REGISTER_METHOD(void, SBUnixSignals, Clear, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, operator bool, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
-                             (int32_t));
-  LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
-                             (const char *));
-  LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress,
-                             (int32_t));
-  LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldSuppress,
-                       (int32_t, bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t));
-  LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t));
-  LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool));
-  LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetNumSignals, ());
-  LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex,
-                             (int32_t));
-}
-
-}
-}
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;
 }
diff --git a/lldb/source/API/SBValueList.cpp b/lldb/source/API/SBValueList.cpp
index 0fd2a591c321..a67030c506f4 100644
--- a/lldb/source/API/SBValueList.cpp
+++ b/lldb/source/API/SBValueList.cpp
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #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/Instrumentation.h"
 
 #include <vector>
 
@@ -19,7 +19,7 @@ using namespace lldb_private;
 
 class ValueListImpl {
 public:
-  ValueListImpl() : m_values() {}
+  ValueListImpl() {}
 
   ValueListImpl(const ValueListImpl &rhs) : m_values(rhs.m_values) {}
 
@@ -67,18 +67,16 @@ private:
   std::vector<lldb::SBValue> m_values;
 };
 
-SBValueList::SBValueList() : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValueList);
-}
+SBValueList::SBValueList() { LLDB_INSTRUMENT_VA(this); }
 
-SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_up() {
-  LLDB_RECORD_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &), rhs);
+SBValueList::SBValueList(const SBValueList &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (rhs.IsValid())
     m_opaque_up = std::make_unique<ValueListImpl>(*rhs);
 }
 
-SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() {
+SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) {
   if (lldb_object_ptr)
     m_opaque_up = std::make_unique<ValueListImpl>(*lldb_object_ptr);
 }
@@ -86,24 +84,23 @@ SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() {
 SBValueList::~SBValueList() = default;
 
 bool SBValueList::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBValueList::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return (m_opaque_up != nullptr);
 }
 
 void SBValueList::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBValueList, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_up.reset();
 }
 
 const SBValueList &SBValueList::operator=(const SBValueList &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBValueList &,
-                     SBValueList, operator=,(const lldb::SBValueList &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     if (rhs.IsValid())
@@ -111,7 +108,7 @@ const SBValueList &SBValueList::operator=(const SBValueList &rhs) {
     else
       m_opaque_up.reset();
   }
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 ValueListImpl *SBValueList::operator->() { return m_opaque_up.get(); }
@@ -125,8 +122,7 @@ const ValueListImpl *SBValueList::operator->() const {
 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);
+  LLDB_INSTRUMENT_VA(this, val_obj);
 
   CreateIfNeeded();
   m_opaque_up->Append(val_obj);
@@ -140,8 +136,7 @@ void SBValueList::Append(lldb::ValueObjectSP &val_obj_sp) {
 }
 
 void SBValueList::Append(const lldb::SBValueList &value_list) {
-  LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &),
-                     value_list);
+  LLDB_INSTRUMENT_VA(this, value_list);
 
   if (value_list.IsValid()) {
     CreateIfNeeded();
@@ -150,19 +145,17 @@ void SBValueList::Append(const lldb::SBValueList &value_list) {
 }
 
 SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
-                           (uint32_t), idx);
-
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBValue sb_value;
   if (m_opaque_up)
     sb_value = m_opaque_up->GetValueAtIndex(idx);
 
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 uint32_t SBValueList::GetSize() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t size = 0;
   if (m_opaque_up)
@@ -177,23 +170,21 @@ void SBValueList::CreateIfNeeded() {
 }
 
 SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {
-  LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
-                     (lldb::user_id_t), uid);
+  LLDB_INSTRUMENT_VA(this, uid);
 
   SBValue sb_value;
   if (m_opaque_up)
     sb_value = m_opaque_up->FindValueByUID(uid);
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 SBValue SBValueList::GetFirstValueByName(const char *name) const {
-  LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
-                           (const char *), name);
+  LLDB_INSTRUMENT_VA(this, name);
 
   SBValue sb_value;
   if (m_opaque_up)
     sb_value = m_opaque_up->GetFirstValueByName(name);
-  return LLDB_RECORD_RESULT(sb_value);
+  return sb_value;
 }
 
 void *SBValueList::opaque_ptr() { return m_opaque_up.get(); }
@@ -202,30 +193,3 @@ ValueListImpl &SBValueList::ref() {
   CreateIfNeeded();
   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 *));
-}
-
-}
-}
diff --git a/lldb/source/API/SBVariablesOptions.cpp b/lldb/source/API/SBVariablesOptions.cpp
index 1af582a0c3d7..989d159139cc 100644
--- a/lldb/source/API/SBVariablesOptions.cpp
+++ b/lldb/source/API/SBVariablesOptions.cpp
@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBVariablesOptions.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/lldb-private.h"
 
@@ -80,132 +80,116 @@ private:
 
 SBVariablesOptions::SBVariablesOptions()
     : m_opaque_up(new VariablesOptionsImpl()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBVariablesOptions);
+  LLDB_INSTRUMENT_VA(this);
 }
 
 SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)
     : m_opaque_up(new VariablesOptionsImpl(options.ref())) {
-  LLDB_RECORD_CONSTRUCTOR(SBVariablesOptions,
-                          (const lldb::SBVariablesOptions &), options);
+  LLDB_INSTRUMENT_VA(this, options);
 }
 
 SBVariablesOptions &SBVariablesOptions::
 operator=(const SBVariablesOptions &options) {
-  LLDB_RECORD_METHOD(
-      lldb::SBVariablesOptions &,
-      SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &),
-      options);
+  LLDB_INSTRUMENT_VA(this, options);
 
   m_opaque_up = std::make_unique<VariablesOptionsImpl>(options.ref());
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBVariablesOptions::~SBVariablesOptions() = default;
 
 bool SBVariablesOptions::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBVariablesOptions::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up != nullptr;
 }
 
 bool SBVariablesOptions::GetIncludeArguments() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
-                                   GetIncludeArguments);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetIncludeArguments();
 }
 
 void SBVariablesOptions::SetIncludeArguments(bool arguments) {
-  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool),
-                     arguments);
+  LLDB_INSTRUMENT_VA(this, arguments);
 
   m_opaque_up->SetIncludeArguments(arguments);
 }
 
 bool SBVariablesOptions::GetIncludeRecognizedArguments(
     const lldb::SBTarget &target) const {
-  LLDB_RECORD_METHOD_CONST(bool, SBVariablesOptions,
-                           GetIncludeRecognizedArguments,
-                           (const lldb::SBTarget &), target);
+  LLDB_INSTRUMENT_VA(this, target);
 
   return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP());
 }
 
 void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
-  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments,
-                     (bool), arguments);
+  LLDB_INSTRUMENT_VA(this, arguments);
 
   m_opaque_up->SetIncludeRecognizedArguments(arguments);
 }
 
 bool SBVariablesOptions::GetIncludeLocals() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeLocals);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetIncludeLocals();
 }
 
 void SBVariablesOptions::SetIncludeLocals(bool locals) {
-  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool),
-                     locals);
+  LLDB_INSTRUMENT_VA(this, locals);
 
   m_opaque_up->SetIncludeLocals(locals);
 }
 
 bool SBVariablesOptions::GetIncludeStatics() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeStatics);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetIncludeStatics();
 }
 
 void SBVariablesOptions::SetIncludeStatics(bool statics) {
-  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool),
-                     statics);
+  LLDB_INSTRUMENT_VA(this, statics);
 
   m_opaque_up->SetIncludeStatics(statics);
 }
 
 bool SBVariablesOptions::GetInScopeOnly() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetInScopeOnly);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetInScopeOnly();
 }
 
 void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) {
-  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool),
-                     in_scope_only);
+  LLDB_INSTRUMENT_VA(this, in_scope_only);
 
   m_opaque_up->SetInScopeOnly(in_scope_only);
 }
 
 bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
-                                   GetIncludeRuntimeSupportValues);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetIncludeRuntimeSupportValues();
 }
 
 void SBVariablesOptions::SetIncludeRuntimeSupportValues(
     bool runtime_support_values) {
-  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRuntimeSupportValues,
-                     (bool), runtime_support_values);
+  LLDB_INSTRUMENT_VA(this, runtime_support_values);
 
   m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values);
 }
 
 lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBVariablesOptions,
-                                   GetUseDynamic);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetUseDynamic();
 }
 
 void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) {
-  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetUseDynamic,
-                     (lldb::DynamicValueType), dynamic);
+  LLDB_INSTRUMENT_VA(this, dynamic);
 
   m_opaque_up->SetUseDynamic(dynamic);
 }
@@ -232,43 +216,3 @@ SBVariablesOptions::SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr)
 void SBVariablesOptions::SetOptions(VariablesOptionsImpl *lldb_object_ptr) {
   m_opaque_up.reset(std::move(lldb_object_ptr));
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBVariablesOptions>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions,
-                            (const lldb::SBVariablesOptions &));
-  LLDB_REGISTER_METHOD(
-      lldb::SBVariablesOptions &,
-      SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, operator bool, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeArguments,
-                             ());
-  LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
-                             GetIncludeRecognizedArguments,
-                             (const lldb::SBTarget &));
-  LLDB_REGISTER_METHOD(void, SBVariablesOptions,
-                       SetIncludeRecognizedArguments, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeLocals, ());
-  LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeStatics, ());
-  LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetInScopeOnly, ());
-  LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool));
-  LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
-                             GetIncludeRuntimeSupportValues, ());
-  LLDB_REGISTER_METHOD(void, SBVariablesOptions,
-                       SetIncludeRuntimeSupportValues, (bool));
-  LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBVariablesOptions,
-                             GetUseDynamic, ());
-  LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetUseDynamic,
-                       (lldb::DynamicValueType));
-}
-
-}
-}
diff --git a/lldb/source/API/SBWatchpoint.cpp b/lldb/source/API/SBWatchpoint.cpp
index eba75dea8f8d..f5bd9cd1a946 100644
--- a/lldb/source/API/SBWatchpoint.cpp
+++ b/lldb/source/API/SBWatchpoint.cpp
@@ -7,12 +7,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBWatchpoint.h"
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBStream.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Breakpoint/WatchpointList.h"
@@ -26,31 +26,29 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBWatchpoint::SBWatchpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBWatchpoint); }
+SBWatchpoint::SBWatchpoint() { LLDB_INSTRUMENT_VA(this); }
 
 SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp)
     : m_opaque_wp(wp_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &), wp_sp);
+  LLDB_INSTRUMENT_VA(this, wp_sp);
 }
 
 SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs)
     : m_opaque_wp(rhs.m_opaque_wp) {
-  LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBWatchpoint &,
-                     SBWatchpoint, operator=,(const lldb::SBWatchpoint &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_wp = rhs.m_opaque_wp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBWatchpoint::~SBWatchpoint() = default;
 
 watch_id_t SBWatchpoint::GetID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID);
-
+  LLDB_INSTRUMENT_VA(this);
 
   watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
   lldb::WatchpointSP watchpoint_sp(GetSP());
@@ -61,42 +59,40 @@ watch_id_t SBWatchpoint::GetID() {
 }
 
 bool SBWatchpoint::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBWatchpoint::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return bool(m_opaque_wp.lock());
 }
 
 bool SBWatchpoint::operator==(const SBWatchpoint &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBWatchpoint, operator==,(const SBWatchpoint &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return GetSP() == rhs.GetSP();
 }
 
 bool SBWatchpoint::operator!=(const SBWatchpoint &rhs) const {
-  LLDB_RECORD_METHOD_CONST(
-      bool, SBWatchpoint, operator!=,(const SBWatchpoint &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   return !(*this == rhs);
 }
 
 SBError SBWatchpoint::GetError() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBWatchpoint, GetError);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError sb_error;
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     sb_error.SetError(watchpoint_sp->GetError());
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 int32_t SBWatchpoint::GetHardwareIndex() {
-  LLDB_RECORD_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex);
+  LLDB_INSTRUMENT_VA(this);
 
   int32_t hw_index = -1;
 
@@ -111,7 +107,7 @@ int32_t SBWatchpoint::GetHardwareIndex() {
 }
 
 addr_t SBWatchpoint::GetWatchAddress() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBWatchpoint, GetWatchAddress);
+  LLDB_INSTRUMENT_VA(this);
 
   addr_t ret_addr = LLDB_INVALID_ADDRESS;
 
@@ -126,7 +122,7 @@ addr_t SBWatchpoint::GetWatchAddress() {
 }
 
 size_t SBWatchpoint::GetWatchSize() {
-  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize);
+  LLDB_INSTRUMENT_VA(this);
 
   size_t watch_size = 0;
 
@@ -141,7 +137,7 @@ size_t SBWatchpoint::GetWatchSize() {
 }
 
 void SBWatchpoint::SetEnabled(bool enabled) {
-  LLDB_RECORD_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled);
+  LLDB_INSTRUMENT_VA(this, enabled);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
@@ -161,7 +157,7 @@ void SBWatchpoint::SetEnabled(bool enabled) {
 }
 
 bool SBWatchpoint::IsEnabled() {
-  LLDB_RECORD_METHOD_NO_ARGS(bool, SBWatchpoint, IsEnabled);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
@@ -173,7 +169,7 @@ bool SBWatchpoint::IsEnabled() {
 }
 
 uint32_t SBWatchpoint::GetHitCount() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetHitCount);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t count = 0;
   lldb::WatchpointSP watchpoint_sp(GetSP());
@@ -187,7 +183,7 @@ uint32_t SBWatchpoint::GetHitCount() {
 }
 
 uint32_t SBWatchpoint::GetIgnoreCount() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
@@ -199,7 +195,7 @@ uint32_t SBWatchpoint::GetIgnoreCount() {
 }
 
 void SBWatchpoint::SetIgnoreCount(uint32_t n) {
-  LLDB_RECORD_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n);
+  LLDB_INSTRUMENT_VA(this, n);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
@@ -210,7 +206,7 @@ void SBWatchpoint::SetIgnoreCount(uint32_t n) {
 }
 
 const char *SBWatchpoint::GetCondition() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBWatchpoint, GetCondition);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
@@ -222,8 +218,7 @@ const char *SBWatchpoint::GetCondition() {
 }
 
 void SBWatchpoint::SetCondition(const char *condition) {
-  LLDB_RECORD_METHOD(void, SBWatchpoint, SetCondition, (const char *),
-                     condition);
+  LLDB_INSTRUMENT_VA(this, condition);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
@@ -235,9 +230,7 @@ void SBWatchpoint::SetCondition(const char *condition) {
 
 bool SBWatchpoint::GetDescription(SBStream &description,
                                   DescriptionLevel level) {
-  LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription,
-                     (lldb::SBStream &, lldb::DescriptionLevel), description,
-                     level);
+  LLDB_INSTRUMENT_VA(this, description, level);
 
   Stream &strm = description.ref();
 
@@ -254,27 +247,25 @@ bool SBWatchpoint::GetDescription(SBStream &description,
 }
 
 void SBWatchpoint::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBWatchpoint, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_wp.reset();
 }
 
 lldb::WatchpointSP SBWatchpoint::GetSP() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP);
+  LLDB_INSTRUMENT_VA(this);
 
-  return LLDB_RECORD_RESULT(m_opaque_wp.lock());
+  return m_opaque_wp.lock();
 }
 
 void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) {
-  LLDB_RECORD_METHOD(void, SBWatchpoint, SetSP, (const lldb::WatchpointSP &),
-                     sp);
+  LLDB_INSTRUMENT_VA(this, sp);
 
   m_opaque_wp = sp;
 }
 
 bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) !=
          nullptr;
@@ -282,9 +273,7 @@ bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) {
 
 WatchpointEventType
 SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
-                            GetWatchpointEventTypeFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   if (event.IsValid())
     return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
@@ -293,60 +282,11 @@ SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
 }
 
 SBWatchpoint SBWatchpoint::GetWatchpointFromEvent(const lldb::SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
-                            GetWatchpointFromEvent, (const lldb::SBEvent &),
-                            event);
+  LLDB_INSTRUMENT_VA(event);
 
   SBWatchpoint sb_watchpoint;
   if (event.IsValid())
     sb_watchpoint =
         Watchpoint::WatchpointEventData::GetWatchpointFromEvent(event.GetSP());
-  return LLDB_RECORD_RESULT(sb_watchpoint);
-}
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBWatchpoint>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &));
-  LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &));
-  LLDB_REGISTER_METHOD(const lldb::SBWatchpoint &,
-                       SBWatchpoint, operator=,(const lldb::SBWatchpoint &));
-  LLDB_REGISTER_METHOD(lldb::watch_id_t, SBWatchpoint, GetID, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, operator bool, ());
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBWatchpoint, operator==,(const lldb::SBWatchpoint &));
-  LLDB_REGISTER_METHOD_CONST(
-      bool, SBWatchpoint, operator!=,(const lldb::SBWatchpoint &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBWatchpoint, GetError, ());
-  LLDB_REGISTER_METHOD(int32_t, SBWatchpoint, GetHardwareIndex, ());
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBWatchpoint, GetWatchAddress, ());
-  LLDB_REGISTER_METHOD(size_t, SBWatchpoint, GetWatchSize, ());
-  LLDB_REGISTER_METHOD(void, SBWatchpoint, SetEnabled, (bool));
-  LLDB_REGISTER_METHOD(bool, SBWatchpoint, IsEnabled, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetHitCount, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetIgnoreCount, ());
-  LLDB_REGISTER_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t));
-  LLDB_REGISTER_METHOD(const char *, SBWatchpoint, GetCondition, ());
-  LLDB_REGISTER_METHOD(void, SBWatchpoint, SetCondition, (const char *));
-  LLDB_REGISTER_METHOD(bool, SBWatchpoint, GetDescription,
-                       (lldb::SBStream &, lldb::DescriptionLevel));
-  LLDB_REGISTER_METHOD(void, SBWatchpoint, Clear, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::WatchpointSP, SBWatchpoint, GetSP, ());
-  LLDB_REGISTER_METHOD(void, SBWatchpoint, SetSP,
-                       (const lldb::WatchpointSP &));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
-                              GetWatchpointEventTypeFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
-                              GetWatchpointFromEvent,
-                              (const lldb::SBEvent &));
-}
-
-}
+  return sb_watchpoint;
 }
diff --git a/lldb/source/API/SystemInitializerFull.cpp b/lldb/source/API/SystemInitializerFull.cpp
index b01cb2ff545b..d662d370f813 100644
--- a/lldb/source/API/SystemInitializerFull.cpp
+++ b/lldb/source/API/SystemInitializerFull.cpp
@@ -39,7 +39,7 @@ constexpr lldb_private::HostInfo::SharedLibraryDirectoryHelper
 
 #else
 constexpr lldb_private::HostInfo::SharedLibraryDirectoryHelper
-    *g_shlib_dir_helper = 0;
+    *g_shlib_dir_helper = nullptr;
 #endif
 
 using namespace lldb_private;